Add vendor

vendor/github.com/caarlos0/env/v6/.gitignore

@@ -0,0 +1,4 @@
+coverage.txt
+bin
+card.png
+dist

vendor/github.com/caarlos0/env/v6/.gorelangci.yml

@@ -0,0 +1,7 @@
+linters:
+  enable-all: true
+  disable:
+    - wsl
+    - lll
+    - funlen
+    - godox

vendor/github.com/caarlos0/env/v6/.goreleaser.yml

@@ -0,0 +1,11 @@
+before:
+  hooks:
+    - go mod tidy
+builds:
+- skip: true
+changelog:
+  sort: asc
+  filters:
+    exclude:
+    - '^docs:'
+    - '^test:'

vendor/github.com/caarlos0/env/v6/.hound.yml

@@ -0,0 +1,2 @@
+go:
+  enabled: true

vendor/github.com/caarlos0/env/v6/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2019 Carlos Alexandro Becker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/caarlos0/env/v6/Makefile

@@ -0,0 +1,38 @@
+SOURCE_FILES?=./...
+TEST_PATTERN?=.
+
+export GO111MODULE := on
+
+setup:
+	curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh
+	go mod download
+.PHONY: setup
+
+build:
+	go build
+.PHONY: build
+
+test:
+	go test -v -failfast -race -coverpkg=./... -covermode=atomic -coverprofile=coverage.txt $(SOURCE_FILES) -run $(TEST_PATTERN) -timeout=2m
+.PHONY: test
+
+cover: test
+	go tool cover -html=coverage.txt
+.PHONY: cover
+
+fmt:
+	find . -name '*.go' -not -wholename './vendor/*' | while read -r file; do gofmt -w -s "$$file"; goimports -w "$$file"; done
+.PHONY: fmt
+
+lint:
+	./bin/golangci-lint run ./...
+.PHONY: lint
+
+ci: build test lint
+.PHONY: ci
+
+card:
+	wget -O card.png -c "https://og.caarlos0.dev/**env**: parse envs to structs.png?theme=light&md=1&fontSize=100px&images=https://github.com/caarlos0.png"
+.PHONY: card
+
+.DEFAULT_GOAL := ci

vendor/github.com/caarlos0/env/v6/README.md

@@ -0,0 +1,181 @@
+# env
+
+[![Build Status](https://img.shields.io/github/workflow/status/caarlos0/env/build?style=for-the-badge)](https://github.com/caarlos0/env/actions?workflow=build)
+[![Coverage Status](https://img.shields.io/codecov/c/gh/caarlos0/env.svg?logo=codecov&style=for-the-badge)](https://codecov.io/gh/caarlos0/env)
+[![](http://img.shields.io/badge/godoc-reference-5272B4.svg?style=for-the-badge)](http://godoc.org/github.com/caarlos0/env)
+
+Simple lib to parse envs to structs in Go.
+
+## Example
+
+A very basic example:
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+
+	// if using go modules
+	"github.com/caarlos0/env/v6"
+
+	// if using dep/others
+	"github.com/caarlos0/env"
+)
+
+type config struct {
+	Home         string        `env:"HOME"`
+	Port         int           `env:"PORT" envDefault:"3000"`
+	IsProduction bool          `env:"PRODUCTION"`
+	Hosts        []string      `env:"HOSTS" envSeparator:":"`
+	Duration     time.Duration `env:"DURATION"`
+	TempFolder   string        `env:"TEMP_FOLDER" envDefault:"${HOME}/tmp" envExpand:"true"`
+}
+
+func main() {
+	cfg := config{}
+	if err := env.Parse(&cfg); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+You can run it like this:
+
+```sh
+$ PRODUCTION=true HOSTS="host1:host2:host3" DURATION=1s go run main.go
+{Home:/your/home Port:3000 IsProduction:true Hosts:[host1 host2 host3] Duration:1s}
+```
+
+## Supported types and defaults
+
+Out of the box all built-in types are supported, plus a few others that
+are commonly used.
+
+Complete list:
+
+- `string`
+- `bool`
+- `int`
+- `int8`
+- `int16`
+- `int32`
+- `int64`
+- `uint`
+- `uint8`
+- `uint16`
+- `uint32`
+- `uint64`
+- `float32`
+- `float64`
+- `string`
+- `time.Duration`
+- `encoding.TextUnmarshaler`
+- `url.URL`
+
+Pointers, slices and slices of pointers of those types are also supported.
+
+You can also use/define a [custom parser func](#custom-parser-funcs) for any
+other type you want.
+
+If you set the `envDefault` tag for something, this value will be used in the
+case of absence of it in the environment.
+
+By default, slice types will split the environment value on `,`; you can change
+this behavior by setting the `envSeparator` tag.
+
+If you set the `envExpand` tag, environment variables (either in `${var}` or
+`$var` format) in the string will be replaced according with the actual value
+of the variable.
+
+Unexported fields are ignored.
+
+## Custom Parser Funcs
+
+If you have a type that is not supported out of the box by the lib, you are able
+to use (or define) and pass custom parsers (and their associated `reflect.Type`)
+to the `env.ParseWithFuncs()` function.
+
+In addition to accepting a struct pointer (same as `Parse()`), this function
+also accepts a `map[reflect.Type]env.ParserFunc`.
+
+`env` also ships with some pre-built custom parser funcs for common types. You
+can check them out [here](parsers/).
+
+If you add a custom parser for, say `Foo`, it will also be used to parse
+`*Foo` and `[]Foo` types.
+
+This directory contains pre-built, custom parsers that can be used with `env.ParseWithFuncs`
+to facilitate the parsing of envs that are not basic types.
+
+Check the example in the [go doc](http://godoc.org/github.com/caarlos0/env)
+for more info.
+
+## Required fields
+
+The `env` tag option `required` (e.g., `env:"tagKey,required"`) can be added
+to ensure that some environment variable is set.  In the example above,
+an error is returned if the `config` struct is changed to:
+
+
+```go
+type config struct {
+    Home         string   `env:"HOME"`
+    Port         int      `env:"PORT" envDefault:"3000"`
+    IsProduction bool     `env:"PRODUCTION"`
+    Hosts        []string `env:"HOSTS" envSeparator:":"`
+    SecretKey    string   `env:"SECRET_KEY,required"`
+}
+```
+
+
+## From file
+
+The `env` tag option `file` (e.g., `env:"tagKey,file"`) can be added
+to in order to indicate that the value of the variable shall be loaded from a file. The path of that file is given
+by the environment variable associated with it
+Example below
+
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+	"github.com/caarlos0/env"
+)
+
+type config struct {
+	Secret       string   `env:"SECRET,file"`
+	Password     string   `env:"PASSWORD,file" envDefault:"/tmp/password"`
+	Certificate  string   `env:"CERTIFICATE,file" envDefault:"${CERTIFICATE_FILE}" envExpand:"true"`
+}
+
+func main() {
+	cfg := config{}
+	if err := env.Parse(&cfg); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+
+	fmt.Printf("%+v\n", cfg)
+}
+```
+
+```sh
+$ echo qwerty > /tmp/secret
+$ echo dvorak > /tmp/password
+$ echo coleman > /tmp/certificate
+
+$ SECRET=/tmp/secret  \
+	CERTIFICATE_FILE=/tmp/certificate \
+	go run main.go
+{Secret:qwerty Password:dvorak Certificate:coleman}
+```
+
+## Stargazers over time
+
+[![Stargazers over time](https://starchart.cc/caarlos0/env.svg)](https://starchart.cc/caarlos0/env)
+

vendor/github.com/caarlos0/env/v6/env.go

@@ -0,0 +1,373 @@
+package env
+
+import (
+	"encoding"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// nolint: gochecknoglobals
+var (
+	// ErrNotAStructPtr is returned if you pass something that is not a pointer to a
+	// Struct to Parse
+	ErrNotAStructPtr = errors.New("env: expected a pointer to a Struct")
+
+	defaultBuiltInParsers = map[reflect.Kind]ParserFunc{
+		reflect.Bool: func(v string) (interface{}, error) {
+			return strconv.ParseBool(v)
+		},
+		reflect.String: func(v string) (interface{}, error) {
+			return v, nil
+		},
+		reflect.Int: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 32)
+			return int(i), err
+		},
+		reflect.Int16: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 16)
+			return int16(i), err
+		},
+		reflect.Int32: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 32)
+			return int32(i), err
+		},
+		reflect.Int64: func(v string) (interface{}, error) {
+			return strconv.ParseInt(v, 10, 64)
+		},
+		reflect.Int8: func(v string) (interface{}, error) {
+			i, err := strconv.ParseInt(v, 10, 8)
+			return int8(i), err
+		},
+		reflect.Uint: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 32)
+			return uint(i), err
+		},
+		reflect.Uint16: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 16)
+			return uint16(i), err
+		},
+		reflect.Uint32: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 32)
+			return uint32(i), err
+		},
+		reflect.Uint64: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 64)
+			return i, err
+		},
+		reflect.Uint8: func(v string) (interface{}, error) {
+			i, err := strconv.ParseUint(v, 10, 8)
+			return uint8(i), err
+		},
+		reflect.Float64: func(v string) (interface{}, error) {
+			return strconv.ParseFloat(v, 64)
+		},
+		reflect.Float32: func(v string) (interface{}, error) {
+			f, err := strconv.ParseFloat(v, 32)
+			return float32(f), err
+		},
+	}
+
+	defaultTypeParsers = map[reflect.Type]ParserFunc{
+		reflect.TypeOf(url.URL{}): func(v string) (interface{}, error) {
+			u, err := url.Parse(v)
+			if err != nil {
+				return nil, fmt.Errorf("unable to parse URL: %v", err)
+			}
+			return *u, nil
+		},
+		reflect.TypeOf(time.Nanosecond): func(v string) (interface{}, error) {
+			s, err := time.ParseDuration(v)
+			if err != nil {
+				return nil, fmt.Errorf("unable to parse duration: %v", err)
+			}
+			return s, err
+		},
+	}
+)
+
+// ParserFunc defines the signature of a function that can be used within `CustomParsers`
+type ParserFunc func(v string) (interface{}, error)
+
+// Parse parses a struct containing `env` tags and loads its values from
+// environment variables.
+func Parse(v interface{}) error {
+	return ParseWithFuncs(v, map[reflect.Type]ParserFunc{})
+}
+
+// ParseWithFuncs is the same as `Parse` except it also allows the user to pass
+// in custom parsers.
+func ParseWithFuncs(v interface{}, funcMap map[reflect.Type]ParserFunc) error {
+	ptrRef := reflect.ValueOf(v)
+	if ptrRef.Kind() != reflect.Ptr {
+		return ErrNotAStructPtr
+	}
+	ref := ptrRef.Elem()
+	if ref.Kind() != reflect.Struct {
+		return ErrNotAStructPtr
+	}
+	var parsers = defaultTypeParsers
+	for k, v := range funcMap {
+		parsers[k] = v
+	}
+	return doParse(ref, parsers)
+}
+
+func doParse(ref reflect.Value, funcMap map[reflect.Type]ParserFunc) error {
+	var refType = ref.Type()
+
+	for i := 0; i < refType.NumField(); i++ {
+		refField := ref.Field(i)
+		if !refField.CanSet() {
+			continue
+		}
+		if reflect.Ptr == refField.Kind() && !refField.IsNil() {
+			err := ParseWithFuncs(refField.Interface(), funcMap)
+			if err != nil {
+				return err
+			}
+			continue
+		}
+		if reflect.Struct == refField.Kind() && refField.CanAddr() && refField.Type().Name() == "" {
+			err := Parse(refField.Addr().Interface())
+			if err != nil {
+				return err
+			}
+			continue
+		}
+		refTypeField := refType.Field(i)
+		value, err := get(refTypeField)
+		if err != nil {
+			return err
+		}
+		if value == "" {
+			if reflect.Struct == refField.Kind() {
+				if err := doParse(refField, funcMap); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		if err := set(refField, refTypeField, value, funcMap); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func get(field reflect.StructField) (val string, err error) {
+	var required bool
+	var exists bool
+	var loadFile bool
+	var expand = strings.EqualFold(field.Tag.Get("envExpand"), "true")
+
+	key, opts := parseKeyForOption(field.Tag.Get("env"))
+
+	for _, opt := range opts {
+		switch opt {
+		case "":
+			break
+		case "file":
+			loadFile = true
+		case "required":
+			required = true
+		default:
+			return "", fmt.Errorf("env: tag option %q not supported", opt)
+		}
+	}
+
+	defaultValue := field.Tag.Get("envDefault")
+	val, exists = getOr(key, defaultValue)
+
+	if expand {
+		val = os.ExpandEnv(val)
+	}
+
+	if required && !exists {
+		return "", fmt.Errorf(`env: required environment variable %q is not set`, key)
+	}
+
+	if loadFile && val != "" {
+		filename := val
+		val, err = getFromFile(filename)
+		if err != nil {
+			return "", fmt.Errorf(`env: could not load content of file "%s" from variable %s: %v`, filename, key, err)
+		}
+	}
+
+	return val, err
+}
+
+// split the env tag's key into the expected key and desired option, if any.
+func parseKeyForOption(key string) (string, []string) {
+	opts := strings.Split(key, ",")
+	return opts[0], opts[1:]
+}
+
+func getFromFile(filename string) (value string, err error) {
+	b, err := ioutil.ReadFile(filename)
+	return string(b), err
+}
+
+func getOr(key, defaultValue string) (value string, exists bool) {
+	value, exists = os.LookupEnv(key)
+	if !exists {
+		value = defaultValue
+	}
+	return value, exists
+}
+
+func set(field reflect.Value, sf reflect.StructField, value string, funcMap map[reflect.Type]ParserFunc) error {
+	if field.Kind() == reflect.Slice {
+		return handleSlice(field, value, sf, funcMap)
+	}
+
+	var tm = asTextUnmarshaler(field)
+	if tm != nil {
+		var err = tm.UnmarshalText([]byte(value))
+		return newParseError(sf, err)
+	}
+
+	var typee = sf.Type
+	var fieldee = field
+	if typee.Kind() == reflect.Ptr {
+		typee = typee.Elem()
+		fieldee = field.Elem()
+	}
+
+	parserFunc, ok := funcMap[typee]
+	if ok {
+		val, err := parserFunc(value)
+		if err != nil {
+			return newParseError(sf, err)
+		}
+
+		fieldee.Set(reflect.ValueOf(val))
+		return nil
+	}
+
+	parserFunc, ok = defaultBuiltInParsers[typee.Kind()]
+	if ok {
+		val, err := parserFunc(value)
+		if err != nil {
+			return newParseError(sf, err)
+		}
+
+		fieldee.Set(reflect.ValueOf(val).Convert(typee))
+		return nil
+	}
+
+	return newNoParserError(sf)
+}
+
+func handleSlice(field reflect.Value, value string, sf reflect.StructField, funcMap map[reflect.Type]ParserFunc) error {
+	var separator = sf.Tag.Get("envSeparator")
+	if separator == "" {
+		separator = ","
+	}
+	var parts = strings.Split(value, separator)
+
+	var typee = sf.Type.Elem()
+	if typee.Kind() == reflect.Ptr {
+		typee = typee.Elem()
+	}
+
+	if _, ok := reflect.New(typee).Interface().(encoding.TextUnmarshaler); ok {
+		return parseTextUnmarshalers(field, parts, sf)
+	}
+
+	parserFunc, ok := funcMap[typee]
+	if !ok {
+		parserFunc, ok = defaultBuiltInParsers[typee.Kind()]
+		if !ok {
+			return newNoParserError(sf)
+		}
+	}
+
+	var result = reflect.MakeSlice(sf.Type, 0, len(parts))
+	for _, part := range parts {
+		r, err := parserFunc(part)
+		if err != nil {
+			return newParseError(sf, err)
+		}
+		var v = reflect.ValueOf(r).Convert(typee)
+		if sf.Type.Elem().Kind() == reflect.Ptr {
+			v = reflect.New(typee)
+			v.Elem().Set(reflect.ValueOf(r).Convert(typee))
+		}
+		result = reflect.Append(result, v)
+	}
+	field.Set(result)
+	return nil
+}
+
+func asTextUnmarshaler(field reflect.Value) encoding.TextUnmarshaler {
+	if reflect.Ptr == field.Kind() {
+		if field.IsNil() {
+			field.Set(reflect.New(field.Type().Elem()))
+		}
+	} else if field.CanAddr() {
+		field = field.Addr()
+	}
+
+	tm, ok := field.Interface().(encoding.TextUnmarshaler)
+	if !ok {
+		return nil
+	}
+	return tm
+}
+
+func parseTextUnmarshalers(field reflect.Value, data []string, sf reflect.StructField) error {
+	s := len(data)
+	elemType := field.Type().Elem()
+	slice := reflect.MakeSlice(reflect.SliceOf(elemType), s, s)
+	for i, v := range data {
+		sv := slice.Index(i)
+		kind := sv.Kind()
+		if kind == reflect.Ptr {
+			sv = reflect.New(elemType.Elem())
+		} else {
+			sv = sv.Addr()
+		}
+		tm := sv.Interface().(encoding.TextUnmarshaler)
+		if err := tm.UnmarshalText([]byte(v)); err != nil {
+			return newParseError(sf, err)
+		}
+		if kind == reflect.Ptr {
+			slice.Index(i).Set(sv)
+		}
+	}
+
+	field.Set(slice)
+
+	return nil
+}
+
+func newParseError(sf reflect.StructField, err error) error {
+	if err == nil {
+		return nil
+	}
+	return parseError{
+		sf:  sf,
+		err: err,
+	}
+}
+
+type parseError struct {
+	sf  reflect.StructField
+	err error
+}
+
+func (e parseError) Error() string {
+	return fmt.Sprintf(`env: parse error on field "%s" of type "%s": %v`, e.sf.Name, e.sf.Type, e.err)
+}
+
+func newNoParserError(sf reflect.StructField) error {
+	return fmt.Errorf(`env: no parser found for field "%s" of type "%s"`, sf.Name, sf.Type)
+}

vendor/github.com/caarlos0/env/v6/go.mod

@@ -0,0 +1,5 @@
+module github.com/caarlos0/env/v6
+
+require github.com/stretchr/testify v1.5.1
+
+go 1.14

vendor/github.com/caarlos0/env/v6/go.sum

@@ -0,0 +1,12 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

vendor/github.com/caarlos0/env/v6/renovate.json

@@ -0,0 +1,5 @@
+{
+  "extends": [
+    "config:base"
+  ]
+}

vendor/github.com/gin-contrib/sse/.travis.yml

@@ -0,0 +1,26 @@
+language: go
+sudo: false
+go:
+  - 1.8.x
+  - 1.9.x
+  - 1.10.x
+  - 1.11.x
+  - 1.12.x
+  - master
+
+git:
+  depth: 10
+
+matrix:
+  fast_finish: true
+  include:
+  - go: 1.11.x
+    env: GO111MODULE=on
+  - go: 1.12.x
+    env: GO111MODULE=on
+
+script:
+  - go test -v -covermode=count -coverprofile=coverage.out
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)

vendor/github.com/gin-contrib/sse/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Manuel Martínez-Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/gin-contrib/sse/README.md

@@ -0,0 +1,58 @@
+# Server-Sent Events
+
+[![GoDoc](https://godoc.org/github.com/gin-contrib/sse?status.svg)](https://godoc.org/github.com/gin-contrib/sse)
+[![Build Status](https://travis-ci.org/gin-contrib/sse.svg)](https://travis-ci.org/gin-contrib/sse)
+[![codecov](https://codecov.io/gh/gin-contrib/sse/branch/master/graph/badge.svg)](https://codecov.io/gh/gin-contrib/sse)
+[![Go Report Card](https://goreportcard.com/badge/github.com/gin-contrib/sse)](https://goreportcard.com/report/github.com/gin-contrib/sse)
+
+Server-sent events (SSE) is a technology where a browser receives automatic updates from a server via HTTP connection. The Server-Sent Events EventSource API is [standardized as part of HTML5[1] by the W3C](http://www.w3.org/TR/2009/WD-eventsource-20091029/).
+
+- [Read this great SSE introduction by the HTML5Rocks guys](http://www.html5rocks.com/en/tutorials/eventsource/basics/)
+- [Browser support](http://caniuse.com/#feat=eventsource)
+
+## Sample code
+
+```go
+import "github.com/gin-contrib/sse"
+
+func httpHandler(w http.ResponseWriter, req *http.Request) {
+	// data can be a primitive like a string, an integer or a float
+	sse.Encode(w, sse.Event{
+		Event: "message",
+		Data:  "some data\nmore data",
+	})
+
+	// also a complex type, like a map, a struct or a slice
+	sse.Encode(w, sse.Event{
+		Id:    "124",
+		Event: "message",
+		Data: map[string]interface{}{
+			"user":    "manu",
+			"date":    time.Now().Unix(),
+			"content": "hi!",
+		},
+	})
+}
+```
+```
+event: message
+data: some data\\nmore data
+
+id: 124
+event: message
+data: {"content":"hi!","date":1431540810,"user":"manu"}
+ 
+```
+
+## Content-Type
+
+```go
+fmt.Println(sse.ContentType)
+```
+```
+text/event-stream
+```
+
+## Decoding support
+
+There is a client-side implementation of SSE coming soon.

vendor/github.com/gin-contrib/sse/go.mod

@@ -0,0 +1,5 @@
+module github.com/gin-contrib/sse
+
+go 1.12
+
+require github.com/stretchr/testify v1.3.0

vendor/github.com/gin-contrib/sse/go.sum

@@ -0,0 +1,7 @@
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

vendor/github.com/gin-contrib/sse/sse-decoder.go

@@ -0,0 +1,116 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package sse
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+)
+
+type decoder struct {
+	events []Event
+}
+
+func Decode(r io.Reader) ([]Event, error) {
+	var dec decoder
+	return dec.decode(r)
+}
+
+func (d *decoder) dispatchEvent(event Event, data string) {
+	dataLength := len(data)
+	if dataLength > 0 {
+		//If the data buffer's last character is a U+000A LINE FEED (LF) character, then remove the last character from the data buffer.
+		data = data[:dataLength-1]
+		dataLength--
+	}
+	if dataLength == 0 && event.Event == "" {
+		return
+	}
+	if event.Event == "" {
+		event.Event = "message"
+	}
+	event.Data = data
+	d.events = append(d.events, event)
+}
+
+func (d *decoder) decode(r io.Reader) ([]Event, error) {
+	buf, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	var currentEvent Event
+	var dataBuffer *bytes.Buffer = new(bytes.Buffer)
+	// TODO (and unit tests)
+	// Lines must be separated by either a U+000D CARRIAGE RETURN U+000A LINE FEED (CRLF) character pair,
+	// a single U+000A LINE FEED (LF) character,
+	// or a single U+000D CARRIAGE RETURN (CR) character.
+	lines := bytes.Split(buf, []byte{'\n'})
+	for _, line := range lines {
+		if len(line) == 0 {
+			// If the line is empty (a blank line). Dispatch the event.
+			d.dispatchEvent(currentEvent, dataBuffer.String())
+
+			// reset current event and data buffer
+			currentEvent = Event{}
+			dataBuffer.Reset()
+			continue
+		}
+		if line[0] == byte(':') {
+			// If the line starts with a U+003A COLON character (:), ignore the line.
+			continue
+		}
+
+		var field, value []byte
+		colonIndex := bytes.IndexRune(line, ':')
+		if colonIndex != -1 {
+			// If the line contains a U+003A COLON character character (:)
+			// Collect the characters on the line before the first U+003A COLON character (:),
+			// and let field be that string.
+			field = line[:colonIndex]
+			// Collect the characters on the line after the first U+003A COLON character (:),
+			// and let value be that string.
+			value = line[colonIndex+1:]
+			// If value starts with a single U+0020 SPACE character, remove it from value.
+			if len(value) > 0 && value[0] == ' ' {
+				value = value[1:]
+			}
+		} else {
+			// Otherwise, the string is not empty but does not contain a U+003A COLON character character (:)
+			// Use the whole line as the field name, and the empty string as the field value.
+			field = line
+			value = []byte{}
+		}
+		// The steps to process the field given a field name and a field value depend on the field name,
+		// as given in the following list. Field names must be compared literally,
+		// with no case folding performed.
+		switch string(field) {
+		case "event":
+			// Set the event name buffer to field value.
+			currentEvent.Event = string(value)
+		case "id":
+			// Set the event stream's last event ID to the field value.
+			currentEvent.Id = string(value)
+		case "retry":
+			// If the field value consists of only characters in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9),
+			// then interpret the field value as an integer in base ten, and set the event stream's reconnection time to that integer.
+			// Otherwise, ignore the field.
+			currentEvent.Id = string(value)
+		case "data":
+			// Append the field value to the data buffer,
+			dataBuffer.Write(value)
+			// then append a single U+000A LINE FEED (LF) character to the data buffer.
+			dataBuffer.WriteString("\n")
+		default:
+			//Otherwise. The field is ignored.
+			continue
+		}
+	}
+	// Once the end of the file is reached, the user agent must dispatch the event one final time.
+	d.dispatchEvent(currentEvent, dataBuffer.String())
+
+	return d.events, nil
+}

vendor/github.com/gin-contrib/sse/sse-encoder.go

@@ -0,0 +1,110 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package sse
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Server-Sent Events
+// W3C Working Draft 29 October 2009
+// http://www.w3.org/TR/2009/WD-eventsource-20091029/
+
+const ContentType = "text/event-stream"
+
+var contentType = []string{ContentType}
+var noCache = []string{"no-cache"}
+
+var fieldReplacer = strings.NewReplacer(
+	"\n", "\\n",
+	"\r", "\\r")
+
+var dataReplacer = strings.NewReplacer(
+	"\n", "\ndata:",
+	"\r", "\\r")
+
+type Event struct {
+	Event string
+	Id    string
+	Retry uint
+	Data  interface{}
+}
+
+func Encode(writer io.Writer, event Event) error {
+	w := checkWriter(writer)
+	writeId(w, event.Id)
+	writeEvent(w, event.Event)
+	writeRetry(w, event.Retry)
+	return writeData(w, event.Data)
+}
+
+func writeId(w stringWriter, id string) {
+	if len(id) > 0 {
+		w.WriteString("id:")
+		fieldReplacer.WriteString(w, id)
+		w.WriteString("\n")
+	}
+}
+
+func writeEvent(w stringWriter, event string) {
+	if len(event) > 0 {
+		w.WriteString("event:")
+		fieldReplacer.WriteString(w, event)
+		w.WriteString("\n")
+	}
+}
+
+func writeRetry(w stringWriter, retry uint) {
+	if retry > 0 {
+		w.WriteString("retry:")
+		w.WriteString(strconv.FormatUint(uint64(retry), 10))
+		w.WriteString("\n")
+	}
+}
+
+func writeData(w stringWriter, data interface{}) error {
+	w.WriteString("data:")
+	switch kindOfData(data) {
+	case reflect.Struct, reflect.Slice, reflect.Map:
+		err := json.NewEncoder(w).Encode(data)
+		if err != nil {
+			return err
+		}
+		w.WriteString("\n")
+	default:
+		dataReplacer.WriteString(w, fmt.Sprint(data))
+		w.WriteString("\n\n")
+	}
+	return nil
+}
+
+func (r Event) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+	return Encode(w, r)
+}
+
+func (r Event) WriteContentType(w http.ResponseWriter) {
+	header := w.Header()
+	header["Content-Type"] = contentType
+
+	if _, exist := header["Cache-Control"]; !exist {
+		header["Cache-Control"] = noCache
+	}
+}
+
+func kindOfData(data interface{}) reflect.Kind {
+	value := reflect.ValueOf(data)
+	valueType := value.Kind()
+	if valueType == reflect.Ptr {
+		valueType = value.Elem().Kind()
+	}
+	return valueType
+}

vendor/github.com/gin-contrib/sse/writer.go

@@ -0,0 +1,24 @@
+package sse
+
+import "io"
+
+type stringWriter interface {
+	io.Writer
+	WriteString(string) (int, error)
+}
+
+type stringWrapper struct {
+	io.Writer
+}
+
+func (w stringWrapper) WriteString(str string) (int, error) {
+	return w.Writer.Write([]byte(str))
+}
+
+func checkWriter(writer io.Writer) stringWriter {
+	if w, ok := writer.(stringWriter); ok {
+		return w
+	} else {
+		return stringWrapper{writer}
+	}
+}

vendor/github.com/gin-gonic/gin/.gitignore

@@ -0,0 +1,7 @@
+vendor/*
+!vendor/vendor.json
+coverage.out
+count.out
+test
+profile.out
+tmp.out

vendor/github.com/gin-gonic/gin/.travis.yml

@@ -0,0 +1,48 @@
+language: go
+
+matrix:
+  fast_finish: true
+  include:
+  - go: 1.11.x
+    env: GO111MODULE=on
+  - go: 1.12.x
+    env: GO111MODULE=on
+  - go: 1.13.x
+  - go: 1.13.x
+    env: 
+      - TESTTAGS=nomsgpack
+  - go: 1.14.x
+  - go: 1.14.x
+    env:
+      - TESTTAGS=nomsgpack
+  - go: master
+
+git:
+  depth: 10
+
+before_install:
+  - if [[ "${GO111MODULE}" = "on" ]]; then mkdir "${HOME}/go"; export GOPATH="${HOME}/go"; fi
+
+install:
+  - if [[ "${GO111MODULE}" = "on" ]]; then go mod download; fi
+  - if [[ "${GO111MODULE}" = "on" ]]; then export PATH="${GOPATH}/bin:${GOROOT}/bin:${PATH}"; fi
+  - if [[ "${GO111MODULE}" = "on" ]]; then make tools; fi
+
+go_import_path: github.com/gin-gonic/gin
+
+script:
+  - make vet
+  - make fmt-check
+  - make misspell-check
+  - make test
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
+
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/7f95bf605c4d356372f4
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: false     # default: false

vendor/github.com/gin-gonic/gin/AUTHORS.md

@@ -0,0 +1,231 @@
+List of all the awesome people working to make Gin the best Web Framework in Go.
+
+## gin 1.x series authors
+
+**Gin Core Team:** Bo-Yi Wu (@appleboy), 田欧 (@thinkerou), Javier Provecho (@javierprovecho)
+
+## gin 0.x series authors
+
+**Maintainers:** Manu Martinez-Almeida (@manucorporat), Javier Provecho (@javierprovecho)
+
+People and companies, who have contributed, in alphabetical order.
+
+**@858806258 (杰哥)**
+- Fix typo in example
+
+
+**@achedeuzot (Klemen Sever)**
+- Fix newline debug printing
+
+
+**@adammck (Adam Mckaig)**
+- Add MIT license
+
+
+**@AlexanderChen1989 (Alexander)**
+- Typos in README
+
+
+**@alexanderdidenko (Aleksandr Didenko)**
+- Add support multipart/form-data
+
+
+**@alexandernyquist (Alexander Nyquist)**
+- Using template.Must to fix multiple return issue
+- ★ Added support for OPTIONS verb
+- ★ Setting response headers before calling WriteHeader
+- Improved documentation for model binding
+- ★ Added Content.Redirect()
+- ★ Added tons of Unit tests
+
+
+**@austinheap (Austin Heap)**
+- Added travis CI integration
+
+
+**@andredublin (Andre Dublin)**
+- Fix typo in comment
+
+
+**@bredov (Ludwig Valda Vasquez)**
+- Fix html templating in debug mode
+
+
+**@bluele (Jun Kimura)**
+- Fixes code examples in README
+
+
+**@chad-russell**
+- ★ Support for serializing gin.H into XML
+
+
+**@dickeyxxx (Jeff Dickey)**
+- Typos in README
+- Add example about serving static files
+
+
+**@donileo (Adonis)**
+- Add NoMethod handler
+
+
+**@dutchcoders (DutchCoders)**
+- ★ Fix security bug that allows client to spoof ip
+- Fix typo. r.HTMLTemplates -> SetHTMLTemplate
+
+
+**@el3ctro- (Joshua Loper)**
+- Fix typo in example
+
+
+**@ethankan (Ethan Kan)**
+- Unsigned integers in binding
+
+
+**(Evgeny Persienko)**
+- Validate sub structures
+
+
+**@frankbille (Frank Bille)**
+- Add support for HTTP Realm Auth
+
+
+**@fmd (Fareed Dudhia)**
+- Fix typo. SetHTTPTemplate -> SetHTMLTemplate
+
+
+**@ironiridis (Christopher Harrington)**
+- Remove old reference
+
+
+**@jammie-stackhouse (Jamie Stackhouse)**
+- Add more shortcuts for router methods
+
+
+**@jasonrhansen**
+- Fix spelling and grammar errors in documentation
+
+
+**@JasonSoft (Jason Lee)**
+- Fix typo in comment
+
+
+**@joiggama (Ignacio Galindo)**
+- Add utf-8 charset header on renders
+
+
+**@julienschmidt (Julien Schmidt)**
+- gofmt the code examples
+
+
+**@kelcecil (Kel Cecil)**
+- Fix readme typo
+
+
+**@kyledinh (Kyle Dinh)**
+- Adds RunTLS()
+
+
+**@LinusU (Linus Unnebäck)**
+- Small fixes in README
+
+
+**@loongmxbt (Saint Asky)**
+- Fix typo in example
+
+
+**@lucas-clemente (Lucas Clemente)**
+- ★ work around path.Join removing trailing slashes from routes
+
+
+**@mattn (Yasuhiro Matsumoto)**
+- Improve color logger
+
+
+**@mdigger (Dmitry Sedykh)**
+- Fixes Form binding when content-type is x-www-form-urlencoded
+- No repeat call c.Writer.Status() in gin.Logger
+- Fixes Content-Type for json render
+
+
+**@mirzac (Mirza Ceric)**
+- Fix debug printing
+
+
+**@mopemope (Yutaka Matsubara)**
+- ★ Adds Godep support (Dependencies Manager)
+- Fix variadic parameter in the flexible render API
+- Fix Corrupted plain render
+- Add Pluggable View Renderer Example
+ 
+
+**@msemenistyi (Mykyta Semenistyi)**
+- update Readme.md. Add code to String method
+
+
+**@msoedov (Sasha Myasoedov)**
+- ★ Adds tons of unit tests.
+
+
+**@ngerakines (Nick Gerakines)**
+- ★ Improves API, c.GET() doesn't panic
+- Adds MustGet() method
+
+
+**@r8k (Rajiv Kilaparti)**
+- Fix Port usage in README.
+
+
+**@rayrod2030 (Ray Rodriguez)**
+- Fix typo in example
+
+
+**@rns**
+- Fix typo in example
+
+
+**@RobAWilkinson (Robert Wilkinson)**
+- Add example of forms and params
+
+
+**@rogierlommers (Rogier Lommers)**
+- Add updated static serve example
+
+
+**@se77en (Damon Zhao)**
+- Improve color logging
+
+
+**@silasb (Silas Baronda)**
+- Fixing quotes in README
+
+
+**@SkuliOskarsson (Skuli Oskarsson)**
+- Fixes some texts in README II
+
+
+**@slimmy (Jimmy Pettersson)**
+- Added messages for required bindings
+
+
+**@smira (Andrey Smirnov)**
+- Add support for ignored/unexported fields in binding
+
+
+**@superalsrk (SRK.Lyu)**
+- Update httprouter godeps
+
+
+**@tebeka (Miki Tebeka)**
+- Use net/http constants instead of numeric values
+
+
+**@techjanitor**
+- Update context.go reserved IPs
+
+
+**@yosssi (Keiji Yoshida)**
+- Fix link in README
+
+
+**@yuyabee**
+- Fixed README

vendor/github.com/gin-gonic/gin/BENCHMARKS.md

@@ -0,0 +1,693 @@
+
+## Benchmark System
+
+**VM HOST:** DigitalOcean  
+**Machine:** 12 CPU, 24 GB RAM. Ubuntu 16.04.2 x64  
+**Date:** Nov 26th, 2019  
+**Go Version:** 1.13.4 linux/amd64  
+**Source:** [Go HTTP Router Benchmark](https://github.com/julienschmidt/go-http-routing-benchmark)
+**Result:** [See the gist](https://gist.github.com/appleboy/b5f2ecfaf50824ae9c64dcfb9165ae5e)
+
+## Static Routes: 157
+
+```
+Gin:                 34936 Bytes
+
+HttpServeMux:        14512 Bytes
+Ace:                 30648 Bytes
+Aero:               800696 Bytes
+Bear:                30664 Bytes
+Beego:               98456 Bytes
+Bone:                40224 Bytes
+Chi:                 83608 Bytes
+CloudyKitRouter:     30448 Bytes
+Denco:                9928 Bytes
+Echo:                76584 Bytes
+GocraftWeb:          55496 Bytes
+Goji:                29744 Bytes
+Gojiv2:             105840 Bytes
+GoJsonRest:         137512 Bytes
+GoRestful:          816936 Bytes
+GorillaMux:         585632 Bytes
+GowwwRouter:         24968 Bytes
+HttpRouter:          21680 Bytes
+HttpTreeMux:         73448 Bytes
+Kocha:              115472 Bytes
+LARS:                30640 Bytes
+Macaron:             38592 Bytes
+Martini:            310864 Bytes
+Pat:                 19696 Bytes
+Possum:              89920 Bytes
+R2router:            23712 Bytes
+Rivet:               24608 Bytes
+Tango:               28264 Bytes
+TigerTonic:          78768 Bytes
+Traffic:            538976 Bytes
+Vulcan:             369960 Bytes
+```
+
+## GithubAPI Routes: 203
+
+```
+Gin:                 58512 Bytes
+
+Ace:                 48640 Bytes
+Aero:              1386208 Bytes
+Bear:                82536 Bytes
+Beego:              150936 Bytes
+Bone:               100976 Bytes
+Chi:                 95112 Bytes
+CloudyKitRouter:     93704 Bytes
+Denco:               36736 Bytes
+Echo:                96328 Bytes
+GocraftWeb:          95432 Bytes
+Goji:                51600 Bytes
+Gojiv2:             104704 Bytes
+GoJsonRest:         142024 Bytes
+GoRestful:         1241656 Bytes
+GorillaMux:        1322784 Bytes
+GowwwRouter:         80008 Bytes
+HttpRouter:          37096 Bytes
+HttpTreeMux:         78800 Bytes
+Kocha:              785408 Bytes
+LARS:                48600 Bytes
+Macaron:             93680 Bytes
+Martini:            485264 Bytes
+Pat:                 21200 Bytes
+Possum:              85312 Bytes
+R2router:            47104 Bytes
+Rivet:               42840 Bytes
+Tango:               54840 Bytes
+TigerTonic:          96176 Bytes
+Traffic:            921744 Bytes
+Vulcan:             425368 Bytes
+```
+
+## GPlusAPI Routes: 13
+
+```
+Gin:              4384 Bytes
+
+Ace: 3             664 Bytes
+Aero:            88248 Bytes
+Bear:             7112 Bytes
+Beego:           10272 Bytes
+Bone:             6688 Bytes
+Chi:              8024 Bytes
+CloudyKitRouter:  6728 Bytes
+Denco:            3264 Bytes
+Echo:             9272 Bytes
+GocraftWeb:       7496 Bytes
+Goji:             3152 Bytes
+Gojiv2:           7376 Bytes
+GoJsonRest:      11416 Bytes
+GoRestful:       74328 Bytes
+GorillaMux:      66208 Bytes
+GowwwRouter:      5744 Bytes
+HttpRouter:       2760 Bytes
+HttpTreeMux:      7440 Bytes
+Kocha:          128880 Bytes
+LARS:             3656 Bytes
+Macaron:          8656 Bytes
+Martini:         23920 Bytes
+Pat:              1856 Bytes
+Possum:           7248 Bytes
+R2router:         3928 Bytes
+Rivet:            3064 Bytes
+Tango:            5168 Bytes
+TigerTonic:       9408 Bytes
+Traffic:         46400 Bytes
+Vulcan:          25544 Bytes
+```
+
+## ParseAPI Routes: 26
+
+```
+Gin:              7776 Bytes
+
+Ace:              6656 Bytes
+Aero:           163736 Bytes
+Bear:            12528 Bytes
+Beego:           19280 Bytes
+Bone:            11440 Bytes
+Chi:              9744 Bytes
+Denco:            4192 Bytes
+Echo:            11648 Bytes
+GocraftWeb:      12800 Bytes
+Goji:             5680 Bytes
+Gojiv2:          14464 Bytes
+GoJsonRest:      14424 Bytes
+GoRestful:      116264 Bytes
+GorillaMux:     105880 Bytes
+GowwwRouter:      9344 Bytes
+HttpRouter:       5024 Bytes
+HttpTreeMux:      7848 Bytes
+Kocha:          181712 Bytes
+LARS:             6632 Bytes
+Macaron:         13648 Bytes
+Martini:         45888 Bytes
+Pat:              2560 Bytes
+Possum:           9200 Bytes
+R2router:         7056 Bytes
+Rivet:            5680 Bytes
+Tango:            8920 Bytes
+TigerTonic:       9840 Bytes
+Traffic:         79096 Bytes
+Vulcan:          44504 Bytes
+```
+
+## Static Routes
+
+```
+BenchmarkGin_StaticAll                     25604             45487 ns/op               0 B/op          0 allocs/op
+
+BenchmarkAce_StaticAll                     28402             42046 ns/op               0 B/op          0 allocs/op
+BenchmarkAero_StaticAll                    38766             30333 ns/op               0 B/op          0 allocs/op
+BenchmarkHttpServeMux_StaticAll            25728             46511 ns/op               0 B/op          0 allocs/op
+BenchmarkBeego_StaticAll                    5098            288527 ns/op           55264 B/op        471 allocs/op
+BenchmarkBear_StaticAll                    10000            126323 ns/op           20272 B/op        469 allocs/op
+BenchmarkBone_StaticAll                     9499            113631 ns/op               0 B/op          0 allocs/op
+BenchmarkChi_StaticAll                      7912            237363 ns/op           67824 B/op        471 allocs/op
+BenchmarkCloudyKitRouter_StaticAll         41626             28668 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_StaticAll                   95774             12221 ns/op               0 B/op          0 allocs/op
+BenchmarkEcho_StaticAll                    26246             44603 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_StaticAll              10000            193337 ns/op           46312 B/op        785 allocs/op
+BenchmarkGoji_StaticAll                    15886             75789 ns/op               0 B/op          0 allocs/op
+BenchmarkGojiv2_StaticAll                   1886            597374 ns/op          205984 B/op       1570 allocs/op
+BenchmarkGoJsonRest_StaticAll               4700            307144 ns/op           51653 B/op       1727 allocs/op
+BenchmarkGoRestful_StaticAll                 429           2880165 ns/op          613280 B/op       2053 allocs/op
+BenchmarkGorillaMux_StaticAll                754           1491761 ns/op          153233 B/op       1413 allocs/op
+BenchmarkGowwwRouter_StaticAll             28071             42629 ns/op               0 B/op          0 allocs/op
+BenchmarkHttpRouter_StaticAll              47672             24875 ns/op               0 B/op          0 allocs/op
+BenchmarkHttpTreeMux_StaticAll             46770             25100 ns/op               0 B/op          0 allocs/op
+BenchmarkKocha_StaticAll                   61045             19494 ns/op               0 B/op          0 allocs/op
+BenchmarkLARS_StaticAll                    36103             32700 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_StaticAll                  4261            430131 ns/op          115552 B/op       1256 allocs/op
+BenchmarkMartini_StaticAll                   481           2320157 ns/op          125444 B/op       1717 allocs/op
+BenchmarkPat_StaticAll                       325           3739521 ns/op          602832 B/op      12559 allocs/op
+BenchmarkPossum_StaticAll                  10000            203575 ns/op           65312 B/op        471 allocs/op
+BenchmarkR2router_StaticAll                10000            110536 ns/op           22608 B/op        628 allocs/op
+BenchmarkRivet_StaticAll                   23344             51174 ns/op               0 B/op          0 allocs/op
+BenchmarkTango_StaticAll                    3596            340045 ns/op           39209 B/op       1256 allocs/op
+BenchmarkTigerTonic_StaticAll              16784             71807 ns/op            7376 B/op        157 allocs/op
+BenchmarkTraffic_StaticAll                   350           3435155 ns/op          754862 B/op      14601 allocs/op
+BenchmarkVulcan_StaticAll                   5930            200284 ns/op           15386 B/op        471 allocs/op
+```
+
+## Micro Benchmarks
+
+```
+BenchmarkGin_Param                       8623915               139 ns/op               0 B/op          0 allocs/op
+
+BenchmarkAce_Param                       3976539               290 ns/op              32 B/op          1 allocs/op
+BenchmarkAero_Param                      8948976               133 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_Param                      1000000              1277 ns/op             456 B/op          5 allocs/op
+BenchmarkBeego_Param                      889404              1785 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_Param                      1000000              2219 ns/op             816 B/op          6 allocs/op
+BenchmarkChi_Param                       1000000              1386 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_Param          18343244                61.2 ns/op             0 B/op          0 allocs/op
+BenchmarkDenco_Param                     5637424               204 ns/op              32 B/op          1 allocs/op
+BenchmarkEcho_Param                      9540910               122 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_Param                1000000              1939 ns/op             648 B/op          8 allocs/op
+BenchmarkGoji_Param                      1283509               938 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_Param                     331266              3554 ns/op            1328 B/op         11 allocs/op
+BenchmarkGoJsonRest_Param                 908851              2158 ns/op             649 B/op         13 allocs/op
+BenchmarkGoRestful_Param                  135781              9339 ns/op            4192 B/op         14 allocs/op
+BenchmarkGorillaMux_Param                 308407              3893 ns/op            1280 B/op         10 allocs/op
+BenchmarkGowwwRouter_Param               1000000              1044 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_Param                6653476               162 ns/op              32 B/op          1 allocs/op
+BenchmarkHttpTreeMux_Param               1361378               819 ns/op             352 B/op          3 allocs/op
+BenchmarkKocha_Param                     3084330               353 ns/op              56 B/op          3 allocs/op
+BenchmarkLARS_Param                     11502079               107 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_Param                    439095              3750 ns/op            1072 B/op         10 allocs/op
+BenchmarkMartini_Param                    177099              7479 ns/op            1072 B/op         10 allocs/op
+BenchmarkPat_Param                        729747              2048 ns/op             536 B/op         11 allocs/op
+BenchmarkPossum_Param                     995989              1705 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_Param                  1000000              1037 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_Param                     4057065               271 ns/op              48 B/op          1 allocs/op
+BenchmarkTango_Param                      812029              1682 ns/op             248 B/op          8 allocs/op
+BenchmarkTigerTonic_Param                 450592              3358 ns/op             776 B/op         16 allocs/op
+BenchmarkTraffic_Param                    206390              5661 ns/op            1856 B/op         21 allocs/op
+BenchmarkVulcan_Param                    1441147               792 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_Param5                      1891473               632 ns/op             160 B/op          1 allocs/op
+BenchmarkAero_Param5                     5191258               227 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_Param5                      988882              1734 ns/op             501 B/op          5 allocs/op
+BenchmarkBeego_Param5                     625438              2132 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_Param5                      622030              3061 ns/op             864 B/op          6 allocs/op
+BenchmarkChi_Param5                      1000000              1735 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_Param5          5167868               225 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_Param5                    2174550               550 ns/op             160 B/op          1 allocs/op
+BenchmarkEcho_Param5                     4272258               275 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_Param5                      4190391               275 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_Param5                623739              3107 ns/op             920 B/op         11 allocs/op
+BenchmarkGoji_Param5                     1000000              1310 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_Param5                    314694              3803 ns/op            1392 B/op         11 allocs/op
+BenchmarkGoJsonRest_Param5                308203              4108 ns/op            1097 B/op         16 allocs/op
+BenchmarkGoRestful_Param5                 115048              9787 ns/op            4288 B/op         14 allocs/op
+BenchmarkGorillaMux_Param5                180812              5658 ns/op            1344 B/op         10 allocs/op
+BenchmarkGowwwRouter_Param5              1000000              1156 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_Param5               2395767               502 ns/op             160 B/op          1 allocs/op
+BenchmarkHttpTreeMux_Param5               899263              2096 ns/op             576 B/op          6 allocs/op
+BenchmarkKocha_Param5                    1000000              1639 ns/op             440 B/op         10 allocs/op
+BenchmarkLARS_Param5                     5807994               203 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_Param5                   272967              4087 ns/op            1072 B/op         10 allocs/op
+BenchmarkMartini_Param5                   120735              8886 ns/op            1232 B/op         11 allocs/op
+BenchmarkPat_Param5                       294714              4943 ns/op             888 B/op         29 allocs/op
+BenchmarkPossum_Param5                   1000000              1689 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_Param5                 1000000              1319 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_Param5                    1347289               883 ns/op             240 B/op          1 allocs/op
+BenchmarkTango_Param5                     617077              2091 ns/op             360 B/op          8 allocs/op
+BenchmarkTigerTonic_Param5                113659             11212 ns/op            2279 B/op         39 allocs/op
+BenchmarkTraffic_Param5                   134148              9039 ns/op            2208 B/op         27 allocs/op
+BenchmarkVulcan_Param5                   1000000              1095 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_Param20                     1000000              1838 ns/op             640 B/op          1 allocs/op
+BenchmarkAero_Param20                   17120668                66.1 ns/op             0 B/op          0 allocs/op
+BenchmarkBear_Param20                     205585              5332 ns/op            1665 B/op          5 allocs/op
+BenchmarkBeego_Param20                    230522              5382 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_Param20                     167190              8076 ns/op            2031 B/op          6 allocs/op
+BenchmarkChi_Param20                      480528              3044 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_Param20         1347794               872 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_Param20                   1000000              1867 ns/op             640 B/op          1 allocs/op
+BenchmarkEcho_Param20                    1363526               897 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_Param20                     1607217               748 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_Param20                97314             11671 ns/op            3795 B/op         15 allocs/op
+BenchmarkGoji_Param20                     289407              4220 ns/op            1246 B/op          2 allocs/op
+BenchmarkGojiv2_Param20                   245186              4869 ns/op            1632 B/op         11 allocs/op
+BenchmarkGoJsonRest_Param20                78049             15725 ns/op            4485 B/op         20 allocs/op
+BenchmarkGoRestful_Param20                 66907             18031 ns/op            6716 B/op         18 allocs/op
+BenchmarkGorillaMux_Param20                81866             12422 ns/op            3452 B/op         12 allocs/op
+BenchmarkGowwwRouter_Param20              955983              1688 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_Param20              1000000              1629 ns/op             640 B/op          1 allocs/op
+BenchmarkHttpTreeMux_Param20              108940             10241 ns/op            3195 B/op         10 allocs/op
+BenchmarkKocha_Param20                    197022              5488 ns/op            1808 B/op         27 allocs/op
+BenchmarkLARS_Param20                    2451241               490 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_Param20                  106770             10788 ns/op            2923 B/op         12 allocs/op
+BenchmarkMartini_Param20                   69028             17112 ns/op            3596 B/op         13 allocs/op
+BenchmarkPat_Param20                       56275             21535 ns/op            4424 B/op         93 allocs/op
+BenchmarkPossum_Param20                  1000000              1705 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_Param20                 172215              7099 ns/op            2283 B/op          7 allocs/op
+BenchmarkRivet_Param20                    447265              2987 ns/op            1024 B/op          1 allocs/op
+BenchmarkTango_Param20                    327494              3850 ns/op             856 B/op          8 allocs/op
+BenchmarkTigerTonic_Param20                27176             44571 ns/op            9871 B/op        119 allocs/op
+BenchmarkTraffic_Param20                   38828             31025 ns/op            7856 B/op         47 allocs/op
+BenchmarkVulcan_Param20                   560442              1807 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_ParamWrite                  2712150               442 ns/op              40 B/op          2 allocs/op
+BenchmarkAero_ParamWrite                 6392880               189 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_ParamWrite                 1000000              1338 ns/op             456 B/op          5 allocs/op
+BenchmarkBeego_ParamWrite                 821431              1886 ns/op             360 B/op          4 allocs/op
+BenchmarkBone_ParamWrite                  913227              2350 ns/op             816 B/op          6 allocs/op
+BenchmarkChi_ParamWrite                  1000000              1427 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_ParamWrite     18645724                60.9 ns/op             0 B/op          0 allocs/op
+BenchmarkDenco_ParamWrite                4394764               264 ns/op              32 B/op          1 allocs/op
+BenchmarkEcho_ParamWrite                 5288883               242 ns/op               8 B/op          1 allocs/op
+BenchmarkGin_ParamWrite                  4584932               253 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_ParamWrite            866242              2094 ns/op             656 B/op          9 allocs/op
+BenchmarkGoji_ParamWrite                 1201875              1004 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_ParamWrite                317766              3777 ns/op            1360 B/op         13 allocs/op
+BenchmarkGoJsonRest_ParamWrite            380242              3447 ns/op            1128 B/op         18 allocs/op
+BenchmarkGoRestful_ParamWrite             131046              9340 ns/op            4200 B/op         15 allocs/op
+BenchmarkGorillaMux_ParamWrite            298428              3970 ns/op            1280 B/op         10 allocs/op
+BenchmarkGowwwRouter_ParamWrite           655940              2744 ns/op             976 B/op          8 allocs/op
+BenchmarkHttpRouter_ParamWrite           5237014               219 ns/op              32 B/op          1 allocs/op
+BenchmarkHttpTreeMux_ParamWrite          1379904               853 ns/op             352 B/op          3 allocs/op
+BenchmarkKocha_ParamWrite                2939042               400 ns/op              56 B/op          3 allocs/op
+BenchmarkLARS_ParamWrite                 6181642               199 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_ParamWrite               352497              4670 ns/op            1176 B/op         14 allocs/op
+BenchmarkMartini_ParamWrite               138259              8543 ns/op            1176 B/op         14 allocs/op
+BenchmarkPat_ParamWrite                   552386              3262 ns/op             960 B/op         15 allocs/op
+BenchmarkPossum_ParamWrite               1000000              1711 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_ParamWrite             1000000              1085 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_ParamWrite                2374513               489 ns/op             112 B/op          2 allocs/op
+BenchmarkTango_ParamWrite                1443907               812 ns/op             136 B/op          4 allocs/op
+BenchmarkTigerTonic_ParamWrite            324264              4874 ns/op            1216 B/op         21 allocs/op
+BenchmarkTraffic_ParamWrite               170726              7155 ns/op            2280 B/op         25 allocs/op
+BenchmarkVulcan_ParamWrite               1498888               776 ns/op              98 B/op          3 allocs/op
+
+```
+
+## GitHub
+
+```
+BenchmarkGin_GithubStatic                5866748               194 ns/op               0 B/op          0 allocs/op
+
+BenchmarkAce_GithubStatic                5815826               205 ns/op               0 B/op          0 allocs/op
+BenchmarkAero_GithubStatic              10822906               106 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_GithubStatic               1678065               707 ns/op             120 B/op          3 allocs/op
+BenchmarkBeego_GithubStatic               828814              1717 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_GithubStatic                 67484             18858 ns/op            2880 B/op         60 allocs/op
+BenchmarkCloudyKitRouter_GithubStatic   10219297               115 ns/op               0 B/op          0 allocs/op
+BenchmarkChi_GithubStatic                1000000              1348 ns/op             432 B/op          3 allocs/op
+BenchmarkDenco_GithubStatic             15220622                75.4 ns/op             0 B/op          0 allocs/op
+BenchmarkEcho_GithubStatic               7255897               158 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GithubStatic         1000000              1198 ns/op             296 B/op          5 allocs/op
+BenchmarkGoji_GithubStatic               3659361               320 ns/op               0 B/op          0 allocs/op
+BenchmarkGojiv2_GithubStatic              402402              3384 ns/op            1312 B/op         10 allocs/op
+BenchmarkGoRestful_GithubStatic            54592             22045 ns/op            4256 B/op         13 allocs/op
+BenchmarkGoJsonRest_GithubStatic          801067              1673 ns/op             329 B/op         11 allocs/op
+BenchmarkGorillaMux_GithubStatic          169690              8171 ns/op             976 B/op          9 allocs/op
+BenchmarkGowwwRouter_GithubStatic        5372910               218 ns/op               0 B/op          0 allocs/op
+BenchmarkHttpRouter_GithubStatic        10965576               103 ns/op               0 B/op          0 allocs/op
+BenchmarkHttpTreeMux_GithubStatic       10505365               106 ns/op               0 B/op          0 allocs/op
+BenchmarkKocha_GithubStatic             14153763                81.9 ns/op             0 B/op          0 allocs/op
+BenchmarkLARS_GithubStatic               7874017               152 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_GithubStatic             696940              2678 ns/op             736 B/op          8 allocs/op
+BenchmarkMartini_GithubStatic             102384             12276 ns/op             768 B/op          9 allocs/op
+BenchmarkPat_GithubStatic                  69907             17437 ns/op            3648 B/op         76 allocs/op
+BenchmarkPossum_GithubStatic             1000000              1262 ns/op             416 B/op          3 allocs/op
+BenchmarkR2router_GithubStatic           1981592               614 ns/op             144 B/op          4 allocs/op
+BenchmarkRivet_GithubStatic              6103872               196 ns/op               0 B/op          0 allocs/op
+BenchmarkTango_GithubStatic               629551              2023 ns/op             248 B/op          8 allocs/op
+BenchmarkTigerTonic_GithubStatic         2801569               424 ns/op              48 B/op          1 allocs/op
+BenchmarkTraffic_GithubStatic              63716             18009 ns/op            4664 B/op         90 allocs/op
+BenchmarkVulcan_GithubStatic              885640              1177 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_GithubParam                 2016942               582 ns/op              96 B/op          1 allocs/op
+BenchmarkAero_GithubParam                4009522               296 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_GithubParam                1000000              1575 ns/op             496 B/op          5 allocs/op
+BenchmarkBeego_GithubParam                796662              2038 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_GithubParam                 114823             10325 ns/op            1888 B/op         19 allocs/op
+BenchmarkChi_GithubParam                 1000000              1783 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_GithubParam     3910996               303 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_GithubParam               2298172               521 ns/op             128 B/op          1 allocs/op
+BenchmarkEcho_GithubParam                3336364               357 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_GithubParam                 2729161               439 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GithubParam           825784              2338 ns/op             712 B/op          9 allocs/op
+BenchmarkGoji_GithubParam                 933397              1559 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_GithubParam               253884              4335 ns/op            1408 B/op         13 allocs/op
+BenchmarkGoJsonRest_GithubParam           575532              2967 ns/op             713 B/op         14 allocs/op
+BenchmarkGoRestful_GithubParam             38160             30638 ns/op            4352 B/op         16 allocs/op
+BenchmarkGorillaMux_GithubParam            94554             12035 ns/op            1296 B/op         10 allocs/op
+BenchmarkGowwwRouter_GithubParam         1000000              1223 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_GithubParam          2562079               468 ns/op              96 B/op          1 allocs/op
+BenchmarkHttpTreeMux_GithubParam         1000000              1386 ns/op             384 B/op          4 allocs/op
+BenchmarkKocha_GithubParam               1573026               754 ns/op             128 B/op          5 allocs/op
+BenchmarkLARS_GithubParam                4203394               282 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_GithubParam              365078              4137 ns/op            1072 B/op         10 allocs/op
+BenchmarkMartini_GithubParam               71608             15811 ns/op            1152 B/op         11 allocs/op
+BenchmarkPat_GithubParam                   92768             13297 ns/op            2408 B/op         48 allocs/op
+BenchmarkPossum_GithubParam              1000000              1704 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_GithubParam            1000000              1120 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_GithubParam               1642794               720 ns/op              96 B/op          1 allocs/op
+BenchmarkTango_GithubParam                574195              2345 ns/op             344 B/op          8 allocs/op
+BenchmarkTigerTonic_GithubParam           272430              5493 ns/op            1176 B/op         22 allocs/op
+BenchmarkTraffic_GithubParam               81914             15078 ns/op            2816 B/op         40 allocs/op
+BenchmarkVulcan_GithubParam               581272              1902 ns/op              98 B/op          3 allocs/op
+
+
+BenchmarkAce_GithubAll                     10000            103571 ns/op           13792 B/op        167 allocs/op
+BenchmarkAero_GithubAll                    21366             55615 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_GithubAll                     5288            327648 ns/op           86448 B/op        943 allocs/op
+BenchmarkBeego_GithubAll                    3974            413453 ns/op           71456 B/op        609 allocs/op
+BenchmarkBone_GithubAll                      267           4450294 ns/op          720160 B/op       8620 allocs/op
+BenchmarkChi_GithubAll                      5067            358773 ns/op           87696 B/op        609 allocs/op
+BenchmarkCloudyKitRouter_GithubAll         24210             49233 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_GithubAll                   12508             95341 ns/op           20224 B/op        167 allocs/op
+BenchmarkEcho_GithubAll                    16353             73267 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_GithubAll                     15516             77716 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GithubAll               2908            466970 ns/op          131656 B/op       1686 allocs/op
+BenchmarkGoji_GithubAll                     1746            691392 ns/op           56112 B/op        334 allocs/op
+BenchmarkGojiv2_GithubAll                    954           1289604 ns/op          352720 B/op       4321 allocs/op
+BenchmarkGoJsonRest_GithubAll               2013            599088 ns/op          134371 B/op       2737 allocs/op
+BenchmarkGoRestful_GithubAll                 223           5404307 ns/op          910144 B/op       2938 allocs/op
+BenchmarkGorillaMux_GithubAll                202           5943565 ns/op          251650 B/op       1994 allocs/op
+BenchmarkGowwwRouter_GithubAll              9009            227799 ns/op           72144 B/op        501 allocs/op
+BenchmarkHttpRouter_GithubAll              14570             78718 ns/op           13792 B/op        167 allocs/op
+BenchmarkHttpTreeMux_GithubAll              7226            242491 ns/op           65856 B/op        671 allocs/op
+BenchmarkKocha_GithubAll                    8282            159873 ns/op           23304 B/op        843 allocs/op
+BenchmarkLARS_GithubAll                    22711             52745 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_GithubAll                  2067            563117 ns/op          149409 B/op       1624 allocs/op
+BenchmarkMartini_GithubAll                   218           5455290 ns/op          226552 B/op       2325 allocs/op
+BenchmarkPat_GithubAll                       174           6801582 ns/op         1483152 B/op      26963 allocs/op
+BenchmarkPossum_GithubAll                   8113            263665 ns/op           84448 B/op        609 allocs/op
+BenchmarkR2router_GithubAll                 7172            247198 ns/op           77328 B/op        979 allocs/op
+BenchmarkRivet_GithubAll                   10000            128086 ns/op           16272 B/op        167 allocs/op
+BenchmarkTango_GithubAll                    3316            472753 ns/op           63825 B/op       1618 allocs/op
+BenchmarkTigerTonic_GithubAll               1176           1041991 ns/op          193856 B/op       4474 allocs/op
+BenchmarkTraffic_GithubAll                   226           5312082 ns/op          820742 B/op      14114 allocs/op
+BenchmarkVulcan_GithubAll                   3904            304440 ns/op           19894 B/op        609 allocs/op
+```
+
+## Google+
+
+```
+BenchmarkGin_GPlusStatic                 9172405               124 ns/op               0 B/op          0 allocs/op
+
+BenchmarkAce_GPlusStatic                 7784710               152 ns/op               0 B/op          0 allocs/op
+BenchmarkAero_GPlusStatic               12771894                89.2 ns/op             0 B/op          0 allocs/op
+BenchmarkBear_GPlusStatic                2351325               512 ns/op             104 B/op          3 allocs/op
+BenchmarkBeego_GPlusStatic               1000000              1643 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_GPlusStatic                4419217               263 ns/op              32 B/op          1 allocs/op
+BenchmarkChi_GPlusStatic                 1000000              1282 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_GPlusStatic    17730754                61.9 ns/op             0 B/op          0 allocs/op
+BenchmarkDenco_GPlusStatic              29549895                38.3 ns/op             0 B/op          0 allocs/op
+BenchmarkEcho_GPlusStatic               10521789               111 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlusStatic          1000000              1053 ns/op             280 B/op          5 allocs/op
+BenchmarkGoji_GPlusStatic                5209968               228 ns/op               0 B/op          0 allocs/op
+BenchmarkGojiv2_GPlusStatic               306363              3348 ns/op            1312 B/op         10 allocs/op
+BenchmarkGoJsonRest_GPlusStatic          1000000              1424 ns/op             329 B/op         11 allocs/op
+BenchmarkGoRestful_GPlusStatic            130754              8760 ns/op            3872 B/op         13 allocs/op
+BenchmarkGorillaMux_GPlusStatic           496250              2860 ns/op             976 B/op          9 allocs/op
+BenchmarkGowwwRouter_GPlusStatic        16401519                66.5 ns/op             0 B/op          0 allocs/op
+BenchmarkHttpRouter_GPlusStatic         21323139                50.3 ns/op             0 B/op          0 allocs/op
+BenchmarkHttpTreeMux_GPlusStatic        14877926                68.7 ns/op             0 B/op          0 allocs/op
+BenchmarkKocha_GPlusStatic              18375128                57.6 ns/op             0 B/op          0 allocs/op
+BenchmarkLARS_GPlusStatic               11153810               101 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_GPlusStatic              652598              2720 ns/op             736 B/op          8 allocs/op
+BenchmarkMartini_GPlusStatic              218824              6532 ns/op             768 B/op          9 allocs/op
+BenchmarkPat_GPlusStatic                 2825560               428 ns/op              96 B/op          2 allocs/op
+BenchmarkPossum_GPlusStatic              1000000              1236 ns/op             416 B/op          3 allocs/op
+BenchmarkR2router_GPlusStatic            2222193               541 ns/op             144 B/op          4 allocs/op
+BenchmarkRivet_GPlusStatic               9802023               114 ns/op               0 B/op          0 allocs/op
+BenchmarkTango_GPlusStatic                980658              1465 ns/op             200 B/op          8 allocs/op
+BenchmarkTigerTonic_GPlusStatic          4882701               239 ns/op              32 B/op          1 allocs/op
+BenchmarkTraffic_GPlusStatic              508060              3465 ns/op            1112 B/op         16 allocs/op
+BenchmarkVulcan_GPlusStatic              1608979               725 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_GPlusParam                  2962957               414 ns/op              64 B/op          1 allocs/op
+BenchmarkAero_GPlusParam                 5667668               202 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_GPlusParam                 1000000              1271 ns/op             480 B/op          5 allocs/op
+BenchmarkBeego_GPlusParam                 869858              1874 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_GPlusParam                  869476              2395 ns/op             816 B/op          6 allocs/op
+BenchmarkChi_GPlusParam                  1000000              1469 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_GPlusParam     11149783               108 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_GPlusParam                4007298               301 ns/op              64 B/op          1 allocs/op
+BenchmarkEcho_GPlusParam                 6448201               174 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_GPlusParam                  5470827               218 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlusParam           1000000              1939 ns/op             648 B/op          8 allocs/op
+BenchmarkGoji_GPlusParam                 1207621               997 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_GPlusParam                271326              4013 ns/op            1328 B/op         11 allocs/op
+BenchmarkGoJsonRest_GPlusParam            781062              2303 ns/op             649 B/op         13 allocs/op
+BenchmarkGoRestful_GPlusParam             121267              9871 ns/op            4192 B/op         14 allocs/op
+BenchmarkGorillaMux_GPlusParam            228406              5156 ns/op            1280 B/op         10 allocs/op
+BenchmarkGowwwRouter_GPlusParam          1000000              1074 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_GPlusParam           4399740               276 ns/op              64 B/op          1 allocs/op
+BenchmarkHttpTreeMux_GPlusParam          1309540               898 ns/op             352 B/op          3 allocs/op
+BenchmarkKocha_GPlusParam                2930965               403 ns/op              56 B/op          3 allocs/op
+BenchmarkLARS_GPlusParam                 7588237               151 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_GPlusParam               434997              4195 ns/op            1072 B/op         10 allocs/op
+BenchmarkMartini_GPlusParam               148207              8144 ns/op            1072 B/op         10 allocs/op
+BenchmarkPat_GPlusParam                   566829              2533 ns/op             576 B/op         11 allocs/op
+BenchmarkPossum_GPlusParam               1000000              1723 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_GPlusParam             1000000              1100 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_GPlusParam                3309052               331 ns/op              48 B/op          1 allocs/op
+BenchmarkTango_GPlusParam                 693728              1825 ns/op             264 B/op          8 allocs/op
+BenchmarkTigerTonic_GPlusParam            417693              3800 ns/op             856 B/op         16 allocs/op
+BenchmarkTraffic_GPlusParam               179424              6641 ns/op            1872 B/op         21 allocs/op
+BenchmarkVulcan_GPlusParam               1000000              1063 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_GPlus2Params                2720149               460 ns/op              64 B/op          1 allocs/op
+BenchmarkAero_GPlus2Params               3525165               343 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_GPlus2Params               1000000              1502 ns/op             496 B/op          5 allocs/op
+BenchmarkBeego_GPlus2Params               730123              2102 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_GPlus2Params                253177              5583 ns/op            1168 B/op         10 allocs/op
+BenchmarkChi_GPlus2Params                1000000              1531 ns/op             432 B/op          3 allocs/op
+BenchmarkCloudyKitRouter_GPlus2Params    6943176               168 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_GPlus2Params              2912601               413 ns/op              64 B/op          1 allocs/op
+BenchmarkEcho_GPlus2Params               4149189               278 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_GPlus2Params                3271269               356 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlus2Params          915531              2321 ns/op             712 B/op          9 allocs/op
+BenchmarkGoji_GPlus2Params               1000000              1413 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_GPlus2Params              256640              4521 ns/op            1408 B/op         14 allocs/op
+BenchmarkGoJsonRest_GPlus2Params          499140              3076 ns/op             713 B/op         14 allocs/op
+BenchmarkGoRestful_GPlus2Params           105928             10148 ns/op            4384 B/op         16 allocs/op
+BenchmarkGorillaMux_GPlus2Params          110953              9682 ns/op            1296 B/op         10 allocs/op
+BenchmarkGowwwRouter_GPlus2Params        1000000              1112 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_GPlus2Params         3491893               321 ns/op              64 B/op          1 allocs/op
+BenchmarkHttpTreeMux_GPlus2Params        1000000              1341 ns/op             384 B/op          4 allocs/op
+BenchmarkKocha_GPlus2Params              1445288               790 ns/op             128 B/op          5 allocs/op
+BenchmarkLARS_GPlus2Params               6644953               185 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_GPlus2Params             424291              4321 ns/op            1072 B/op         10 allocs/op
+BenchmarkMartini_GPlus2Params              70866             16407 ns/op            1200 B/op         13 allocs/op
+BenchmarkPat_GPlus2Params                 121308             10221 ns/op            2168 B/op         33 allocs/op
+BenchmarkPossum_GPlus2Params             1000000              1847 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_GPlus2Params           1000000              1267 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_GPlus2Params              2017526               590 ns/op              96 B/op          1 allocs/op
+BenchmarkTango_GPlus2Params               846003              2143 ns/op             344 B/op          8 allocs/op
+BenchmarkTigerTonic_GPlus2Params          303597              5736 ns/op            1200 B/op         22 allocs/op
+BenchmarkTraffic_GPlus2Params              95032             12817 ns/op            2248 B/op         28 allocs/op
+BenchmarkVulcan_GPlus2Params              692610              1575 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_GPlusAll                     271720              4948 ns/op             640 B/op         11 allocs/op
+BenchmarkAero_GPlusAll                    367956              2926 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_GPlusAll                     68161             17883 ns/op            5488 B/op         61 allocs/op
+BenchmarkBeego_GPlusAll                    46634             25369 ns/op            4576 B/op         39 allocs/op
+BenchmarkBone_GPlusAll                     24628             49198 ns/op           11744 B/op        109 allocs/op
+BenchmarkChi_GPlusAll                      60778             19356 ns/op            5616 B/op         39 allocs/op
+BenchmarkCloudyKitRouter_GPlusAll         706952              1693 ns/op               0 B/op          0 allocs/op
+BenchmarkDenco_GPlusAll                   327422              4222 ns/op             672 B/op         11 allocs/op
+BenchmarkEcho_GPlusAll                    331987              3176 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_GPlusAll                     289526              3559 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_GPlusAll               45805             26768 ns/op            8040 B/op        103 allocs/op
+BenchmarkGoji_GPlusAll                     74786             14428 ns/op            3696 B/op         22 allocs/op
+BenchmarkGojiv2_GPlusAll                   23822             50355 ns/op           17616 B/op        154 allocs/op
+BenchmarkGoJsonRest_GPlusAll               35280             32989 ns/op            8117 B/op        170 allocs/op
+BenchmarkGoRestful_GPlusAll                10000            129418 ns/op           55520 B/op        192 allocs/op
+BenchmarkGorillaMux_GPlusAll               15968             76492 ns/op           16112 B/op        128 allocs/op
+BenchmarkGowwwRouter_GPlusAll             100096             12644 ns/op            4752 B/op         33 allocs/op
+BenchmarkHttpRouter_GPlusAll              474584              3704 ns/op             640 B/op         11 allocs/op
+BenchmarkHttpTreeMux_GPlusAll              98506             12480 ns/op            4032 B/op         38 allocs/op
+BenchmarkKocha_GPlusAll                   213709              7358 ns/op             976 B/op         43 allocs/op
+BenchmarkLARS_GPlusAll                    466608              2363 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_GPlusAll                  34136             35790 ns/op            9568 B/op        104 allocs/op
+BenchmarkMartini_GPlusAll                   8911            124543 ns/op           14016 B/op        145 allocs/op
+BenchmarkPat_GPlusAll                      17391             69198 ns/op           15264 B/op        271 allocs/op
+BenchmarkPossum_GPlusAll                   66774             17004 ns/op            5408 B/op         39 allocs/op
+BenchmarkR2router_GPlusAll                 79681             13996 ns/op            5040 B/op         63 allocs/op
+BenchmarkRivet_GPlusAll                   258788              5344 ns/op             768 B/op         11 allocs/op
+BenchmarkTango_GPlusAll                    46930             25591 ns/op            3656 B/op        104 allocs/op
+BenchmarkTigerTonic_GPlusAll               20768             58038 ns/op           11600 B/op        242 allocs/op
+BenchmarkTraffic_GPlusAll                  10000            108031 ns/op           26248 B/op        341 allocs/op
+BenchmarkVulcan_GPlusAll                   71826             15724 ns/op            1274 B/op         39 allocs/op
+```
+
+## Parse.com
+
+```
+BenchmarkGin_ParseStatic                 8683893               140 ns/op               0 B/op          0 allocs/op
+
+BenchmarkAce_ParseStatic                 7255582               160 ns/op               0 B/op          0 allocs/op
+BenchmarkAero_ParseStatic               11960128                95.0 ns/op             0 B/op          0 allocs/op
+BenchmarkBear_ParseStatic                1791033               659 ns/op             120 B/op          3 allocs/op
+BenchmarkBeego_ParseStatic                937918              1688 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_ParseStatic                1261682               949 ns/op             144 B/op          3 allocs/op
+BenchmarkChi_ParseStatic                 1000000              1303 ns/op             432 B/op          3 allocs/op
+BenchmarkDenco_ParseStatic              23731242                49.8 ns/op             0 B/op          0 allocs/op
+BenchmarkEcho_ParseStatic               10585060               116 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_ParseStatic          1000000              1156 ns/op             296 B/op          5 allocs/op
+BenchmarkGoji_ParseStatic                3927530               300 ns/op               0 B/op          0 allocs/op
+BenchmarkGojiv2_ParseStatic               474836              3281 ns/op            1312 B/op         10 allocs/op
+BenchmarkGoJsonRest_ParseStatic          1000000              1445 ns/op             329 B/op         11 allocs/op
+BenchmarkGoRestful_ParseStatic            101262             11612 ns/op            4256 B/op         13 allocs/op
+BenchmarkGorillaMux_ParseStatic           562705              3530 ns/op             976 B/op          9 allocs/op
+BenchmarkGowwwRouter_ParseStatic        16479007                69.5 ns/op             0 B/op          0 allocs/op
+BenchmarkHttpRouter_ParseStatic         23205590                51.5 ns/op             0 B/op          0 allocs/op
+BenchmarkHttpTreeMux_ParseStatic        10763127               106 ns/op               0 B/op          0 allocs/op
+BenchmarkKocha_ParseStatic              17850259                60.9 ns/op             0 B/op          0 allocs/op
+BenchmarkLARS_ParseStatic               10727432               108 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_ParseStatic              685586              2665 ns/op             736 B/op          8 allocs/op
+BenchmarkMartini_ParseStatic              200642              7158 ns/op             768 B/op          9 allocs/op
+BenchmarkPat_ParseStatic                 1000000              1139 ns/op             240 B/op          5 allocs/op
+BenchmarkPossum_ParseStatic              1000000              1241 ns/op             416 B/op          3 allocs/op
+BenchmarkR2router_ParseStatic            2035426               597 ns/op             144 B/op          4 allocs/op
+BenchmarkRivet_ParseStatic               9707011               127 ns/op               0 B/op          0 allocs/op
+BenchmarkTango_ParseStatic                910617              1693 ns/op             248 B/op          8 allocs/op
+BenchmarkTigerTonic_ParseStatic          3168885               385 ns/op              48 B/op          1 allocs/op
+BenchmarkTraffic_ParseStatic              493339              4264 ns/op            1256 B/op         19 allocs/op
+BenchmarkVulcan_ParseStatic              1394142               848 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_ParseParam                  3106903               387 ns/op              64 B/op          1 allocs/op
+BenchmarkAero_ParseParam                 8045266               141 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_ParseParam                 1000000              1434 ns/op             467 B/op          5 allocs/op
+BenchmarkBeego_ParseParam                 951460              1937 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_ParseParam                  855555              2776 ns/op             896 B/op          7 allocs/op
+BenchmarkChi_ParseParam                  1000000              1457 ns/op             432 B/op          3 allocs/op
+BenchmarkDenco_ParseParam                4084116               301 ns/op              64 B/op          1 allocs/op
+BenchmarkEcho_ParseParam                 8440170               142 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_ParseParam                  7716948               157 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_ParseParam            886284              2045 ns/op             664 B/op          8 allocs/op
+BenchmarkGoji_ParseParam                 1000000              1167 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_ParseParam                269731              3945 ns/op            1360 B/op         12 allocs/op
+BenchmarkGoJsonRest_ParseParam            719587              2277 ns/op             649 B/op         13 allocs/op
+BenchmarkGoRestful_ParseParam              96408             11925 ns/op            4576 B/op         14 allocs/op
+BenchmarkGorillaMux_ParseParam            289303              4154 ns/op            1280 B/op         10 allocs/op
+BenchmarkGowwwRouter_ParseParam          1000000              1070 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_ParseParam           4917758               232 ns/op              64 B/op          1 allocs/op
+BenchmarkHttpTreeMux_ParseParam          1445443               828 ns/op             352 B/op          3 allocs/op
+BenchmarkKocha_ParseParam                3116233               382 ns/op              56 B/op          3 allocs/op
+BenchmarkLARS_ParseParam                10584750               113 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_ParseParam               413617              3872 ns/op            1072 B/op         10 allocs/op
+BenchmarkMartini_ParseParam               166545              7605 ns/op            1072 B/op         10 allocs/op
+BenchmarkPat_ParseParam                   491829              3394 ns/op             992 B/op         15 allocs/op
+BenchmarkPossum_ParseParam               1000000              1692 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_ParseParam             1000000              1059 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_ParseParam                3572359               311 ns/op              48 B/op          1 allocs/op
+BenchmarkTango_ParseParam                 787552              1889 ns/op             280 B/op          8 allocs/op
+BenchmarkTigerTonic_ParseParam            487208              3706 ns/op             784 B/op         15 allocs/op
+BenchmarkTraffic_ParseParam               186190              5812 ns/op            1896 B/op         21 allocs/op
+BenchmarkVulcan_ParseParam               1275432               892 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_Parse2Params                2959621               412 ns/op              64 B/op          1 allocs/op
+BenchmarkAero_Parse2Params               6208641               192 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_Parse2Params               1000000              1512 ns/op             496 B/op          5 allocs/op
+BenchmarkBeego_Parse2Params               761940              1973 ns/op             352 B/op          3 allocs/op
+BenchmarkBone_Parse2Params                715987              2582 ns/op             848 B/op          6 allocs/op
+BenchmarkChi_Parse2Params                1000000              1495 ns/op             432 B/op          3 allocs/op
+BenchmarkDenco_Parse2Params              3585452               341 ns/op              64 B/op          1 allocs/op
+BenchmarkEcho_Parse2Params               5193693               204 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_Parse2Params                5338316               236 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_Parse2Params          939637              2299 ns/op             712 B/op          9 allocs/op
+BenchmarkGoji_Parse2Params               1000000              1094 ns/op             336 B/op          2 allocs/op
+BenchmarkGojiv2_Parse2Params              339514              3733 ns/op            1344 B/op         11 allocs/op
+BenchmarkGoJsonRest_Parse2Params          512572              2733 ns/op             713 B/op         14 allocs/op
+BenchmarkGoRestful_Parse2Params            95913             12973 ns/op            4928 B/op         14 allocs/op
+BenchmarkGorillaMux_Parse2Params          261208              4758 ns/op            1296 B/op         10 allocs/op
+BenchmarkGowwwRouter_Parse2Params        1000000              1084 ns/op             432 B/op          3 allocs/op
+BenchmarkHttpRouter_Parse2Params         4399953               277 ns/op              64 B/op          1 allocs/op
+BenchmarkHttpTreeMux_Parse2Params        1000000              1198 ns/op             384 B/op          4 allocs/op
+BenchmarkKocha_Parse2Params              1669431               683 ns/op             128 B/op          5 allocs/op
+BenchmarkLARS_Parse2Params               8535754               142 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_Parse2Params             424590              3959 ns/op            1072 B/op         10 allocs/op
+BenchmarkMartini_Parse2Params             162448              8141 ns/op            1152 B/op         11 allocs/op
+BenchmarkPat_Parse2Params                 431336              3484 ns/op             752 B/op         16 allocs/op
+BenchmarkPossum_Parse2Params             1000000              1721 ns/op             496 B/op          5 allocs/op
+BenchmarkR2router_Parse2Params           1000000              1136 ns/op             432 B/op          5 allocs/op
+BenchmarkRivet_Parse2Params              2630935               442 ns/op              96 B/op          1 allocs/op
+BenchmarkTango_Parse2Params               759218              1876 ns/op             312 B/op          8 allocs/op
+BenchmarkTigerTonic_Parse2Params          290810              5558 ns/op            1168 B/op         22 allocs/op
+BenchmarkTraffic_Parse2Params             181099              6917 ns/op            1944 B/op         22 allocs/op
+BenchmarkVulcan_Parse2Params             1000000              1080 ns/op              98 B/op          3 allocs/op
+
+BenchmarkAce_ParseAll                     162906              7888 ns/op             640 B/op         16 allocs/op
+BenchmarkAero_ParseAll                    219260              4833 ns/op               0 B/op          0 allocs/op
+BenchmarkBear_ParseAll                     37566             32863 ns/op            8928 B/op        110 allocs/op
+BenchmarkBeego_ParseAll                    25400             46518 ns/op            9152 B/op         78 allocs/op
+BenchmarkBone_ParseAll                     19568             61814 ns/op           16208 B/op        147 allocs/op
+BenchmarkChi_ParseAll                      30562             38281 ns/op           11232 B/op         78 allocs/op
+BenchmarkDenco_ParseAll                   232554              6371 ns/op             928 B/op         16 allocs/op
+BenchmarkEcho_ParseAll                    224400              5090 ns/op               0 B/op          0 allocs/op
+BenchmarkGin_ParseAll                     189829              6134 ns/op               0 B/op          0 allocs/op
+BenchmarkGocraftWeb_ParseAll               25446             47000 ns/op           13728 B/op        181 allocs/op
+BenchmarkGoji_ParseAll                     50503             22949 ns/op            5376 B/op         32 allocs/op
+BenchmarkGojiv2_ParseAll                   12806             93106 ns/op           34448 B/op        277 allocs/op
+BenchmarkGoJsonRest_ParseAll               20764             57021 ns/op           13866 B/op        321 allocs/op
+BenchmarkGoRestful_ParseAll                 4234            317238 ns/op          117600 B/op        354 allocs/op
+BenchmarkGorillaMux_ParseAll               10000            146942 ns/op           30288 B/op        250 allocs/op
+BenchmarkGowwwRouter_ParseAll              62548             19363 ns/op            6912 B/op         48 allocs/op
+BenchmarkHttpRouter_ParseAll              286662              5091 ns/op             640 B/op         16 allocs/op
+BenchmarkHttpTreeMux_ParseAll              66952             18262 ns/op            5728 B/op         51 allocs/op
+BenchmarkKocha_ParseAll                   109771              9811 ns/op            1112 B/op         54 allocs/op
+BenchmarkLARS_ParseAll                    272516              3976 ns/op               0 B/op          0 allocs/op
+BenchmarkMacaron_ParseAll                  17094             71634 ns/op           19136 B/op        208 allocs/op
+BenchmarkMartini_ParseAll                   6799            208122 ns/op           25072 B/op        253 allocs/op
+BenchmarkPat_ParseAll                      15993             74594 ns/op           15216 B/op        308 allocs/op
+BenchmarkPossum_ParseAll                   34897             33398 ns/op           10816 B/op         78 allocs/op
+BenchmarkR2router_ParseAll                 46909             25410 ns/op            8352 B/op        120 allocs/op
+BenchmarkRivet_ParseAll                   185193              7725 ns/op             912 B/op         16 allocs/op
+BenchmarkTango_ParseAll                    24481             47963 ns/op            7168 B/op        208 allocs/op
+BenchmarkTigerTonic_ParseAll               15236             79623 ns/op           16048 B/op        332 allocs/op
+BenchmarkTraffic_ParseAll                   8955            169411 ns/op           45520 B/op        605 allocs/op
+BenchmarkVulcan_ParseAll                   40406             28971 ns/op            2548 B/op         78 allocs/op
+```

vendor/github.com/gin-gonic/gin/CHANGELOG.md

@@ -0,0 +1,373 @@
+# Gin ChangeLog
+
+## Gin v1.6.3
+
+### ENHANCEMENTS
+
+  * Improve performance: Change `*sync.RWMutex` to `sync.RWMutex` in context. [#2351](https://github.com/gin-gonic/gin/pull/2351)
+
+## Gin v1.6.2
+
+### BUFIXES
+  * fix missing initial sync.RWMutex [#2305](https://github.com/gin-gonic/gin/pull/2305)
+### ENHANCEMENTS
+  * Add set samesite in cookie. [#2306](https://github.com/gin-gonic/gin/pull/2306)
+
+## Gin v1.6.1
+
+### BUFIXES
+  * Revert "fix accept incoming network connections" [#2294](https://github.com/gin-gonic/gin/pull/2294)
+
+## Gin v1.6.0
+
+### BREAKING
+  * chore(performance): Improve performance for adding RemoveExtraSlash flag [#2159](https://github.com/gin-gonic/gin/pull/2159)
+  * drop support govendor [#2148](https://github.com/gin-gonic/gin/pull/2148)
+  * Added support for SameSite cookie flag [#1615](https://github.com/gin-gonic/gin/pull/1615)
+### FEATURES
+  * add yaml negotitation [#2220](https://github.com/gin-gonic/gin/pull/2220)
+  * FileFromFS [#2112](https://github.com/gin-gonic/gin/pull/2112)
+### BUGFIXES
+  * Unix Socket Handling [#2280](https://github.com/gin-gonic/gin/pull/2280)
+  * Use json marshall in context json to fix breaking new line issue. Fixes #2209 [#2228](https://github.com/gin-gonic/gin/pull/2228)
+  * fix accept incoming network connections [#2216](https://github.com/gin-gonic/gin/pull/2216)
+  * Fixed a bug in the calculation of the maximum number of parameters [#2166](https://github.com/gin-gonic/gin/pull/2166)
+  * [FIX] allow empty headers on DataFromReader [#2121](https://github.com/gin-gonic/gin/pull/2121)
+  * Add mutex for protect Context.Keys map [#1391](https://github.com/gin-gonic/gin/pull/1391)
+### ENHANCEMENTS
+  * Add mitigation for log injection [#2277](https://github.com/gin-gonic/gin/pull/2277)
+  * tree: range over nodes values [#2229](https://github.com/gin-gonic/gin/pull/2229)
+  * tree: remove duplicate assignment [#2222](https://github.com/gin-gonic/gin/pull/2222)
+  * chore: upgrade go-isatty and json-iterator/go [#2215](https://github.com/gin-gonic/gin/pull/2215)
+  * path: sync code with httprouter [#2212](https://github.com/gin-gonic/gin/pull/2212)
+  * Use zero-copy approach to convert types between string and byte slice [#2206](https://github.com/gin-gonic/gin/pull/2206)
+  * Reuse bytes when cleaning the URL paths [#2179](https://github.com/gin-gonic/gin/pull/2179)
+  * tree: remove one else statement [#2177](https://github.com/gin-gonic/gin/pull/2177)
+  * tree: sync httprouter update (#2173) (#2172) [#2171](https://github.com/gin-gonic/gin/pull/2171)
+  * tree: sync part httprouter codes and reduce if/else [#2163](https://github.com/gin-gonic/gin/pull/2163)
+  * use http method constant [#2155](https://github.com/gin-gonic/gin/pull/2155)
+  * upgrade go-validator to v10 [#2149](https://github.com/gin-gonic/gin/pull/2149)
+  * Refactor redirect request in gin.go [#1970](https://github.com/gin-gonic/gin/pull/1970)
+  * Add build tag nomsgpack [#1852](https://github.com/gin-gonic/gin/pull/1852)
+### DOCS
+  * docs(path): improve comments [#2223](https://github.com/gin-gonic/gin/pull/2223)
+  * Renew README to fit the modification of SetCookie method [#2217](https://github.com/gin-gonic/gin/pull/2217)
+  * Fix spelling [#2202](https://github.com/gin-gonic/gin/pull/2202)
+  * Remove broken link from README. [#2198](https://github.com/gin-gonic/gin/pull/2198)
+  * Update docs on Context.Done(), Context.Deadline() and Context.Err() [#2196](https://github.com/gin-gonic/gin/pull/2196)
+  * Update validator to v10 [#2190](https://github.com/gin-gonic/gin/pull/2190)
+  * upgrade go-validator to v10 for README [#2189](https://github.com/gin-gonic/gin/pull/2189)
+  * Update to currently output [#2188](https://github.com/gin-gonic/gin/pull/2188)
+  * Fix "Custom Validators" example [#2186](https://github.com/gin-gonic/gin/pull/2186)
+  * Add project to README [#2165](https://github.com/gin-gonic/gin/pull/2165)
+  * docs(benchmarks): for gin v1.5 [#2153](https://github.com/gin-gonic/gin/pull/2153)
+  * Changed wording for clarity in README.md [#2122](https://github.com/gin-gonic/gin/pull/2122)
+### MISC
+  * ci support go1.14 [#2262](https://github.com/gin-gonic/gin/pull/2262)
+  * chore: upgrade depend version [#2231](https://github.com/gin-gonic/gin/pull/2231)
+  * Drop support go1.10 [#2147](https://github.com/gin-gonic/gin/pull/2147)
+  * fix comment in `mode.go` [#2129](https://github.com/gin-gonic/gin/pull/2129)
+
+## Gin v1.5.0
+
+- [FIX] Use DefaultWriter and DefaultErrorWriter for debug messages [#1891](https://github.com/gin-gonic/gin/pull/1891)
+- [NEW] Now you can parse the inline lowercase start structure [#1893](https://github.com/gin-gonic/gin/pull/1893)
+- [FIX] Some code improvements [#1909](https://github.com/gin-gonic/gin/pull/1909)
+- [FIX] Use encode replace json marshal increase json encoder speed [#1546](https://github.com/gin-gonic/gin/pull/1546)
+- [NEW] Hold matched route full path in the Context [#1826](https://github.com/gin-gonic/gin/pull/1826)
+- [FIX] Fix context.Params race condition on Copy() [#1841](https://github.com/gin-gonic/gin/pull/1841)
+- [NEW] Add context param query cache [#1450](https://github.com/gin-gonic/gin/pull/1450)
+- [FIX] Improve GetQueryMap performance [#1918](https://github.com/gin-gonic/gin/pull/1918)
+- [FIX] Improve get post data [#1920](https://github.com/gin-gonic/gin/pull/1920)
+- [FIX] Use context instead of x/net/context [#1922](https://github.com/gin-gonic/gin/pull/1922)
+- [FIX] Attempt to fix PostForm cache bug [#1931](https://github.com/gin-gonic/gin/pull/1931)
+- [NEW] Add support of multipart multi files [#1949](https://github.com/gin-gonic/gin/pull/1949)
+- [NEW] Support bind http header param [#1957](https://github.com/gin-gonic/gin/pull/1957)
+- [FIX] Drop support for go1.8 and go1.9 [#1933](https://github.com/gin-gonic/gin/pull/1933)
+- [FIX] Bugfix for the FullPath feature [#1919](https://github.com/gin-gonic/gin/pull/1919)
+- [FIX] Gin1.5 bytes.Buffer to strings.Builder [#1939](https://github.com/gin-gonic/gin/pull/1939)
+- [FIX] Upgrade github.com/ugorji/go/codec [#1969](https://github.com/gin-gonic/gin/pull/1969)
+- [NEW] Support bind unix time [#1980](https://github.com/gin-gonic/gin/pull/1980)
+- [FIX] Simplify code [#2004](https://github.com/gin-gonic/gin/pull/2004)
+- [NEW] Support negative Content-Length in DataFromReader [#1981](https://github.com/gin-gonic/gin/pull/1981)
+- [FIX] Identify terminal on a RISC-V architecture for auto-colored logs [#2019](https://github.com/gin-gonic/gin/pull/2019)
+- [BREAKING] `Context.JSONP()` now expects a semicolon (`;`) at the end [#2007](https://github.com/gin-gonic/gin/pull/2007)
+- [BREAKING] Upgrade default `binding.Validator` to v9 (see [its changelog](https://github.com/go-playground/validator/releases/tag/v9.0.0)) [#1015](https://github.com/gin-gonic/gin/pull/1015)
+- [NEW] Add `DisallowUnknownFields()` in `Context.BindJSON()` [#2028](https://github.com/gin-gonic/gin/pull/2028)
+- [NEW] Use specific `net.Listener` with `Engine.RunListener()` [#2023](https://github.com/gin-gonic/gin/pull/2023)
+- [FIX] Fix some typo [#2079](https://github.com/gin-gonic/gin/pull/2079) [#2080](https://github.com/gin-gonic/gin/pull/2080)
+- [FIX] Relocate binding body tests [#2086](https://github.com/gin-gonic/gin/pull/2086)
+- [FIX] Use Writer in Context.Status [#1606](https://github.com/gin-gonic/gin/pull/1606)
+- [FIX] `Engine.RunUnix()` now returns the error if it can't change the file mode [#2093](https://github.com/gin-gonic/gin/pull/2093)
+- [FIX] `RouterGroup.StaticFS()` leaked files. Now it closes them. [#2118](https://github.com/gin-gonic/gin/pull/2118)
+- [FIX] `Context.Request.FormFile` leaked file. Now it closes it. [#2114](https://github.com/gin-gonic/gin/pull/2114)
+- [FIX] Ignore walking on `form:"-"` mapping [#1943](https://github.com/gin-gonic/gin/pull/1943)
+
+### Gin v1.4.0
+
+- [NEW] Support for [Go Modules](https://github.com/golang/go/wiki/Modules)  [#1569](https://github.com/gin-gonic/gin/pull/1569)
+- [NEW] Refactor of form mapping multipart request [#1829](https://github.com/gin-gonic/gin/pull/1829)
+- [FIX] Truncate Latency precision in long running request [#1830](https://github.com/gin-gonic/gin/pull/1830)
+- [FIX] IsTerm flag should not be affected by DisableConsoleColor method. [#1802](https://github.com/gin-gonic/gin/pull/1802)
+- [NEW] Supporting file binding [#1264](https://github.com/gin-gonic/gin/pull/1264)
+- [NEW] Add support for mapping arrays [#1797](https://github.com/gin-gonic/gin/pull/1797)
+- [FIX] Readme updates [#1793](https://github.com/gin-gonic/gin/pull/1793) [#1788](https://github.com/gin-gonic/gin/pull/1788) [1789](https://github.com/gin-gonic/gin/pull/1789)
+- [FIX] StaticFS: Fixed Logging two log lines on 404.  [#1805](https://github.com/gin-gonic/gin/pull/1805), [#1804](https://github.com/gin-gonic/gin/pull/1804)
+- [NEW] Make context.Keys available as LogFormatterParams [#1779](https://github.com/gin-gonic/gin/pull/1779)
+- [NEW] Use internal/json for Marshal/Unmarshal [#1791](https://github.com/gin-gonic/gin/pull/1791)
+- [NEW] Support mapping time.Duration [#1794](https://github.com/gin-gonic/gin/pull/1794)
+- [NEW] Refactor form mappings [#1749](https://github.com/gin-gonic/gin/pull/1749)
+- [NEW] Added flag to context.Stream indicates if client disconnected in middle of stream [#1252](https://github.com/gin-gonic/gin/pull/1252)
+- [FIX] Moved [examples](https://github.com/gin-gonic/examples) to stand alone Repo [#1775](https://github.com/gin-gonic/gin/pull/1775)
+- [NEW] Extend context.File to allow for the content-disposition attachments via a new method context.Attachment [#1260](https://github.com/gin-gonic/gin/pull/1260)
+- [FIX] Support HTTP content negotiation wildcards [#1112](https://github.com/gin-gonic/gin/pull/1112)
+- [NEW] Add prefix from X-Forwarded-Prefix in redirectTrailingSlash [#1238](https://github.com/gin-gonic/gin/pull/1238)
+- [FIX] context.Copy() race condition [#1020](https://github.com/gin-gonic/gin/pull/1020)
+- [NEW] Add context.HandlerNames() [#1729](https://github.com/gin-gonic/gin/pull/1729)
+- [FIX] Change color methods to public in the defaultLogger. [#1771](https://github.com/gin-gonic/gin/pull/1771)
+- [FIX] Update writeHeaders method to use http.Header.Set [#1722](https://github.com/gin-gonic/gin/pull/1722)
+- [NEW] Add response size to LogFormatterParams [#1752](https://github.com/gin-gonic/gin/pull/1752)
+- [NEW] Allow ignoring field on form mapping [#1733](https://github.com/gin-gonic/gin/pull/1733)
+- [NEW] Add a function to force color in console output. [#1724](https://github.com/gin-gonic/gin/pull/1724)
+- [FIX] Context.Next() - recheck len of handlers on every iteration. [#1745](https://github.com/gin-gonic/gin/pull/1745)
+- [FIX] Fix all errcheck warnings [#1739](https://github.com/gin-gonic/gin/pull/1739) [#1653](https://github.com/gin-gonic/gin/pull/1653)
+- [NEW] context: inherits context cancellation and deadline from http.Request context for Go>=1.7 [#1690](https://github.com/gin-gonic/gin/pull/1690)
+- [NEW] Binding for URL Params [#1694](https://github.com/gin-gonic/gin/pull/1694)
+- [NEW] Add LoggerWithFormatter method [#1677](https://github.com/gin-gonic/gin/pull/1677)
+- [FIX] CI testing updates [#1671](https://github.com/gin-gonic/gin/pull/1671) [#1670](https://github.com/gin-gonic/gin/pull/1670) [#1682](https://github.com/gin-gonic/gin/pull/1682) [#1669](https://github.com/gin-gonic/gin/pull/1669)
+- [FIX] StaticFS(): Send 404 when path does not exist [#1663](https://github.com/gin-gonic/gin/pull/1663)
+- [FIX] Handle nil body for JSON binding [#1638](https://github.com/gin-gonic/gin/pull/1638)
+- [FIX] Support bind uri param [#1612](https://github.com/gin-gonic/gin/pull/1612)
+- [FIX] recovery: fix issue with syscall import on google app engine [#1640](https://github.com/gin-gonic/gin/pull/1640)
+- [FIX] Make sure the debug log contains line breaks [#1650](https://github.com/gin-gonic/gin/pull/1650)
+- [FIX] Panic stack trace being printed during recovery of broken pipe [#1089](https://github.com/gin-gonic/gin/pull/1089) [#1259](https://github.com/gin-gonic/gin/pull/1259)
+- [NEW] RunFd method to run http.Server through a file descriptor [#1609](https://github.com/gin-gonic/gin/pull/1609)
+- [NEW] Yaml binding support [#1618](https://github.com/gin-gonic/gin/pull/1618)
+- [FIX] Pass MaxMultipartMemory when FormFile is called [#1600](https://github.com/gin-gonic/gin/pull/1600)
+- [FIX] LoadHTML* tests [#1559](https://github.com/gin-gonic/gin/pull/1559)
+- [FIX] Removed use of sync.pool from HandleContext [#1565](https://github.com/gin-gonic/gin/pull/1565)
+- [FIX] Format output log to os.Stderr [#1571](https://github.com/gin-gonic/gin/pull/1571)
+- [FIX] Make logger use a yellow background and a darkgray text for legibility [#1570](https://github.com/gin-gonic/gin/pull/1570)
+- [FIX] Remove sensitive request information from panic log. [#1370](https://github.com/gin-gonic/gin/pull/1370)
+- [FIX] log.Println() does not print timestamp [#829](https://github.com/gin-gonic/gin/pull/829) [#1560](https://github.com/gin-gonic/gin/pull/1560)
+- [NEW] Add PureJSON renderer [#694](https://github.com/gin-gonic/gin/pull/694)
+- [FIX] Add missing copyright and update if/else [#1497](https://github.com/gin-gonic/gin/pull/1497)
+- [FIX] Update msgpack usage [#1498](https://github.com/gin-gonic/gin/pull/1498)
+- [FIX] Use protobuf on render [#1496](https://github.com/gin-gonic/gin/pull/1496)
+- [FIX] Add support for Protobuf format response [#1479](https://github.com/gin-gonic/gin/pull/1479)
+- [NEW] Set default time format in form binding [#1487](https://github.com/gin-gonic/gin/pull/1487)
+- [FIX] Add BindXML and ShouldBindXML [#1485](https://github.com/gin-gonic/gin/pull/1485)
+- [NEW] Upgrade dependency libraries [#1491](https://github.com/gin-gonic/gin/pull/1491)
+
+
+## Gin v1.3.0
+
+- [NEW] Add [`func (*Context) QueryMap`](https://godoc.org/github.com/gin-gonic/gin#Context.QueryMap), [`func (*Context) GetQueryMap`](https://godoc.org/github.com/gin-gonic/gin#Context.GetQueryMap), [`func (*Context) PostFormMap`](https://godoc.org/github.com/gin-gonic/gin#Context.PostFormMap) and [`func (*Context) GetPostFormMap`](https://godoc.org/github.com/gin-gonic/gin#Context.GetPostFormMap) to support `type map[string]string` as query string or form parameters, see [#1383](https://github.com/gin-gonic/gin/pull/1383)
+- [NEW] Add [`func (*Context) AsciiJSON`](https://godoc.org/github.com/gin-gonic/gin#Context.AsciiJSON), see [#1358](https://github.com/gin-gonic/gin/pull/1358)
+- [NEW] Add `Pusher()` in [`type ResponseWriter`](https://godoc.org/github.com/gin-gonic/gin#ResponseWriter) for supporting http2 push, see [#1273](https://github.com/gin-gonic/gin/pull/1273)
+- [NEW] Add [`func (*Context) DataFromReader`](https://godoc.org/github.com/gin-gonic/gin#Context.DataFromReader) for serving dynamic data, see [#1304](https://github.com/gin-gonic/gin/pull/1304)
+- [NEW] Add [`func (*Context) ShouldBindBodyWith`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBindBodyWith) allowing to call binding multiple times, see [#1341](https://github.com/gin-gonic/gin/pull/1341)
+- [NEW] Support pointers in form binding, see [#1336](https://github.com/gin-gonic/gin/pull/1336)
+- [NEW] Add [`func (*Context) JSONP`](https://godoc.org/github.com/gin-gonic/gin#Context.JSONP), see [#1333](https://github.com/gin-gonic/gin/pull/1333)
+- [NEW] Support default value in form binding, see [#1138](https://github.com/gin-gonic/gin/pull/1138)
+- [NEW] Expose validator engine in [`type StructValidator`](https://godoc.org/github.com/gin-gonic/gin/binding#StructValidator), see [#1277](https://github.com/gin-gonic/gin/pull/1277)
+- [NEW] Add [`func (*Context) ShouldBind`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBind), [`func (*Context) ShouldBindQuery`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBindQuery) and [`func (*Context) ShouldBindJSON`](https://godoc.org/github.com/gin-gonic/gin#Context.ShouldBindJSON), see [#1047](https://github.com/gin-gonic/gin/pull/1047)
+- [NEW] Add support for `time.Time` location in form binding, see [#1117](https://github.com/gin-gonic/gin/pull/1117)
+- [NEW] Add [`func (*Context) BindQuery`](https://godoc.org/github.com/gin-gonic/gin#Context.BindQuery), see [#1029](https://github.com/gin-gonic/gin/pull/1029)
+- [NEW] Make [jsonite](https://github.com/json-iterator/go) optional with build tags, see [#1026](https://github.com/gin-gonic/gin/pull/1026)
+- [NEW] Show query string in logger, see [#999](https://github.com/gin-gonic/gin/pull/999)
+- [NEW] Add [`func (*Context) SecureJSON`](https://godoc.org/github.com/gin-gonic/gin#Context.SecureJSON), see [#987](https://github.com/gin-gonic/gin/pull/987) and [#993](https://github.com/gin-gonic/gin/pull/993)
+- [DEPRECATE] `func (*Context) GetCookie` for [`func (*Context) Cookie`](https://godoc.org/github.com/gin-gonic/gin#Context.Cookie)
+- [FIX] Don't display color tags if [`func DisableConsoleColor`](https://godoc.org/github.com/gin-gonic/gin#DisableConsoleColor) called, see [#1072](https://github.com/gin-gonic/gin/pull/1072)
+- [FIX] Gin Mode `""` when calling [`func Mode`](https://godoc.org/github.com/gin-gonic/gin#Mode) now returns `const DebugMode`, see [#1250](https://github.com/gin-gonic/gin/pull/1250)
+- [FIX] `Flush()` now doesn't overwrite `responseWriter` status code, see [#1460](https://github.com/gin-gonic/gin/pull/1460)
+
+## Gin 1.2.0
+
+- [NEW] Switch from godeps to govendor
+- [NEW] Add support for Let's Encrypt via gin-gonic/autotls
+- [NEW] Improve README examples and add extra at examples folder
+- [NEW] Improved support with App Engine
+- [NEW] Add custom template delimiters, see #860
+- [NEW] Add Template Func Maps, see #962
+- [NEW] Add \*context.Handler(), see #928
+- [NEW] Add \*context.GetRawData()
+- [NEW] Add \*context.GetHeader() (request)
+- [NEW] Add \*context.AbortWithStatusJSON() (JSON content type)
+- [NEW] Add \*context.Keys type cast helpers
+- [NEW] Add \*context.ShouldBindWith()
+- [NEW] Add \*context.MustBindWith()
+- [NEW] Add \*engine.SetFuncMap()
+- [DEPRECATE] On next release: \*context.BindWith(), see #855
+- [FIX] Refactor render
+- [FIX] Reworked tests
+- [FIX] logger now supports cygwin
+- [FIX] Use X-Forwarded-For before X-Real-Ip
+- [FIX] time.Time binding (#904)
+
+## Gin 1.1.4
+
+- [NEW] Support google appengine for IsTerminal func
+
+## Gin 1.1.3
+
+- [FIX] Reverted Logger: skip ANSI color commands
+
+## Gin 1.1
+
+- [NEW] Implement QueryArray and PostArray methods 
+- [NEW] Refactor GetQuery and GetPostForm 
+- [NEW] Add contribution guide 
+- [FIX] Corrected typos in README
+- [FIX] Removed additional Iota  
+- [FIX] Changed imports to gopkg instead of github in README (#733) 
+- [FIX] Logger: skip ANSI color commands if output is not a tty
+
+## Gin 1.0rc2 (...)
+
+- [PERFORMANCE] Fast path for writing Content-Type.
+- [PERFORMANCE] Much faster 404 routing
+- [PERFORMANCE] Allocation optimizations
+- [PERFORMANCE] Faster root tree lookup
+- [PERFORMANCE] Zero overhead, String() and JSON() rendering.
+- [PERFORMANCE] Faster ClientIP parsing
+- [PERFORMANCE] Much faster SSE implementation
+- [NEW] Benchmarks suite
+- [NEW] Bind validation can be disabled and replaced with custom validators.
+- [NEW] More flexible HTML render
+- [NEW] Multipart and PostForm bindings
+- [NEW] Adds method to return all the registered routes
+- [NEW] Context.HandlerName() returns the main handler's name
+- [NEW] Adds Error.IsType() helper
+- [FIX] Binding multipart form
+- [FIX] Integration tests
+- [FIX] Crash when binding non struct object in Context.
+- [FIX] RunTLS() implementation
+- [FIX] Logger() unit tests
+- [FIX] Adds SetHTMLTemplate() warning
+- [FIX] Context.IsAborted()
+- [FIX] More unit tests
+- [FIX] JSON, XML, HTML renders accept custom content-types
+- [FIX] gin.AbortIndex is unexported
+- [FIX] Better approach to avoid directory listing in StaticFS()
+- [FIX] Context.ClientIP() always returns the IP with trimmed spaces.
+- [FIX] Better warning when running in debug mode.
+- [FIX] Google App Engine integration. debugPrint does not use os.Stdout
+- [FIX] Fixes integer overflow in error type
+- [FIX] Error implements the json.Marshaller interface
+- [FIX] MIT license in every file
+
+
+## Gin 1.0rc1 (May 22, 2015)
+
+- [PERFORMANCE] Zero allocation router
+- [PERFORMANCE] Faster JSON, XML and text rendering
+- [PERFORMANCE] Custom hand optimized HttpRouter for Gin
+- [PERFORMANCE] Misc code optimizations. Inlining, tail call optimizations
+- [NEW] Built-in support for golang.org/x/net/context
+- [NEW] Any(path, handler). Create a route that matches any path
+- [NEW] Refactored rendering pipeline (faster and static typed)
+- [NEW] Refactored errors API
+- [NEW] IndentedJSON() prints pretty JSON
+- [NEW] Added gin.DefaultWriter
+- [NEW] UNIX socket support
+- [NEW] RouterGroup.BasePath is exposed
+- [NEW] JSON validation using go-validate-yourself (very powerful options)
+- [NEW] Completed suite of unit tests
+- [NEW] HTTP streaming with c.Stream()
+- [NEW] StaticFile() creates a router for serving just one file.
+- [NEW] StaticFS() has an option to disable directory listing.
+- [NEW] StaticFS() for serving static files through virtual filesystems
+- [NEW] Server-Sent Events native support
+- [NEW] WrapF() and WrapH() helpers for wrapping http.HandlerFunc and http.Handler
+- [NEW] Added LoggerWithWriter() middleware
+- [NEW] Added RecoveryWithWriter() middleware
+- [NEW] Added DefaultPostFormValue()
+- [NEW] Added DefaultFormValue()
+- [NEW] Added DefaultParamValue()
+- [FIX] BasicAuth() when using custom realm
+- [FIX] Bug when serving static files in nested routing group
+- [FIX] Redirect using built-in http.Redirect()
+- [FIX] Logger when printing the requested path
+- [FIX] Documentation typos
+- [FIX] Context.Engine renamed to Context.engine
+- [FIX] Better debugging messages
+- [FIX] ErrorLogger
+- [FIX] Debug HTTP render
+- [FIX] Refactored binding and render modules
+- [FIX] Refactored Context initialization
+- [FIX] Refactored BasicAuth()
+- [FIX] NoMethod/NoRoute handlers
+- [FIX] Hijacking http
+- [FIX] Better support for Google App Engine (using log instead of fmt)
+
+
+## Gin 0.6 (Mar 9, 2015)
+
+- [NEW] Support multipart/form-data
+- [NEW] NoMethod handler
+- [NEW] Validate sub structures
+- [NEW] Support for HTTP Realm Auth
+- [FIX] Unsigned integers in binding
+- [FIX] Improve color logger
+
+
+## Gin 0.5 (Feb 7, 2015)
+
+- [NEW] Content Negotiation
+- [FIX] Solved security bug that allow a client to spoof ip
+- [FIX] Fix unexported/ignored fields in binding
+
+
+## Gin 0.4 (Aug 21, 2014)
+
+- [NEW] Development mode
+- [NEW] Unit tests
+- [NEW] Add Content.Redirect()
+- [FIX] Deferring WriteHeader()
+- [FIX] Improved documentation for model binding
+
+
+## Gin 0.3 (Jul 18, 2014)
+
+- [PERFORMANCE] Normal log and error log are printed in the same call.
+- [PERFORMANCE] Improve performance of NoRouter()
+- [PERFORMANCE] Improve context's memory locality, reduce CPU cache faults.
+- [NEW] Flexible rendering API
+- [NEW] Add Context.File()
+- [NEW] Add shortcut RunTLS() for http.ListenAndServeTLS
+- [FIX] Rename NotFound404() to NoRoute()
+- [FIX] Errors in context are purged
+- [FIX] Adds HEAD method in Static file serving
+- [FIX] Refactors Static() file serving
+- [FIX] Using keyed initialization to fix app-engine integration
+- [FIX] Can't unmarshal JSON array, #63
+- [FIX] Renaming Context.Req to Context.Request
+- [FIX] Check application/x-www-form-urlencoded when parsing form
+
+
+## Gin 0.2b (Jul 08, 2014)
+- [PERFORMANCE] Using sync.Pool to allocatio/gc overhead
+- [NEW] Travis CI integration
+- [NEW] Completely new logger
+- [NEW] New API for serving static files. gin.Static()
+- [NEW] gin.H() can be serialized into XML
+- [NEW] Typed errors. Errors can be typed. Internet/external/custom.
+- [NEW] Support for Godeps
+- [NEW] Travis/Godocs badges in README
+- [NEW] New Bind() and BindWith() methods for parsing request body.
+- [NEW] Add Content.Copy()
+- [NEW] Add context.LastError()
+- [NEW] Add shortcut for OPTIONS HTTP method
+- [FIX] Tons of README fixes
+- [FIX] Header is written before body
+- [FIX] BasicAuth() and changes API a little bit
+- [FIX] Recovery() middleware only prints panics
+- [FIX] Context.Get() does not panic anymore. Use MustGet() instead.
+- [FIX] Multiple http.WriteHeader() in NotFound handlers
+- [FIX] Engine.Run() panics if http server can't be set up
+- [FIX] Crash when route path doesn't start with '/'
+- [FIX] Do not update header when status code is negative
+- [FIX] Setting response headers before calling WriteHeader in context.String()
+- [FIX] Add MIT license
+- [FIX] Changes behaviour of ErrorLogger() and Logger()

vendor/github.com/gin-gonic/gin/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at teamgingonic@gmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

vendor/github.com/gin-gonic/gin/CONTRIBUTING.md

@@ -0,0 +1,13 @@
+## Contributing 
+
+- With issues:
+  - Use the search tool before opening a new issue.
+  - Please provide source code and commit sha if you found a bug.
+  - Review existing issues and provide feedback or react to them.
+
+- With pull requests:
+  - Open your pull request against `master`
+  - Your pull request should have no more than two commits, if not you should squash them.
+  - It should pass all tests in the available continuous integrations systems such as TravisCI.
+  - You should add/modify tests to cover your proposed code changes.
+  - If your pull request contains a new feature, please document it on the README.

vendor/github.com/gin-gonic/gin/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Manuel Martínez-Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/gin-gonic/gin/Makefile

@@ -0,0 +1,71 @@
+GO ?= go
+GOFMT ?= gofmt "-s"
+PACKAGES ?= $(shell $(GO) list ./...)
+VETPACKAGES ?= $(shell $(GO) list ./... | grep -v /examples/)
+GOFILES := $(shell find . -name "*.go")
+TESTFOLDER := $(shell $(GO) list ./... | grep -E 'gin$$|binding$$|render$$' | grep -v examples)
+TESTTAGS ?= ""
+
+.PHONY: test
+test:
+	echo "mode: count" > coverage.out
+	for d in $(TESTFOLDER); do \
+		$(GO) test -tags $(TESTTAGS) -v -covermode=count -coverprofile=profile.out $$d > tmp.out; \
+		cat tmp.out; \
+		if grep -q "^--- FAIL" tmp.out; then \
+			rm tmp.out; \
+			exit 1; \
+		elif grep -q "build failed" tmp.out; then \
+			rm tmp.out; \
+			exit 1; \
+		elif grep -q "setup failed" tmp.out; then \
+			rm tmp.out; \
+			exit 1; \
+		fi; \
+		if [ -f profile.out ]; then \
+			cat profile.out | grep -v "mode:" >> coverage.out; \
+			rm profile.out; \
+		fi; \
+	done
+
+.PHONY: fmt
+fmt:
+	$(GOFMT) -w $(GOFILES)
+
+.PHONY: fmt-check
+fmt-check:
+	@diff=$$($(GOFMT) -d $(GOFILES)); \
+	if [ -n "$$diff" ]; then \
+		echo "Please run 'make fmt' and commit the result:"; \
+		echo "$${diff}"; \
+		exit 1; \
+	fi;
+
+vet:
+	$(GO) vet $(VETPACKAGES)
+
+.PHONY: lint
+lint:
+	@hash golint > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) get -u golang.org/x/lint/golint; \
+	fi
+	for PKG in $(PACKAGES); do golint -set_exit_status $$PKG || exit 1; done;
+
+.PHONY: misspell-check
+misspell-check:
+	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) get -u github.com/client9/misspell/cmd/misspell; \
+	fi
+	misspell -error $(GOFILES)
+
+.PHONY: misspell
+misspell:
+	@hash misspell > /dev/null 2>&1; if [ $$? -ne 0 ]; then \
+		$(GO) get -u github.com/client9/misspell/cmd/misspell; \
+	fi
+	misspell -w $(GOFILES)
+
+.PHONY: tools
+tools:
+	go install golang.org/x/lint/golint; \
+	go install github.com/client9/misspell/cmd/misspell;

vendor/github.com/gin-gonic/gin/auth.go

@@ -0,0 +1,89 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"encoding/base64"
+	"net/http"
+	"strconv"
+
+	"github.com/gin-gonic/gin/internal/bytesconv"
+)
+
+// AuthUserKey is the cookie name for user credential in basic auth.
+const AuthUserKey = "user"
+
+// Accounts defines a key/value for user/pass list of authorized logins.
+type Accounts map[string]string
+
+type authPair struct {
+	value string
+	user  string
+}
+
+type authPairs []authPair
+
+func (a authPairs) searchCredential(authValue string) (string, bool) {
+	if authValue == "" {
+		return "", false
+	}
+	for _, pair := range a {
+		if pair.value == authValue {
+			return pair.user, true
+		}
+	}
+	return "", false
+}
+
+// BasicAuthForRealm returns a Basic HTTP Authorization middleware. It takes as arguments a map[string]string where
+// the key is the user name and the value is the password, as well as the name of the Realm.
+// If the realm is empty, "Authorization Required" will be used by default.
+// (see http://tools.ietf.org/html/rfc2617#section-1.2)
+func BasicAuthForRealm(accounts Accounts, realm string) HandlerFunc {
+	if realm == "" {
+		realm = "Authorization Required"
+	}
+	realm = "Basic realm=" + strconv.Quote(realm)
+	pairs := processAccounts(accounts)
+	return func(c *Context) {
+		// Search user in the slice of allowed credentials
+		user, found := pairs.searchCredential(c.requestHeader("Authorization"))
+		if !found {
+			// Credentials doesn't match, we return 401 and abort handlers chain.
+			c.Header("WWW-Authenticate", realm)
+			c.AbortWithStatus(http.StatusUnauthorized)
+			return
+		}
+
+		// The user credentials was found, set user's id to key AuthUserKey in this context, the user's id can be read later using
+		// c.MustGet(gin.AuthUserKey).
+		c.Set(AuthUserKey, user)
+	}
+}
+
+// BasicAuth returns a Basic HTTP Authorization middleware. It takes as argument a map[string]string where
+// the key is the user name and the value is the password.
+func BasicAuth(accounts Accounts) HandlerFunc {
+	return BasicAuthForRealm(accounts, "")
+}
+
+func processAccounts(accounts Accounts) authPairs {
+	assert1(len(accounts) > 0, "Empty list of authorized credentials")
+	pairs := make(authPairs, 0, len(accounts))
+	for user, password := range accounts {
+		assert1(user != "", "User can not be empty")
+		value := authorizationHeader(user, password)
+		pairs = append(pairs, authPair{
+			value: value,
+			user:  user,
+		})
+	}
+	return pairs
+}
+
+func authorizationHeader(user, password string) string {
+	base := user + ":" + password
+	return "Basic " + base64.StdEncoding.EncodeToString(bytesconv.StringToBytes(base))
+}

vendor/github.com/gin-gonic/gin/binding/binding.go

@@ -0,0 +1,116 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build !nomsgpack
+
+package binding
+
+import "net/http"
+
+// Content-Type MIME of the most common data formats.
+const (
+	MIMEJSON              = "application/json"
+	MIMEHTML              = "text/html"
+	MIMEXML               = "application/xml"
+	MIMEXML2              = "text/xml"
+	MIMEPlain             = "text/plain"
+	MIMEPOSTForm          = "application/x-www-form-urlencoded"
+	MIMEMultipartPOSTForm = "multipart/form-data"
+	MIMEPROTOBUF          = "application/x-protobuf"
+	MIMEMSGPACK           = "application/x-msgpack"
+	MIMEMSGPACK2          = "application/msgpack"
+	MIMEYAML              = "application/x-yaml"
+)
+
+// Binding describes the interface which needs to be implemented for binding the
+// data present in the request such as JSON request body, query parameters or
+// the form POST.
+type Binding interface {
+	Name() string
+	Bind(*http.Request, interface{}) error
+}
+
+// BindingBody adds BindBody method to Binding. BindBody is similar with Bind,
+// but it reads the body from supplied bytes instead of req.Body.
+type BindingBody interface {
+	Binding
+	BindBody([]byte, interface{}) error
+}
+
+// BindingUri adds BindUri method to Binding. BindUri is similar with Bind,
+// but it read the Params.
+type BindingUri interface {
+	Name() string
+	BindUri(map[string][]string, interface{}) error
+}
+
+// StructValidator is the minimal interface which needs to be implemented in
+// order for it to be used as the validator engine for ensuring the correctness
+// of the request. Gin provides a default implementation for this using
+// https://github.com/go-playground/validator/tree/v8.18.2.
+type StructValidator interface {
+	// ValidateStruct can receive any kind of type and it should never panic, even if the configuration is not right.
+	// If the received type is not a struct, any validation should be skipped and nil must be returned.
+	// If the received type is a struct or pointer to a struct, the validation should be performed.
+	// If the struct is not valid or the validation itself fails, a descriptive error should be returned.
+	// Otherwise nil must be returned.
+	ValidateStruct(interface{}) error
+
+	// Engine returns the underlying validator engine which powers the
+	// StructValidator implementation.
+	Engine() interface{}
+}
+
+// Validator is the default validator which implements the StructValidator
+// interface. It uses https://github.com/go-playground/validator/tree/v8.18.2
+// under the hood.
+var Validator StructValidator = &defaultValidator{}
+
+// These implement the Binding interface and can be used to bind the data
+// present in the request to struct instances.
+var (
+	JSON          = jsonBinding{}
+	XML           = xmlBinding{}
+	Form          = formBinding{}
+	Query         = queryBinding{}
+	FormPost      = formPostBinding{}
+	FormMultipart = formMultipartBinding{}
+	ProtoBuf      = protobufBinding{}
+	MsgPack       = msgpackBinding{}
+	YAML          = yamlBinding{}
+	Uri           = uriBinding{}
+	Header        = headerBinding{}
+)
+
+// Default returns the appropriate Binding instance based on the HTTP method
+// and the content type.
+func Default(method, contentType string) Binding {
+	if method == http.MethodGet {
+		return Form
+	}
+
+	switch contentType {
+	case MIMEJSON:
+		return JSON
+	case MIMEXML, MIMEXML2:
+		return XML
+	case MIMEPROTOBUF:
+		return ProtoBuf
+	case MIMEMSGPACK, MIMEMSGPACK2:
+		return MsgPack
+	case MIMEYAML:
+		return YAML
+	case MIMEMultipartPOSTForm:
+		return FormMultipart
+	default: // case MIMEPOSTForm:
+		return Form
+	}
+}
+
+func validate(obj interface{}) error {
+	if Validator == nil {
+		return nil
+	}
+	return Validator.ValidateStruct(obj)
+}

vendor/github.com/gin-gonic/gin/binding/binding_nomsgpack.go

@@ -0,0 +1,111 @@
+// Copyright 2020 Gin Core Team. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build nomsgpack
+
+package binding
+
+import "net/http"
+
+// Content-Type MIME of the most common data formats.
+const (
+	MIMEJSON              = "application/json"
+	MIMEHTML              = "text/html"
+	MIMEXML               = "application/xml"
+	MIMEXML2              = "text/xml"
+	MIMEPlain             = "text/plain"
+	MIMEPOSTForm          = "application/x-www-form-urlencoded"
+	MIMEMultipartPOSTForm = "multipart/form-data"
+	MIMEPROTOBUF          = "application/x-protobuf"
+	MIMEYAML              = "application/x-yaml"
+)
+
+// Binding describes the interface which needs to be implemented for binding the
+// data present in the request such as JSON request body, query parameters or
+// the form POST.
+type Binding interface {
+	Name() string
+	Bind(*http.Request, interface{}) error
+}
+
+// BindingBody adds BindBody method to Binding. BindBody is similar with Bind,
+// but it reads the body from supplied bytes instead of req.Body.
+type BindingBody interface {
+	Binding
+	BindBody([]byte, interface{}) error
+}
+
+// BindingUri adds BindUri method to Binding. BindUri is similar with Bind,
+// but it read the Params.
+type BindingUri interface {
+	Name() string
+	BindUri(map[string][]string, interface{}) error
+}
+
+// StructValidator is the minimal interface which needs to be implemented in
+// order for it to be used as the validator engine for ensuring the correctness
+// of the request. Gin provides a default implementation for this using
+// https://github.com/go-playground/validator/tree/v8.18.2.
+type StructValidator interface {
+	// ValidateStruct can receive any kind of type and it should never panic, even if the configuration is not right.
+	// If the received type is not a struct, any validation should be skipped and nil must be returned.
+	// If the received type is a struct or pointer to a struct, the validation should be performed.
+	// If the struct is not valid or the validation itself fails, a descriptive error should be returned.
+	// Otherwise nil must be returned.
+	ValidateStruct(interface{}) error
+
+	// Engine returns the underlying validator engine which powers the
+	// StructValidator implementation.
+	Engine() interface{}
+}
+
+// Validator is the default validator which implements the StructValidator
+// interface. It uses https://github.com/go-playground/validator/tree/v8.18.2
+// under the hood.
+var Validator StructValidator = &defaultValidator{}
+
+// These implement the Binding interface and can be used to bind the data
+// present in the request to struct instances.
+var (
+	JSON          = jsonBinding{}
+	XML           = xmlBinding{}
+	Form          = formBinding{}
+	Query         = queryBinding{}
+	FormPost      = formPostBinding{}
+	FormMultipart = formMultipartBinding{}
+	ProtoBuf      = protobufBinding{}
+	YAML          = yamlBinding{}
+	Uri           = uriBinding{}
+	Header        = headerBinding{}
+)
+
+// Default returns the appropriate Binding instance based on the HTTP method
+// and the content type.
+func Default(method, contentType string) Binding {
+	if method == "GET" {
+		return Form
+	}
+
+	switch contentType {
+	case MIMEJSON:
+		return JSON
+	case MIMEXML, MIMEXML2:
+		return XML
+	case MIMEPROTOBUF:
+		return ProtoBuf
+	case MIMEYAML:
+		return YAML
+	case MIMEMultipartPOSTForm:
+		return FormMultipart
+	default: // case MIMEPOSTForm:
+		return Form
+	}
+}
+
+func validate(obj interface{}) error {
+	if Validator == nil {
+		return nil
+	}
+	return Validator.ValidateStruct(obj)
+}

vendor/github.com/gin-gonic/gin/binding/default_validator.go

@@ -0,0 +1,51 @@
+// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"reflect"
+	"sync"
+
+	"github.com/go-playground/validator/v10"
+)
+
+type defaultValidator struct {
+	once     sync.Once
+	validate *validator.Validate
+}
+
+var _ StructValidator = &defaultValidator{}
+
+// ValidateStruct receives any kind of type, but only performed struct or pointer to struct type.
+func (v *defaultValidator) ValidateStruct(obj interface{}) error {
+	value := reflect.ValueOf(obj)
+	valueType := value.Kind()
+	if valueType == reflect.Ptr {
+		valueType = value.Elem().Kind()
+	}
+	if valueType == reflect.Struct {
+		v.lazyinit()
+		if err := v.validate.Struct(obj); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Engine returns the underlying validator engine which powers the default
+// Validator instance. This is useful if you want to register custom validations
+// or struct level validations. See validator GoDoc for more info -
+// https://godoc.org/gopkg.in/go-playground/validator.v8
+func (v *defaultValidator) Engine() interface{} {
+	v.lazyinit()
+	return v.validate
+}
+
+func (v *defaultValidator) lazyinit() {
+	v.once.Do(func() {
+		v.validate = validator.New()
+		v.validate.SetTagName("binding")
+	})
+}

vendor/github.com/gin-gonic/gin/binding/form.go

@@ -0,0 +1,63 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"net/http"
+)
+
+const defaultMemory = 32 << 20
+
+type formBinding struct{}
+type formPostBinding struct{}
+type formMultipartBinding struct{}
+
+func (formBinding) Name() string {
+	return "form"
+}
+
+func (formBinding) Bind(req *http.Request, obj interface{}) error {
+	if err := req.ParseForm(); err != nil {
+		return err
+	}
+	if err := req.ParseMultipartForm(defaultMemory); err != nil {
+		if err != http.ErrNotMultipart {
+			return err
+		}
+	}
+	if err := mapForm(obj, req.Form); err != nil {
+		return err
+	}
+	return validate(obj)
+}
+
+func (formPostBinding) Name() string {
+	return "form-urlencoded"
+}
+
+func (formPostBinding) Bind(req *http.Request, obj interface{}) error {
+	if err := req.ParseForm(); err != nil {
+		return err
+	}
+	if err := mapForm(obj, req.PostForm); err != nil {
+		return err
+	}
+	return validate(obj)
+}
+
+func (formMultipartBinding) Name() string {
+	return "multipart/form-data"
+}
+
+func (formMultipartBinding) Bind(req *http.Request, obj interface{}) error {
+	if err := req.ParseMultipartForm(defaultMemory); err != nil {
+		return err
+	}
+	if err := mappingByPtr(obj, (*multipartRequest)(req), "form"); err != nil {
+		return err
+	}
+
+	return validate(obj)
+}

vendor/github.com/gin-gonic/gin/binding/form_mapping.go

@@ -0,0 +1,351 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin/internal/bytesconv"
+	"github.com/gin-gonic/gin/internal/json"
+)
+
+var errUnknownType = errors.New("unknown type")
+
+func mapUri(ptr interface{}, m map[string][]string) error {
+	return mapFormByTag(ptr, m, "uri")
+}
+
+func mapForm(ptr interface{}, form map[string][]string) error {
+	return mapFormByTag(ptr, form, "form")
+}
+
+var emptyField = reflect.StructField{}
+
+func mapFormByTag(ptr interface{}, form map[string][]string, tag string) error {
+	return mappingByPtr(ptr, formSource(form), tag)
+}
+
+// setter tries to set value on a walking by fields of a struct
+type setter interface {
+	TrySet(value reflect.Value, field reflect.StructField, key string, opt setOptions) (isSetted bool, err error)
+}
+
+type formSource map[string][]string
+
+var _ setter = formSource(nil)
+
+// TrySet tries to set a value by request's form source (like map[string][]string)
+func (form formSource) TrySet(value reflect.Value, field reflect.StructField, tagValue string, opt setOptions) (isSetted bool, err error) {
+	return setByForm(value, field, form, tagValue, opt)
+}
+
+func mappingByPtr(ptr interface{}, setter setter, tag string) error {
+	_, err := mapping(reflect.ValueOf(ptr), emptyField, setter, tag)
+	return err
+}
+
+func mapping(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
+	if field.Tag.Get(tag) == "-" { // just ignoring this field
+		return false, nil
+	}
+
+	var vKind = value.Kind()
+
+	if vKind == reflect.Ptr {
+		var isNew bool
+		vPtr := value
+		if value.IsNil() {
+			isNew = true
+			vPtr = reflect.New(value.Type().Elem())
+		}
+		isSetted, err := mapping(vPtr.Elem(), field, setter, tag)
+		if err != nil {
+			return false, err
+		}
+		if isNew && isSetted {
+			value.Set(vPtr)
+		}
+		return isSetted, nil
+	}
+
+	if vKind != reflect.Struct || !field.Anonymous {
+		ok, err := tryToSetValue(value, field, setter, tag)
+		if err != nil {
+			return false, err
+		}
+		if ok {
+			return true, nil
+		}
+	}
+
+	if vKind == reflect.Struct {
+		tValue := value.Type()
+
+		var isSetted bool
+		for i := 0; i < value.NumField(); i++ {
+			sf := tValue.Field(i)
+			if sf.PkgPath != "" && !sf.Anonymous { // unexported
+				continue
+			}
+			ok, err := mapping(value.Field(i), tValue.Field(i), setter, tag)
+			if err != nil {
+				return false, err
+			}
+			isSetted = isSetted || ok
+		}
+		return isSetted, nil
+	}
+	return false, nil
+}
+
+type setOptions struct {
+	isDefaultExists bool
+	defaultValue    string
+}
+
+func tryToSetValue(value reflect.Value, field reflect.StructField, setter setter, tag string) (bool, error) {
+	var tagValue string
+	var setOpt setOptions
+
+	tagValue = field.Tag.Get(tag)
+	tagValue, opts := head(tagValue, ",")
+
+	if tagValue == "" { // default value is FieldName
+		tagValue = field.Name
+	}
+	if tagValue == "" { // when field is "emptyField" variable
+		return false, nil
+	}
+
+	var opt string
+	for len(opts) > 0 {
+		opt, opts = head(opts, ",")
+
+		if k, v := head(opt, "="); k == "default" {
+			setOpt.isDefaultExists = true
+			setOpt.defaultValue = v
+		}
+	}
+
+	return setter.TrySet(value, field, tagValue, setOpt)
+}
+
+func setByForm(value reflect.Value, field reflect.StructField, form map[string][]string, tagValue string, opt setOptions) (isSetted bool, err error) {
+	vs, ok := form[tagValue]
+	if !ok && !opt.isDefaultExists {
+		return false, nil
+	}
+
+	switch value.Kind() {
+	case reflect.Slice:
+		if !ok {
+			vs = []string{opt.defaultValue}
+		}
+		return true, setSlice(vs, value, field)
+	case reflect.Array:
+		if !ok {
+			vs = []string{opt.defaultValue}
+		}
+		if len(vs) != value.Len() {
+			return false, fmt.Errorf("%q is not valid value for %s", vs, value.Type().String())
+		}
+		return true, setArray(vs, value, field)
+	default:
+		var val string
+		if !ok {
+			val = opt.defaultValue
+		}
+
+		if len(vs) > 0 {
+			val = vs[0]
+		}
+		return true, setWithProperType(val, value, field)
+	}
+}
+
+func setWithProperType(val string, value reflect.Value, field reflect.StructField) error {
+	switch value.Kind() {
+	case reflect.Int:
+		return setIntField(val, 0, value)
+	case reflect.Int8:
+		return setIntField(val, 8, value)
+	case reflect.Int16:
+		return setIntField(val, 16, value)
+	case reflect.Int32:
+		return setIntField(val, 32, value)
+	case reflect.Int64:
+		switch value.Interface().(type) {
+		case time.Duration:
+			return setTimeDuration(val, value, field)
+		}
+		return setIntField(val, 64, value)
+	case reflect.Uint:
+		return setUintField(val, 0, value)
+	case reflect.Uint8:
+		return setUintField(val, 8, value)
+	case reflect.Uint16:
+		return setUintField(val, 16, value)
+	case reflect.Uint32:
+		return setUintField(val, 32, value)
+	case reflect.Uint64:
+		return setUintField(val, 64, value)
+	case reflect.Bool:
+		return setBoolField(val, value)
+	case reflect.Float32:
+		return setFloatField(val, 32, value)
+	case reflect.Float64:
+		return setFloatField(val, 64, value)
+	case reflect.String:
+		value.SetString(val)
+	case reflect.Struct:
+		switch value.Interface().(type) {
+		case time.Time:
+			return setTimeField(val, field, value)
+		}
+		return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
+	case reflect.Map:
+		return json.Unmarshal(bytesconv.StringToBytes(val), value.Addr().Interface())
+	default:
+		return errUnknownType
+	}
+	return nil
+}
+
+func setIntField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0"
+	}
+	intVal, err := strconv.ParseInt(val, 10, bitSize)
+	if err == nil {
+		field.SetInt(intVal)
+	}
+	return err
+}
+
+func setUintField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0"
+	}
+	uintVal, err := strconv.ParseUint(val, 10, bitSize)
+	if err == nil {
+		field.SetUint(uintVal)
+	}
+	return err
+}
+
+func setBoolField(val string, field reflect.Value) error {
+	if val == "" {
+		val = "false"
+	}
+	boolVal, err := strconv.ParseBool(val)
+	if err == nil {
+		field.SetBool(boolVal)
+	}
+	return err
+}
+
+func setFloatField(val string, bitSize int, field reflect.Value) error {
+	if val == "" {
+		val = "0.0"
+	}
+	floatVal, err := strconv.ParseFloat(val, bitSize)
+	if err == nil {
+		field.SetFloat(floatVal)
+	}
+	return err
+}
+
+func setTimeField(val string, structField reflect.StructField, value reflect.Value) error {
+	timeFormat := structField.Tag.Get("time_format")
+	if timeFormat == "" {
+		timeFormat = time.RFC3339
+	}
+
+	switch tf := strings.ToLower(timeFormat); tf {
+	case "unix", "unixnano":
+		tv, err := strconv.ParseInt(val, 10, 0)
+		if err != nil {
+			return err
+		}
+
+		d := time.Duration(1)
+		if tf == "unixnano" {
+			d = time.Second
+		}
+
+		t := time.Unix(tv/int64(d), tv%int64(d))
+		value.Set(reflect.ValueOf(t))
+		return nil
+
+	}
+
+	if val == "" {
+		value.Set(reflect.ValueOf(time.Time{}))
+		return nil
+	}
+
+	l := time.Local
+	if isUTC, _ := strconv.ParseBool(structField.Tag.Get("time_utc")); isUTC {
+		l = time.UTC
+	}
+
+	if locTag := structField.Tag.Get("time_location"); locTag != "" {
+		loc, err := time.LoadLocation(locTag)
+		if err != nil {
+			return err
+		}
+		l = loc
+	}
+
+	t, err := time.ParseInLocation(timeFormat, val, l)
+	if err != nil {
+		return err
+	}
+
+	value.Set(reflect.ValueOf(t))
+	return nil
+}
+
+func setArray(vals []string, value reflect.Value, field reflect.StructField) error {
+	for i, s := range vals {
+		err := setWithProperType(s, value.Index(i), field)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func setSlice(vals []string, value reflect.Value, field reflect.StructField) error {
+	slice := reflect.MakeSlice(value.Type(), len(vals), len(vals))
+	err := setArray(vals, slice, field)
+	if err != nil {
+		return err
+	}
+	value.Set(slice)
+	return nil
+}
+
+func setTimeDuration(val string, value reflect.Value, field reflect.StructField) error {
+	d, err := time.ParseDuration(val)
+	if err != nil {
+		return err
+	}
+	value.Set(reflect.ValueOf(d))
+	return nil
+}
+
+func head(str, sep string) (head string, tail string) {
+	idx := strings.Index(str, sep)
+	if idx < 0 {
+		return str, ""
+	}
+	return str[:idx], str[idx+len(sep):]
+}

vendor/github.com/gin-gonic/gin/binding/header.go

@@ -0,0 +1,34 @@
+package binding
+
+import (
+	"net/http"
+	"net/textproto"
+	"reflect"
+)
+
+type headerBinding struct{}
+
+func (headerBinding) Name() string {
+	return "header"
+}
+
+func (headerBinding) Bind(req *http.Request, obj interface{}) error {
+
+	if err := mapHeader(obj, req.Header); err != nil {
+		return err
+	}
+
+	return validate(obj)
+}
+
+func mapHeader(ptr interface{}, h map[string][]string) error {
+	return mappingByPtr(ptr, headerSource(h), "header")
+}
+
+type headerSource map[string][]string
+
+var _ setter = headerSource(nil)
+
+func (hs headerSource) TrySet(value reflect.Value, field reflect.StructField, tagValue string, opt setOptions) (isSetted bool, err error) {
+	return setByForm(value, field, hs, textproto.CanonicalMIMEHeaderKey(tagValue), opt)
+}

vendor/github.com/gin-gonic/gin/binding/json.go

@@ -0,0 +1,56 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+
+	"github.com/gin-gonic/gin/internal/json"
+)
+
+// EnableDecoderUseNumber is used to call the UseNumber method on the JSON
+// Decoder instance. UseNumber causes the Decoder to unmarshal a number into an
+// interface{} as a Number instead of as a float64.
+var EnableDecoderUseNumber = false
+
+// EnableDecoderDisallowUnknownFields is used to call the DisallowUnknownFields method
+// on the JSON Decoder instance. DisallowUnknownFields causes the Decoder to
+// return an error when the destination is a struct and the input contains object
+// keys which do not match any non-ignored, exported fields in the destination.
+var EnableDecoderDisallowUnknownFields = false
+
+type jsonBinding struct{}
+
+func (jsonBinding) Name() string {
+	return "json"
+}
+
+func (jsonBinding) Bind(req *http.Request, obj interface{}) error {
+	if req == nil || req.Body == nil {
+		return fmt.Errorf("invalid request")
+	}
+	return decodeJSON(req.Body, obj)
+}
+
+func (jsonBinding) BindBody(body []byte, obj interface{}) error {
+	return decodeJSON(bytes.NewReader(body), obj)
+}
+
+func decodeJSON(r io.Reader, obj interface{}) error {
+	decoder := json.NewDecoder(r)
+	if EnableDecoderUseNumber {
+		decoder.UseNumber()
+	}
+	if EnableDecoderDisallowUnknownFields {
+		decoder.DisallowUnknownFields()
+	}
+	if err := decoder.Decode(obj); err != nil {
+		return err
+	}
+	return validate(obj)
+}

vendor/github.com/gin-gonic/gin/binding/msgpack.go

@@ -0,0 +1,37 @@
+// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build !nomsgpack
+
+package binding
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+
+	"github.com/ugorji/go/codec"
+)
+
+type msgpackBinding struct{}
+
+func (msgpackBinding) Name() string {
+	return "msgpack"
+}
+
+func (msgpackBinding) Bind(req *http.Request, obj interface{}) error {
+	return decodeMsgPack(req.Body, obj)
+}
+
+func (msgpackBinding) BindBody(body []byte, obj interface{}) error {
+	return decodeMsgPack(bytes.NewReader(body), obj)
+}
+
+func decodeMsgPack(r io.Reader, obj interface{}) error {
+	cdc := new(codec.MsgpackHandle)
+	if err := codec.NewDecoder(r, cdc).Decode(&obj); err != nil {
+		return err
+	}
+	return validate(obj)
+}

vendor/github.com/gin-gonic/gin/binding/multipart_form_mapping.go

@@ -0,0 +1,66 @@
+// Copyright 2019 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"errors"
+	"mime/multipart"
+	"net/http"
+	"reflect"
+)
+
+type multipartRequest http.Request
+
+var _ setter = (*multipartRequest)(nil)
+
+// TrySet tries to set a value by the multipart request with the binding a form file
+func (r *multipartRequest) TrySet(value reflect.Value, field reflect.StructField, key string, opt setOptions) (isSetted bool, err error) {
+	if files := r.MultipartForm.File[key]; len(files) != 0 {
+		return setByMultipartFormFile(value, field, files)
+	}
+
+	return setByForm(value, field, r.MultipartForm.Value, key, opt)
+}
+
+func setByMultipartFormFile(value reflect.Value, field reflect.StructField, files []*multipart.FileHeader) (isSetted bool, err error) {
+	switch value.Kind() {
+	case reflect.Ptr:
+		switch value.Interface().(type) {
+		case *multipart.FileHeader:
+			value.Set(reflect.ValueOf(files[0]))
+			return true, nil
+		}
+	case reflect.Struct:
+		switch value.Interface().(type) {
+		case multipart.FileHeader:
+			value.Set(reflect.ValueOf(*files[0]))
+			return true, nil
+		}
+	case reflect.Slice:
+		slice := reflect.MakeSlice(value.Type(), len(files), len(files))
+		isSetted, err = setArrayOfMultipartFormFiles(slice, field, files)
+		if err != nil || !isSetted {
+			return isSetted, err
+		}
+		value.Set(slice)
+		return true, nil
+	case reflect.Array:
+		return setArrayOfMultipartFormFiles(value, field, files)
+	}
+	return false, errors.New("unsupported field type for multipart.FileHeader")
+}
+
+func setArrayOfMultipartFormFiles(value reflect.Value, field reflect.StructField, files []*multipart.FileHeader) (isSetted bool, err error) {
+	if value.Len() != len(files) {
+		return false, errors.New("unsupported len of array for []*multipart.FileHeader")
+	}
+	for i := range files {
+		setted, err := setByMultipartFormFile(value.Index(i), field, files[i:i+1])
+		if err != nil || !setted {
+			return setted, err
+		}
+	}
+	return true, nil
+}

vendor/github.com/gin-gonic/gin/binding/protobuf.go

@@ -0,0 +1,36 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"io/ioutil"
+	"net/http"
+
+	"github.com/golang/protobuf/proto"
+)
+
+type protobufBinding struct{}
+
+func (protobufBinding) Name() string {
+	return "protobuf"
+}
+
+func (b protobufBinding) Bind(req *http.Request, obj interface{}) error {
+	buf, err := ioutil.ReadAll(req.Body)
+	if err != nil {
+		return err
+	}
+	return b.BindBody(buf, obj)
+}
+
+func (protobufBinding) BindBody(body []byte, obj interface{}) error {
+	if err := proto.Unmarshal(body, obj.(proto.Message)); err != nil {
+		return err
+	}
+	// Here it's same to return validate(obj), but util now we can't add
+	// `binding:""` to the struct which automatically generate by gen-proto
+	return nil
+	// return validate(obj)
+}

vendor/github.com/gin-gonic/gin/binding/query.go

@@ -0,0 +1,21 @@
+// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import "net/http"
+
+type queryBinding struct{}
+
+func (queryBinding) Name() string {
+	return "query"
+}
+
+func (queryBinding) Bind(req *http.Request, obj interface{}) error {
+	values := req.URL.Query()
+	if err := mapForm(obj, values); err != nil {
+		return err
+	}
+	return validate(obj)
+}

vendor/github.com/gin-gonic/gin/binding/uri.go

@@ -0,0 +1,18 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+type uriBinding struct{}
+
+func (uriBinding) Name() string {
+	return "uri"
+}
+
+func (uriBinding) BindUri(m map[string][]string, obj interface{}) error {
+	if err := mapUri(obj, m); err != nil {
+		return err
+	}
+	return validate(obj)
+}

vendor/github.com/gin-gonic/gin/binding/xml.go

@@ -0,0 +1,33 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"bytes"
+	"encoding/xml"
+	"io"
+	"net/http"
+)
+
+type xmlBinding struct{}
+
+func (xmlBinding) Name() string {
+	return "xml"
+}
+
+func (xmlBinding) Bind(req *http.Request, obj interface{}) error {
+	return decodeXML(req.Body, obj)
+}
+
+func (xmlBinding) BindBody(body []byte, obj interface{}) error {
+	return decodeXML(bytes.NewReader(body), obj)
+}
+func decodeXML(r io.Reader, obj interface{}) error {
+	decoder := xml.NewDecoder(r)
+	if err := decoder.Decode(obj); err != nil {
+		return err
+	}
+	return validate(obj)
+}

vendor/github.com/gin-gonic/gin/binding/yaml.go

@@ -0,0 +1,35 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package binding
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+
+	"gopkg.in/yaml.v2"
+)
+
+type yamlBinding struct{}
+
+func (yamlBinding) Name() string {
+	return "yaml"
+}
+
+func (yamlBinding) Bind(req *http.Request, obj interface{}) error {
+	return decodeYAML(req.Body, obj)
+}
+
+func (yamlBinding) BindBody(body []byte, obj interface{}) error {
+	return decodeYAML(bytes.NewReader(body), obj)
+}
+
+func decodeYAML(r io.Reader, obj interface{}) error {
+	decoder := yaml.NewDecoder(r)
+	if err := decoder.Decode(obj); err != nil {
+		return err
+	}
+	return validate(obj)
+}

vendor/github.com/gin-gonic/gin/codecov.yml

@@ -0,0 +1,5 @@
+coverage:
+  notify:
+    gitter:
+      default:
+        url: https://webhooks.gitter.im/e/d90dcdeeab2f1e357165

vendor/github.com/gin-gonic/gin/context_appengine.go

@@ -0,0 +1,11 @@
+// +build appengine
+
+// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+func init() {
+	defaultAppEngine = true
+}

vendor/github.com/gin-gonic/gin/debug.go

@@ -0,0 +1,103 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"fmt"
+	"html/template"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+const ginSupportMinGoVer = 10
+
+// IsDebugging returns true if the framework is running in debug mode.
+// Use SetMode(gin.ReleaseMode) to disable debug mode.
+func IsDebugging() bool {
+	return ginMode == debugCode
+}
+
+// DebugPrintRouteFunc indicates debug log output format.
+var DebugPrintRouteFunc func(httpMethod, absolutePath, handlerName string, nuHandlers int)
+
+func debugPrintRoute(httpMethod, absolutePath string, handlers HandlersChain) {
+	if IsDebugging() {
+		nuHandlers := len(handlers)
+		handlerName := nameOfFunction(handlers.Last())
+		if DebugPrintRouteFunc == nil {
+			debugPrint("%-6s %-25s --> %s (%d handlers)\n", httpMethod, absolutePath, handlerName, nuHandlers)
+		} else {
+			DebugPrintRouteFunc(httpMethod, absolutePath, handlerName, nuHandlers)
+		}
+	}
+}
+
+func debugPrintLoadTemplate(tmpl *template.Template) {
+	if IsDebugging() {
+		var buf strings.Builder
+		for _, tmpl := range tmpl.Templates() {
+			buf.WriteString("\t- ")
+			buf.WriteString(tmpl.Name())
+			buf.WriteString("\n")
+		}
+		debugPrint("Loaded HTML Templates (%d): \n%s\n", len(tmpl.Templates()), buf.String())
+	}
+}
+
+func debugPrint(format string, values ...interface{}) {
+	if IsDebugging() {
+		if !strings.HasSuffix(format, "\n") {
+			format += "\n"
+		}
+		fmt.Fprintf(DefaultWriter, "[GIN-debug] "+format, values...)
+	}
+}
+
+func getMinVer(v string) (uint64, error) {
+	first := strings.IndexByte(v, '.')
+	last := strings.LastIndexByte(v, '.')
+	if first == last {
+		return strconv.ParseUint(v[first+1:], 10, 64)
+	}
+	return strconv.ParseUint(v[first+1:last], 10, 64)
+}
+
+func debugPrintWARNINGDefault() {
+	if v, e := getMinVer(runtime.Version()); e == nil && v <= ginSupportMinGoVer {
+		debugPrint(`[WARNING] Now Gin requires Go 1.11 or later and Go 1.12 will be required soon.
+
+`)
+	}
+	debugPrint(`[WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.
+
+`)
+}
+
+func debugPrintWARNINGNew() {
+	debugPrint(`[WARNING] Running in "debug" mode. Switch to "release" mode in production.
+ - using env:	export GIN_MODE=release
+ - using code:	gin.SetMode(gin.ReleaseMode)
+
+`)
+}
+
+func debugPrintWARNINGSetHTMLTemplate() {
+	debugPrint(`[WARNING] Since SetHTMLTemplate() is NOT thread-safe. It should only be called
+at initialization. ie. before any route is registered or the router is listening in a socket:
+
+	router := gin.Default()
+	router.SetHTMLTemplate(template) // << good place
+
+`)
+}
+
+func debugPrintError(err error) {
+	if err != nil {
+		if IsDebugging() {
+			fmt.Fprintf(DefaultErrorWriter, "[GIN-debug] [ERROR] %v\n", err)
+		}
+	}
+}

vendor/github.com/gin-gonic/gin/deprecated.go

@@ -0,0 +1,21 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"log"
+
+	"github.com/gin-gonic/gin/binding"
+)
+
+// BindWith binds the passed struct pointer using the specified binding engine.
+// See the binding package.
+func (c *Context) BindWith(obj interface{}, b binding.Binding) error {
+	log.Println(`BindWith(\"interface{}, binding.Binding\") error is going to
+	be deprecated, please check issue #662 and either use MustBindWith() if you
+	want HTTP 400 to be automatically returned if any error occur, or use
+	ShouldBindWith() if you need to manage the error.`)
+	return c.MustBindWith(obj, b)
+}

vendor/github.com/gin-gonic/gin/doc.go

@@ -0,0 +1,6 @@
+/*
+Package gin implements a HTTP web framework called gin.
+
+See https://gin-gonic.com/ for more information about gin.
+*/
+package gin // import "github.com/gin-gonic/gin"

vendor/github.com/gin-gonic/gin/errors.go

@@ -0,0 +1,169 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/gin-gonic/gin/internal/json"
+)
+
+// ErrorType is an unsigned 64-bit error code as defined in the gin spec.
+type ErrorType uint64
+
+const (
+	// ErrorTypeBind is used when Context.Bind() fails.
+	ErrorTypeBind ErrorType = 1 << 63
+	// ErrorTypeRender is used when Context.Render() fails.
+	ErrorTypeRender ErrorType = 1 << 62
+	// ErrorTypePrivate indicates a private error.
+	ErrorTypePrivate ErrorType = 1 << 0
+	// ErrorTypePublic indicates a public error.
+	ErrorTypePublic ErrorType = 1 << 1
+	// ErrorTypeAny indicates any other error.
+	ErrorTypeAny ErrorType = 1<<64 - 1
+	// ErrorTypeNu indicates any other error.
+	ErrorTypeNu = 2
+)
+
+// Error represents a error's specification.
+type Error struct {
+	Err  error
+	Type ErrorType
+	Meta interface{}
+}
+
+type errorMsgs []*Error
+
+var _ error = &Error{}
+
+// SetType sets the error's type.
+func (msg *Error) SetType(flags ErrorType) *Error {
+	msg.Type = flags
+	return msg
+}
+
+// SetMeta sets the error's meta data.
+func (msg *Error) SetMeta(data interface{}) *Error {
+	msg.Meta = data
+	return msg
+}
+
+// JSON creates a properly formatted JSON
+func (msg *Error) JSON() interface{} {
+	json := H{}
+	if msg.Meta != nil {
+		value := reflect.ValueOf(msg.Meta)
+		switch value.Kind() {
+		case reflect.Struct:
+			return msg.Meta
+		case reflect.Map:
+			for _, key := range value.MapKeys() {
+				json[key.String()] = value.MapIndex(key).Interface()
+			}
+		default:
+			json["meta"] = msg.Meta
+		}
+	}
+	if _, ok := json["error"]; !ok {
+		json["error"] = msg.Error()
+	}
+	return json
+}
+
+// MarshalJSON implements the json.Marshaller interface.
+func (msg *Error) MarshalJSON() ([]byte, error) {
+	return json.Marshal(msg.JSON())
+}
+
+// Error implements the error interface.
+func (msg Error) Error() string {
+	return msg.Err.Error()
+}
+
+// IsType judges one error.
+func (msg *Error) IsType(flags ErrorType) bool {
+	return (msg.Type & flags) > 0
+}
+
+// ByType returns a readonly copy filtered the byte.
+// ie ByType(gin.ErrorTypePublic) returns a slice of errors with type=ErrorTypePublic.
+func (a errorMsgs) ByType(typ ErrorType) errorMsgs {
+	if len(a) == 0 {
+		return nil
+	}
+	if typ == ErrorTypeAny {
+		return a
+	}
+	var result errorMsgs
+	for _, msg := range a {
+		if msg.IsType(typ) {
+			result = append(result, msg)
+		}
+	}
+	return result
+}
+
+// Last returns the last error in the slice. It returns nil if the array is empty.
+// Shortcut for errors[len(errors)-1].
+func (a errorMsgs) Last() *Error {
+	if length := len(a); length > 0 {
+		return a[length-1]
+	}
+	return nil
+}
+
+// Errors returns an array will all the error messages.
+// Example:
+// 		c.Error(errors.New("first"))
+// 		c.Error(errors.New("second"))
+// 		c.Error(errors.New("third"))
+// 		c.Errors.Errors() // == []string{"first", "second", "third"}
+func (a errorMsgs) Errors() []string {
+	if len(a) == 0 {
+		return nil
+	}
+	errorStrings := make([]string, len(a))
+	for i, err := range a {
+		errorStrings[i] = err.Error()
+	}
+	return errorStrings
+}
+
+func (a errorMsgs) JSON() interface{} {
+	switch len(a) {
+	case 0:
+		return nil
+	case 1:
+		return a.Last().JSON()
+	default:
+		json := make([]interface{}, len(a))
+		for i, err := range a {
+			json[i] = err.JSON()
+		}
+		return json
+	}
+}
+
+// MarshalJSON implements the json.Marshaller interface.
+func (a errorMsgs) MarshalJSON() ([]byte, error) {
+	return json.Marshal(a.JSON())
+}
+
+func (a errorMsgs) String() string {
+	if len(a) == 0 {
+		return ""
+	}
+	var buffer strings.Builder
+	for i, msg := range a {
+		fmt.Fprintf(&buffer, "Error #%02d: %s\n", i+1, msg.Err)
+		if msg.Meta != nil {
+			fmt.Fprintf(&buffer, "     Meta: %v\n", msg.Meta)
+		}
+	}
+	return buffer.String()
+}

vendor/github.com/gin-gonic/gin/fs.go

@@ -0,0 +1,45 @@
+// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"net/http"
+	"os"
+)
+
+type onlyfilesFS struct {
+	fs http.FileSystem
+}
+
+type neuteredReaddirFile struct {
+	http.File
+}
+
+// Dir returns a http.Filesystem that can be used by http.FileServer(). It is used internally
+// in router.Static().
+// if listDirectory == true, then it works the same as http.Dir() otherwise it returns
+// a filesystem that prevents http.FileServer() to list the directory files.
+func Dir(root string, listDirectory bool) http.FileSystem {
+	fs := http.Dir(root)
+	if listDirectory {
+		return fs
+	}
+	return &onlyfilesFS{fs}
+}
+
+// Open conforms to http.Filesystem.
+func (fs onlyfilesFS) Open(name string) (http.File, error) {
+	f, err := fs.fs.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	return neuteredReaddirFile{f}, nil
+}
+
+// Readdir overrides the http.File default implementation.
+func (f neuteredReaddirFile) Readdir(count int) ([]os.FileInfo, error) {
+	// this disables directory listing
+	return nil, nil
+}

vendor/github.com/gin-gonic/gin/gin.go

@@ -0,0 +1,497 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"fmt"
+	"html/template"
+	"net"
+	"net/http"
+	"os"
+	"path"
+	"sync"
+
+	"github.com/gin-gonic/gin/internal/bytesconv"
+	"github.com/gin-gonic/gin/render"
+)
+
+const defaultMultipartMemory = 32 << 20 // 32 MB
+
+var (
+	default404Body   = []byte("404 page not found")
+	default405Body   = []byte("405 method not allowed")
+	defaultAppEngine bool
+)
+
+// HandlerFunc defines the handler used by gin middleware as return value.
+type HandlerFunc func(*Context)
+
+// HandlersChain defines a HandlerFunc array.
+type HandlersChain []HandlerFunc
+
+// Last returns the last handler in the chain. ie. the last handler is the main one.
+func (c HandlersChain) Last() HandlerFunc {
+	if length := len(c); length > 0 {
+		return c[length-1]
+	}
+	return nil
+}
+
+// RouteInfo represents a request route's specification which contains method and path and its handler.
+type RouteInfo struct {
+	Method      string
+	Path        string
+	Handler     string
+	HandlerFunc HandlerFunc
+}
+
+// RoutesInfo defines a RouteInfo array.
+type RoutesInfo []RouteInfo
+
+// Engine is the framework's instance, it contains the muxer, middleware and configuration settings.
+// Create an instance of Engine, by using New() or Default()
+type Engine struct {
+	RouterGroup
+
+	// Enables automatic redirection if the current route can't be matched but a
+	// handler for the path with (without) the trailing slash exists.
+	// For example if /foo/ is requested but a route only exists for /foo, the
+	// client is redirected to /foo with http status code 301 for GET requests
+	// and 307 for all other request methods.
+	RedirectTrailingSlash bool
+
+	// If enabled, the router tries to fix the current request path, if no
+	// handle is registered for it.
+	// First superfluous path elements like ../ or // are removed.
+	// Afterwards the router does a case-insensitive lookup of the cleaned path.
+	// If a handle can be found for this route, the router makes a redirection
+	// to the corrected path with status code 301 for GET requests and 307 for
+	// all other request methods.
+	// For example /FOO and /..//Foo could be redirected to /foo.
+	// RedirectTrailingSlash is independent of this option.
+	RedirectFixedPath bool
+
+	// If enabled, the router checks if another method is allowed for the
+	// current route, if the current request can not be routed.
+	// If this is the case, the request is answered with 'Method Not Allowed'
+	// and HTTP status code 405.
+	// If no other Method is allowed, the request is delegated to the NotFound
+	// handler.
+	HandleMethodNotAllowed bool
+	ForwardedByClientIP    bool
+
+	// #726 #755 If enabled, it will thrust some headers starting with
+	// 'X-AppEngine...' for better integration with that PaaS.
+	AppEngine bool
+
+	// If enabled, the url.RawPath will be used to find parameters.
+	UseRawPath bool
+
+	// If true, the path value will be unescaped.
+	// If UseRawPath is false (by default), the UnescapePathValues effectively is true,
+	// as url.Path gonna be used, which is already unescaped.
+	UnescapePathValues bool
+
+	// Value of 'maxMemory' param that is given to http.Request's ParseMultipartForm
+	// method call.
+	MaxMultipartMemory int64
+
+	// RemoveExtraSlash a parameter can be parsed from the URL even with extra slashes.
+	// See the PR #1817 and issue #1644
+	RemoveExtraSlash bool
+
+	delims           render.Delims
+	secureJsonPrefix string
+	HTMLRender       render.HTMLRender
+	FuncMap          template.FuncMap
+	allNoRoute       HandlersChain
+	allNoMethod      HandlersChain
+	noRoute          HandlersChain
+	noMethod         HandlersChain
+	pool             sync.Pool
+	trees            methodTrees
+}
+
+var _ IRouter = &Engine{}
+
+// New returns a new blank Engine instance without any middleware attached.
+// By default the configuration is:
+// - RedirectTrailingSlash:  true
+// - RedirectFixedPath:      false
+// - HandleMethodNotAllowed: false
+// - ForwardedByClientIP:    true
+// - UseRawPath:             false
+// - UnescapePathValues:     true
+func New() *Engine {
+	debugPrintWARNINGNew()
+	engine := &Engine{
+		RouterGroup: RouterGroup{
+			Handlers: nil,
+			basePath: "/",
+			root:     true,
+		},
+		FuncMap:                template.FuncMap{},
+		RedirectTrailingSlash:  true,
+		RedirectFixedPath:      false,
+		HandleMethodNotAllowed: false,
+		ForwardedByClientIP:    true,
+		AppEngine:              defaultAppEngine,
+		UseRawPath:             false,
+		RemoveExtraSlash:       false,
+		UnescapePathValues:     true,
+		MaxMultipartMemory:     defaultMultipartMemory,
+		trees:                  make(methodTrees, 0, 9),
+		delims:                 render.Delims{Left: "{{", Right: "}}"},
+		secureJsonPrefix:       "while(1);",
+	}
+	engine.RouterGroup.engine = engine
+	engine.pool.New = func() interface{} {
+		return engine.allocateContext()
+	}
+	return engine
+}
+
+// Default returns an Engine instance with the Logger and Recovery middleware already attached.
+func Default() *Engine {
+	debugPrintWARNINGDefault()
+	engine := New()
+	engine.Use(Logger(), Recovery())
+	return engine
+}
+
+func (engine *Engine) allocateContext() *Context {
+	return &Context{engine: engine}
+}
+
+// Delims sets template left and right delims and returns a Engine instance.
+func (engine *Engine) Delims(left, right string) *Engine {
+	engine.delims = render.Delims{Left: left, Right: right}
+	return engine
+}
+
+// SecureJsonPrefix sets the secureJsonPrefix used in Context.SecureJSON.
+func (engine *Engine) SecureJsonPrefix(prefix string) *Engine {
+	engine.secureJsonPrefix = prefix
+	return engine
+}
+
+// LoadHTMLGlob loads HTML files identified by glob pattern
+// and associates the result with HTML renderer.
+func (engine *Engine) LoadHTMLGlob(pattern string) {
+	left := engine.delims.Left
+	right := engine.delims.Right
+	templ := template.Must(template.New("").Delims(left, right).Funcs(engine.FuncMap).ParseGlob(pattern))
+
+	if IsDebugging() {
+		debugPrintLoadTemplate(templ)
+		engine.HTMLRender = render.HTMLDebug{Glob: pattern, FuncMap: engine.FuncMap, Delims: engine.delims}
+		return
+	}
+
+	engine.SetHTMLTemplate(templ)
+}
+
+// LoadHTMLFiles loads a slice of HTML files
+// and associates the result with HTML renderer.
+func (engine *Engine) LoadHTMLFiles(files ...string) {
+	if IsDebugging() {
+		engine.HTMLRender = render.HTMLDebug{Files: files, FuncMap: engine.FuncMap, Delims: engine.delims}
+		return
+	}
+
+	templ := template.Must(template.New("").Delims(engine.delims.Left, engine.delims.Right).Funcs(engine.FuncMap).ParseFiles(files...))
+	engine.SetHTMLTemplate(templ)
+}
+
+// SetHTMLTemplate associate a template with HTML renderer.
+func (engine *Engine) SetHTMLTemplate(templ *template.Template) {
+	if len(engine.trees) > 0 {
+		debugPrintWARNINGSetHTMLTemplate()
+	}
+
+	engine.HTMLRender = render.HTMLProduction{Template: templ.Funcs(engine.FuncMap)}
+}
+
+// SetFuncMap sets the FuncMap used for template.FuncMap.
+func (engine *Engine) SetFuncMap(funcMap template.FuncMap) {
+	engine.FuncMap = funcMap
+}
+
+// NoRoute adds handlers for NoRoute. It return a 404 code by default.
+func (engine *Engine) NoRoute(handlers ...HandlerFunc) {
+	engine.noRoute = handlers
+	engine.rebuild404Handlers()
+}
+
+// NoMethod sets the handlers called when... TODO.
+func (engine *Engine) NoMethod(handlers ...HandlerFunc) {
+	engine.noMethod = handlers
+	engine.rebuild405Handlers()
+}
+
+// Use attaches a global middleware to the router. ie. the middleware attached though Use() will be
+// included in the handlers chain for every single request. Even 404, 405, static files...
+// For example, this is the right place for a logger or error management middleware.
+func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
+	engine.RouterGroup.Use(middleware...)
+	engine.rebuild404Handlers()
+	engine.rebuild405Handlers()
+	return engine
+}
+
+func (engine *Engine) rebuild404Handlers() {
+	engine.allNoRoute = engine.combineHandlers(engine.noRoute)
+}
+
+func (engine *Engine) rebuild405Handlers() {
+	engine.allNoMethod = engine.combineHandlers(engine.noMethod)
+}
+
+func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
+	assert1(path[0] == '/', "path must begin with '/'")
+	assert1(method != "", "HTTP method can not be empty")
+	assert1(len(handlers) > 0, "there must be at least one handler")
+
+	debugPrintRoute(method, path, handlers)
+	root := engine.trees.get(method)
+	if root == nil {
+		root = new(node)
+		root.fullPath = "/"
+		engine.trees = append(engine.trees, methodTree{method: method, root: root})
+	}
+	root.addRoute(path, handlers)
+}
+
+// Routes returns a slice of registered routes, including some useful information, such as:
+// the http method, path and the handler name.
+func (engine *Engine) Routes() (routes RoutesInfo) {
+	for _, tree := range engine.trees {
+		routes = iterate("", tree.method, routes, tree.root)
+	}
+	return routes
+}
+
+func iterate(path, method string, routes RoutesInfo, root *node) RoutesInfo {
+	path += root.path
+	if len(root.handlers) > 0 {
+		handlerFunc := root.handlers.Last()
+		routes = append(routes, RouteInfo{
+			Method:      method,
+			Path:        path,
+			Handler:     nameOfFunction(handlerFunc),
+			HandlerFunc: handlerFunc,
+		})
+	}
+	for _, child := range root.children {
+		routes = iterate(path, method, routes, child)
+	}
+	return routes
+}
+
+// Run attaches the router to a http.Server and starts listening and serving HTTP requests.
+// It is a shortcut for http.ListenAndServe(addr, router)
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
+func (engine *Engine) Run(addr ...string) (err error) {
+	defer func() { debugPrintError(err) }()
+
+	address := resolveAddress(addr)
+	debugPrint("Listening and serving HTTP on %s\n", address)
+	err = http.ListenAndServe(address, engine)
+	return
+}
+
+// RunTLS attaches the router to a http.Server and starts listening and serving HTTPS (secure) requests.
+// It is a shortcut for http.ListenAndServeTLS(addr, certFile, keyFile, router)
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
+func (engine *Engine) RunTLS(addr, certFile, keyFile string) (err error) {
+	debugPrint("Listening and serving HTTPS on %s\n", addr)
+	defer func() { debugPrintError(err) }()
+
+	err = http.ListenAndServeTLS(addr, certFile, keyFile, engine)
+	return
+}
+
+// RunUnix attaches the router to a http.Server and starts listening and serving HTTP requests
+// through the specified unix socket (ie. a file).
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
+func (engine *Engine) RunUnix(file string) (err error) {
+	debugPrint("Listening and serving HTTP on unix:/%s", file)
+	defer func() { debugPrintError(err) }()
+
+	listener, err := net.Listen("unix", file)
+	if err != nil {
+		return
+	}
+	defer listener.Close()
+	defer os.Remove(file)
+
+	err = http.Serve(listener, engine)
+	return
+}
+
+// RunFd attaches the router to a http.Server and starts listening and serving HTTP requests
+// through the specified file descriptor.
+// Note: this method will block the calling goroutine indefinitely unless an error happens.
+func (engine *Engine) RunFd(fd int) (err error) {
+	debugPrint("Listening and serving HTTP on fd@%d", fd)
+	defer func() { debugPrintError(err) }()
+
+	f := os.NewFile(uintptr(fd), fmt.Sprintf("fd@%d", fd))
+	listener, err := net.FileListener(f)
+	if err != nil {
+		return
+	}
+	defer listener.Close()
+	err = engine.RunListener(listener)
+	return
+}
+
+// RunListener attaches the router to a http.Server and starts listening and serving HTTP requests
+// through the specified net.Listener
+func (engine *Engine) RunListener(listener net.Listener) (err error) {
+	debugPrint("Listening and serving HTTP on listener what's bind with address@%s", listener.Addr())
+	defer func() { debugPrintError(err) }()
+	err = http.Serve(listener, engine)
+	return
+}
+
+// ServeHTTP conforms to the http.Handler interface.
+func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	c := engine.pool.Get().(*Context)
+	c.writermem.reset(w)
+	c.Request = req
+	c.reset()
+
+	engine.handleHTTPRequest(c)
+
+	engine.pool.Put(c)
+}
+
+// HandleContext re-enter a context that has been rewritten.
+// This can be done by setting c.Request.URL.Path to your new target.
+// Disclaimer: You can loop yourself to death with this, use wisely.
+func (engine *Engine) HandleContext(c *Context) {
+	oldIndexValue := c.index
+	c.reset()
+	engine.handleHTTPRequest(c)
+
+	c.index = oldIndexValue
+}
+
+func (engine *Engine) handleHTTPRequest(c *Context) {
+	httpMethod := c.Request.Method
+	rPath := c.Request.URL.Path
+	unescape := false
+	if engine.UseRawPath && len(c.Request.URL.RawPath) > 0 {
+		rPath = c.Request.URL.RawPath
+		unescape = engine.UnescapePathValues
+	}
+
+	if engine.RemoveExtraSlash {
+		rPath = cleanPath(rPath)
+	}
+
+	// Find root of the tree for the given HTTP method
+	t := engine.trees
+	for i, tl := 0, len(t); i < tl; i++ {
+		if t[i].method != httpMethod {
+			continue
+		}
+		root := t[i].root
+		// Find route in tree
+		value := root.getValue(rPath, c.Params, unescape)
+		if value.handlers != nil {
+			c.handlers = value.handlers
+			c.Params = value.params
+			c.fullPath = value.fullPath
+			c.Next()
+			c.writermem.WriteHeaderNow()
+			return
+		}
+		if httpMethod != "CONNECT" && rPath != "/" {
+			if value.tsr && engine.RedirectTrailingSlash {
+				redirectTrailingSlash(c)
+				return
+			}
+			if engine.RedirectFixedPath && redirectFixedPath(c, root, engine.RedirectFixedPath) {
+				return
+			}
+		}
+		break
+	}
+
+	if engine.HandleMethodNotAllowed {
+		for _, tree := range engine.trees {
+			if tree.method == httpMethod {
+				continue
+			}
+			if value := tree.root.getValue(rPath, nil, unescape); value.handlers != nil {
+				c.handlers = engine.allNoMethod
+				serveError(c, http.StatusMethodNotAllowed, default405Body)
+				return
+			}
+		}
+	}
+	c.handlers = engine.allNoRoute
+	serveError(c, http.StatusNotFound, default404Body)
+}
+
+var mimePlain = []string{MIMEPlain}
+
+func serveError(c *Context, code int, defaultMessage []byte) {
+	c.writermem.status = code
+	c.Next()
+	if c.writermem.Written() {
+		return
+	}
+	if c.writermem.Status() == code {
+		c.writermem.Header()["Content-Type"] = mimePlain
+		_, err := c.Writer.Write(defaultMessage)
+		if err != nil {
+			debugPrint("cannot write message to writer during serve error: %v", err)
+		}
+		return
+	}
+	c.writermem.WriteHeaderNow()
+}
+
+func redirectTrailingSlash(c *Context) {
+	req := c.Request
+	p := req.URL.Path
+	if prefix := path.Clean(c.Request.Header.Get("X-Forwarded-Prefix")); prefix != "." {
+		p = prefix + "/" + req.URL.Path
+	}
+	req.URL.Path = p + "/"
+	if length := len(p); length > 1 && p[length-1] == '/' {
+		req.URL.Path = p[:length-1]
+	}
+	redirectRequest(c)
+}
+
+func redirectFixedPath(c *Context, root *node, trailingSlash bool) bool {
+	req := c.Request
+	rPath := req.URL.Path
+
+	if fixedPath, ok := root.findCaseInsensitivePath(cleanPath(rPath), trailingSlash); ok {
+		req.URL.Path = bytesconv.BytesToString(fixedPath)
+		redirectRequest(c)
+		return true
+	}
+	return false
+}
+
+func redirectRequest(c *Context) {
+	req := c.Request
+	rPath := req.URL.Path
+	rURL := req.URL.String()
+
+	code := http.StatusMovedPermanently // Permanent redirect, request with GET method
+	if req.Method != http.MethodGet {
+		code = http.StatusTemporaryRedirect
+	}
+	debugPrint("redirecting request %d: %s --> %s", code, rPath, rURL)
+	http.Redirect(c.Writer, req, rURL, code)
+	c.writermem.WriteHeaderNow()
+}

vendor/github.com/gin-gonic/gin/go.mod

@@ -0,0 +1,14 @@
+module github.com/gin-gonic/gin
+
+go 1.13
+
+require (
+	github.com/gin-contrib/sse v0.1.0
+	github.com/go-playground/validator/v10 v10.2.0
+	github.com/golang/protobuf v1.3.3
+	github.com/json-iterator/go v1.1.9
+	github.com/mattn/go-isatty v0.0.12
+	github.com/stretchr/testify v1.4.0
+	github.com/ugorji/go/codec v1.1.7
+	gopkg.in/yaml.v2 v2.2.8
+)

vendor/github.com/gin-gonic/gin/go.sum

@@ -0,0 +1,45 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/go-playground/assert/v2 v2.0.1 h1:MsBgLAaY856+nPRTKrp3/OZK38U/wa0CcBYNjji3q3A=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1Vv0sFl1UcHBOY=
+github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
+github.com/golang/protobuf v1.3.3 h1:gyjaxf+svBWX08ZjK86iN9geUJF0H6gp2IRKX6Nf6/I=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/json-iterator/go v1.1.9 h1:9yzud/Ht36ygwatGx56VwCZtlI/2AD15T1X2sjSuGns=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742 h1:Esafd1046DLDQ0W1YjYsBW+p8U2u7vzgW2SQVmlNazg=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
+github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
+github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs=
+github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42 h1:vEOn+mP2zCOVzKckCZy6YsCtDblrpj/w7B9nxGNELpg=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

vendor/github.com/gin-gonic/gin/internal/bytesconv/bytesconv.go

@@ -0,0 +1,19 @@
+package bytesconv
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// StringToBytes converts string to byte slice without a memory allocation.
+func StringToBytes(s string) (b []byte) {
+	sh := *(*reflect.StringHeader)(unsafe.Pointer(&s))
+	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	bh.Data, bh.Len, bh.Cap = sh.Data, sh.Len, sh.Len
+	return b
+}
+
+// BytesToString converts byte slice to string without a memory allocation.
+func BytesToString(b []byte) string {
+	return *(*string)(unsafe.Pointer(&b))
+}

vendor/github.com/gin-gonic/gin/internal/json/json.go

@@ -0,0 +1,22 @@
+// Copyright 2017 Bo-Yi Wu.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build !jsoniter
+
+package json
+
+import "encoding/json"
+
+var (
+	// Marshal is exported by gin/json package.
+	Marshal = json.Marshal
+	// Unmarshal is exported by gin/json package.
+	Unmarshal = json.Unmarshal
+	// MarshalIndent is exported by gin/json package.
+	MarshalIndent = json.MarshalIndent
+	// NewDecoder is exported by gin/json package.
+	NewDecoder = json.NewDecoder
+	// NewEncoder is exported by gin/json package.
+	NewEncoder = json.NewEncoder
+)

vendor/github.com/gin-gonic/gin/internal/json/jsoniter.go

@@ -0,0 +1,23 @@
+// Copyright 2017 Bo-Yi Wu.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build jsoniter
+
+package json
+
+import "github.com/json-iterator/go"
+
+var (
+	json = jsoniter.ConfigCompatibleWithStandardLibrary
+	// Marshal is exported by gin/json package.
+	Marshal = json.Marshal
+	// Unmarshal is exported by gin/json package.
+	Unmarshal = json.Unmarshal
+	// MarshalIndent is exported by gin/json package.
+	MarshalIndent = json.MarshalIndent
+	// NewDecoder is exported by gin/json package.
+	NewDecoder = json.NewDecoder
+	// NewEncoder is exported by gin/json package.
+	NewEncoder = json.NewEncoder
+)

vendor/github.com/gin-gonic/gin/logger.go

@@ -0,0 +1,271 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/mattn/go-isatty"
+)
+
+type consoleColorModeValue int
+
+const (
+	autoColor consoleColorModeValue = iota
+	disableColor
+	forceColor
+)
+
+const (
+	green   = "\033[97;42m"
+	white   = "\033[90;47m"
+	yellow  = "\033[90;43m"
+	red     = "\033[97;41m"
+	blue    = "\033[97;44m"
+	magenta = "\033[97;45m"
+	cyan    = "\033[97;46m"
+	reset   = "\033[0m"
+)
+
+var consoleColorMode = autoColor
+
+// LoggerConfig defines the config for Logger middleware.
+type LoggerConfig struct {
+	// Optional. Default value is gin.defaultLogFormatter
+	Formatter LogFormatter
+
+	// Output is a writer where logs are written.
+	// Optional. Default value is gin.DefaultWriter.
+	Output io.Writer
+
+	// SkipPaths is a url path array which logs are not written.
+	// Optional.
+	SkipPaths []string
+}
+
+// LogFormatter gives the signature of the formatter function passed to LoggerWithFormatter
+type LogFormatter func(params LogFormatterParams) string
+
+// LogFormatterParams is the structure any formatter will be handed when time to log comes
+type LogFormatterParams struct {
+	Request *http.Request
+
+	// TimeStamp shows the time after the server returns a response.
+	TimeStamp time.Time
+	// StatusCode is HTTP response code.
+	StatusCode int
+	// Latency is how much time the server cost to process a certain request.
+	Latency time.Duration
+	// ClientIP equals Context's ClientIP method.
+	ClientIP string
+	// Method is the HTTP method given to the request.
+	Method string
+	// Path is a path the client requests.
+	Path string
+	// ErrorMessage is set if error has occurred in processing the request.
+	ErrorMessage string
+	// isTerm shows whether does gin's output descriptor refers to a terminal.
+	isTerm bool
+	// BodySize is the size of the Response Body
+	BodySize int
+	// Keys are the keys set on the request's context.
+	Keys map[string]interface{}
+}
+
+// StatusCodeColor is the ANSI color for appropriately logging http status code to a terminal.
+func (p *LogFormatterParams) StatusCodeColor() string {
+	code := p.StatusCode
+
+	switch {
+	case code >= http.StatusOK && code < http.StatusMultipleChoices:
+		return green
+	case code >= http.StatusMultipleChoices && code < http.StatusBadRequest:
+		return white
+	case code >= http.StatusBadRequest && code < http.StatusInternalServerError:
+		return yellow
+	default:
+		return red
+	}
+}
+
+// MethodColor is the ANSI color for appropriately logging http method to a terminal.
+func (p *LogFormatterParams) MethodColor() string {
+	method := p.Method
+
+	switch method {
+	case http.MethodGet:
+		return blue
+	case http.MethodPost:
+		return cyan
+	case http.MethodPut:
+		return yellow
+	case http.MethodDelete:
+		return red
+	case http.MethodPatch:
+		return green
+	case http.MethodHead:
+		return magenta
+	case http.MethodOptions:
+		return white
+	default:
+		return reset
+	}
+}
+
+// ResetColor resets all escape attributes.
+func (p *LogFormatterParams) ResetColor() string {
+	return reset
+}
+
+// IsOutputColor indicates whether can colors be outputted to the log.
+func (p *LogFormatterParams) IsOutputColor() bool {
+	return consoleColorMode == forceColor || (consoleColorMode == autoColor && p.isTerm)
+}
+
+// defaultLogFormatter is the default log format function Logger middleware uses.
+var defaultLogFormatter = func(param LogFormatterParams) string {
+	var statusColor, methodColor, resetColor string
+	if param.IsOutputColor() {
+		statusColor = param.StatusCodeColor()
+		methodColor = param.MethodColor()
+		resetColor = param.ResetColor()
+	}
+
+	if param.Latency > time.Minute {
+		// Truncate in a golang < 1.8 safe way
+		param.Latency = param.Latency - param.Latency%time.Second
+	}
+	return fmt.Sprintf("[GIN] %v |%s %3d %s| %13v | %15s |%s %-7s %s %#v\n%s",
+		param.TimeStamp.Format("2006/01/02 - 15:04:05"),
+		statusColor, param.StatusCode, resetColor,
+		param.Latency,
+		param.ClientIP,
+		methodColor, param.Method, resetColor,
+		param.Path,
+		param.ErrorMessage,
+	)
+}
+
+// DisableConsoleColor disables color output in the console.
+func DisableConsoleColor() {
+	consoleColorMode = disableColor
+}
+
+// ForceConsoleColor force color output in the console.
+func ForceConsoleColor() {
+	consoleColorMode = forceColor
+}
+
+// ErrorLogger returns a handlerfunc for any error type.
+func ErrorLogger() HandlerFunc {
+	return ErrorLoggerT(ErrorTypeAny)
+}
+
+// ErrorLoggerT returns a handlerfunc for a given error type.
+func ErrorLoggerT(typ ErrorType) HandlerFunc {
+	return func(c *Context) {
+		c.Next()
+		errors := c.Errors.ByType(typ)
+		if len(errors) > 0 {
+			c.JSON(-1, errors)
+		}
+	}
+}
+
+// Logger instances a Logger middleware that will write the logs to gin.DefaultWriter.
+// By default gin.DefaultWriter = os.Stdout.
+func Logger() HandlerFunc {
+	return LoggerWithConfig(LoggerConfig{})
+}
+
+// LoggerWithFormatter instance a Logger middleware with the specified log format function.
+func LoggerWithFormatter(f LogFormatter) HandlerFunc {
+	return LoggerWithConfig(LoggerConfig{
+		Formatter: f,
+	})
+}
+
+// LoggerWithWriter instance a Logger middleware with the specified writer buffer.
+// Example: os.Stdout, a file opened in write mode, a socket...
+func LoggerWithWriter(out io.Writer, notlogged ...string) HandlerFunc {
+	return LoggerWithConfig(LoggerConfig{
+		Output:    out,
+		SkipPaths: notlogged,
+	})
+}
+
+// LoggerWithConfig instance a Logger middleware with config.
+func LoggerWithConfig(conf LoggerConfig) HandlerFunc {
+	formatter := conf.Formatter
+	if formatter == nil {
+		formatter = defaultLogFormatter
+	}
+
+	out := conf.Output
+	if out == nil {
+		out = DefaultWriter
+	}
+
+	notlogged := conf.SkipPaths
+
+	isTerm := true
+
+	if w, ok := out.(*os.File); !ok || os.Getenv("TERM") == "dumb" ||
+		(!isatty.IsTerminal(w.Fd()) && !isatty.IsCygwinTerminal(w.Fd())) {
+		isTerm = false
+	}
+
+	var skip map[string]struct{}
+
+	if length := len(notlogged); length > 0 {
+		skip = make(map[string]struct{}, length)
+
+		for _, path := range notlogged {
+			skip[path] = struct{}{}
+		}
+	}
+
+	return func(c *Context) {
+		// Start timer
+		start := time.Now()
+		path := c.Request.URL.Path
+		raw := c.Request.URL.RawQuery
+
+		// Process request
+		c.Next()
+
+		// Log only when path is not being skipped
+		if _, ok := skip[path]; !ok {
+			param := LogFormatterParams{
+				Request: c.Request,
+				isTerm:  isTerm,
+				Keys:    c.Keys,
+			}
+
+			// Stop timer
+			param.TimeStamp = time.Now()
+			param.Latency = param.TimeStamp.Sub(start)
+
+			param.ClientIP = c.ClientIP()
+			param.Method = c.Request.Method
+			param.StatusCode = c.Writer.Status()
+			param.ErrorMessage = c.Errors.ByType(ErrorTypePrivate).String()
+
+			param.BodySize = c.Writer.Size()
+
+			if raw != "" {
+				path = path + "?" + raw
+			}
+
+			param.Path = path
+
+			fmt.Fprint(out, formatter(param))
+		}
+	}
+}

vendor/github.com/gin-gonic/gin/mode.go

@@ -0,0 +1,89 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"io"
+	"os"
+
+	"github.com/gin-gonic/gin/binding"
+)
+
+// EnvGinMode indicates environment name for gin mode.
+const EnvGinMode = "GIN_MODE"
+
+const (
+	// DebugMode indicates gin mode is debug.
+	DebugMode = "debug"
+	// ReleaseMode indicates gin mode is release.
+	ReleaseMode = "release"
+	// TestMode indicates gin mode is test.
+	TestMode = "test"
+)
+const (
+	debugCode = iota
+	releaseCode
+	testCode
+)
+
+// DefaultWriter is the default io.Writer used by Gin for debug output and
+// middleware output like Logger() or Recovery().
+// Note that both Logger and Recovery provides custom ways to configure their
+// output io.Writer.
+// To support coloring in Windows use:
+// 		import "github.com/mattn/go-colorable"
+// 		gin.DefaultWriter = colorable.NewColorableStdout()
+var DefaultWriter io.Writer = os.Stdout
+
+// DefaultErrorWriter is the default io.Writer used by Gin to debug errors
+var DefaultErrorWriter io.Writer = os.Stderr
+
+var ginMode = debugCode
+var modeName = DebugMode
+
+func init() {
+	mode := os.Getenv(EnvGinMode)
+	SetMode(mode)
+}
+
+// SetMode sets gin mode according to input string.
+func SetMode(value string) {
+	switch value {
+	case DebugMode, "":
+		ginMode = debugCode
+	case ReleaseMode:
+		ginMode = releaseCode
+	case TestMode:
+		ginMode = testCode
+	default:
+		panic("gin mode unknown: " + value)
+	}
+	if value == "" {
+		value = DebugMode
+	}
+	modeName = value
+}
+
+// DisableBindValidation closes the default validator.
+func DisableBindValidation() {
+	binding.Validator = nil
+}
+
+// EnableJsonDecoderUseNumber sets true for binding.EnableDecoderUseNumber to
+// call the UseNumber method on the JSON Decoder instance.
+func EnableJsonDecoderUseNumber() {
+	binding.EnableDecoderUseNumber = true
+}
+
+// EnableJsonDecoderDisallowUnknownFields sets true for binding.EnableDecoderDisallowUnknownFields to
+// call the DisallowUnknownFields method on the JSON Decoder instance.
+func EnableJsonDecoderDisallowUnknownFields() {
+	binding.EnableDecoderDisallowUnknownFields = true
+}
+
+// Mode returns currently gin mode.
+func Mode() string {
+	return modeName
+}

vendor/github.com/gin-gonic/gin/path.go

@@ -0,0 +1,149 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Based on the path package, Copyright 2009 The Go Authors.
+// Use of this source code is governed by a BSD-style license that can be found
+// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE.
+
+package gin
+
+// cleanPath is the URL version of path.Clean, it returns a canonical URL path
+// for p, eliminating . and .. elements.
+//
+// The following rules are applied iteratively until no further processing can
+// be done:
+//	1. Replace multiple slashes with a single slash.
+//	2. Eliminate each . path name element (the current directory).
+//	3. Eliminate each inner .. path name element (the parent directory)
+//	   along with the non-.. element that precedes it.
+//	4. Eliminate .. elements that begin a rooted path:
+//	   that is, replace "/.." by "/" at the beginning of a path.
+//
+// If the result of this process is an empty string, "/" is returned.
+func cleanPath(p string) string {
+	const stackBufSize = 128
+	// Turn empty string into "/"
+	if p == "" {
+		return "/"
+	}
+
+	// Reasonably sized buffer on stack to avoid allocations in the common case.
+	// If a larger buffer is required, it gets allocated dynamically.
+	buf := make([]byte, 0, stackBufSize)
+
+	n := len(p)
+
+	// Invariants:
+	//      reading from path; r is index of next byte to process.
+	//      writing to buf; w is index of next byte to write.
+
+	// path must start with '/'
+	r := 1
+	w := 1
+
+	if p[0] != '/' {
+		r = 0
+
+		if n+1 > stackBufSize {
+			buf = make([]byte, n+1)
+		} else {
+			buf = buf[:n+1]
+		}
+		buf[0] = '/'
+	}
+
+	trailing := n > 1 && p[n-1] == '/'
+
+	// A bit more clunky without a 'lazybuf' like the path package, but the loop
+	// gets completely inlined (bufApp calls).
+	// loop has no expensive function calls (except 1x make)		// So in contrast to the path package this loop has no expensive function
+	// calls (except make, if needed).
+
+	for r < n {
+		switch {
+		case p[r] == '/':
+			// empty path element, trailing slash is added after the end
+			r++
+
+		case p[r] == '.' && r+1 == n:
+			trailing = true
+			r++
+
+		case p[r] == '.' && p[r+1] == '/':
+			// . element
+			r += 2
+
+		case p[r] == '.' && p[r+1] == '.' && (r+2 == n || p[r+2] == '/'):
+			// .. element: remove to last /
+			r += 3
+
+			if w > 1 {
+				// can backtrack
+				w--
+
+				if len(buf) == 0 {
+					for w > 1 && p[w] != '/' {
+						w--
+					}
+				} else {
+					for w > 1 && buf[w] != '/' {
+						w--
+					}
+				}
+			}
+
+		default:
+			// Real path element.
+			// Add slash if needed
+			if w > 1 {
+				bufApp(&buf, p, w, '/')
+				w++
+			}
+
+			// Copy element
+			for r < n && p[r] != '/' {
+				bufApp(&buf, p, w, p[r])
+				w++
+				r++
+			}
+		}
+	}
+
+	// Re-append trailing slash
+	if trailing && w > 1 {
+		bufApp(&buf, p, w, '/')
+		w++
+	}
+
+	// If the original string was not modified (or only shortened at the end),
+	// return the respective substring of the original string.
+	// Otherwise return a new string from the buffer.
+	if len(buf) == 0 {
+		return p[:w]
+	}
+	return string(buf[:w])
+}
+
+// Internal helper to lazily create a buffer if necessary.
+// Calls to this function get inlined.
+func bufApp(buf *[]byte, s string, w int, c byte) {
+	b := *buf
+	if len(b) == 0 {
+		// No modification of the original string so far.
+		// If the next character is the same as in the original string, we do
+		// not yet have to allocate a buffer.
+		if s[w] == c {
+			return
+		}
+
+		// Otherwise use either the stack buffer, if it is large enough, or
+		// allocate a new buffer on the heap, and copy all previous characters.
+		if l := len(s); l > cap(b) {
+			*buf = make([]byte, len(s))
+		} else {
+			*buf = (*buf)[:l]
+		}
+		b = *buf
+
+		copy(b, s[:w])
+	}
+	b[w] = c
+}

vendor/github.com/gin-gonic/gin/recovery.go

@@ -0,0 +1,151 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"os"
+	"runtime"
+	"strings"
+	"time"
+)
+
+var (
+	dunno     = []byte("???")
+	centerDot = []byte("·")
+	dot       = []byte(".")
+	slash     = []byte("/")
+)
+
+// Recovery returns a middleware that recovers from any panics and writes a 500 if there was one.
+func Recovery() HandlerFunc {
+	return RecoveryWithWriter(DefaultErrorWriter)
+}
+
+// RecoveryWithWriter returns a middleware for a given writer that recovers from any panics and writes a 500 if there was one.
+func RecoveryWithWriter(out io.Writer) HandlerFunc {
+	var logger *log.Logger
+	if out != nil {
+		logger = log.New(out, "\n\n\x1b[31m", log.LstdFlags)
+	}
+	return func(c *Context) {
+		defer func() {
+			if err := recover(); err != nil {
+				// Check for a broken connection, as it is not really a
+				// condition that warrants a panic stack trace.
+				var brokenPipe bool
+				if ne, ok := err.(*net.OpError); ok {
+					if se, ok := ne.Err.(*os.SyscallError); ok {
+						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
+							brokenPipe = true
+						}
+					}
+				}
+				if logger != nil {
+					stack := stack(3)
+					httpRequest, _ := httputil.DumpRequest(c.Request, false)
+					headers := strings.Split(string(httpRequest), "\r\n")
+					for idx, header := range headers {
+						current := strings.Split(header, ":")
+						if current[0] == "Authorization" {
+							headers[idx] = current[0] + ": *"
+						}
+					}
+					if brokenPipe {
+						logger.Printf("%s\n%s%s", err, string(httpRequest), reset)
+					} else if IsDebugging() {
+						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
+							timeFormat(time.Now()), strings.Join(headers, "\r\n"), err, stack, reset)
+					} else {
+						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s",
+							timeFormat(time.Now()), err, stack, reset)
+					}
+				}
+
+				// If the connection is dead, we can't write a status to it.
+				if brokenPipe {
+					c.Error(err.(error)) // nolint: errcheck
+					c.Abort()
+				} else {
+					c.AbortWithStatus(http.StatusInternalServerError)
+				}
+			}
+		}()
+		c.Next()
+	}
+}
+
+// stack returns a nicely formatted stack frame, skipping skip frames.
+func stack(skip int) []byte {
+	buf := new(bytes.Buffer) // the returned data
+	// As we loop, we open files and read them. These variables record the currently
+	// loaded file.
+	var lines [][]byte
+	var lastFile string
+	for i := skip; ; i++ { // Skip the expected number of frames
+		pc, file, line, ok := runtime.Caller(i)
+		if !ok {
+			break
+		}
+		// Print this much at least.  If we can't find the source, it won't show.
+		fmt.Fprintf(buf, "%s:%d (0x%x)\n", file, line, pc)
+		if file != lastFile {
+			data, err := ioutil.ReadFile(file)
+			if err != nil {
+				continue
+			}
+			lines = bytes.Split(data, []byte{'\n'})
+			lastFile = file
+		}
+		fmt.Fprintf(buf, "\t%s: %s\n", function(pc), source(lines, line))
+	}
+	return buf.Bytes()
+}
+
+// source returns a space-trimmed slice of the n'th line.
+func source(lines [][]byte, n int) []byte {
+	n-- // in stack trace, lines are 1-indexed but our array is 0-indexed
+	if n < 0 || n >= len(lines) {
+		return dunno
+	}
+	return bytes.TrimSpace(lines[n])
+}
+
+// function returns, if possible, the name of the function containing the PC.
+func function(pc uintptr) []byte {
+	fn := runtime.FuncForPC(pc)
+	if fn == nil {
+		return dunno
+	}
+	name := []byte(fn.Name())
+	// The name includes the path name to the package, which is unnecessary
+	// since the file name is already included.  Plus, it has center dots.
+	// That is, we see
+	//	runtime/debug.*T·ptrmethod
+	// and want
+	//	*T.ptrmethod
+	// Also the package path might contains dot (e.g. code.google.com/...),
+	// so first eliminate the path prefix
+	if lastSlash := bytes.LastIndex(name, slash); lastSlash >= 0 {
+		name = name[lastSlash+1:]
+	}
+	if period := bytes.Index(name, dot); period >= 0 {
+		name = name[period+1:]
+	}
+	name = bytes.Replace(name, centerDot, dot, -1)
+	return name
+}
+
+func timeFormat(t time.Time) string {
+	var timeString = t.Format("2006/01/02 - 15:04:05")
+	return timeString
+}

vendor/github.com/gin-gonic/gin/render/data.go

@@ -0,0 +1,25 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import "net/http"
+
+// Data contains ContentType and bytes data.
+type Data struct {
+	ContentType string
+	Data        []byte
+}
+
+// Render (Data) writes data with custom ContentType.
+func (r Data) Render(w http.ResponseWriter) (err error) {
+	r.WriteContentType(w)
+	_, err = w.Write(r.Data)
+	return
+}
+
+// WriteContentType (Data) writes custom ContentType.
+func (r Data) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, []string{r.ContentType})
+}

vendor/github.com/gin-gonic/gin/render/html.go

@@ -0,0 +1,92 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"html/template"
+	"net/http"
+)
+
+// Delims represents a set of Left and Right delimiters for HTML template rendering.
+type Delims struct {
+	// Left delimiter, defaults to {{.
+	Left string
+	// Right delimiter, defaults to }}.
+	Right string
+}
+
+// HTMLRender interface is to be implemented by HTMLProduction and HTMLDebug.
+type HTMLRender interface {
+	// Instance returns an HTML instance.
+	Instance(string, interface{}) Render
+}
+
+// HTMLProduction contains template reference and its delims.
+type HTMLProduction struct {
+	Template *template.Template
+	Delims   Delims
+}
+
+// HTMLDebug contains template delims and pattern and function with file list.
+type HTMLDebug struct {
+	Files   []string
+	Glob    string
+	Delims  Delims
+	FuncMap template.FuncMap
+}
+
+// HTML contains template reference and its name with given interface object.
+type HTML struct {
+	Template *template.Template
+	Name     string
+	Data     interface{}
+}
+
+var htmlContentType = []string{"text/html; charset=utf-8"}
+
+// Instance (HTMLProduction) returns an HTML instance which it realizes Render interface.
+func (r HTMLProduction) Instance(name string, data interface{}) Render {
+	return HTML{
+		Template: r.Template,
+		Name:     name,
+		Data:     data,
+	}
+}
+
+// Instance (HTMLDebug) returns an HTML instance which it realizes Render interface.
+func (r HTMLDebug) Instance(name string, data interface{}) Render {
+	return HTML{
+		Template: r.loadTemplate(),
+		Name:     name,
+		Data:     data,
+	}
+}
+func (r HTMLDebug) loadTemplate() *template.Template {
+	if r.FuncMap == nil {
+		r.FuncMap = template.FuncMap{}
+	}
+	if len(r.Files) > 0 {
+		return template.Must(template.New("").Delims(r.Delims.Left, r.Delims.Right).Funcs(r.FuncMap).ParseFiles(r.Files...))
+	}
+	if r.Glob != "" {
+		return template.Must(template.New("").Delims(r.Delims.Left, r.Delims.Right).Funcs(r.FuncMap).ParseGlob(r.Glob))
+	}
+	panic("the HTML debug render was created without files or glob pattern")
+}
+
+// Render (HTML) executes template and writes its result with custom ContentType for response.
+func (r HTML) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+
+	if r.Name == "" {
+		return r.Template.Execute(w, r.Data)
+	}
+	return r.Template.ExecuteTemplate(w, r.Name, r.Data)
+}
+
+// WriteContentType (HTML) writes HTML ContentType.
+func (r HTML) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, htmlContentType)
+}

vendor/github.com/gin-gonic/gin/render/json.go

@@ -0,0 +1,196 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"bytes"
+	"fmt"
+	"html/template"
+	"net/http"
+
+	"github.com/gin-gonic/gin/internal/bytesconv"
+	"github.com/gin-gonic/gin/internal/json"
+)
+
+// JSON contains the given interface object.
+type JSON struct {
+	Data interface{}
+}
+
+// IndentedJSON contains the given interface object.
+type IndentedJSON struct {
+	Data interface{}
+}
+
+// SecureJSON contains the given interface object and its prefix.
+type SecureJSON struct {
+	Prefix string
+	Data   interface{}
+}
+
+// JsonpJSON contains the given interface object its callback.
+type JsonpJSON struct {
+	Callback string
+	Data     interface{}
+}
+
+// AsciiJSON contains the given interface object.
+type AsciiJSON struct {
+	Data interface{}
+}
+
+// SecureJSONPrefix is a string which represents SecureJSON prefix.
+type SecureJSONPrefix string
+
+// PureJSON contains the given interface object.
+type PureJSON struct {
+	Data interface{}
+}
+
+var jsonContentType = []string{"application/json; charset=utf-8"}
+var jsonpContentType = []string{"application/javascript; charset=utf-8"}
+var jsonAsciiContentType = []string{"application/json"}
+
+// Render (JSON) writes data with custom ContentType.
+func (r JSON) Render(w http.ResponseWriter) (err error) {
+	if err = WriteJSON(w, r.Data); err != nil {
+		panic(err)
+	}
+	return
+}
+
+// WriteContentType (JSON) writes JSON ContentType.
+func (r JSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonContentType)
+}
+
+// WriteJSON marshals the given interface object and writes it with custom ContentType.
+func WriteJSON(w http.ResponseWriter, obj interface{}) error {
+	writeContentType(w, jsonContentType)
+	jsonBytes, err := json.Marshal(obj)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(jsonBytes)
+	return err
+}
+
+// Render (IndentedJSON) marshals the given interface object and writes it with custom ContentType.
+func (r IndentedJSON) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+	jsonBytes, err := json.MarshalIndent(r.Data, "", "    ")
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(jsonBytes)
+	return err
+}
+
+// WriteContentType (IndentedJSON) writes JSON ContentType.
+func (r IndentedJSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonContentType)
+}
+
+// Render (SecureJSON) marshals the given interface object and writes it with custom ContentType.
+func (r SecureJSON) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+	jsonBytes, err := json.Marshal(r.Data)
+	if err != nil {
+		return err
+	}
+	// if the jsonBytes is array values
+	if bytes.HasPrefix(jsonBytes, bytesconv.StringToBytes("[")) && bytes.HasSuffix(jsonBytes,
+		bytesconv.StringToBytes("]")) {
+		_, err = w.Write(bytesconv.StringToBytes(r.Prefix))
+		if err != nil {
+			return err
+		}
+	}
+	_, err = w.Write(jsonBytes)
+	return err
+}
+
+// WriteContentType (SecureJSON) writes JSON ContentType.
+func (r SecureJSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonContentType)
+}
+
+// Render (JsonpJSON) marshals the given interface object and writes it and its callback with custom ContentType.
+func (r JsonpJSON) Render(w http.ResponseWriter) (err error) {
+	r.WriteContentType(w)
+	ret, err := json.Marshal(r.Data)
+	if err != nil {
+		return err
+	}
+
+	if r.Callback == "" {
+		_, err = w.Write(ret)
+		return err
+	}
+
+	callback := template.JSEscapeString(r.Callback)
+	_, err = w.Write(bytesconv.StringToBytes(callback))
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(bytesconv.StringToBytes("("))
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(ret)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(bytesconv.StringToBytes(");"))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// WriteContentType (JsonpJSON) writes Javascript ContentType.
+func (r JsonpJSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonpContentType)
+}
+
+// Render (AsciiJSON) marshals the given interface object and writes it with custom ContentType.
+func (r AsciiJSON) Render(w http.ResponseWriter) (err error) {
+	r.WriteContentType(w)
+	ret, err := json.Marshal(r.Data)
+	if err != nil {
+		return err
+	}
+
+	var buffer bytes.Buffer
+	for _, r := range bytesconv.BytesToString(ret) {
+		cvt := string(r)
+		if r >= 128 {
+			cvt = fmt.Sprintf("\\u%04x", int64(r))
+		}
+		buffer.WriteString(cvt)
+	}
+
+	_, err = w.Write(buffer.Bytes())
+	return err
+}
+
+// WriteContentType (AsciiJSON) writes JSON ContentType.
+func (r AsciiJSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonAsciiContentType)
+}
+
+// Render (PureJSON) writes custom ContentType and encodes the given interface object.
+func (r PureJSON) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+	encoder := json.NewEncoder(w)
+	encoder.SetEscapeHTML(false)
+	return encoder.Encode(r.Data)
+}
+
+// WriteContentType (PureJSON) writes custom ContentType.
+func (r PureJSON) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, jsonContentType)
+}

vendor/github.com/gin-gonic/gin/render/msgpack.go

@@ -0,0 +1,41 @@
+// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// +build !nomsgpack
+
+package render
+
+import (
+	"net/http"
+
+	"github.com/ugorji/go/codec"
+)
+
+var (
+	_ Render = MsgPack{}
+)
+
+// MsgPack contains the given interface object.
+type MsgPack struct {
+	Data interface{}
+}
+
+var msgpackContentType = []string{"application/msgpack; charset=utf-8"}
+
+// WriteContentType (MsgPack) writes MsgPack ContentType.
+func (r MsgPack) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, msgpackContentType)
+}
+
+// Render (MsgPack) encodes the given interface object and writes data with custom ContentType.
+func (r MsgPack) Render(w http.ResponseWriter) error {
+	return WriteMsgPack(w, r.Data)
+}
+
+// WriteMsgPack writes MsgPack ContentType and encodes the given interface object.
+func WriteMsgPack(w http.ResponseWriter, obj interface{}) error {
+	writeContentType(w, msgpackContentType)
+	var mh codec.MsgpackHandle
+	return codec.NewEncoder(w, &mh).Encode(obj)
+}

vendor/github.com/gin-gonic/gin/render/protobuf.go

@@ -0,0 +1,36 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"net/http"
+
+	"github.com/golang/protobuf/proto"
+)
+
+// ProtoBuf contains the given interface object.
+type ProtoBuf struct {
+	Data interface{}
+}
+
+var protobufContentType = []string{"application/x-protobuf"}
+
+// Render (ProtoBuf) marshals the given interface object and writes data with custom ContentType.
+func (r ProtoBuf) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+
+	bytes, err := proto.Marshal(r.Data.(proto.Message))
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(bytes)
+	return err
+}
+
+// WriteContentType (ProtoBuf) writes ProtoBuf ContentType.
+func (r ProtoBuf) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, protobufContentType)
+}

vendor/github.com/gin-gonic/gin/render/reader.go

@@ -0,0 +1,48 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"io"
+	"net/http"
+	"strconv"
+)
+
+// Reader contains the IO reader and its length, and custom ContentType and other headers.
+type Reader struct {
+	ContentType   string
+	ContentLength int64
+	Reader        io.Reader
+	Headers       map[string]string
+}
+
+// Render (Reader) writes data with custom ContentType and headers.
+func (r Reader) Render(w http.ResponseWriter) (err error) {
+	r.WriteContentType(w)
+	if r.ContentLength >= 0 {
+		if r.Headers == nil {
+			r.Headers = map[string]string{}
+		}
+		r.Headers["Content-Length"] = strconv.FormatInt(r.ContentLength, 10)
+	}
+	r.writeHeaders(w, r.Headers)
+	_, err = io.Copy(w, r.Reader)
+	return
+}
+
+// WriteContentType (Reader) writes custom ContentType.
+func (r Reader) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, []string{r.ContentType})
+}
+
+// writeHeaders writes custom Header.
+func (r Reader) writeHeaders(w http.ResponseWriter, headers map[string]string) {
+	header := w.Header()
+	for k, v := range headers {
+		if header.Get(k) == "" {
+			header.Set(k, v)
+		}
+	}
+}

vendor/github.com/gin-gonic/gin/render/redirect.go

@@ -0,0 +1,29 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Redirect contains the http request reference and redirects status code and location.
+type Redirect struct {
+	Code     int
+	Request  *http.Request
+	Location string
+}
+
+// Render (Redirect) redirects the http request to new location and writes redirect response.
+func (r Redirect) Render(w http.ResponseWriter) error {
+	if (r.Code < http.StatusMultipleChoices || r.Code > http.StatusPermanentRedirect) && r.Code != http.StatusCreated {
+		panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code))
+	}
+	http.Redirect(w, r.Request, r.Location, r.Code)
+	return nil
+}
+
+// WriteContentType (Redirect) don't write any ContentType.
+func (r Redirect) WriteContentType(http.ResponseWriter) {}

vendor/github.com/gin-gonic/gin/render/render.go

@@ -0,0 +1,40 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import "net/http"
+
+// Render interface is to be implemented by JSON, XML, HTML, YAML and so on.
+type Render interface {
+	// Render writes data with custom ContentType.
+	Render(http.ResponseWriter) error
+	// WriteContentType writes custom ContentType.
+	WriteContentType(w http.ResponseWriter)
+}
+
+var (
+	_ Render     = JSON{}
+	_ Render     = IndentedJSON{}
+	_ Render     = SecureJSON{}
+	_ Render     = JsonpJSON{}
+	_ Render     = XML{}
+	_ Render     = String{}
+	_ Render     = Redirect{}
+	_ Render     = Data{}
+	_ Render     = HTML{}
+	_ HTMLRender = HTMLDebug{}
+	_ HTMLRender = HTMLProduction{}
+	_ Render     = YAML{}
+	_ Render     = Reader{}
+	_ Render     = AsciiJSON{}
+	_ Render     = ProtoBuf{}
+)
+
+func writeContentType(w http.ResponseWriter, value []string) {
+	header := w.Header()
+	if val := header["Content-Type"]; len(val) == 0 {
+		header["Content-Type"] = value
+	}
+}

vendor/github.com/gin-gonic/gin/render/text.go

@@ -0,0 +1,40 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+)
+
+// String contains the given interface object slice and its format.
+type String struct {
+	Format string
+	Data   []interface{}
+}
+
+var plainContentType = []string{"text/plain; charset=utf-8"}
+
+// Render (String) writes data with custom ContentType.
+func (r String) Render(w http.ResponseWriter) error {
+	return WriteString(w, r.Format, r.Data)
+}
+
+// WriteContentType (String) writes Plain ContentType.
+func (r String) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, plainContentType)
+}
+
+// WriteString writes data according to its format and write custom ContentType.
+func WriteString(w http.ResponseWriter, format string, data []interface{}) (err error) {
+	writeContentType(w, plainContentType)
+	if len(data) > 0 {
+		_, err = fmt.Fprintf(w, format, data...)
+		return
+	}
+	_, err = io.WriteString(w, format)
+	return
+}

vendor/github.com/gin-gonic/gin/render/xml.go

@@ -0,0 +1,28 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"encoding/xml"
+	"net/http"
+)
+
+// XML contains the given interface object.
+type XML struct {
+	Data interface{}
+}
+
+var xmlContentType = []string{"application/xml; charset=utf-8"}
+
+// Render (XML) encodes the given interface object and writes data with custom ContentType.
+func (r XML) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+	return xml.NewEncoder(w).Encode(r.Data)
+}
+
+// WriteContentType (XML) writes XML ContentType for response.
+func (r XML) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, xmlContentType)
+}

vendor/github.com/gin-gonic/gin/render/yaml.go

@@ -0,0 +1,36 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package render
+
+import (
+	"net/http"
+
+	"gopkg.in/yaml.v2"
+)
+
+// YAML contains the given interface object.
+type YAML struct {
+	Data interface{}
+}
+
+var yamlContentType = []string{"application/x-yaml; charset=utf-8"}
+
+// Render (YAML) marshals the given interface object and writes data with custom ContentType.
+func (r YAML) Render(w http.ResponseWriter) error {
+	r.WriteContentType(w)
+
+	bytes, err := yaml.Marshal(r.Data)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(bytes)
+	return err
+}
+
+// WriteContentType (YAML) writes YAML ContentType for response.
+func (r YAML) WriteContentType(w http.ResponseWriter) {
+	writeContentType(w, yamlContentType)
+}

vendor/github.com/gin-gonic/gin/response_writer.go

@@ -0,0 +1,126 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+)
+
+const (
+	noWritten     = -1
+	defaultStatus = http.StatusOK
+)
+
+// ResponseWriter ...
+type ResponseWriter interface {
+	http.ResponseWriter
+	http.Hijacker
+	http.Flusher
+	http.CloseNotifier
+
+	// Returns the HTTP response status code of the current request.
+	Status() int
+
+	// Returns the number of bytes already written into the response http body.
+	// See Written()
+	Size() int
+
+	// Writes the string into the response body.
+	WriteString(string) (int, error)
+
+	// Returns true if the response body was already written.
+	Written() bool
+
+	// Forces to write the http header (status code + headers).
+	WriteHeaderNow()
+
+	// get the http.Pusher for server push
+	Pusher() http.Pusher
+}
+
+type responseWriter struct {
+	http.ResponseWriter
+	size   int
+	status int
+}
+
+var _ ResponseWriter = &responseWriter{}
+
+func (w *responseWriter) reset(writer http.ResponseWriter) {
+	w.ResponseWriter = writer
+	w.size = noWritten
+	w.status = defaultStatus
+}
+
+func (w *responseWriter) WriteHeader(code int) {
+	if code > 0 && w.status != code {
+		if w.Written() {
+			debugPrint("[WARNING] Headers were already written. Wanted to override status code %d with %d", w.status, code)
+		}
+		w.status = code
+	}
+}
+
+func (w *responseWriter) WriteHeaderNow() {
+	if !w.Written() {
+		w.size = 0
+		w.ResponseWriter.WriteHeader(w.status)
+	}
+}
+
+func (w *responseWriter) Write(data []byte) (n int, err error) {
+	w.WriteHeaderNow()
+	n, err = w.ResponseWriter.Write(data)
+	w.size += n
+	return
+}
+
+func (w *responseWriter) WriteString(s string) (n int, err error) {
+	w.WriteHeaderNow()
+	n, err = io.WriteString(w.ResponseWriter, s)
+	w.size += n
+	return
+}
+
+func (w *responseWriter) Status() int {
+	return w.status
+}
+
+func (w *responseWriter) Size() int {
+	return w.size
+}
+
+func (w *responseWriter) Written() bool {
+	return w.size != noWritten
+}
+
+// Hijack implements the http.Hijacker interface.
+func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if w.size < 0 {
+		w.size = 0
+	}
+	return w.ResponseWriter.(http.Hijacker).Hijack()
+}
+
+// CloseNotify implements the http.CloseNotify interface.
+func (w *responseWriter) CloseNotify() <-chan bool {
+	return w.ResponseWriter.(http.CloseNotifier).CloseNotify()
+}
+
+// Flush implements the http.Flush interface.
+func (w *responseWriter) Flush() {
+	w.WriteHeaderNow()
+	w.ResponseWriter.(http.Flusher).Flush()
+}
+
+func (w *responseWriter) Pusher() (pusher http.Pusher) {
+	if pusher, ok := w.ResponseWriter.(http.Pusher); ok {
+		return pusher
+	}
+	return nil
+}

vendor/github.com/gin-gonic/gin/routergroup.go

@@ -0,0 +1,230 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"net/http"
+	"path"
+	"regexp"
+	"strings"
+)
+
+// IRouter defines all router handle interface includes single and group router.
+type IRouter interface {
+	IRoutes
+	Group(string, ...HandlerFunc) *RouterGroup
+}
+
+// IRoutes defines all router handle interface.
+type IRoutes interface {
+	Use(...HandlerFunc) IRoutes
+
+	Handle(string, string, ...HandlerFunc) IRoutes
+	Any(string, ...HandlerFunc) IRoutes
+	GET(string, ...HandlerFunc) IRoutes
+	POST(string, ...HandlerFunc) IRoutes
+	DELETE(string, ...HandlerFunc) IRoutes
+	PATCH(string, ...HandlerFunc) IRoutes
+	PUT(string, ...HandlerFunc) IRoutes
+	OPTIONS(string, ...HandlerFunc) IRoutes
+	HEAD(string, ...HandlerFunc) IRoutes
+
+	StaticFile(string, string) IRoutes
+	Static(string, string) IRoutes
+	StaticFS(string, http.FileSystem) IRoutes
+}
+
+// RouterGroup is used internally to configure router, a RouterGroup is associated with
+// a prefix and an array of handlers (middleware).
+type RouterGroup struct {
+	Handlers HandlersChain
+	basePath string
+	engine   *Engine
+	root     bool
+}
+
+var _ IRouter = &RouterGroup{}
+
+// Use adds middleware to the group, see example code in GitHub.
+func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
+	group.Handlers = append(group.Handlers, middleware...)
+	return group.returnObj()
+}
+
+// Group creates a new router group. You should add all the routes that have common middlewares or the same path prefix.
+// For example, all the routes that use a common middleware for authorization could be grouped.
+func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
+	return &RouterGroup{
+		Handlers: group.combineHandlers(handlers),
+		basePath: group.calculateAbsolutePath(relativePath),
+		engine:   group.engine,
+	}
+}
+
+// BasePath returns the base path of router group.
+// For example, if v := router.Group("/rest/n/v1/api"), v.BasePath() is "/rest/n/v1/api".
+func (group *RouterGroup) BasePath() string {
+	return group.basePath
+}
+
+func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
+	absolutePath := group.calculateAbsolutePath(relativePath)
+	handlers = group.combineHandlers(handlers)
+	group.engine.addRoute(httpMethod, absolutePath, handlers)
+	return group.returnObj()
+}
+
+// Handle registers a new request handle and middleware with the given path and method.
+// The last handler should be the real handler, the other ones should be middleware that can and should be shared among different routes.
+// See the example code in GitHub.
+//
+// For GET, POST, PUT, PATCH and DELETE requests the respective shortcut
+// functions can be used.
+//
+// This function is intended for bulk loading and to allow the usage of less
+// frequently used, non-standardized or custom methods (e.g. for internal
+// communication with a proxy).
+func (group *RouterGroup) Handle(httpMethod, relativePath string, handlers ...HandlerFunc) IRoutes {
+	if matches, err := regexp.MatchString("^[A-Z]+$", httpMethod); !matches || err != nil {
+		panic("http method " + httpMethod + " is not valid")
+	}
+	return group.handle(httpMethod, relativePath, handlers)
+}
+
+// POST is a shortcut for router.Handle("POST", path, handle).
+func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
+	return group.handle(http.MethodPost, relativePath, handlers)
+}
+
+// GET is a shortcut for router.Handle("GET", path, handle).
+func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
+	return group.handle(http.MethodGet, relativePath, handlers)
+}
+
+// DELETE is a shortcut for router.Handle("DELETE", path, handle).
+func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes {
+	return group.handle(http.MethodDelete, relativePath, handlers)
+}
+
+// PATCH is a shortcut for router.Handle("PATCH", path, handle).
+func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) IRoutes {
+	return group.handle(http.MethodPatch, relativePath, handlers)
+}
+
+// PUT is a shortcut for router.Handle("PUT", path, handle).
+func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes {
+	return group.handle(http.MethodPut, relativePath, handlers)
+}
+
+// OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle).
+func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes {
+	return group.handle(http.MethodOptions, relativePath, handlers)
+}
+
+// HEAD is a shortcut for router.Handle("HEAD", path, handle).
+func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) IRoutes {
+	return group.handle(http.MethodHead, relativePath, handlers)
+}
+
+// Any registers a route that matches all the HTTP methods.
+// GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE, CONNECT, TRACE.
+func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) IRoutes {
+	group.handle(http.MethodGet, relativePath, handlers)
+	group.handle(http.MethodPost, relativePath, handlers)
+	group.handle(http.MethodPut, relativePath, handlers)
+	group.handle(http.MethodPatch, relativePath, handlers)
+	group.handle(http.MethodHead, relativePath, handlers)
+	group.handle(http.MethodOptions, relativePath, handlers)
+	group.handle(http.MethodDelete, relativePath, handlers)
+	group.handle(http.MethodConnect, relativePath, handlers)
+	group.handle(http.MethodTrace, relativePath, handlers)
+	return group.returnObj()
+}
+
+// StaticFile registers a single route in order to serve a single file of the local filesystem.
+// router.StaticFile("favicon.ico", "./resources/favicon.ico")
+func (group *RouterGroup) StaticFile(relativePath, filepath string) IRoutes {
+	if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
+		panic("URL parameters can not be used when serving a static file")
+	}
+	handler := func(c *Context) {
+		c.File(filepath)
+	}
+	group.GET(relativePath, handler)
+	group.HEAD(relativePath, handler)
+	return group.returnObj()
+}
+
+// Static serves files from the given file system root.
+// Internally a http.FileServer is used, therefore http.NotFound is used instead
+// of the Router's NotFound handler.
+// To use the operating system's file system implementation,
+// use :
+//     router.Static("/static", "/var/www")
+func (group *RouterGroup) Static(relativePath, root string) IRoutes {
+	return group.StaticFS(relativePath, Dir(root, false))
+}
+
+// StaticFS works just like `Static()` but a custom `http.FileSystem` can be used instead.
+// Gin by default user: gin.Dir()
+func (group *RouterGroup) StaticFS(relativePath string, fs http.FileSystem) IRoutes {
+	if strings.Contains(relativePath, ":") || strings.Contains(relativePath, "*") {
+		panic("URL parameters can not be used when serving a static folder")
+	}
+	handler := group.createStaticHandler(relativePath, fs)
+	urlPattern := path.Join(relativePath, "/*filepath")
+
+	// Register GET and HEAD handlers
+	group.GET(urlPattern, handler)
+	group.HEAD(urlPattern, handler)
+	return group.returnObj()
+}
+
+func (group *RouterGroup) createStaticHandler(relativePath string, fs http.FileSystem) HandlerFunc {
+	absolutePath := group.calculateAbsolutePath(relativePath)
+	fileServer := http.StripPrefix(absolutePath, http.FileServer(fs))
+
+	return func(c *Context) {
+		if _, nolisting := fs.(*onlyfilesFS); nolisting {
+			c.Writer.WriteHeader(http.StatusNotFound)
+		}
+
+		file := c.Param("filepath")
+		// Check if file exists and/or if we have permission to access it
+		f, err := fs.Open(file)
+		if err != nil {
+			c.Writer.WriteHeader(http.StatusNotFound)
+			c.handlers = group.engine.noRoute
+			// Reset index
+			c.index = -1
+			return
+		}
+		f.Close()
+
+		fileServer.ServeHTTP(c.Writer, c.Request)
+	}
+}
+
+func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
+	finalSize := len(group.Handlers) + len(handlers)
+	if finalSize >= int(abortIndex) {
+		panic("too many handlers")
+	}
+	mergedHandlers := make(HandlersChain, finalSize)
+	copy(mergedHandlers, group.Handlers)
+	copy(mergedHandlers[len(group.Handlers):], handlers)
+	return mergedHandlers
+}
+
+func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {
+	return joinPaths(group.basePath, relativePath)
+}
+
+func (group *RouterGroup) returnObj() IRoutes {
+	if group.root {
+		return group.engine
+	}
+	return group
+}

vendor/github.com/gin-gonic/gin/test_helpers.go

@@ -0,0 +1,16 @@
+// Copyright 2017 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import "net/http"
+
+// CreateTestContext returns a fresh engine and context for testing purposes
+func CreateTestContext(w http.ResponseWriter) (c *Context, r *Engine) {
+	r = New()
+	c = r.allocateContext()
+	c.reset()
+	c.writermem.reset(w)
+	return
+}

vendor/github.com/gin-gonic/gin/tree.go

@@ -0,0 +1,684 @@
+// Copyright 2013 Julien Schmidt. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be found
+// at https://github.com/julienschmidt/httprouter/blob/master/LICENSE
+
+package gin
+
+import (
+	"net/url"
+	"strings"
+	"unicode"
+)
+
+// Param is a single URL parameter, consisting of a key and a value.
+type Param struct {
+	Key   string
+	Value string
+}
+
+// Params is a Param-slice, as returned by the router.
+// The slice is ordered, the first URL parameter is also the first slice value.
+// It is therefore safe to read values by the index.
+type Params []Param
+
+// Get returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) Get(name string) (string, bool) {
+	for _, entry := range ps {
+		if entry.Key == name {
+			return entry.Value, true
+		}
+	}
+	return "", false
+}
+
+// ByName returns the value of the first Param which key matches the given name.
+// If no matching Param is found, an empty string is returned.
+func (ps Params) ByName(name string) (va string) {
+	va, _ = ps.Get(name)
+	return
+}
+
+type methodTree struct {
+	method string
+	root   *node
+}
+
+type methodTrees []methodTree
+
+func (trees methodTrees) get(method string) *node {
+	for _, tree := range trees {
+		if tree.method == method {
+			return tree.root
+		}
+	}
+	return nil
+}
+
+func min(a, b int) int {
+	if a <= b {
+		return a
+	}
+	return b
+}
+
+func longestCommonPrefix(a, b string) int {
+	i := 0
+	max := min(len(a), len(b))
+	for i < max && a[i] == b[i] {
+		i++
+	}
+	return i
+}
+
+func countParams(path string) uint8 {
+	var n uint
+	for i := 0; i < len(path); i++ {
+		if path[i] == ':' || path[i] == '*' {
+			n++
+		}
+	}
+	if n >= 255 {
+		return 255
+	}
+	return uint8(n)
+}
+
+type nodeType uint8
+
+const (
+	static nodeType = iota // default
+	root
+	param
+	catchAll
+)
+
+type node struct {
+	path      string
+	indices   string
+	children  []*node
+	handlers  HandlersChain
+	priority  uint32
+	nType     nodeType
+	maxParams uint8
+	wildChild bool
+	fullPath  string
+}
+
+// increments priority of the given child and reorders if necessary.
+func (n *node) incrementChildPrio(pos int) int {
+	cs := n.children
+	cs[pos].priority++
+	prio := cs[pos].priority
+
+	// Adjust position (move to front)
+	newPos := pos
+	for ; newPos > 0 && cs[newPos-1].priority < prio; newPos-- {
+		// Swap node positions
+		cs[newPos-1], cs[newPos] = cs[newPos], cs[newPos-1]
+	}
+
+	// build new index char string
+	if newPos != pos {
+		n.indices = n.indices[:newPos] + // unchanged prefix, might be empty
+			n.indices[pos:pos+1] + // the index char we move
+			n.indices[newPos:pos] + n.indices[pos+1:] // rest without char at 'pos'
+	}
+
+	return newPos
+}
+
+// addRoute adds a node with the given handle to the path.
+// Not concurrency-safe!
+func (n *node) addRoute(path string, handlers HandlersChain) {
+	fullPath := path
+	n.priority++
+	numParams := countParams(path)
+
+	// Empty tree
+	if len(n.path) == 0 && len(n.children) == 0 {
+		n.insertChild(numParams, path, fullPath, handlers)
+		n.nType = root
+		return
+	}
+
+	parentFullPathIndex := 0
+
+walk:
+	for {
+		// Update maxParams of the current node
+		if numParams > n.maxParams {
+			n.maxParams = numParams
+		}
+
+		// Find the longest common prefix.
+		// This also implies that the common prefix contains no ':' or '*'
+		// since the existing key can't contain those chars.
+		i := longestCommonPrefix(path, n.path)
+
+		// Split edge
+		if i < len(n.path) {
+			child := node{
+				path:      n.path[i:],
+				wildChild: n.wildChild,
+				indices:   n.indices,
+				children:  n.children,
+				handlers:  n.handlers,
+				priority:  n.priority - 1,
+				fullPath:  n.fullPath,
+			}
+
+			// Update maxParams (max of all children)
+			for _, v := range child.children {
+				if v.maxParams > child.maxParams {
+					child.maxParams = v.maxParams
+				}
+			}
+
+			n.children = []*node{&child}
+			// []byte for proper unicode char conversion, see #65
+			n.indices = string([]byte{n.path[i]})
+			n.path = path[:i]
+			n.handlers = nil
+			n.wildChild = false
+			n.fullPath = fullPath[:parentFullPathIndex+i]
+		}
+
+		// Make new node a child of this node
+		if i < len(path) {
+			path = path[i:]
+
+			if n.wildChild {
+				parentFullPathIndex += len(n.path)
+				n = n.children[0]
+				n.priority++
+
+				// Update maxParams of the child node
+				if numParams > n.maxParams {
+					n.maxParams = numParams
+				}
+				numParams--
+
+				// Check if the wildcard matches
+				if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
+					// check for longer wildcard, e.g. :name and :names
+					if len(n.path) >= len(path) || path[len(n.path)] == '/' {
+						continue walk
+					}
+				}
+
+				pathSeg := path
+				if n.nType != catchAll {
+					pathSeg = strings.SplitN(path, "/", 2)[0]
+				}
+				prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
+				panic("'" + pathSeg +
+					"' in new path '" + fullPath +
+					"' conflicts with existing wildcard '" + n.path +
+					"' in existing prefix '" + prefix +
+					"'")
+			}
+
+			c := path[0]
+
+			// slash after param
+			if n.nType == param && c == '/' && len(n.children) == 1 {
+				parentFullPathIndex += len(n.path)
+				n = n.children[0]
+				n.priority++
+				continue walk
+			}
+
+			// Check if a child with the next path byte exists
+			for i, max := 0, len(n.indices); i < max; i++ {
+				if c == n.indices[i] {
+					parentFullPathIndex += len(n.path)
+					i = n.incrementChildPrio(i)
+					n = n.children[i]
+					continue walk
+				}
+			}
+
+			// Otherwise insert it
+			if c != ':' && c != '*' {
+				// []byte for proper unicode char conversion, see #65
+				n.indices += string([]byte{c})
+				child := &node{
+					maxParams: numParams,
+					fullPath:  fullPath,
+				}
+				n.children = append(n.children, child)
+				n.incrementChildPrio(len(n.indices) - 1)
+				n = child
+			}
+			n.insertChild(numParams, path, fullPath, handlers)
+			return
+		}
+
+		// Otherwise and handle to current node
+		if n.handlers != nil {
+			panic("handlers are already registered for path '" + fullPath + "'")
+		}
+		n.handlers = handlers
+		return
+	}
+}
+
+// Search for a wildcard segment and check the name for invalid characters.
+// Returns -1 as index, if no wildcard war found.
+func findWildcard(path string) (wildcard string, i int, valid bool) {
+	// Find start
+	for start, c := range []byte(path) {
+		// A wildcard starts with ':' (param) or '*' (catch-all)
+		if c != ':' && c != '*' {
+			continue
+		}
+
+		// Find end and check for invalid characters
+		valid = true
+		for end, c := range []byte(path[start+1:]) {
+			switch c {
+			case '/':
+				return path[start : start+1+end], start, valid
+			case ':', '*':
+				valid = false
+			}
+		}
+		return path[start:], start, valid
+	}
+	return "", -1, false
+}
+
+func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers HandlersChain) {
+	for numParams > 0 {
+		// Find prefix until first wildcard
+		wildcard, i, valid := findWildcard(path)
+		if i < 0 { // No wildcard found
+			break
+		}
+
+		// The wildcard name must not contain ':' and '*'
+		if !valid {
+			panic("only one wildcard per path segment is allowed, has: '" +
+				wildcard + "' in path '" + fullPath + "'")
+		}
+
+		// check if the wildcard has a name
+		if len(wildcard) < 2 {
+			panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
+		}
+
+		// Check if this node has existing children which would be
+		// unreachable if we insert the wildcard here
+		if len(n.children) > 0 {
+			panic("wildcard segment '" + wildcard +
+				"' conflicts with existing children in path '" + fullPath + "'")
+		}
+
+		if wildcard[0] == ':' { // param
+			if i > 0 {
+				// Insert prefix before the current wildcard
+				n.path = path[:i]
+				path = path[i:]
+			}
+
+			n.wildChild = true
+			child := &node{
+				nType:     param,
+				path:      wildcard,
+				maxParams: numParams,
+				fullPath:  fullPath,
+			}
+			n.children = []*node{child}
+			n = child
+			n.priority++
+			numParams--
+
+			// if the path doesn't end with the wildcard, then there
+			// will be another non-wildcard subpath starting with '/'
+			if len(wildcard) < len(path) {
+				path = path[len(wildcard):]
+
+				child := &node{
+					maxParams: numParams,
+					priority:  1,
+					fullPath:  fullPath,
+				}
+				n.children = []*node{child}
+				n = child
+				continue
+			}
+
+			// Otherwise we're done. Insert the handle in the new leaf
+			n.handlers = handlers
+			return
+		}
+
+		// catchAll
+		if i+len(wildcard) != len(path) || numParams > 1 {
+			panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
+		}
+
+		if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
+			panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
+		}
+
+		// currently fixed width 1 for '/'
+		i--
+		if path[i] != '/' {
+			panic("no / before catch-all in path '" + fullPath + "'")
+		}
+
+		n.path = path[:i]
+
+		// First node: catchAll node with empty path
+		child := &node{
+			wildChild: true,
+			nType:     catchAll,
+			maxParams: 1,
+			fullPath:  fullPath,
+		}
+		// update maxParams of the parent node
+		if n.maxParams < 1 {
+			n.maxParams = 1
+		}
+		n.children = []*node{child}
+		n.indices = string('/')
+		n = child
+		n.priority++
+
+		// second node: node holding the variable
+		child = &node{
+			path:      path[i:],
+			nType:     catchAll,
+			maxParams: 1,
+			handlers:  handlers,
+			priority:  1,
+			fullPath:  fullPath,
+		}
+		n.children = []*node{child}
+
+		return
+	}
+
+	// If no wildcard was found, simply insert the path and handle
+	n.path = path
+	n.handlers = handlers
+	n.fullPath = fullPath
+}
+
+// nodeValue holds return values of (*Node).getValue method
+type nodeValue struct {
+	handlers HandlersChain
+	params   Params
+	tsr      bool
+	fullPath string
+}
+
+// getValue returns the handle registered with the given path (key). The values of
+// wildcards are saved to a map.
+// If no handle can be found, a TSR (trailing slash redirect) recommendation is
+// made if a handle exists with an extra (without the) trailing slash for the
+// given path.
+func (n *node) getValue(path string, po Params, unescape bool) (value nodeValue) {
+	value.params = po
+walk: // Outer loop for walking the tree
+	for {
+		prefix := n.path
+		if path == prefix {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if value.handlers = n.handlers; value.handlers != nil {
+				value.fullPath = n.fullPath
+				return
+			}
+
+			if path == "/" && n.wildChild && n.nType != root {
+				value.tsr = true
+				return
+			}
+
+			// No handle found. Check if a handle for this path + a
+			// trailing slash exists for trailing slash recommendation
+			indices := n.indices
+			for i, max := 0, len(indices); i < max; i++ {
+				if indices[i] == '/' {
+					n = n.children[i]
+					value.tsr = (len(n.path) == 1 && n.handlers != nil) ||
+						(n.nType == catchAll && n.children[0].handlers != nil)
+					return
+				}
+			}
+
+			return
+		}
+
+		if len(path) > len(prefix) && path[:len(prefix)] == prefix {
+			path = path[len(prefix):]
+			// If this node does not have a wildcard (param or catchAll)
+			// child,  we can just look up the next child node and continue
+			// to walk down the tree
+			if !n.wildChild {
+				c := path[0]
+				indices := n.indices
+				for i, max := 0, len(indices); i < max; i++ {
+					if c == indices[i] {
+						n = n.children[i]
+						continue walk
+					}
+				}
+
+				// Nothing found.
+				// We can recommend to redirect to the same URL without a
+				// trailing slash if a leaf exists for that path.
+				value.tsr = path == "/" && n.handlers != nil
+				return
+			}
+
+			// handle wildcard child
+			n = n.children[0]
+			switch n.nType {
+			case param:
+				// find param end (either '/' or path end)
+				end := 0
+				for end < len(path) && path[end] != '/' {
+					end++
+				}
+
+				// save param value
+				if cap(value.params) < int(n.maxParams) {
+					value.params = make(Params, 0, n.maxParams)
+				}
+				i := len(value.params)
+				value.params = value.params[:i+1] // expand slice within preallocated capacity
+				value.params[i].Key = n.path[1:]
+				val := path[:end]
+				if unescape {
+					var err error
+					if value.params[i].Value, err = url.QueryUnescape(val); err != nil {
+						value.params[i].Value = val // fallback, in case of error
+					}
+				} else {
+					value.params[i].Value = val
+				}
+
+				// we need to go deeper!
+				if end < len(path) {
+					if len(n.children) > 0 {
+						path = path[end:]
+						n = n.children[0]
+						continue walk
+					}
+
+					// ... but we can't
+					value.tsr = len(path) == end+1
+					return
+				}
+
+				if value.handlers = n.handlers; value.handlers != nil {
+					value.fullPath = n.fullPath
+					return
+				}
+				if len(n.children) == 1 {
+					// No handle found. Check if a handle for this path + a
+					// trailing slash exists for TSR recommendation
+					n = n.children[0]
+					value.tsr = n.path == "/" && n.handlers != nil
+				}
+				return
+
+			case catchAll:
+				// save param value
+				if cap(value.params) < int(n.maxParams) {
+					value.params = make(Params, 0, n.maxParams)
+				}
+				i := len(value.params)
+				value.params = value.params[:i+1] // expand slice within preallocated capacity
+				value.params[i].Key = n.path[2:]
+				if unescape {
+					var err error
+					if value.params[i].Value, err = url.QueryUnescape(path); err != nil {
+						value.params[i].Value = path // fallback, in case of error
+					}
+				} else {
+					value.params[i].Value = path
+				}
+
+				value.handlers = n.handlers
+				value.fullPath = n.fullPath
+				return
+
+			default:
+				panic("invalid node type")
+			}
+		}
+
+		// Nothing found. We can recommend to redirect to the same URL with an
+		// extra trailing slash if a leaf exists for that path
+		value.tsr = (path == "/") ||
+			(len(prefix) == len(path)+1 && prefix[len(path)] == '/' &&
+				path == prefix[:len(prefix)-1] && n.handlers != nil)
+		return
+	}
+}
+
+// findCaseInsensitivePath makes a case-insensitive lookup of the given path and tries to find a handler.
+// It can optionally also fix trailing slashes.
+// It returns the case-corrected path and a bool indicating whether the lookup
+// was successful.
+func (n *node) findCaseInsensitivePath(path string, fixTrailingSlash bool) (ciPath []byte, found bool) {
+	ciPath = make([]byte, 0, len(path)+1) // preallocate enough memory
+
+	// Outer loop for walking the tree
+	for len(path) >= len(n.path) && strings.EqualFold(path[:len(n.path)], n.path) {
+		path = path[len(n.path):]
+		ciPath = append(ciPath, n.path...)
+
+		if len(path) == 0 {
+			// We should have reached the node containing the handle.
+			// Check if this node has a handle registered.
+			if n.handlers != nil {
+				return ciPath, true
+			}
+
+			// No handle found.
+			// Try to fix the path by adding a trailing slash
+			if fixTrailingSlash {
+				for i := 0; i < len(n.indices); i++ {
+					if n.indices[i] == '/' {
+						n = n.children[i]
+						if (len(n.path) == 1 && n.handlers != nil) ||
+							(n.nType == catchAll && n.children[0].handlers != nil) {
+							return append(ciPath, '/'), true
+						}
+						return
+					}
+				}
+			}
+			return
+		}
+
+		// If this node does not have a wildcard (param or catchAll) child,
+		// we can just look up the next child node and continue to walk down
+		// the tree
+		if !n.wildChild {
+			r := unicode.ToLower(rune(path[0]))
+			for i, index := range n.indices {
+				// must use recursive approach since both index and
+				// ToLower(index) could exist. We must check both.
+				if r == unicode.ToLower(index) {
+					out, found := n.children[i].findCaseInsensitivePath(path, fixTrailingSlash)
+					if found {
+						return append(ciPath, out...), true
+					}
+				}
+			}
+
+			// Nothing found. We can recommend to redirect to the same URL
+			// without a trailing slash if a leaf exists for that path
+			found = fixTrailingSlash && path == "/" && n.handlers != nil
+			return
+		}
+
+		n = n.children[0]
+		switch n.nType {
+		case param:
+			// Find param end (either '/' or path end)
+			end := 0
+			for end < len(path) && path[end] != '/' {
+				end++
+			}
+
+			// add param value to case insensitive path
+			ciPath = append(ciPath, path[:end]...)
+
+			// we need to go deeper!
+			if end < len(path) {
+				if len(n.children) > 0 {
+					path = path[end:]
+					n = n.children[0]
+					continue
+				}
+
+				// ... but we can't
+				if fixTrailingSlash && len(path) == end+1 {
+					return ciPath, true
+				}
+				return
+			}
+
+			if n.handlers != nil {
+				return ciPath, true
+			}
+			if fixTrailingSlash && len(n.children) == 1 {
+				// No handle found. Check if a handle for this path + a
+				// trailing slash exists
+				n = n.children[0]
+				if n.path == "/" && n.handlers != nil {
+					return append(ciPath, '/'), true
+				}
+			}
+			return
+
+		case catchAll:
+			return append(ciPath, path...), true
+
+		default:
+			panic("invalid node type")
+		}
+	}
+
+	// Nothing found.
+	// Try to fix the path by adding / removing a trailing slash
+	if fixTrailingSlash {
+		if path == "/" {
+			return ciPath, true
+		}
+		if len(path)+1 == len(n.path) && n.path[len(path)] == '/' &&
+			strings.EqualFold(path, n.path[:len(path)]) &&
+			n.handlers != nil {
+			return append(ciPath, n.path...), true
+		}
+	}
+	return
+}

vendor/github.com/gin-gonic/gin/utils.go

@@ -0,0 +1,151 @@
+// Copyright 2014 Manu Martinez-Almeida.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+import (
+	"encoding/xml"
+	"net/http"
+	"os"
+	"path"
+	"reflect"
+	"runtime"
+	"strings"
+)
+
+// BindKey indicates a default bind key.
+const BindKey = "_gin-gonic/gin/bindkey"
+
+// Bind is a helper function for given interface object and returns a Gin middleware.
+func Bind(val interface{}) HandlerFunc {
+	value := reflect.ValueOf(val)
+	if value.Kind() == reflect.Ptr {
+		panic(`Bind struct can not be a pointer. Example:
+	Use: gin.Bind(Struct{}) instead of gin.Bind(&Struct{})
+`)
+	}
+	typ := value.Type()
+
+	return func(c *Context) {
+		obj := reflect.New(typ).Interface()
+		if c.Bind(obj) == nil {
+			c.Set(BindKey, obj)
+		}
+	}
+}
+
+// WrapF is a helper function for wrapping http.HandlerFunc and returns a Gin middleware.
+func WrapF(f http.HandlerFunc) HandlerFunc {
+	return func(c *Context) {
+		f(c.Writer, c.Request)
+	}
+}
+
+// WrapH is a helper function for wrapping http.Handler and returns a Gin middleware.
+func WrapH(h http.Handler) HandlerFunc {
+	return func(c *Context) {
+		h.ServeHTTP(c.Writer, c.Request)
+	}
+}
+
+// H is a shortcut for map[string]interface{}
+type H map[string]interface{}
+
+// MarshalXML allows type H to be used with xml.Marshal.
+func (h H) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	start.Name = xml.Name{
+		Space: "",
+		Local: "map",
+	}
+	if err := e.EncodeToken(start); err != nil {
+		return err
+	}
+	for key, value := range h {
+		elem := xml.StartElement{
+			Name: xml.Name{Space: "", Local: key},
+			Attr: []xml.Attr{},
+		}
+		if err := e.EncodeElement(value, elem); err != nil {
+			return err
+		}
+	}
+
+	return e.EncodeToken(xml.EndElement{Name: start.Name})
+}
+
+func assert1(guard bool, text string) {
+	if !guard {
+		panic(text)
+	}
+}
+
+func filterFlags(content string) string {
+	for i, char := range content {
+		if char == ' ' || char == ';' {
+			return content[:i]
+		}
+	}
+	return content
+}
+
+func chooseData(custom, wildcard interface{}) interface{} {
+	if custom == nil {
+		if wildcard == nil {
+			panic("negotiation config is invalid")
+		}
+		return wildcard
+	}
+	return custom
+}
+
+func parseAccept(acceptHeader string) []string {
+	parts := strings.Split(acceptHeader, ",")
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		if part = strings.TrimSpace(strings.Split(part, ";")[0]); part != "" {
+			out = append(out, part)
+		}
+	}
+	return out
+}
+
+func lastChar(str string) uint8 {
+	if str == "" {
+		panic("The length of the string can't be 0")
+	}
+	return str[len(str)-1]
+}
+
+func nameOfFunction(f interface{}) string {
+	return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
+}
+
+func joinPaths(absolutePath, relativePath string) string {
+	if relativePath == "" {
+		return absolutePath
+	}
+
+	finalPath := path.Join(absolutePath, relativePath)
+	appendSlash := lastChar(relativePath) == '/' && lastChar(finalPath) != '/'
+	if appendSlash {
+		return finalPath + "/"
+	}
+	return finalPath
+}
+
+func resolveAddress(addr []string) string {
+	switch len(addr) {
+	case 0:
+		if port := os.Getenv("PORT"); port != "" {
+			debugPrint("Environment variable PORT=\"%s\"", port)
+			return ":" + port
+		}
+		debugPrint("Environment variable PORT is undefined. Using port :8080 by default")
+		return ":8080"
+	case 1:
+		return addr[0]
+	default:
+		panic("too many parameters")
+	}
+}

vendor/github.com/gin-gonic/gin/version.go

@@ -0,0 +1,8 @@
+// Copyright 2018 Gin Core Team.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package gin
+
+// Version is the current gin framework's version.
+const Version = "v1.6.3"

vendor/github.com/go-playground/locales/.gitignore

@@ -0,0 +1,24 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof

vendor/github.com/go-playground/locales/.travis.yml

@@ -0,0 +1,26 @@
+language: go
+go:
+  - 1.13.1
+  - tip
+matrix:
+  allow_failures:
+    - go: tip
+
+notifications:
+  email:
+    recipients: dean.karn@gmail.com
+    on_success: change
+    on_failure: always
+
+before_install:
+  - go install github.com/mattn/goveralls
+
+# Only clone the most recent commit.
+git:
+  depth: 1
+
+script:
+  - go test -v -race -covermode=atomic -coverprofile=coverage.coverprofile ./...
+
+after_success: |
+  goveralls -coverprofile=coverage.coverprofile -service travis-ci -repotoken $COVERALLS_TOKEN

vendor/github.com/go-playground/locales/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Go Playground
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/go-playground/locales/README.md

@@ -0,0 +1,172 @@
+## locales
+<img align="right" src="https://raw.githubusercontent.com/go-playground/locales/master/logo.png">![Project status](https://img.shields.io/badge/version-0.13.0-green.svg)
+[![Build Status](https://travis-ci.org/go-playground/locales.svg?branch=master)](https://travis-ci.org/go-playground/locales)
+[![Go Report Card](https://goreportcard.com/badge/github.com/go-playground/locales)](https://goreportcard.com/report/github.com/go-playground/locales)
+[![GoDoc](https://godoc.org/github.com/go-playground/locales?status.svg)](https://godoc.org/github.com/go-playground/locales)
+![License](https://img.shields.io/dub/l/vibe-d.svg)
+[![Gitter](https://badges.gitter.im/go-playground/locales.svg)](https://gitter.im/go-playground/locales?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+Locales is a set of locales generated from the [Unicode CLDR Project](http://cldr.unicode.org/) which can be used independently or within
+an i18n package; these were built for use with, but not exclusive to, [Universal Translator](https://github.com/go-playground/universal-translator).
+
+Features
+--------
+- [x] Rules generated from the latest [CLDR](http://cldr.unicode.org/index/downloads) data, v31.0.1
+- [x] Contains Cardinal, Ordinal and Range Plural Rules
+- [x] Contains Month, Weekday and Timezone translations built in
+- [x] Contains Date & Time formatting functions
+- [x] Contains Number, Currency, Accounting and Percent formatting functions
+- [x] Supports the "Gregorian" calendar only ( my time isn't unlimited, had to draw the line somewhere )
+
+Full Tests
+--------------------
+I could sure use your help adding tests for every locale, it is a huge undertaking and I just don't have the free time to do it all at the moment;
+any help would be **greatly appreciated!!!!** please see [issue](https://github.com/go-playground/locales/issues/1) for details.
+
+Installation
+-----------
+
+Use go get 
+
+```shell
+go get github.com/go-playground/locales
+```  
+
+NOTES
+--------
+You'll notice most return types are []byte, this is because most of the time the results will be concatenated with a larger body
+of text and can avoid some allocations if already appending to a byte array, otherwise just cast as string.
+
+Usage
+-------
+```go
+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/go-playground/locales/currency"
+	"github.com/go-playground/locales/en_CA"
+)
+
+func main() {
+
+	loc, _ := time.LoadLocation("America/Toronto")
+	datetime := time.Date(2016, 02, 03, 9, 0, 1, 0, loc)
+
+	l := en_CA.New()
+
+	// Dates
+	fmt.Println(l.FmtDateFull(datetime))
+	fmt.Println(l.FmtDateLong(datetime))
+	fmt.Println(l.FmtDateMedium(datetime))
+	fmt.Println(l.FmtDateShort(datetime))
+
+	// Times
+	fmt.Println(l.FmtTimeFull(datetime))
+	fmt.Println(l.FmtTimeLong(datetime))
+	fmt.Println(l.FmtTimeMedium(datetime))
+	fmt.Println(l.FmtTimeShort(datetime))
+
+	// Months Wide
+	fmt.Println(l.MonthWide(time.January))
+	fmt.Println(l.MonthWide(time.February))
+	fmt.Println(l.MonthWide(time.March))
+	// ...
+
+	// Months Abbreviated
+	fmt.Println(l.MonthAbbreviated(time.January))
+	fmt.Println(l.MonthAbbreviated(time.February))
+	fmt.Println(l.MonthAbbreviated(time.March))
+	// ...
+
+	// Months Narrow
+	fmt.Println(l.MonthNarrow(time.January))
+	fmt.Println(l.MonthNarrow(time.February))
+	fmt.Println(l.MonthNarrow(time.March))
+	// ...
+
+	// Weekdays Wide
+	fmt.Println(l.WeekdayWide(time.Sunday))
+	fmt.Println(l.WeekdayWide(time.Monday))
+	fmt.Println(l.WeekdayWide(time.Tuesday))
+	// ...
+
+	// Weekdays Abbreviated
+	fmt.Println(l.WeekdayAbbreviated(time.Sunday))
+	fmt.Println(l.WeekdayAbbreviated(time.Monday))
+	fmt.Println(l.WeekdayAbbreviated(time.Tuesday))
+	// ...
+
+	// Weekdays Short
+	fmt.Println(l.WeekdayShort(time.Sunday))
+	fmt.Println(l.WeekdayShort(time.Monday))
+	fmt.Println(l.WeekdayShort(time.Tuesday))
+	// ...
+
+	// Weekdays Narrow
+	fmt.Println(l.WeekdayNarrow(time.Sunday))
+	fmt.Println(l.WeekdayNarrow(time.Monday))
+	fmt.Println(l.WeekdayNarrow(time.Tuesday))
+	// ...
+
+	var f64 float64
+
+	f64 = -10356.4523
+
+	// Number
+	fmt.Println(l.FmtNumber(f64, 2))
+
+	// Currency
+	fmt.Println(l.FmtCurrency(f64, 2, currency.CAD))
+	fmt.Println(l.FmtCurrency(f64, 2, currency.USD))
+
+	// Accounting
+	fmt.Println(l.FmtAccounting(f64, 2, currency.CAD))
+	fmt.Println(l.FmtAccounting(f64, 2, currency.USD))
+
+	f64 = 78.12
+
+	// Percent
+	fmt.Println(l.FmtPercent(f64, 0))
+
+	// Plural Rules for locale, so you know what rules you must cover
+	fmt.Println(l.PluralsCardinal())
+	fmt.Println(l.PluralsOrdinal())
+
+	// Cardinal Plural Rules
+	fmt.Println(l.CardinalPluralRule(1, 0))
+	fmt.Println(l.CardinalPluralRule(1.0, 0))
+	fmt.Println(l.CardinalPluralRule(1.0, 1))
+	fmt.Println(l.CardinalPluralRule(3, 0))
+
+	// Ordinal Plural Rules
+	fmt.Println(l.OrdinalPluralRule(21, 0)) // 21st
+	fmt.Println(l.OrdinalPluralRule(22, 0)) // 22nd
+	fmt.Println(l.OrdinalPluralRule(33, 0)) // 33rd
+	fmt.Println(l.OrdinalPluralRule(34, 0)) // 34th
+
+	// Range Plural Rules
+	fmt.Println(l.RangePluralRule(1, 0, 1, 0)) // 1-1
+	fmt.Println(l.RangePluralRule(1, 0, 2, 0)) // 1-2
+	fmt.Println(l.RangePluralRule(5, 0, 8, 0)) // 5-8
+}
+```
+
+NOTES:
+-------
+These rules were generated from the [Unicode CLDR Project](http://cldr.unicode.org/), if you encounter any issues
+I strongly encourage contributing to the CLDR project to get the locale information corrected and the next time 
+these locales are regenerated the fix will come with.
+
+I do however realize that time constraints are often important and so there are two options:
+
+1. Create your own locale, copy, paste and modify, and ensure it complies with the `Translator` interface.
+2. Add an exception in the locale generation code directly and once regenerated, fix will be in place.
+
+Please to not make fixes inside the locale files, they WILL get overwritten when the locales are regenerated.
+
+License
+------
+Distributed under MIT License, please see license file in code for more details.

vendor/github.com/go-playground/locales/currency/currency.go

@@ -0,0 +1,308 @@
+package currency
+
+// Type is the currency type associated with the locales currency enum
+type Type int
+
+// locale currencies
+const (
+	ADP Type = iota
+	AED
+	AFA
+	AFN
+	ALK
+	ALL
+	AMD
+	ANG
+	AOA
+	AOK
+	AON
+	AOR
+	ARA
+	ARL
+	ARM
+	ARP
+	ARS
+	ATS
+	AUD
+	AWG
+	AZM
+	AZN
+	BAD
+	BAM
+	BAN
+	BBD
+	BDT
+	BEC
+	BEF
+	BEL
+	BGL
+	BGM
+	BGN
+	BGO
+	BHD
+	BIF
+	BMD
+	BND
+	BOB
+	BOL
+	BOP
+	BOV
+	BRB
+	BRC
+	BRE
+	BRL
+	BRN
+	BRR
+	BRZ
+	BSD
+	BTN
+	BUK
+	BWP
+	BYB
+	BYN
+	BYR
+	BZD
+	CAD
+	CDF
+	CHE
+	CHF
+	CHW
+	CLE
+	CLF
+	CLP
+	CNH
+	CNX
+	CNY
+	COP
+	COU
+	CRC
+	CSD
+	CSK
+	CUC
+	CUP
+	CVE
+	CYP
+	CZK
+	DDM
+	DEM
+	DJF
+	DKK
+	DOP
+	DZD
+	ECS
+	ECV
+	EEK
+	EGP
+	ERN
+	ESA
+	ESB
+	ESP
+	ETB
+	EUR
+	FIM
+	FJD
+	FKP
+	FRF
+	GBP
+	GEK
+	GEL
+	GHC
+	GHS
+	GIP
+	GMD
+	GNF
+	GNS
+	GQE
+	GRD
+	GTQ
+	GWE
+	GWP
+	GYD
+	HKD
+	HNL
+	HRD
+	HRK
+	HTG
+	HUF
+	IDR
+	IEP
+	ILP
+	ILR
+	ILS
+	INR
+	IQD
+	IRR
+	ISJ
+	ISK
+	ITL
+	JMD
+	JOD
+	JPY
+	KES
+	KGS
+	KHR
+	KMF
+	KPW
+	KRH
+	KRO
+	KRW
+	KWD
+	KYD
+	KZT
+	LAK
+	LBP
+	LKR
+	LRD
+	LSL
+	LTL
+	LTT
+	LUC
+	LUF
+	LUL
+	LVL
+	LVR
+	LYD
+	MAD
+	MAF
+	MCF
+	MDC
+	MDL
+	MGA
+	MGF
+	MKD
+	MKN
+	MLF
+	MMK
+	MNT
+	MOP
+	MRO
+	MTL
+	MTP
+	MUR
+	MVP
+	MVR
+	MWK
+	MXN
+	MXP
+	MXV
+	MYR
+	MZE
+	MZM
+	MZN
+	NAD
+	NGN
+	NIC
+	NIO
+	NLG
+	NOK
+	NPR
+	NZD
+	OMR
+	PAB
+	PEI
+	PEN
+	PES
+	PGK
+	PHP
+	PKR
+	PLN
+	PLZ
+	PTE
+	PYG
+	QAR
+	RHD
+	ROL
+	RON
+	RSD
+	RUB
+	RUR
+	RWF
+	SAR
+	SBD
+	SCR
+	SDD
+	SDG
+	SDP
+	SEK
+	SGD
+	SHP
+	SIT
+	SKK
+	SLL
+	SOS
+	SRD
+	SRG
+	SSP
+	STD
+	STN
+	SUR
+	SVC
+	SYP
+	SZL
+	THB
+	TJR
+	TJS
+	TMM
+	TMT
+	TND
+	TOP
+	TPE
+	TRL
+	TRY
+	TTD
+	TWD
+	TZS
+	UAH
+	UAK
+	UGS
+	UGX
+	USD
+	USN
+	USS
+	UYI
+	UYP
+	UYU
+	UZS
+	VEB
+	VEF
+	VND
+	VNN
+	VUV
+	WST
+	XAF
+	XAG
+	XAU
+	XBA
+	XBB
+	XBC
+	XBD
+	XCD
+	XDR
+	XEU
+	XFO
+	XFU
+	XOF
+	XPD
+	XPF
+	XPT
+	XRE
+	XSU
+	XTS
+	XUA
+	XXX
+	YDD
+	YER
+	YUD
+	YUM
+	YUN
+	YUR
+	ZAL
+	ZAR
+	ZMK
+	ZMW
+	ZRN
+	ZRZ
+	ZWD
+	ZWL
+	ZWR
+)

vendor/github.com/go-playground/locales/go.mod

@@ -0,0 +1,5 @@
+module github.com/go-playground/locales
+
+go 1.13
+
+require golang.org/x/text v0.3.2

vendor/github.com/go-playground/locales/go.sum

@@ -0,0 +1,3 @@
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

vendor/github.com/go-playground/locales/rules.go

@@ -0,0 +1,293 @@
+package locales
+
+import (
+	"strconv"
+	"time"
+
+	"github.com/go-playground/locales/currency"
+)
+
+// // ErrBadNumberValue is returned when the number passed for
+// // plural rule determination cannot be parsed
+// type ErrBadNumberValue struct {
+// 	NumberValue string
+// 	InnerError  error
+// }
+
+// // Error returns ErrBadNumberValue error string
+// func (e *ErrBadNumberValue) Error() string {
+// 	return fmt.Sprintf("Invalid Number Value '%s' %s", e.NumberValue, e.InnerError)
+// }
+
+// var _ error = new(ErrBadNumberValue)
+
+// PluralRule denotes the type of plural rules
+type PluralRule int
+
+// PluralRule's
+const (
+	PluralRuleUnknown PluralRule = iota
+	PluralRuleZero               // zero
+	PluralRuleOne                // one - singular
+	PluralRuleTwo                // two - dual
+	PluralRuleFew                // few - paucal
+	PluralRuleMany               // many - also used for fractions if they have a separate class
+	PluralRuleOther              // other - required—general plural form—also used if the language only has a single form
+)
+
+const (
+	pluralsString = "UnknownZeroOneTwoFewManyOther"
+)
+
+// Translator encapsulates an instance of a locale
+// NOTE: some values are returned as a []byte just in case the caller
+// wishes to add more and can help avoid allocations; otherwise just cast as string
+type Translator interface {
+
+	// The following Functions are for overriding, debugging or developing
+	// with a Translator Locale
+
+	// Locale returns the string value of the translator
+	Locale() string
+
+	// returns an array of cardinal plural rules associated
+	// with this translator
+	PluralsCardinal() []PluralRule
+
+	// returns an array of ordinal plural rules associated
+	// with this translator
+	PluralsOrdinal() []PluralRule
+
+	// returns an array of range plural rules associated
+	// with this translator
+	PluralsRange() []PluralRule
+
+	// returns the cardinal PluralRule given 'num' and digits/precision of 'v' for locale
+	CardinalPluralRule(num float64, v uint64) PluralRule
+
+	// returns the ordinal PluralRule given 'num' and digits/precision of 'v' for locale
+	OrdinalPluralRule(num float64, v uint64) PluralRule
+
+	// returns the ordinal PluralRule given 'num1', 'num2' and digits/precision of 'v1' and 'v2' for locale
+	RangePluralRule(num1 float64, v1 uint64, num2 float64, v2 uint64) PluralRule
+
+	// returns the locales abbreviated month given the 'month' provided
+	MonthAbbreviated(month time.Month) string
+
+	// returns the locales abbreviated months
+	MonthsAbbreviated() []string
+
+	// returns the locales narrow month given the 'month' provided
+	MonthNarrow(month time.Month) string
+
+	// returns the locales narrow months
+	MonthsNarrow() []string
+
+	// returns the locales wide month given the 'month' provided
+	MonthWide(month time.Month) string
+
+	// returns the locales wide months
+	MonthsWide() []string
+
+	// returns the locales abbreviated weekday given the 'weekday' provided
+	WeekdayAbbreviated(weekday time.Weekday) string
+
+	// returns the locales abbreviated weekdays
+	WeekdaysAbbreviated() []string
+
+	// returns the locales narrow weekday given the 'weekday' provided
+	WeekdayNarrow(weekday time.Weekday) string
+
+	// WeekdaysNarrowreturns the locales narrow weekdays
+	WeekdaysNarrow() []string
+
+	// returns the locales short weekday given the 'weekday' provided
+	WeekdayShort(weekday time.Weekday) string
+
+	// returns the locales short weekdays
+	WeekdaysShort() []string
+
+	// returns the locales wide weekday given the 'weekday' provided
+	WeekdayWide(weekday time.Weekday) string
+
+	// returns the locales wide weekdays
+	WeekdaysWide() []string
+
+	// The following Functions are common Formatting functionsfor the Translator's Locale
+
+	// returns 'num' with digits/precision of 'v' for locale and handles both Whole and Real numbers based on 'v'
+	FmtNumber(num float64, v uint64) string
+
+	// returns 'num' with digits/precision of 'v' for locale and handles both Whole and Real numbers based on 'v'
+	// NOTE: 'num' passed into FmtPercent is assumed to be in percent already
+	FmtPercent(num float64, v uint64) string
+
+	// returns the currency representation of 'num' with digits/precision of 'v' for locale
+	FmtCurrency(num float64, v uint64, currency currency.Type) string
+
+	// returns the currency representation of 'num' with digits/precision of 'v' for locale
+	// in accounting notation.
+	FmtAccounting(num float64, v uint64, currency currency.Type) string
+
+	// returns the short date representation of 't' for locale
+	FmtDateShort(t time.Time) string
+
+	// returns the medium date representation of 't' for locale
+	FmtDateMedium(t time.Time) string
+
+	//  returns the long date representation of 't' for locale
+	FmtDateLong(t time.Time) string
+
+	// returns the full date representation of 't' for locale
+	FmtDateFull(t time.Time) string
+
+	// returns the short time representation of 't' for locale
+	FmtTimeShort(t time.Time) string
+
+	// returns the medium time representation of 't' for locale
+	FmtTimeMedium(t time.Time) string
+
+	// returns the long time representation of 't' for locale
+	FmtTimeLong(t time.Time) string
+
+	// returns the full time representation of 't' for locale
+	FmtTimeFull(t time.Time) string
+}
+
+// String returns the string value  of PluralRule
+func (p PluralRule) String() string {
+
+	switch p {
+	case PluralRuleZero:
+		return pluralsString[7:11]
+	case PluralRuleOne:
+		return pluralsString[11:14]
+	case PluralRuleTwo:
+		return pluralsString[14:17]
+	case PluralRuleFew:
+		return pluralsString[17:20]
+	case PluralRuleMany:
+		return pluralsString[20:24]
+	case PluralRuleOther:
+		return pluralsString[24:]
+	default:
+		return pluralsString[:7]
+	}
+}
+
+//
+// Precision Notes:
+//
+// must specify a precision >= 0, and here is why https://play.golang.org/p/LyL90U0Vyh
+//
+// 	v := float64(3.141)
+// 	i := float64(int64(v))
+//
+// 	fmt.Println(v - i)
+//
+// 	or
+//
+// 	s := strconv.FormatFloat(v-i, 'f', -1, 64)
+// 	fmt.Println(s)
+//
+// these will not print what you'd expect: 0.14100000000000001
+// and so this library requires a precision to be specified, or
+// inaccurate plural rules could be applied.
+//
+//
+//
+// n - absolute value of the source number (integer and decimals).
+// i - integer digits of n.
+// v - number of visible fraction digits in n, with trailing zeros.
+// w - number of visible fraction digits in n, without trailing zeros.
+// f - visible fractional digits in n, with trailing zeros.
+// t - visible fractional digits in n, without trailing zeros.
+//
+//
+// Func(num float64, v uint64) // v = digits/precision and prevents -1 as a special case as this can lead to very unexpected behaviour, see precision note's above.
+//
+// n := math.Abs(num)
+// i := int64(n)
+// v := v
+//
+//
+// w := strconv.FormatFloat(num-float64(i), 'f', int(v), 64)  // then parse backwards on string until no more zero's....
+// f := strconv.FormatFloat(n, 'f', int(v), 64) 			  // then turn everything after decimal into an int64
+// t := strconv.FormatFloat(n, 'f', int(v), 64) 			  // then parse backwards on string until no more zero's....
+//
+//
+//
+// General Inclusion Rules
+// - v will always be available inherently
+// - all require n
+// - w requires i
+//
+
+// W returns the number of visible fraction digits in N, without trailing zeros.
+func W(n float64, v uint64) (w int64) {
+
+	s := strconv.FormatFloat(n-float64(int64(n)), 'f', int(v), 64)
+
+	// with either be '0' or '0.xxxx', so if 1 then w will be zero
+	// otherwise need to parse
+	if len(s) != 1 {
+
+		s = s[2:]
+		end := len(s) + 1
+
+		for i := end; i >= 0; i-- {
+			if s[i] != '0' {
+				end = i + 1
+				break
+			}
+		}
+
+		w = int64(len(s[:end]))
+	}
+
+	return
+}
+
+// F returns the visible fractional digits in N, with trailing zeros.
+func F(n float64, v uint64) (f int64) {
+
+	s := strconv.FormatFloat(n-float64(int64(n)), 'f', int(v), 64)
+
+	// with either be '0' or '0.xxxx', so if 1 then f will be zero
+	// otherwise need to parse
+	if len(s) != 1 {
+
+		// ignoring error, because it can't fail as we generated
+		// the string internally from a real number
+		f, _ = strconv.ParseInt(s[2:], 10, 64)
+	}
+
+	return
+}
+
+// T returns the visible fractional digits in N, without trailing zeros.
+func T(n float64, v uint64) (t int64) {
+
+	s := strconv.FormatFloat(n-float64(int64(n)), 'f', int(v), 64)
+
+	// with either be '0' or '0.xxxx', so if 1 then t will be zero
+	// otherwise need to parse
+	if len(s) != 1 {
+
+		s = s[2:]
+		end := len(s) + 1
+
+		for i := end; i >= 0; i-- {
+			if s[i] != '0' {
+				end = i + 1
+				break
+			}
+		}
+
+		// ignoring error, because it can't fail as we generated
+		// the string internally from a real number
+		t, _ = strconv.ParseInt(s[:end], 10, 64)
+	}
+
+	return
+}

vendor/github.com/go-playground/universal-translator/.gitignore

@@ -0,0 +1,25 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+*.coverprofile

vendor/github.com/go-playground/universal-translator/.travis.yml

@@ -0,0 +1,27 @@
+language: go
+go:
+  - 1.13.4
+  - tip
+matrix:
+  allow_failures:
+    - go: tip
+
+notifications:
+  email:
+    recipients: dean.karn@gmail.com
+    on_success: change
+    on_failure: always
+
+before_install:
+  - go install github.com/mattn/goveralls
+
+# Only clone the most recent commit.
+git:
+  depth: 1
+
+script:
+  - go test -v -race -covermode=atomic -coverprofile=coverage.coverprofile ./...
+
+after_success: |
+  [ $TRAVIS_GO_VERSION = 1.13.4 ] &&
+  goveralls -coverprofile=coverage.coverprofile -service travis-ci -repotoken $COVERALLS_TOKEN

vendor/github.com/go-playground/universal-translator/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Go Playground
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/go-playground/universal-translator/README.md

@@ -0,0 +1,89 @@
+## universal-translator
+<img align="right" src="https://raw.githubusercontent.com/go-playground/universal-translator/master/logo.png">![Project status](https://img.shields.io/badge/version-0.17.0-green.svg)
+[![Build Status](https://travis-ci.org/go-playground/universal-translator.svg?branch=master)](https://travis-ci.org/go-playground/universal-translator)
+[![Coverage Status](https://coveralls.io/repos/github/go-playground/universal-translator/badge.svg)](https://coveralls.io/github/go-playground/universal-translator)
+[![Go Report Card](https://goreportcard.com/badge/github.com/go-playground/universal-translator)](https://goreportcard.com/report/github.com/go-playground/universal-translator)
+[![GoDoc](https://godoc.org/github.com/go-playground/universal-translator?status.svg)](https://godoc.org/github.com/go-playground/universal-translator)
+![License](https://img.shields.io/dub/l/vibe-d.svg)
+[![Gitter](https://badges.gitter.im/go-playground/universal-translator.svg)](https://gitter.im/go-playground/universal-translator?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+Universal Translator is an i18n Translator for Go/Golang using CLDR data + pluralization rules
+
+Why another i18n library?
+--------------------------
+Because none of the plural rules seem to be correct out there, including the previous implementation of this package,
+so I took it upon myself to create [locales](https://github.com/go-playground/locales) for everyone to use; this package 
+is a thin wrapper around [locales](https://github.com/go-playground/locales) in order to store and translate text for 
+use in your applications.
+
+Features
+--------
+- [x] Rules generated from the [CLDR](http://cldr.unicode.org/index/downloads) data, v30.0.3
+- [x] Contains Cardinal, Ordinal and Range Plural Rules
+- [x] Contains Month, Weekday and Timezone translations built in
+- [x] Contains Date & Time formatting functions
+- [x] Contains Number, Currency, Accounting and Percent formatting functions
+- [x] Supports the "Gregorian" calendar only ( my time isn't unlimited, had to draw the line somewhere )
+- [x] Support loading translations from files
+- [x] Exporting translations to file(s), mainly for getting them professionally translated
+- [ ] Code Generation for translation files -> Go code.. i.e. after it has been professionally translated
+- [ ] Tests for all languages, I need help with this, please see [here](https://github.com/go-playground/locales/issues/1)
+
+Installation
+-----------
+
+Use go get 
+
+```shell
+go get github.com/go-playground/universal-translator
+```
+
+Usage & Documentation
+-------
+
+Please see https://godoc.org/github.com/go-playground/universal-translator for usage docs
+
+##### Examples:
+
+- [Basic](https://github.com/go-playground/universal-translator/tree/master/_examples/basic)
+- [Full - no files](https://github.com/go-playground/universal-translator/tree/master/_examples/full-no-files)
+- [Full - with files](https://github.com/go-playground/universal-translator/tree/master/_examples/full-with-files)
+
+File formatting
+--------------
+All types, Plain substitution, Cardinal, Ordinal and Range translations can all be contained withing the same file(s);
+they are only separated for easy viewing.
+
+##### Examples:
+
+- [Formats](https://github.com/go-playground/universal-translator/tree/master/_examples/file-formats)
+
+##### Basic Makeup
+NOTE: not all fields are needed for all translation types, see [examples](https://github.com/go-playground/universal-translator/tree/master/_examples/file-formats)
+```json
+{
+    "locale": "en",
+    "key": "days-left",
+    "trans": "You have {0} day left.",
+    "type": "Cardinal",
+    "rule": "One",
+    "override": false
+}
+```
+|Field|Description|
+|---|---|
+|locale|The locale for which the translation is for.|
+|key|The translation key that will be used to store and lookup each translation; normally it is a string or integer.|
+|trans|The actual translation text.|
+|type|The type of translation Cardinal, Ordinal, Range or "" for a plain substitution(not required to be defined if plain used)|
+|rule|The plural rule for which the translation is for eg. One, Two, Few, Many or Other.(not required to be defined if plain used)|
+|override|If you wish to override an existing translation that has already been registered, set this to 'true'. 99% of the time there is no need to define it.|
+
+Help With Tests
+---------------
+To anyone interesting in helping or contributing, I sure could use some help creating tests for each language.
+Please see issue [here](https://github.com/go-playground/locales/issues/1) for details.
+
+License
+------
+Distributed under MIT License, please see license file in code for more details.

vendor/github.com/go-playground/universal-translator/errors.go

@@ -0,0 +1,148 @@
+package ut
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/go-playground/locales"
+)
+
+var (
+	// ErrUnknowTranslation indicates the translation could not be found
+	ErrUnknowTranslation = errors.New("Unknown Translation")
+)
+
+var _ error = new(ErrConflictingTranslation)
+var _ error = new(ErrRangeTranslation)
+var _ error = new(ErrOrdinalTranslation)
+var _ error = new(ErrCardinalTranslation)
+var _ error = new(ErrMissingPluralTranslation)
+var _ error = new(ErrExistingTranslator)
+
+// ErrExistingTranslator is the error representing a conflicting translator
+type ErrExistingTranslator struct {
+	locale string
+}
+
+// Error returns ErrExistingTranslator's internal error text
+func (e *ErrExistingTranslator) Error() string {
+	return fmt.Sprintf("error: conflicting translator for locale '%s'", e.locale)
+}
+
+// ErrConflictingTranslation is the error representing a conflicting translation
+type ErrConflictingTranslation struct {
+	locale string
+	key    interface{}
+	rule   locales.PluralRule
+	text   string
+}
+
+// Error returns ErrConflictingTranslation's internal error text
+func (e *ErrConflictingTranslation) Error() string {
+
+	if _, ok := e.key.(string); !ok {
+		return fmt.Sprintf("error: conflicting key '%#v' rule '%s' with text '%s' for locale '%s', value being ignored", e.key, e.rule, e.text, e.locale)
+	}
+
+	return fmt.Sprintf("error: conflicting key '%s' rule '%s' with text '%s' for locale '%s', value being ignored", e.key, e.rule, e.text, e.locale)
+}
+
+// ErrRangeTranslation is the error representing a range translation error
+type ErrRangeTranslation struct {
+	text string
+}
+
+// Error returns ErrRangeTranslation's internal error text
+func (e *ErrRangeTranslation) Error() string {
+	return e.text
+}
+
+// ErrOrdinalTranslation is the error representing an ordinal translation error
+type ErrOrdinalTranslation struct {
+	text string
+}
+
+// Error returns ErrOrdinalTranslation's internal error text
+func (e *ErrOrdinalTranslation) Error() string {
+	return e.text
+}
+
+// ErrCardinalTranslation is the error representing a cardinal translation error
+type ErrCardinalTranslation struct {
+	text string
+}
+
+// Error returns ErrCardinalTranslation's internal error text
+func (e *ErrCardinalTranslation) Error() string {
+	return e.text
+}
+
+// ErrMissingPluralTranslation is the error signifying a missing translation given
+// the locales plural rules.
+type ErrMissingPluralTranslation struct {
+	locale          string
+	key             interface{}
+	rule            locales.PluralRule
+	translationType string
+}
+
+// Error returns ErrMissingPluralTranslation's internal error text
+func (e *ErrMissingPluralTranslation) Error() string {
+
+	if _, ok := e.key.(string); !ok {
+		return fmt.Sprintf("error: missing '%s' plural rule '%s' for translation with key '%#v' and locale '%s'", e.translationType, e.rule, e.key, e.locale)
+	}
+
+	return fmt.Sprintf("error: missing '%s' plural rule '%s' for translation with key '%s' and locale '%s'", e.translationType, e.rule, e.key, e.locale)
+}
+
+// ErrMissingBracket is the error representing a missing bracket in a translation
+// eg. This is a {0 <-- missing ending '}'
+type ErrMissingBracket struct {
+	locale string
+	key    interface{}
+	text   string
+}
+
+// Error returns ErrMissingBracket error message
+func (e *ErrMissingBracket) Error() string {
+	return fmt.Sprintf("error: missing bracket '{}', in translation. locale: '%s' key: '%v' text: '%s'", e.locale, e.key, e.text)
+}
+
+// ErrBadParamSyntax is the error representing a bad parameter definition in a translation
+// eg. This is a {must-be-int}
+type ErrBadParamSyntax struct {
+	locale string
+	param  string
+	key    interface{}
+	text   string
+}
+
+// Error returns ErrBadParamSyntax error message
+func (e *ErrBadParamSyntax) Error() string {
+	return fmt.Sprintf("error: bad parameter syntax, missing parameter '%s' in translation. locale: '%s' key: '%v' text: '%s'", e.param, e.locale, e.key, e.text)
+}
+
+// import/export errors
+
+// ErrMissingLocale is the error representing an expected locale that could
+// not be found aka locale not registered with the UniversalTranslator Instance
+type ErrMissingLocale struct {
+	locale string
+}
+
+// Error returns ErrMissingLocale's internal error text
+func (e *ErrMissingLocale) Error() string {
+	return fmt.Sprintf("error: locale '%s' not registered.", e.locale)
+}
+
+// ErrBadPluralDefinition is the error representing an incorrect plural definition
+// usually found within translations defined within files during the import process.
+type ErrBadPluralDefinition struct {
+	tl translation
+}
+
+// Error returns ErrBadPluralDefinition's internal error text
+func (e *ErrBadPluralDefinition) Error() string {
+	return fmt.Sprintf("error: bad plural definition '%#v'", e.tl)
+}

vendor/github.com/go-playground/universal-translator/go.mod

@@ -0,0 +1,5 @@
+module github.com/go-playground/universal-translator
+
+go 1.13
+
+require github.com/go-playground/locales v0.13.0

vendor/github.com/go-playground/universal-translator/go.sum

@@ -0,0 +1,4 @@
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

vendor/github.com/go-playground/universal-translator/import_export.go

@@ -0,0 +1,274 @@
+package ut
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"io"
+
+	"github.com/go-playground/locales"
+)
+
+type translation struct {
+	Locale           string      `json:"locale"`
+	Key              interface{} `json:"key"` // either string or integer
+	Translation      string      `json:"trans"`
+	PluralType       string      `json:"type,omitempty"`
+	PluralRule       string      `json:"rule,omitempty"`
+	OverrideExisting bool        `json:"override,omitempty"`
+}
+
+const (
+	cardinalType = "Cardinal"
+	ordinalType  = "Ordinal"
+	rangeType    = "Range"
+)
+
+// ImportExportFormat is the format of the file import or export
+type ImportExportFormat uint8
+
+// supported Export Formats
+const (
+	FormatJSON ImportExportFormat = iota
+)
+
+// Export writes the translations out to a file on disk.
+//
+// NOTE: this currently only works with string or int translations keys.
+func (t *UniversalTranslator) Export(format ImportExportFormat, dirname string) error {
+
+	_, err := os.Stat(dirname)
+	fmt.Println(dirname, err, os.IsNotExist(err))
+	if err != nil {
+
+		if !os.IsNotExist(err) {
+			return err
+		}
+
+		if err = os.MkdirAll(dirname, 0744); err != nil {
+			return err
+		}
+	}
+
+	// build up translations
+	var trans []translation
+	var b []byte
+	var ext string
+
+	for _, locale := range t.translators {
+
+		for k, v := range locale.(*translator).translations {
+			trans = append(trans, translation{
+				Locale:      locale.Locale(),
+				Key:         k,
+				Translation: v.text,
+			})
+		}
+
+		for k, pluralTrans := range locale.(*translator).cardinalTanslations {
+
+			for i, plural := range pluralTrans {
+
+				// leave enough for all plural rules
+				// but not all are set for all languages.
+				if plural == nil {
+					continue
+				}
+
+				trans = append(trans, translation{
+					Locale:      locale.Locale(),
+					Key:         k.(string),
+					Translation: plural.text,
+					PluralType:  cardinalType,
+					PluralRule:  locales.PluralRule(i).String(),
+				})
+			}
+		}
+
+		for k, pluralTrans := range locale.(*translator).ordinalTanslations {
+
+			for i, plural := range pluralTrans {
+
+				// leave enough for all plural rules
+				// but not all are set for all languages.
+				if plural == nil {
+					continue
+				}
+
+				trans = append(trans, translation{
+					Locale:      locale.Locale(),
+					Key:         k.(string),
+					Translation: plural.text,
+					PluralType:  ordinalType,
+					PluralRule:  locales.PluralRule(i).String(),
+				})
+			}
+		}
+
+		for k, pluralTrans := range locale.(*translator).rangeTanslations {
+
+			for i, plural := range pluralTrans {
+
+				// leave enough for all plural rules
+				// but not all are set for all languages.
+				if plural == nil {
+					continue
+				}
+
+				trans = append(trans, translation{
+					Locale:      locale.Locale(),
+					Key:         k.(string),
+					Translation: plural.text,
+					PluralType:  rangeType,
+					PluralRule:  locales.PluralRule(i).String(),
+				})
+			}
+		}
+
+		switch format {
+		case FormatJSON:
+			b, err = json.MarshalIndent(trans, "", "    ")
+			ext = ".json"
+		}
+
+		if err != nil {
+			return err
+		}
+
+		err = ioutil.WriteFile(filepath.Join(dirname, fmt.Sprintf("%s%s", locale.Locale(), ext)), b, 0644)
+		if err != nil {
+			return err
+		}
+
+		trans = trans[0:0]
+	}
+
+	return nil
+}
+
+// Import reads the translations out of a file or directory on disk.
+//
+// NOTE: this currently only works with string or int translations keys.
+func (t *UniversalTranslator) Import(format ImportExportFormat, dirnameOrFilename string) error {
+
+	fi, err := os.Stat(dirnameOrFilename)
+	if err != nil {
+		return err
+	}
+
+	processFn := func(filename string) error {
+
+		f, err := os.Open(filename)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+
+		return t.ImportByReader(format, f)
+	}
+
+	if !fi.IsDir() {
+		return processFn(dirnameOrFilename)
+	}
+
+	// recursively go through directory
+	walker := func(path string, info os.FileInfo, err error) error {
+
+		if info.IsDir() {
+			return nil
+		}
+
+		switch format {
+		case FormatJSON:
+			// skip non JSON files
+			if filepath.Ext(info.Name()) != ".json" {
+				return nil
+			}
+		}
+
+		return processFn(path)
+	}
+
+	return filepath.Walk(dirnameOrFilename, walker)
+}
+
+// ImportByReader imports the the translations found within the contents read from the supplied reader.
+//
+// NOTE: generally used when assets have been embedded into the binary and are already in memory.
+func (t *UniversalTranslator) ImportByReader(format ImportExportFormat, reader io.Reader) error {
+
+	b, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return err
+	}
+
+	var trans []translation
+
+	switch format {
+	case FormatJSON:
+		err = json.Unmarshal(b, &trans)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	for _, tl := range trans {
+
+		locale, found := t.FindTranslator(tl.Locale)
+		if !found {
+			return &ErrMissingLocale{locale: tl.Locale}
+		}
+
+		pr := stringToPR(tl.PluralRule)
+
+		if pr == locales.PluralRuleUnknown {
+
+			err = locale.Add(tl.Key, tl.Translation, tl.OverrideExisting)
+			if err != nil {
+				return err
+			}
+
+			continue
+		}
+
+		switch tl.PluralType {
+		case cardinalType:
+			err = locale.AddCardinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
+		case ordinalType:
+			err = locale.AddOrdinal(tl.Key, tl.Translation, pr, tl.OverrideExisting)
+		case rangeType:
+			err = locale.AddRange(tl.Key, tl.Translation, pr, tl.OverrideExisting)
+		default:
+			return &ErrBadPluralDefinition{tl: tl}
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func stringToPR(s string) locales.PluralRule {
+
+	switch s {
+	case "One":
+		return locales.PluralRuleOne
+	case "Two":
+		return locales.PluralRuleTwo
+	case "Few":
+		return locales.PluralRuleFew
+	case "Many":
+		return locales.PluralRuleMany
+	case "Other":
+		return locales.PluralRuleOther
+	default:
+		return locales.PluralRuleUnknown
+	}
+
+}

vendor/github.com/go-playground/universal-translator/translator.go

@@ -0,0 +1,420 @@
+package ut
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/go-playground/locales"
+)
+
+const (
+	paramZero          = "{0}"
+	paramOne           = "{1}"
+	unknownTranslation = ""
+)
+
+// Translator is universal translators
+// translator instance which is a thin wrapper
+// around locales.Translator instance providing
+// some extra functionality
+type Translator interface {
+	locales.Translator
+
+	// adds a normal translation for a particular language/locale
+	// {#} is the only replacement type accepted and are ad infinitum
+	// eg. one: '{0} day left' other: '{0} days left'
+	Add(key interface{}, text string, override bool) error
+
+	// adds a cardinal plural translation for a particular language/locale
+	// {0} is the only replacement type accepted and only one variable is accepted as
+	// multiple cannot be used for a plural rule determination, unless it is a range;
+	// see AddRange below.
+	// eg. in locale 'en' one: '{0} day left' other: '{0} days left'
+	AddCardinal(key interface{}, text string, rule locales.PluralRule, override bool) error
+
+	// adds an ordinal plural translation for a particular language/locale
+	// {0} is the only replacement type accepted and only one variable is accepted as
+	// multiple cannot be used for a plural rule determination, unless it is a range;
+	// see AddRange below.
+	// eg. in locale 'en' one: '{0}st day of spring' other: '{0}nd day of spring'
+	// - 1st, 2nd, 3rd...
+	AddOrdinal(key interface{}, text string, rule locales.PluralRule, override bool) error
+
+	// adds a range plural translation for a particular language/locale
+	// {0} and {1} are the only replacement types accepted and only these are accepted.
+	// eg. in locale 'nl' one: '{0}-{1} day left' other: '{0}-{1} days left'
+	AddRange(key interface{}, text string, rule locales.PluralRule, override bool) error
+
+	// creates the translation for the locale given the 'key' and params passed in
+	T(key interface{}, params ...string) (string, error)
+
+	// creates the cardinal translation for the locale given the 'key', 'num' and 'digit' arguments
+	//  and param passed in
+	C(key interface{}, num float64, digits uint64, param string) (string, error)
+
+	// creates the ordinal translation for the locale given the 'key', 'num' and 'digit' arguments
+	// and param passed in
+	O(key interface{}, num float64, digits uint64, param string) (string, error)
+
+	//  creates the range translation for the locale given the 'key', 'num1', 'digit1', 'num2' and
+	//  'digit2' arguments and 'param1' and 'param2' passed in
+	R(key interface{}, num1 float64, digits1 uint64, num2 float64, digits2 uint64, param1, param2 string) (string, error)
+
+	// VerifyTranslations checks to ensures that no plural rules have been
+	// missed within the translations.
+	VerifyTranslations() error
+}
+
+var _ Translator = new(translator)
+var _ locales.Translator = new(translator)
+
+type translator struct {
+	locales.Translator
+	translations        map[interface{}]*transText
+	cardinalTanslations map[interface{}][]*transText // array index is mapped to locales.PluralRule index + the locales.PluralRuleUnknown
+	ordinalTanslations  map[interface{}][]*transText
+	rangeTanslations    map[interface{}][]*transText
+}
+
+type transText struct {
+	text    string
+	indexes []int
+}
+
+func newTranslator(trans locales.Translator) Translator {
+	return &translator{
+		Translator:          trans,
+		translations:        make(map[interface{}]*transText), // translation text broken up by byte index
+		cardinalTanslations: make(map[interface{}][]*transText),
+		ordinalTanslations:  make(map[interface{}][]*transText),
+		rangeTanslations:    make(map[interface{}][]*transText),
+	}
+}
+
+// Add adds a normal translation for a particular language/locale
+// {#} is the only replacement type accepted and are ad infinitum
+// eg. one: '{0} day left' other: '{0} days left'
+func (t *translator) Add(key interface{}, text string, override bool) error {
+
+	if _, ok := t.translations[key]; ok && !override {
+		return &ErrConflictingTranslation{locale: t.Locale(), key: key, text: text}
+	}
+
+	lb := strings.Count(text, "{")
+	rb := strings.Count(text, "}")
+
+	if lb != rb {
+		return &ErrMissingBracket{locale: t.Locale(), key: key, text: text}
+	}
+
+	trans := &transText{
+		text: text,
+	}
+
+	var idx int
+
+	for i := 0; i < lb; i++ {
+		s := "{" + strconv.Itoa(i) + "}"
+		idx = strings.Index(text, s)
+		if idx == -1 {
+			return &ErrBadParamSyntax{locale: t.Locale(), param: s, key: key, text: text}
+		}
+
+		trans.indexes = append(trans.indexes, idx)
+		trans.indexes = append(trans.indexes, idx+len(s))
+	}
+
+	t.translations[key] = trans
+
+	return nil
+}
+
+// AddCardinal adds a cardinal plural translation for a particular language/locale
+// {0} is the only replacement type accepted and only one variable is accepted as
+// multiple cannot be used for a plural rule determination, unless it is a range;
+// see AddRange below.
+// eg. in locale 'en' one: '{0} day left' other: '{0} days left'
+func (t *translator) AddCardinal(key interface{}, text string, rule locales.PluralRule, override bool) error {
+
+	var verified bool
+
+	// verify plural rule exists for locale
+	for _, pr := range t.PluralsCardinal() {
+		if pr == rule {
+			verified = true
+			break
+		}
+	}
+
+	if !verified {
+		return &ErrCardinalTranslation{text: fmt.Sprintf("error: cardinal plural rule '%s' does not exist for locale '%s' key: '%v' text: '%s'", rule, t.Locale(), key, text)}
+	}
+
+	tarr, ok := t.cardinalTanslations[key]
+	if ok {
+		// verify not adding a conflicting record
+		if len(tarr) > 0 && tarr[rule] != nil && !override {
+			return &ErrConflictingTranslation{locale: t.Locale(), key: key, rule: rule, text: text}
+		}
+
+	} else {
+		tarr = make([]*transText, 7, 7)
+		t.cardinalTanslations[key] = tarr
+	}
+
+	trans := &transText{
+		text:    text,
+		indexes: make([]int, 2, 2),
+	}
+
+	tarr[rule] = trans
+
+	idx := strings.Index(text, paramZero)
+	if idx == -1 {
+		tarr[rule] = nil
+		return &ErrCardinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddCardinal'. locale: '%s' key: '%v' text: '%s'", paramZero, t.Locale(), key, text)}
+	}
+
+	trans.indexes[0] = idx
+	trans.indexes[1] = idx + len(paramZero)
+
+	return nil
+}
+
+// AddOrdinal adds an ordinal plural translation for a particular language/locale
+// {0} is the only replacement type accepted and only one variable is accepted as
+// multiple cannot be used for a plural rule determination, unless it is a range;
+// see AddRange below.
+// eg. in locale 'en' one: '{0}st day of spring' other: '{0}nd day of spring' - 1st, 2nd, 3rd...
+func (t *translator) AddOrdinal(key interface{}, text string, rule locales.PluralRule, override bool) error {
+
+	var verified bool
+
+	// verify plural rule exists for locale
+	for _, pr := range t.PluralsOrdinal() {
+		if pr == rule {
+			verified = true
+			break
+		}
+	}
+
+	if !verified {
+		return &ErrOrdinalTranslation{text: fmt.Sprintf("error: ordinal plural rule '%s' does not exist for locale '%s' key: '%v' text: '%s'", rule, t.Locale(), key, text)}
+	}
+
+	tarr, ok := t.ordinalTanslations[key]
+	if ok {
+		// verify not adding a conflicting record
+		if len(tarr) > 0 && tarr[rule] != nil && !override {
+			return &ErrConflictingTranslation{locale: t.Locale(), key: key, rule: rule, text: text}
+		}
+
+	} else {
+		tarr = make([]*transText, 7, 7)
+		t.ordinalTanslations[key] = tarr
+	}
+
+	trans := &transText{
+		text:    text,
+		indexes: make([]int, 2, 2),
+	}
+
+	tarr[rule] = trans
+
+	idx := strings.Index(text, paramZero)
+	if idx == -1 {
+		tarr[rule] = nil
+		return &ErrOrdinalTranslation{text: fmt.Sprintf("error: parameter '%s' not found, may want to use 'Add' instead of 'AddOrdinal'. locale: '%s' key: '%v' text: '%s'", paramZero, t.Locale(), key, text)}
+	}
+
+	trans.indexes[0] = idx
+	trans.indexes[1] = idx + len(paramZero)
+
+	return nil
+}
+
+// AddRange adds a range plural translation for a particular language/locale
+// {0} and {1} are the only replacement types accepted and only these are accepted.
+// eg. in locale 'nl' one: '{0}-{1} day left' other: '{0}-{1} days left'
+func (t *translator) AddRange(key interface{}, text string, rule locales.PluralRule, override bool) error {
+
+	var verified bool
+
+	// verify plural rule exists for locale
+	for _, pr := range t.PluralsRange() {
+		if pr == rule {
+			verified = true
+			break
+		}
+	}
+
+	if !verified {
+		return &ErrRangeTranslation{text: fmt.Sprintf("error: range plural rule '%s' does not exist for locale '%s' key: '%v' text: '%s'", rule, t.Locale(), key, text)}
+	}
+
+	tarr, ok := t.rangeTanslations[key]
+	if ok {
+		// verify not adding a conflicting record
+		if len(tarr) > 0 && tarr[rule] != nil && !override {
+			return &ErrConflictingTranslation{locale: t.Locale(), key: key, rule: rule, text: text}
+		}
+
+	} else {
+		tarr = make([]*transText, 7, 7)
+		t.rangeTanslations[key] = tarr
+	}
+
+	trans := &transText{
+		text:    text,
+		indexes: make([]int, 4, 4),
+	}
+
+	tarr[rule] = trans
+
+	idx := strings.Index(text, paramZero)
+	if idx == -1 {
+		tarr[rule] = nil
+		return &ErrRangeTranslation{text: fmt.Sprintf("error: parameter '%s' not found, are you sure you're adding a Range Translation? locale: '%s' key: '%v' text: '%s'", paramZero, t.Locale(), key, text)}
+	}
+
+	trans.indexes[0] = idx
+	trans.indexes[1] = idx + len(paramZero)
+
+	idx = strings.Index(text, paramOne)
+	if idx == -1 {
+		tarr[rule] = nil
+		return &ErrRangeTranslation{text: fmt.Sprintf("error: parameter '%s' not found, a Range Translation requires two parameters. locale: '%s' key: '%v' text: '%s'", paramOne, t.Locale(), key, text)}
+	}
+
+	trans.indexes[2] = idx
+	trans.indexes[3] = idx + len(paramOne)
+
+	return nil
+}
+
+// T creates the translation for the locale given the 'key' and params passed in
+func (t *translator) T(key interface{}, params ...string) (string, error) {
+
+	trans, ok := t.translations[key]
+	if !ok {
+		return unknownTranslation, ErrUnknowTranslation
+	}
+
+	b := make([]byte, 0, 64)
+
+	var start, end, count int
+
+	for i := 0; i < len(trans.indexes); i++ {
+		end = trans.indexes[i]
+		b = append(b, trans.text[start:end]...)
+		b = append(b, params[count]...)
+		i++
+		start = trans.indexes[i]
+		count++
+	}
+
+	b = append(b, trans.text[start:]...)
+
+	return string(b), nil
+}
+
+// C creates the cardinal translation for the locale given the 'key', 'num' and 'digit' arguments and param passed in
+func (t *translator) C(key interface{}, num float64, digits uint64, param string) (string, error) {
+
+	tarr, ok := t.cardinalTanslations[key]
+	if !ok {
+		return unknownTranslation, ErrUnknowTranslation
+	}
+
+	rule := t.CardinalPluralRule(num, digits)
+
+	trans := tarr[rule]
+
+	b := make([]byte, 0, 64)
+	b = append(b, trans.text[:trans.indexes[0]]...)
+	b = append(b, param...)
+	b = append(b, trans.text[trans.indexes[1]:]...)
+
+	return string(b), nil
+}
+
+// O creates the ordinal translation for the locale given the 'key', 'num' and 'digit' arguments and param passed in
+func (t *translator) O(key interface{}, num float64, digits uint64, param string) (string, error) {
+
+	tarr, ok := t.ordinalTanslations[key]
+	if !ok {
+		return unknownTranslation, ErrUnknowTranslation
+	}
+
+	rule := t.OrdinalPluralRule(num, digits)
+
+	trans := tarr[rule]
+
+	b := make([]byte, 0, 64)
+	b = append(b, trans.text[:trans.indexes[0]]...)
+	b = append(b, param...)
+	b = append(b, trans.text[trans.indexes[1]:]...)
+
+	return string(b), nil
+}
+
+// R creates the range translation for the locale given the 'key', 'num1', 'digit1', 'num2' and 'digit2' arguments
+// and 'param1' and 'param2' passed in
+func (t *translator) R(key interface{}, num1 float64, digits1 uint64, num2 float64, digits2 uint64, param1, param2 string) (string, error) {
+
+	tarr, ok := t.rangeTanslations[key]
+	if !ok {
+		return unknownTranslation, ErrUnknowTranslation
+	}
+
+	rule := t.RangePluralRule(num1, digits1, num2, digits2)
+
+	trans := tarr[rule]
+
+	b := make([]byte, 0, 64)
+	b = append(b, trans.text[:trans.indexes[0]]...)
+	b = append(b, param1...)
+	b = append(b, trans.text[trans.indexes[1]:trans.indexes[2]]...)
+	b = append(b, param2...)
+	b = append(b, trans.text[trans.indexes[3]:]...)
+
+	return string(b), nil
+}
+
+// VerifyTranslations checks to ensures that no plural rules have been
+// missed within the translations.
+func (t *translator) VerifyTranslations() error {
+
+	for k, v := range t.cardinalTanslations {
+
+		for _, rule := range t.PluralsCardinal() {
+
+			if v[rule] == nil {
+				return &ErrMissingPluralTranslation{locale: t.Locale(), translationType: "plural", rule: rule, key: k}
+			}
+		}
+	}
+
+	for k, v := range t.ordinalTanslations {
+
+		for _, rule := range t.PluralsOrdinal() {
+
+			if v[rule] == nil {
+				return &ErrMissingPluralTranslation{locale: t.Locale(), translationType: "ordinal", rule: rule, key: k}
+			}
+		}
+	}
+
+	for k, v := range t.rangeTanslations {
+
+		for _, rule := range t.PluralsRange() {
+
+			if v[rule] == nil {
+				return &ErrMissingPluralTranslation{locale: t.Locale(), translationType: "range", rule: rule, key: k}
+			}
+		}
+	}
+
+	return nil
+}

vendor/github.com/go-playground/universal-translator/universal_translator.go

@@ -0,0 +1,113 @@
+package ut
+
+import (
+	"strings"
+
+	"github.com/go-playground/locales"
+)
+
+// UniversalTranslator holds all locale & translation data
+type UniversalTranslator struct {
+	translators map[string]Translator
+	fallback    Translator
+}
+
+// New returns a new UniversalTranslator instance set with
+// the fallback locale and locales it should support
+func New(fallback locales.Translator, supportedLocales ...locales.Translator) *UniversalTranslator {
+
+	t := &UniversalTranslator{
+		translators: make(map[string]Translator),
+	}
+
+	for _, v := range supportedLocales {
+
+		trans := newTranslator(v)
+		t.translators[strings.ToLower(trans.Locale())] = trans
+
+		if fallback.Locale() == v.Locale() {
+			t.fallback = trans
+		}
+	}
+
+	if t.fallback == nil && fallback != nil {
+		t.fallback = newTranslator(fallback)
+	}
+
+	return t
+}
+
+// FindTranslator trys to find a Translator based on an array of locales
+// and returns the first one it can find, otherwise returns the
+// fallback translator.
+func (t *UniversalTranslator) FindTranslator(locales ...string) (trans Translator, found bool) {
+
+	for _, locale := range locales {
+
+		if trans, found = t.translators[strings.ToLower(locale)]; found {
+			return
+		}
+	}
+
+	return t.fallback, false
+}
+
+// GetTranslator returns the specified translator for the given locale,
+// or fallback if not found
+func (t *UniversalTranslator) GetTranslator(locale string) (trans Translator, found bool) {
+
+	if trans, found = t.translators[strings.ToLower(locale)]; found {
+		return
+	}
+
+	return t.fallback, false
+}
+
+// GetFallback returns the fallback locale
+func (t *UniversalTranslator) GetFallback() Translator {
+	return t.fallback
+}
+
+// AddTranslator adds the supplied translator, if it already exists the override param
+// will be checked and if false an error will be returned, otherwise the translator will be
+// overridden; if the fallback matches the supplied translator it will be overridden as well
+// NOTE: this is normally only used when translator is embedded within a library
+func (t *UniversalTranslator) AddTranslator(translator locales.Translator, override bool) error {
+
+	lc := strings.ToLower(translator.Locale())
+	_, ok := t.translators[lc]
+	if ok && !override {
+		return &ErrExistingTranslator{locale: translator.Locale()}
+	}
+
+	trans := newTranslator(translator)
+
+	if t.fallback.Locale() == translator.Locale() {
+
+		// because it's optional to have a fallback, I don't impose that limitation
+		// don't know why you wouldn't but...
+		if !override {
+			return &ErrExistingTranslator{locale: translator.Locale()}
+		}
+
+		t.fallback = trans
+	}
+
+	t.translators[lc] = trans
+
+	return nil
+}
+
+// VerifyTranslations runs through all locales and identifies any issues
+// eg. missing plural rules for a locale
+func (t *UniversalTranslator) VerifyTranslations() (err error) {
+
+	for _, trans := range t.translators {
+		err = trans.VerifyTranslations()
+		if err != nil {
+			return
+		}
+	}
+
+	return
+}

vendor/github.com/go-playground/validator/v10/.gitignore

@@ -0,0 +1,29 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+*.test
+*.out
+*.txt
+cover.html
+README.html