Update vendor for next release (#1343)

11 files changed, 255 insertions, 606 deletions

diff --git a/vendor/github.com/pelletier/go-toml/azure-pipelines.yml b/vendor/github.com/pelletier/go-toml/azure-pipelines.yml
index 242b5b54..ff5376b0 100644
--- a/vendor/github.com/pelletier/go-toml/azure-pipelines.yml
+++ b/vendor/github.com/pelletier/go-toml/azure-pipelines.yml
@@ -13,9 +13,9 @@ stages:
       vmImage: ubuntu-latest
     steps:
     - task: GoTool@0
-      displayName: "Install Go 1.14"
+      displayName: "Install Go 1.15"
       inputs:
-        version: "1.14"
+        version: "1.15"
     - script: echo "##vso[task.setvariable variable=PATH]${PATH}:/home/vsts/go/bin/"
     - script: mkdir -p ${HOME}/go/src/github.com/pelletier/go-toml
     - script: cp -R . ${HOME}/go/src/github.com/pelletier/go-toml
@@ -36,9 +36,9 @@ stages:
       vmImage: ubuntu-latest
     steps:
     - task: GoTool@0
-      displayName: "Install Go 1.14"
+      displayName: "Install Go 1.15"
       inputs:
-        version: "1.14"
+        version: "1.15"
     - task: Go@0
       displayName: "go fmt ./..."
       inputs:
@@ -51,9 +51,9 @@ stages:
       vmImage: ubuntu-latest
     steps:
     - task: GoTool@0
-      displayName: "Install Go 1.14"
+      displayName: "Install Go 1.15"
       inputs:
-        version: "1.14"
+        version: "1.15"
     - task: Go@0
       displayName: "Generate coverage"
       inputs:
@@ -71,9 +71,9 @@ stages:
       vmImage: ubuntu-latest
     steps:
     - task: GoTool@0
-      displayName: "Install Go 1.14"
+      displayName: "Install Go 1.15"
       inputs:
-        version: "1.14"
+        version: "1.15"
     - script: echo "##vso[task.setvariable variable=PATH]${PATH}:/home/vsts/go/bin/"
     - task: Bash@3
       inputs:
@@ -86,9 +86,9 @@ stages:
       vmImage: ubuntu-latest
     steps:
     - task: GoTool@0
-      displayName: "Install Go 1.14"
+      displayName: "Install Go 1.15"
       inputs:
-        version: "1.14"
+        version: "1.15"
     - script: echo "##vso[task.setvariable variable=PATH]${PATH}:/home/vsts/go/bin/"
     - script: mkdir -p ${HOME}/go/src/github.com/pelletier/go-toml
     - script: cp -R . ${HOME}/go/src/github.com/pelletier/go-toml
@@ -102,6 +102,15 @@ stages:
     displayName: "unit tests"
     strategy:
       matrix:
+        linux 1.15:
+          goVersion: '1.15'
+          imageName: 'ubuntu-latest'
+        mac 1.15:
+          goVersion: '1.15'
+          imageName: 'macOS-latest'
+        windows 1.15:
+          goVersion: '1.15'
+          imageName: 'windows-latest'
         linux 1.14:
           goVersion: '1.14'
           imageName: 'ubuntu-latest'
@@ -111,15 +120,6 @@ stages:
         windows 1.14:
           goVersion: '1.14'
           imageName: 'windows-latest'
-        linux 1.13:
-          goVersion: '1.13'
-          imageName: 'ubuntu-latest'
-        mac 1.13:
-          goVersion: '1.13'
-          imageName: 'macOS-latest'
-        windows 1.13:
-          goVersion: '1.13'
-          imageName: 'windows-latest'
     pool:
       vmImage: $(imageName)
     steps:
@@ -155,7 +155,7 @@ stages:
     - task: GoTool@0
       displayName: "Install Go"
       inputs:
-        version: 1.14
+        version: 1.15
     - task: Bash@3
       inputs:
         targetType: inline
diff --git a/vendor/github.com/pelletier/go-toml/benchmark.json b/vendor/github.com/pelletier/go-toml/benchmark.json
deleted file mode 100644
index 86f99c6a..00000000
--- a/vendor/github.com/pelletier/go-toml/benchmark.json
+++ /dev/null
@@ -1,164 +0,0 @@
-{
-    "array": {
-        "key1": [
-            1,
-            2,
-            3
-        ],
-        "key2": [
-            "red",
-            "yellow",
-            "green"
-        ],
-        "key3": [
-            [
-                1,
-                2
-            ],
-            [
-                3,
-                4,
-                5
-            ]
-        ],
-        "key4": [
-            [
-                1,
-                2
-            ],
-            [
-                "a",
-                "b",
-                "c"
-            ]
-        ],
-        "key5": [
-            1,
-            2,
-            3
-        ],
-        "key6": [
-            1,
-            2
-        ]
-    },
-    "boolean": {
-        "False": false,
-        "True": true
-    },
-    "datetime": {
-        "key1": "1979-05-27T07:32:00Z",
-        "key2": "1979-05-27T00:32:00-07:00",
-        "key3": "1979-05-27T00:32:00.999999-07:00"
-    },
-    "float": {
-        "both": {
-            "key": 6.626e-34
-        },
-        "exponent": {
-            "key1": 5e+22,
-            "key2": 1000000,
-            "key3": -0.02
-        },
-        "fractional": {
-            "key1": 1,
-            "key2": 3.1415,
-            "key3": -0.01
-        },
-        "underscores": {
-            "key1": 9224617.445991227,
-            "key2": 1e+100
-        }
-    },
-    "fruit": [{
-            "name": "apple",
-            "physical": {
-                "color": "red",
-                "shape": "round"
-            },
-            "variety": [{
-                    "name": "red delicious"
-                },
-                {
-                    "name": "granny smith"
-                }
-            ]
-        },
-        {
-            "name": "banana",
-            "variety": [{
-                "name": "plantain"
-            }]
-        }
-    ],
-    "integer": {
-        "key1": 99,
-        "key2": 42,
-        "key3": 0,
-        "key4": -17,
-        "underscores": {
-            "key1": 1000,
-            "key2": 5349221,
-            "key3": 12345
-        }
-    },
-    "products": [{
-            "name": "Hammer",
-            "sku": 738594937
-        },
-        {},
-        {
-            "color": "gray",
-            "name": "Nail",
-            "sku": 284758393
-        }
-    ],
-    "string": {
-        "basic": {
-            "basic": "I'm a string. \"You can quote me\". Name\tJosé\nLocation\tSF."
-        },
-        "literal": {
-            "multiline": {
-                "lines": "The first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n",
-                "regex2": "I [dw]on't need \\d{2} apples"
-            },
-            "quoted": "Tom \"Dubs\" Preston-Werner",
-            "regex": "\u003c\\i\\c*\\s*\u003e",
-            "winpath": "C:\\Users\\nodejs\\templates",
-            "winpath2": "\\\\ServerX\\admin$\\system32\\"
-        },
-        "multiline": {
-            "continued": {
-                "key1": "The quick brown fox jumps over the lazy dog.",
-                "key2": "The quick brown fox jumps over the lazy dog.",
-                "key3": "The quick brown fox jumps over the lazy dog."
-            },
-            "key1": "One\nTwo",
-            "key2": "One\nTwo",
-            "key3": "One\nTwo"
-        }
-    },
-    "table": {
-        "inline": {
-            "name": {
-                "first": "Tom",
-                "last": "Preston-Werner"
-            },
-            "point": {
-                "x": 1,
-                "y": 2
-            }
-        },
-        "key": "value",
-        "subtable": {
-            "key": "another value"
-        }
-    },
-    "x": {
-        "y": {
-            "z": {
-                "w": {}
-            }
-        }
-    }
-}
diff --git a/vendor/github.com/pelletier/go-toml/benchmark.sh b/vendor/github.com/pelletier/go-toml/benchmark.sh
index 7914fff4..a69d3040 100644
--- a/vendor/github.com/pelletier/go-toml/benchmark.sh
+++ b/vendor/github.com/pelletier/go-toml/benchmark.sh
@@ -20,11 +20,15 @@ git clone ${reference_git} ${ref_tempdir} >/dev/null 2>/dev/null
 pushd ${ref_tempdir} >/dev/null
 git checkout ${reference_ref} >/dev/null 2>/dev/null
 go test -bench=. -benchmem | tee ${ref_benchmark}
+cd benchmark
+go test -bench=. -benchmem | tee -a ${ref_benchmark}
 popd >/dev/null
 
 echo ""
 echo "=== local"
 go test -bench=. -benchmem  | tee ${local_benchmark}
+cd benchmark
+go test -bench=. -benchmem | tee -a ${local_benchmark}
 
 echo ""
 echo "=== diff"
diff --git a/vendor/github.com/pelletier/go-toml/benchmark.toml b/vendor/github.com/pelletier/go-toml/benchmark.toml
deleted file mode 100644
index dfd77e09..00000000
--- a/vendor/github.com/pelletier/go-toml/benchmark.toml
+++ /dev/null
@@ -1,244 +0,0 @@
-################################################################################
-## Comment
-
-# Speak your mind with the hash symbol. They go from the symbol to the end of
-# the line.
-
-
-################################################################################
-## Table
-
-# Tables (also known as hash tables or dictionaries) are collections of
-# key/value pairs. They appear in square brackets on a line by themselves.
-
-[table]
-
-key = "value" # Yeah, you can do this.
-
-# Nested tables are denoted by table names with dots in them. Name your tables
-# whatever crap you please, just don't use #, ., [ or ].
-
-[table.subtable]
-
-key = "another value"
-
-# You don't need to specify all the super-tables if you don't want to. TOML
-# knows how to do it for you.
-
-# [x] you
-# [x.y] don't
-# [x.y.z] need these
-[x.y.z.w] # for this to work
-
-
-################################################################################
-## Inline Table
-
-# Inline tables provide a more compact syntax for expressing tables. They are
-# especially useful for grouped data that can otherwise quickly become verbose.
-# Inline tables are enclosed in curly braces `{` and `}`. No newlines are
-# allowed between the curly braces unless they are valid within a value.
-
-[table.inline]
-
-name = { first = "Tom", last = "Preston-Werner" }
-point = { x = 1, y = 2 }
-
-
-################################################################################
-## String
-
-# There are four ways to express strings: basic, multi-line basic, literal, and
-# multi-line literal. All strings must contain only valid UTF-8 characters.
-
-[string.basic]
-
-basic = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."
-
-[string.multiline]
-
-# The following strings are byte-for-byte equivalent:
-key1 = "One\nTwo"
-key2 = """One\nTwo"""
-key3 = """
-One
-Two"""
-
-[string.multiline.continued]
-
-# The following strings are byte-for-byte equivalent:
-key1 = "The quick brown fox jumps over the lazy dog."
-
-key2 = """
-The quick brown \
-
-
-  fox jumps over \
-    the lazy dog."""
-
-key3 = """\
-       The quick brown \
-       fox jumps over \
-       the lazy dog.\
-       """
-
-[string.literal]
-
-# What you see is what you get.
-winpath  = 'C:\Users\nodejs\templates'
-winpath2 = '\\ServerX\admin$\system32\'
-quoted   = 'Tom "Dubs" Preston-Werner'
-regex    = '<\i\c*\s*>'
-
-
-[string.literal.multiline]
-
-regex2 = '''I [dw]on't need \d{2} apples'''
-lines  = '''
-The first newline is
-trimmed in raw strings.
-   All other whitespace
-   is preserved.
-'''
-
-
-################################################################################
-## Integer
-
-# Integers are whole numbers. Positive numbers may be prefixed with a plus sign.
-# Negative numbers are prefixed with a minus sign.
-
-[integer]
-
-key1 = +99
-key2 = 42
-key3 = 0
-key4 = -17
-
-[integer.underscores]
-
-# For large numbers, you may use underscores to enhance readability. Each
-# underscore must be surrounded by at least one digit.
-key1 = 1_000
-key2 = 5_349_221
-key3 = 1_2_3_4_5     # valid but inadvisable
-
-
-################################################################################
-## Float
-
-# A float consists of an integer part (which may be prefixed with a plus or
-# minus sign) followed by a fractional part and/or an exponent part.
-
-[float.fractional]
-
-key1 = +1.0
-key2 = 3.1415
-key3 = -0.01
-
-[float.exponent]
-
-key1 = 5e+22
-key2 = 1e6
-key3 = -2E-2
-
-[float.both]
-
-key = 6.626e-34
-
-[float.underscores]
-
-key1 = 9_224_617.445_991_228_313
-key2 = 1e1_00
-
-
-################################################################################
-## Boolean
-
-# Booleans are just the tokens you're used to. Always lowercase.
-
-[boolean]
-
-True = true
-False = false
-
-
-################################################################################
-## Datetime
-
-# Datetimes are RFC 3339 dates.
-
-[datetime]
-
-key1 = 1979-05-27T07:32:00Z
-key2 = 1979-05-27T00:32:00-07:00
-key3 = 1979-05-27T00:32:00.999999-07:00
-
-
-################################################################################
-## Array
-
-# Arrays are square brackets with other primitives inside. Whitespace is
-# ignored. Elements are separated by commas. Data types may not be mixed.
-
-[array]
-
-key1 = [ 1, 2, 3 ]
-key2 = [ "red", "yellow", "green" ]
-key3 = [ [ 1, 2 ], [3, 4, 5] ]
-#key4 = [ [ 1, 2 ], ["a", "b", "c"] ] # this is ok
-
-# Arrays can also be multiline. So in addition to ignoring whitespace, arrays
-# also ignore newlines between the brackets.  Terminating commas are ok before
-# the closing bracket.
-
-key5 = [
-  1, 2, 3
-]
-key6 = [
-  1,
-  2, # this is ok
-]
-
-
-################################################################################
-## Array of Tables
-
-# These can be expressed by using a table name in double brackets. Each table
-# with the same double bracketed name will be an element in the array. The
-# tables are inserted in the order encountered.
-
-[[products]]
-
-name = "Hammer"
-sku = 738594937
-
-[[products]]
-
-[[products]]
-
-name = "Nail"
-sku = 284758393
-color = "gray"
-
-
-# You can create nested arrays of tables as well.
-
-[[fruit]]
-  name = "apple"
-
-  [fruit.physical]
-    color = "red"
-    shape = "round"
-
-  [[fruit.variety]]
-    name = "red delicious"
-
-  [[fruit.variety]]
-    name = "granny smith"
-
-[[fruit]]
-  name = "banana"
-
-  [[fruit.variety]]
-    name = "plantain"
diff --git a/vendor/github.com/pelletier/go-toml/benchmark.yml b/vendor/github.com/pelletier/go-toml/benchmark.yml
deleted file mode 100644
index 0bd19f08..00000000
--- a/vendor/github.com/pelletier/go-toml/benchmark.yml
+++ /dev/null
@@ -1,121 +0,0 @@
----
-array:
-  key1:
-  - 1
-  - 2
-  - 3
-  key2:
-  - red
-  - yellow
-  - green
-  key3:
-  - - 1
-    - 2
-  - - 3
-    - 4
-    - 5
-  key4:
-  - - 1
-    - 2
-  - - a
-    - b
-    - c
-  key5:
-  - 1
-  - 2
-  - 3
-  key6:
-  - 1
-  - 2
-boolean:
-  'False': false
-  'True': true
-datetime:
-  key1: '1979-05-27T07:32:00Z'
-  key2: '1979-05-27T00:32:00-07:00'
-  key3: '1979-05-27T00:32:00.999999-07:00'
-float:
-  both:
-    key: 6.626e-34
-  exponent:
-    key1: 5.0e+22
-    key2: 1000000
-    key3: -0.02
-  fractional:
-    key1: 1
-    key2: 3.1415
-    key3: -0.01
-  underscores:
-    key1: 9224617.445991227
-    key2: 1.0e+100
-fruit:
-- name: apple
-  physical:
-    color: red
-    shape: round
-  variety:
-  - name: red delicious
-  - name: granny smith
-- name: banana
-  variety:
-  - name: plantain
-integer:
-  key1: 99
-  key2: 42
-  key3: 0
-  key4: -17
-  underscores:
-    key1: 1000
-    key2: 5349221
-    key3: 12345
-products:
-- name: Hammer
-  sku: 738594937
-- {}
-- color: gray
-  name: Nail
-  sku: 284758393
-string:
-  basic:
-    basic: "I'm a string. \"You can quote me\". Name\tJosé\nLocation\tSF."
-  literal:
-    multiline:
-      lines: |
-        The first newline is
-        trimmed in raw strings.
-           All other whitespace
-           is preserved.
-      regex2: I [dw]on't need \d{2} apples
-    quoted: Tom "Dubs" Preston-Werner
-    regex: "<\\i\\c*\\s*>"
-    winpath: C:\Users\nodejs\templates
-    winpath2: "\\\\ServerX\\admin$\\system32\\"
-  multiline:
-    continued:
-      key1: The quick brown fox jumps over the lazy dog.
-      key2: The quick brown fox jumps over the lazy dog.
-      key3: The quick brown fox jumps over the lazy dog.
-    key1: |-
-      One
-      Two
-    key2: |-
-      One
-      Two
-    key3: |-
-      One
-      Two
-table:
-  inline:
-    name:
-      first: Tom
-      last: Preston-Werner
-    point:
-      x: 1
-      y: 2
-  key: value
-  subtable:
-    key: another value
-x:
-  y:
-    z:
-      w: {}
diff --git a/vendor/github.com/pelletier/go-toml/go.mod b/vendor/github.com/pelletier/go-toml/go.mod
index c7faa6b3..e924cb90 100644
--- a/vendor/github.com/pelletier/go-toml/go.mod
+++ b/vendor/github.com/pelletier/go-toml/go.mod
@@ -2,8 +2,4 @@ module github.com/pelletier/go-toml
 
 go 1.12
 
-require (
-	github.com/BurntSushi/toml v0.3.1
-	github.com/davecgh/go-spew v1.1.1
-	gopkg.in/yaml.v2 v2.3.0
-)
+require github.com/davecgh/go-spew v1.1.1
diff --git a/vendor/github.com/pelletier/go-toml/lexer.go b/vendor/github.com/pelletier/go-toml/lexer.go
index 425e847a..b1886192 100644
--- a/vendor/github.com/pelletier/go-toml/lexer.go
+++ b/vendor/github.com/pelletier/go-toml/lexer.go
@@ -306,7 +306,7 @@ func (l *tomlLexer) lexComma() tomlLexStateFn {
 // Parse the key and emits its value without escape sequences.
 // bare keys, basic string keys and literal string keys are supported.
 func (l *tomlLexer) lexKey() tomlLexStateFn {
-	growingString := ""
+	var sb strings.Builder
 
 	for r := l.peek(); isKeyChar(r) || r == '\n' || r == '\r'; r = l.peek() {
 		if r == '"' {
@@ -315,7 +315,9 @@ func (l *tomlLexer) lexKey() tomlLexStateFn {
 			if err != nil {
 				return l.errorf(err.Error())
 			}
-			growingString += "\"" + str + "\""
+			sb.WriteString("\"")
+			sb.WriteString(str)
+			sb.WriteString("\"")
 			l.next()
 			continue
 		} else if r == '\'' {
@@ -324,41 +326,45 @@ func (l *tomlLexer) lexKey() tomlLexStateFn {
 			if err != nil {
 				return l.errorf(err.Error())
 			}
-			growingString += "'" + str + "'"
+			sb.WriteString("'")
+			sb.WriteString(str)
+			sb.WriteString("'")
 			l.next()
 			continue
 		} else if r == '\n' {
 			return l.errorf("keys cannot contain new lines")
 		} else if isSpace(r) {
-			str := " "
+			var str strings.Builder
+			str.WriteString(" ")
+
 			// skip trailing whitespace
 			l.next()
 			for r = l.peek(); isSpace(r); r = l.peek() {
-				str += string(r)
+				str.WriteRune(r)
 				l.next()
 			}
 			// break loop if not a dot
 			if r != '.' {
 				break
 			}
-			str += "."
+			str.WriteString(".")
 			// skip trailing whitespace after dot
 			l.next()
 			for r = l.peek(); isSpace(r); r = l.peek() {
-				str += string(r)
+				str.WriteRune(r)
 				l.next()
 			}
-			growingString += str
+			sb.WriteString(str.String())
 			continue
 		} else if r == '.' {
 			// skip
 		} else if !isValidBareChar(r) {
 			return l.errorf("keys cannot contain %c character", r)
 		}
-		growingString += string(r)
+		sb.WriteRune(r)
 		l.next()
 	}
-	l.emitWithValue(tokenKey, growingString)
+	l.emitWithValue(tokenKey, sb.String())
 	return l.lexVoid
 }
 
@@ -383,7 +389,7 @@ func (l *tomlLexer) lexLeftBracket() tomlLexStateFn {
 }
 
 func (l *tomlLexer) lexLiteralStringAsString(terminator string, discardLeadingNewLine bool) (string, error) {
-	growingString := ""
+	var sb strings.Builder
 
 	if discardLeadingNewLine {
 		if l.follow("\r\n") {
@@ -397,14 +403,14 @@ func (l *tomlLexer) lexLiteralStringAsString(terminator string, discardLeadingNe
 	// find end of string
 	for {
 		if l.follow(terminator) {
-			return growingString, nil
+			return sb.String(), nil
 		}
 
 		next := l.peek()
 		if next == eof {
 			break
 		}
-		growingString += string(l.next())
+		sb.WriteRune(l.next())
 	}
 
 	return "", errors.New("unclosed string")
@@ -438,7 +444,7 @@ func (l *tomlLexer) lexLiteralString() tomlLexStateFn {
 // Terminator is the substring indicating the end of the token.
 // The resulting string does not include the terminator.
 func (l *tomlLexer) lexStringAsString(terminator string, discardLeadingNewLine, acceptNewLines bool) (string, error) {
-	growingString := ""
+	var sb strings.Builder
 
 	if discardLeadingNewLine {
 		if l.follow("\r\n") {
@@ -451,7 +457,7 @@ func (l *tomlLexer) lexStringAsString(terminator string, discardLeadingNewLine,
 
 	for {
 		if l.follow(terminator) {
-			return growingString, nil
+			return sb.String(), nil
 		}
 
 		if l.follow("\\") {
@@ -469,61 +475,61 @@ func (l *tomlLexer) lexStringAsString(terminator string, discardLeadingNewLine,
 					l.next()
 				}
 			case '"':
-				growingString += "\""
+				sb.WriteString("\"")
 				l.next()
 			case 'n':
-				growingString += "\n"
+				sb.WriteString("\n")
 				l.next()
 			case 'b':
-				growingString += "\b"
+				sb.WriteString("\b")
 				l.next()
 			case 'f':
-				growingString += "\f"
+				sb.WriteString("\f")
 				l.next()
 			case '/':
-				growingString += "/"
+				sb.WriteString("/")
 				l.next()
 			case 't':
-				growingString += "\t"
+				sb.WriteString("\t")
 				l.next()
 			case 'r':
-				growingString += "\r"
+				sb.WriteString("\r")
 				l.next()
 			case '\\':
-				growingString += "\\"
+				sb.WriteString("\\")
 				l.next()
 			case 'u':
 				l.next()
-				code := ""
+				var code strings.Builder
 				for i := 0; i < 4; i++ {
 					c := l.peek()
 					if !isHexDigit(c) {
 						return "", errors.New("unfinished unicode escape")
 					}
 					l.next()
-					code = code + string(c)
+					code.WriteRune(c)
 				}
-				intcode, err := strconv.ParseInt(code, 16, 32)
+				intcode, err := strconv.ParseInt(code.String(), 16, 32)
 				if err != nil {
-					return "", errors.New("invalid unicode escape: \\u" + code)
+					return "", errors.New("invalid unicode escape: \\u" + code.String())
 				}
-				growingString += string(rune(intcode))
+				sb.WriteRune(rune(intcode))
 			case 'U':
 				l.next()
-				code := ""
+				var code strings.Builder
 				for i := 0; i < 8; i++ {
 					c := l.peek()
 					if !isHexDigit(c) {
 						return "", errors.New("unfinished unicode escape")
 					}
 					l.next()
-					code = code + string(c)
+					code.WriteRune(c)
 				}
-				intcode, err := strconv.ParseInt(code, 16, 64)
+				intcode, err := strconv.ParseInt(code.String(), 16, 64)
 				if err != nil {
-					return "", errors.New("invalid unicode escape: \\U" + code)
+					return "", errors.New("invalid unicode escape: \\U" + code.String())
 				}
-				growingString += string(rune(intcode))
+				sb.WriteRune(rune(intcode))
 			default:
 				return "", errors.New("invalid escape sequence: \\" + string(l.peek()))
 			}
@@ -534,7 +540,7 @@ func (l *tomlLexer) lexStringAsString(terminator string, discardLeadingNewLine,
 				return "", fmt.Errorf("unescaped control character %U", r)
 			}
 			l.next()
-			growingString += string(r)
+			sb.WriteRune(r)
 		}
 
 		if l.peek() == eof {
@@ -769,19 +775,19 @@ func init() {
 	// /!\ also matches the empty string
 	//
 	// Example matches:
-	//1979-05-27T07:32:00Z
-	//1979-05-27T00:32:00-07:00
-	//1979-05-27T00:32:00.999999-07:00
-	//1979-05-27 07:32:00Z
-	//1979-05-27 00:32:00-07:00
-	//1979-05-27 00:32:00.999999-07:00
-	//1979-05-27T07:32:00
-	//1979-05-27T00:32:00.999999
-	//1979-05-27 07:32:00
-	//1979-05-27 00:32:00.999999
-	//1979-05-27
-	//07:32:00
-	//00:32:00.999999
+	// 1979-05-27T07:32:00Z
+	// 1979-05-27T00:32:00-07:00
+	// 1979-05-27T00:32:00.999999-07:00
+	// 1979-05-27 07:32:00Z
+	// 1979-05-27 00:32:00-07:00
+	// 1979-05-27 00:32:00.999999-07:00
+	// 1979-05-27T07:32:00
+	// 1979-05-27T00:32:00.999999
+	// 1979-05-27 07:32:00
+	// 1979-05-27 00:32:00.999999
+	// 1979-05-27
+	// 07:32:00
+	// 00:32:00.999999
 	dateRegexp = regexp.MustCompile(`^(?:\d{1,4}-\d{2}-\d{2})?(?:[T ]?\d{2}:\d{2}:\d{2}(\.\d{1,9})?(Z|[+-]\d{2}:\d{2})?)?`)
 }
 
diff --git a/vendor/github.com/pelletier/go-toml/marshal.go b/vendor/github.com/pelletier/go-toml/marshal.go
index db5a7b4f..032e0ffc 100644
--- a/vendor/github.com/pelletier/go-toml/marshal.go
+++ b/vendor/github.com/pelletier/go-toml/marshal.go
@@ -76,6 +76,7 @@ var textUnmarshalerType = reflect.TypeOf(new(encoding.TextUnmarshaler)).Elem()
 var localDateType = reflect.TypeOf(LocalDate{})
 var localTimeType = reflect.TypeOf(LocalTime{})
 var localDateTimeType = reflect.TypeOf(LocalDateTime{})
+var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
 
 // Check if the given marshal type maps to a Tree primitive
 func isPrimitive(mtype reflect.Type) bool {
@@ -436,6 +437,7 @@ func (e *Encoder) valueToTree(mtype reflect.Type, mval reflect.Value) (*Tree, er
 					if tree, ok := val.(*Tree); ok && mtypef.Anonymous && !opts.nameFromTag && !e.promoteAnon {
 						e.appendTree(tval, tree)
 					} else {
+						val = e.wrapTomlValue(val, tval)
 						tval.SetPathWithOptions([]string{opts.name}, SetOptions{
 							Comment:   opts.comment,
 							Commented: opts.commented,
@@ -474,6 +476,7 @@ func (e *Encoder) valueToTree(mtype reflect.Type, mval reflect.Value) (*Tree, er
 			if err != nil {
 				return nil, err
 			}
+			val = e.wrapTomlValue(val, tval)
 			if e.quoteMapKeys {
 				keyStr, err := tomlValueStringRepresentation(key.String(), "", "", e.order, e.arraysOneElementPerLine)
 				if err != nil {
@@ -516,13 +519,13 @@ func (e *Encoder) valueToOtherSlice(mtype reflect.Type, mval reflect.Value) (int
 
 // Convert given marshal value to toml value
 func (e *Encoder) valueToToml(mtype reflect.Type, mval reflect.Value) (interface{}, error) {
-	e.line++
 	if mtype.Kind() == reflect.Ptr {
 		switch {
 		case isCustomMarshaler(mtype):
 			return callCustomMarshaler(mval)
 		case isTextMarshaler(mtype):
-			return callTextMarshaler(mval)
+			b, err := callTextMarshaler(mval)
+			return string(b), err
 		default:
 			return e.valueToToml(mtype.Elem(), mval.Elem())
 		}
@@ -534,7 +537,8 @@ func (e *Encoder) valueToToml(mtype reflect.Type, mval reflect.Value) (interface
 	case isCustomMarshaler(mtype):
 		return callCustomMarshaler(mval)
 	case isTextMarshaler(mtype):
-		return callTextMarshaler(mval)
+		b, err := callTextMarshaler(mval)
+		return string(b), err
 	case isTree(mtype):
 		return e.valueToTree(mtype, mval)
 	case isOtherSequence(mtype), isCustomMarshalerSequence(mtype), isTextMarshalerSequence(mtype):
@@ -577,6 +581,25 @@ func (e *Encoder) appendTree(t, o *Tree) error {
 	return nil
 }
 
+// Create a toml value with the current line number as the position line
+func (e *Encoder) wrapTomlValue(val interface{}, parent *Tree) interface{} {
+	_, isTree := val.(*Tree)
+	_, isTreeS := val.([]*Tree)
+	if isTree || isTreeS {
+		return val
+	}
+
+	ret := &tomlValue{
+		value: val,
+		position: Position{
+			e.line,
+			parent.position.Col,
+		},
+	}
+	e.line++
+	return ret
+}
+
 // Unmarshal attempts to unmarshal the Tree into a Go struct pointed by v.
 // Neither Unmarshaler interfaces nor UnmarshalTOML functions are supported for
 // sub-structs, and only definite types can be unmarshaled.
@@ -681,6 +704,8 @@ func (d *Decoder) unmarshal(v interface{}) error {
 
 	switch elem.Kind() {
 	case reflect.Struct, reflect.Map:
+	case reflect.Interface:
+		elem = mapStringInterfaceType
 	default:
 		return errors.New("only a pointer to struct or map can be unmarshaled from TOML")
 	}
@@ -717,6 +742,10 @@ func (d *Decoder) valueFromTree(mtype reflect.Type, tval *Tree, mval1 *reflect.V
 	if mvalPtr := reflect.New(mtype); isCustomUnmarshaler(mvalPtr.Type()) {
 		d.visitor.visitAll()
 
+		if tval == nil {
+			return mvalPtr.Elem(), nil
+		}
+
 		if err := callCustomUnmarshaler(mvalPtr, tval.ToMap()); err != nil {
 			return reflect.ValueOf(nil), fmt.Errorf("unmarshal toml: %v", err)
 		}
diff --git a/vendor/github.com/pelletier/go-toml/toml.go b/vendor/github.com/pelletier/go-toml/toml.go
index d323c39b..cbb89a9a 100644
--- a/vendor/github.com/pelletier/go-toml/toml.go
+++ b/vendor/github.com/pelletier/go-toml/toml.go
@@ -122,6 +122,89 @@ func (t *Tree) GetPath(keys []string) interface{} {
 	}
 }
 
+// GetArray returns the value at key in the Tree.
+// It returns []string, []int64, etc type if key has homogeneous lists
+// Key is a dot-separated path (e.g. a.b.c) without single/double quoted strings.
+// Returns nil if the path does not exist in the tree.
+// If keys is of length zero, the current tree is returned.
+func (t *Tree) GetArray(key string) interface{} {
+	if key == "" {
+		return t
+	}
+	return t.GetArrayPath(strings.Split(key, "."))
+}
+
+// GetArrayPath returns the element in the tree indicated by 'keys'.
+// If keys is of length zero, the current tree is returned.
+func (t *Tree) GetArrayPath(keys []string) interface{} {
+	if len(keys) == 0 {
+		return t
+	}
+	subtree := t
+	for _, intermediateKey := range keys[:len(keys)-1] {
+		value, exists := subtree.values[intermediateKey]
+		if !exists {
+			return nil
+		}
+		switch node := value.(type) {
+		case *Tree:
+			subtree = node
+		case []*Tree:
+			// go to most recent element
+			if len(node) == 0 {
+				return nil
+			}
+			subtree = node[len(node)-1]
+		default:
+			return nil // cannot navigate through other node types
+		}
+	}
+	// branch based on final node type
+	switch node := subtree.values[keys[len(keys)-1]].(type) {
+	case *tomlValue:
+		switch n := node.value.(type) {
+		case []interface{}:
+			return getArray(n)
+		default:
+			return node.value
+		}
+	default:
+		return node
+	}
+}
+
+// if homogeneous array, then return slice type object over []interface{}
+func getArray(n []interface{}) interface{} {
+	var s []string
+	var i64 []int64
+	var f64 []float64
+	var bl []bool
+	for _, value := range n {
+		switch v := value.(type) {
+		case string:
+			s = append(s, v)
+		case int64:
+			i64 = append(i64, v)
+		case float64:
+			f64 = append(f64, v)
+		case bool:
+			bl = append(bl, v)
+		default:
+			return n
+		}
+	}
+	if len(s) == len(n) {
+		return s
+	} else if len(i64) == len(n) {
+		return i64
+	} else if len(f64) == len(n) {
+		return f64
+	} else if len(bl) == len(n) {
+		return bl
+	}
+	return n
+}
+
 // GetPosition returns the position of the given key.
 func (t *Tree) GetPosition(key string) Position {
 	if key == "" {
@@ -130,6 +213,50 @@ func (t *Tree) GetPosition(key string) Position {
 	return t.GetPositionPath(strings.Split(key, "."))
 }
 
+// SetPositionPath sets the position of element in the tree indicated by 'keys'.
+// If keys is of length zero, the current tree position is set.
+func (t *Tree) SetPositionPath(keys []string, pos Position) {
+	if len(keys) == 0 {
+		t.position = pos
+		return
+	}
+	subtree := t
+	for _, intermediateKey := range keys[:len(keys)-1] {
+		value, exists := subtree.values[intermediateKey]
+		if !exists {
+			return
+		}
+		switch node := value.(type) {
+		case *Tree:
+			subtree = node
+		case []*Tree:
+			// go to most recent element
+			if len(node) == 0 {
+				return
+			}
+			subtree = node[len(node)-1]
+		default:
+			return
+		}
+	}
+	// branch based on final node type
+	switch node := subtree.values[keys[len(keys)-1]].(type) {
+	case *tomlValue:
+		node.position = pos
+		return
+	case *Tree:
+		node.position = pos
+		return
+	case []*Tree:
+		// go to most recent element
+		if len(node) == 0 {
+			return
+		}
+		node[len(node)-1].position = pos
+		return
+	}
+}
+
 // GetPositionPath returns the element in the tree indicated by 'keys'.
 // If keys is of length zero, the current tree is returned.
 func (t *Tree) GetPositionPath(keys []string) Position {
@@ -212,7 +339,8 @@ func (t *Tree) SetPathWithOptions(keys []string, opts SetOptions, value interfac
 			// go to most recent element
 			if len(node) == 0 {
 				// create element if it does not exist
-				subtree.values[intermediateKey] = append(node, newTreeWithPosition(Position{Line: t.position.Line + i, Col: t.position.Col}))
+				node = append(node, newTreeWithPosition(Position{Line: t.position.Line + i, Col: t.position.Col}))
+				subtree.values[intermediateKey] = node
 			}
 			subtree = node[len(node)-1]
 		}
@@ -232,6 +360,8 @@ func (t *Tree) SetPathWithOptions(keys []string, opts SetOptions, value interfac
 		toInsert = value
 	case *tomlValue:
 		v.comment = opts.Comment
+		v.commented = opts.Commented
+		v.multiline = opts.Multiline
 		toInsert = v
 	default:
 		toInsert = &tomlValue{value: value,
diff --git a/vendor/github.com/pelletier/go-toml/tomltree_create.go b/vendor/github.com/pelletier/go-toml/tomltree_create.go
index 79610e9b..80353500 100644
--- a/vendor/github.com/pelletier/go-toml/tomltree_create.go
+++ b/vendor/github.com/pelletier/go-toml/tomltree_create.go
@@ -57,6 +57,19 @@ func simpleValueCoercion(object interface{}) (interface{}, error) {
 		return float64(original), nil
 	case fmt.Stringer:
 		return original.String(), nil
+	case []interface{}:
+		value := reflect.ValueOf(original)
+		length := value.Len()
+		arrayValue := reflect.MakeSlice(value.Type(), 0, length)
+		for i := 0; i < length; i++ {
+			val := value.Index(i).Interface()
+			simpleValue, err := simpleValueCoercion(val)
+			if err != nil {
+				return nil, err
+			}
+			arrayValue = reflect.Append(arrayValue, reflect.ValueOf(simpleValue))
+		}
+		return arrayValue.Interface(), nil
 	default:
 		return nil, fmt.Errorf("cannot convert type %T to Tree", object)
 	}
diff --git a/vendor/github.com/pelletier/go-toml/tomltree_write.go b/vendor/github.com/pelletier/go-toml/tomltree_write.go
index 2d6487ed..ae6dac49 100644
--- a/vendor/github.com/pelletier/go-toml/tomltree_write.go
+++ b/vendor/github.com/pelletier/go-toml/tomltree_write.go
@@ -163,7 +163,7 @@ func tomlValueStringRepresentation(v interface{}, commented string, indent strin
 		return "\"" + encodeTomlString(value) + "\"", nil
 	case []byte:
 		b, _ := v.([]byte)
-		return tomlValueStringRepresentation(string(b), commented, indent, ord, arraysOneElementPerLine)
+		return string(b), nil
 	case bool:
 		if value {
 			return "true", nil