Putting vendor/ in repo

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

679 files changed, 9634 insertions, 0 deletions

diff --git a/vendor/github.com/jmespath/go-jmespath/.gitignore b/vendor/github.com/jmespath/go-jmespath/.gitignore
new file mode 100644
index 00000000..5091fb07
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/.gitignore
@@ -0,0 +1,4 @@
+/jpgo
+jmespath-fuzz.zip
+cpu.out
+go-jmespath.test
diff --git a/vendor/github.com/jmespath/go-jmespath/.travis.yml b/vendor/github.com/jmespath/go-jmespath/.travis.yml
new file mode 100644
index 00000000..1f980775
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/.travis.yml
@@ -0,0 +1,9 @@
+language: go
+
+sudo: false
+
+go:
+  - 1.4
+
+install: go get -v -t ./...
+script: make test
diff --git a/vendor/github.com/jmespath/go-jmespath/LICENSE b/vendor/github.com/jmespath/go-jmespath/LICENSE
new file mode 100644
index 00000000..b03310a9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2015 James Saryerwinnie
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/github.com/jmespath/go-jmespath/Makefile b/vendor/github.com/jmespath/go-jmespath/Makefile
new file mode 100644
index 00000000..a828d284
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/Makefile
@@ -0,0 +1,44 @@
+
+CMD = jpgo
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  test                    to run all the tests"
+	@echo "  build                   to build the library and jp executable"
+	@echo "  generate                to run codegen"
+
+
+generate:
+	go generate ./...
+
+build:
+	rm -f $(CMD)
+	go build ./...
+	rm -f cmd/$(CMD)/$(CMD) && cd cmd/$(CMD)/ && go build ./...
+	mv cmd/$(CMD)/$(CMD) .
+
+test:
+	go test -v ./...
+
+check:
+	go vet ./...
+	@echo "golint ./..."
+	@lint=`golint ./...`; \
+	lint=`echo "$$lint" | grep -v "astnodetype_string.go" | grep -v "toktype_string.go"`; \
+	echo "$$lint"; \
+	if [ "$$lint" != "" ]; then exit 1; fi
+
+htmlc:
+	go test -coverprofile="/tmp/jpcov"  && go tool cover -html="/tmp/jpcov" && unlink /tmp/jpcov
+
+buildfuzz:
+	go-fuzz-build github.com/jmespath/go-jmespath/fuzz
+
+fuzz: buildfuzz
+	go-fuzz -bin=./jmespath-fuzz.zip -workdir=fuzz/testdata
+
+bench:
+	go test -bench . -cpuprofile cpu.out
+
+pprof-cpu:
+	go tool pprof ./go-jmespath.test ./cpu.out
diff --git a/vendor/github.com/jmespath/go-jmespath/README.md b/vendor/github.com/jmespath/go-jmespath/README.md
new file mode 100644
index 00000000..187ef676
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/README.md
@@ -0,0 +1,7 @@
+# go-jmespath - A JMESPath implementation in Go
+
+[![Build Status](https://img.shields.io/travis/jmespath/go-jmespath.svg)](https://travis-ci.org/jmespath/go-jmespath)
+
+
+
+See http://jmespath.org for more info.
diff --git a/vendor/github.com/jmespath/go-jmespath/api.go b/vendor/github.com/jmespath/go-jmespath/api.go
new file mode 100644
index 00000000..9cfa988b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/api.go
@@ -0,0 +1,49 @@
+package jmespath
+
+import "strconv"
+
+// JmesPath is the epresentation of a compiled JMES path query. A JmesPath is
+// safe for concurrent use by multiple goroutines.
+type JMESPath struct {
+	ast  ASTNode
+	intr *treeInterpreter
+}
+
+// Compile parses a JMESPath expression and returns, if successful, a JMESPath
+// object that can be used to match against data.
+func Compile(expression string) (*JMESPath, error) {
+	parser := NewParser()
+	ast, err := parser.Parse(expression)
+	if err != nil {
+		return nil, err
+	}
+	jmespath := &JMESPath{ast: ast, intr: newInterpreter()}
+	return jmespath, nil
+}
+
+// MustCompile is like Compile but panics if the expression cannot be parsed.
+// It simplifies safe initialization of global variables holding compiled
+// JMESPaths.
+func MustCompile(expression string) *JMESPath {
+	jmespath, err := Compile(expression)
+	if err != nil {
+		panic(`jmespath: Compile(` + strconv.Quote(expression) + `): ` + err.Error())
+	}
+	return jmespath
+}
+
+// Search evaluates a JMESPath expression against input data and returns the result.
+func (jp *JMESPath) Search(data interface{}) (interface{}, error) {
+	return jp.intr.Execute(jp.ast, data)
+}
+
+// Search evaluates a JMESPath expression against input data and returns the result.
+func Search(expression string, data interface{}) (interface{}, error) {
+	intr := newInterpreter()
+	parser := NewParser()
+	ast, err := parser.Parse(expression)
+	if err != nil {
+		return nil, err
+	}
+	return intr.Execute(ast, data)
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/api_test.go b/vendor/github.com/jmespath/go-jmespath/api_test.go
new file mode 100644
index 00000000..b0b106d3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/api_test.go
@@ -0,0 +1,32 @@
+package jmespath
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestValidPrecompiledExpressionSearches(t *testing.T) {
+	assert := assert.New(t)
+	data := make(map[string]interface{})
+	data["foo"] = "bar"
+	precompiled, err := Compile("foo")
+	assert.Nil(err)
+	result, err := precompiled.Search(data)
+	assert.Nil(err)
+	assert.Equal("bar", result)
+}
+
+func TestInvalidPrecompileErrors(t *testing.T) {
+	assert := assert.New(t)
+	_, err := Compile("not a valid expression")
+	assert.NotNil(err)
+}
+
+func TestInvalidMustCompilePanics(t *testing.T) {
+	defer func() {
+		r := recover()
+		assert.NotNil(t, r)
+	}()
+	MustCompile("not a valid expression")
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/astnodetype_string.go b/vendor/github.com/jmespath/go-jmespath/astnodetype_string.go
new file mode 100644
index 00000000..1cd2d239
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/astnodetype_string.go
@@ -0,0 +1,16 @@
+// generated by stringer -type astNodeType; DO NOT EDIT
+
+package jmespath
+
+import "fmt"
+
+const _astNodeType_name = "ASTEmptyASTComparatorASTCurrentNodeASTExpRefASTFunctionExpressionASTFieldASTFilterProjectionASTFlattenASTIdentityASTIndexASTIndexExpressionASTKeyValPairASTLiteralASTMultiSelectHashASTMultiSelectListASTOrExpressionASTAndExpressionASTNotExpressionASTPipeASTProjectionASTSubexpressionASTSliceASTValueProjection"
+
+var _astNodeType_index = [...]uint16{0, 8, 21, 35, 44, 65, 73, 92, 102, 113, 121, 139, 152, 162, 180, 198, 213, 229, 245, 252, 265, 281, 289, 307}
+
+func (i astNodeType) String() string {
+	if i < 0 || i >= astNodeType(len(_astNodeType_index)-1) {
+		return fmt.Sprintf("astNodeType(%d)", i)
+	}
+	return _astNodeType_name[_astNodeType_index[i]:_astNodeType_index[i+1]]
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/cmd/jpgo/main.go b/vendor/github.com/jmespath/go-jmespath/cmd/jpgo/main.go
new file mode 100644
index 00000000..1c53cfc8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/cmd/jpgo/main.go
@@ -0,0 +1,96 @@
+/*Basic command line interface for debug and testing purposes.
+
+Examples:
+
+Only print the AST for the expression:
+
+    jp.go -ast "foo.bar.baz"
+
+Evaluate the JMESPath expression against JSON data from a file:
+
+    jp.go -input /tmp/data.json "foo.bar.baz"
+
+This program can also be used as an executable to the jp-compliance
+runner (github.com/jmespath/jmespath.test).
+
+*/
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"os"
+)
+
+import (
+	"encoding/json"
+
+	"github.com/jmespath/go-jmespath"
+)
+
+func errMsg(msg string, a ...interface{}) int {
+	fmt.Fprintf(os.Stderr, msg, a...)
+	fmt.Fprintln(os.Stderr)
+	return 1
+}
+
+func run() int {
+
+	astOnly := flag.Bool("ast", false, "Print the AST for the input expression and exit.")
+	inputFile := flag.String("input", "", "Filename containing JSON data to search. If not provided, data is read from stdin.")
+
+	flag.Parse()
+	args := flag.Args()
+	if len(args) != 1 {
+		fmt.Fprintf(os.Stderr, "Usage:\n\n")
+		flag.PrintDefaults()
+		return errMsg("\nError: expected a single argument (the JMESPath expression).")
+	}
+
+	expression := args[0]
+	parser := jmespath.NewParser()
+	parsed, err := parser.Parse(expression)
+	if err != nil {
+		if syntaxError, ok := err.(jmespath.SyntaxError); ok {
+			return errMsg("%s\n%s\n", syntaxError, syntaxError.HighlightLocation())
+		}
+		return errMsg("%s", err)
+	}
+	if *astOnly {
+		fmt.Println("")
+		fmt.Printf("%s\n", parsed)
+		return 0
+	}
+
+	var inputData []byte
+	if *inputFile != "" {
+		inputData, err = ioutil.ReadFile(*inputFile)
+		if err != nil {
+			return errMsg("Error loading file %s: %s", *inputFile, err)
+		}
+	} else {
+		// If an input data file is not provided then we read the
+		// data from stdin.
+		inputData, err = ioutil.ReadAll(os.Stdin)
+		if err != nil {
+			return errMsg("Error reading from stdin: %s", err)
+		}
+	}
+	var data interface{}
+	json.Unmarshal(inputData, &data)
+	result, err := jmespath.Search(expression, data)
+	if err != nil {
+		return errMsg("Error executing expression: %s", err)
+	}
+	toJSON, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return errMsg("Error serializing result to JSON: %s", err)
+	}
+	fmt.Println(string(toJSON))
+	return 0
+}
+
+func main() {
+	os.Exit(run())
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/basic.json b/vendor/github.com/jmespath/go-jmespath/compliance/basic.json
new file mode 100644
index 00000000..d550e969
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/basic.json
@@ -0,0 +1,96 @@
+[{
+    "given":
+        {"foo": {"bar": {"baz": "correct"}}},
+     "cases": [
+         {
+            "expression": "foo",
+            "result": {"bar": {"baz": "correct"}}
+         },
+         {
+            "expression": "foo.bar",
+            "result": {"baz": "correct"}
+         },
+         {
+            "expression": "foo.bar.baz",
+            "result": "correct"
+         },
+         {
+            "expression": "foo\n.\nbar\n.baz",
+            "result": "correct"
+         },
+         {
+            "expression": "foo.bar.baz.bad",
+            "result": null
+         },
+         {
+            "expression": "foo.bar.bad",
+            "result": null
+         },
+         {
+            "expression": "foo.bad",
+            "result": null
+         },
+         {
+            "expression": "bad",
+            "result": null
+         },
+         {
+            "expression": "bad.morebad.morebad",
+            "result": null
+         }
+     ]
+},
+{
+    "given":
+        {"foo": {"bar": ["one", "two", "three"]}},
+    "cases": [
+         {
+            "expression": "foo",
+            "result": {"bar": ["one", "two", "three"]}
+         },
+         {
+            "expression": "foo.bar",
+            "result": ["one", "two", "three"]
+         }
+    ]
+},
+{
+    "given": ["one", "two", "three"],
+    "cases": [
+        {
+            "expression": "one",
+            "result": null
+        },
+        {
+            "expression": "two",
+            "result": null
+        },
+        {
+            "expression": "three",
+            "result": null
+        },
+        {
+            "expression": "one.two",
+            "result": null
+        }
+    ]
+},
+{
+    "given":
+        {"foo": {"1": ["one", "two", "three"], "-1": "bar"}},
+    "cases": [
+         {
+            "expression": "foo.\"1\"",
+            "result": ["one", "two", "three"]
+         },
+         {
+            "expression": "foo.\"1\"[0]",
+            "result": "one"
+         },
+         {
+            "expression": "foo.\"-1\"",
+            "result": "bar"
+         }
+    ]
+}
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/boolean.json b/vendor/github.com/jmespath/go-jmespath/compliance/boolean.json
new file mode 100644
index 00000000..e3fa196b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/boolean.json
@@ -0,0 +1,257 @@
+[
+  {
+    "given": {
+      "outer": {
+        "foo": "foo",
+        "bar": "bar",
+        "baz": "baz"
+      }
+    },
+    "cases": [
+      {
+        "expression": "outer.foo || outer.bar",
+        "result": "foo"
+      },
+      {
+        "expression": "outer.foo||outer.bar",
+        "result": "foo"
+      },
+      {
+        "expression": "outer.bar || outer.baz",
+        "result": "bar"
+      },
+      {
+        "expression": "outer.bar||outer.baz",
+        "result": "bar"
+      },
+      {
+        "expression": "outer.bad || outer.foo",
+        "result": "foo"
+      },
+      {
+        "expression": "outer.bad||outer.foo",
+        "result": "foo"
+      },
+      {
+        "expression": "outer.foo || outer.bad",
+        "result": "foo"
+      },
+      {
+        "expression": "outer.foo||outer.bad",
+        "result": "foo"
+      },
+      {
+        "expression": "outer.bad || outer.alsobad",
+        "result": null
+      },
+      {
+        "expression": "outer.bad||outer.alsobad",
+        "result": null
+      }
+    ]
+  },
+  {
+    "given": {
+      "outer": {
+        "foo": "foo",
+        "bool": false,
+        "empty_list": [],
+        "empty_string": ""
+      }
+    },
+    "cases": [
+      {
+        "expression": "outer.empty_string || outer.foo",
+        "result": "foo"
+      },
+      {
+        "expression": "outer.nokey || outer.bool || outer.empty_list || outer.empty_string || outer.foo",
+        "result": "foo"
+      }
+    ]
+  },
+  {
+    "given": {
+      "True": true,
+      "False": false,
+      "Number": 5,
+      "EmptyList": [],
+      "Zero": 0
+    },
+    "cases": [
+      {
+        "expression": "True && False",
+        "result": false
+      },
+      {
+        "expression": "False && True",
+        "result": false
+      },
+      {
+        "expression": "True && True",
+        "result": true
+      },
+      {
+        "expression": "False && False",
+        "result": false
+      },
+      {
+        "expression": "True && Number",
+        "result": 5
+      },
+      {
+        "expression": "Number && True",
+        "result": true
+      },
+      {
+        "expression": "Number && False",
+        "result": false
+      },
+      {
+        "expression": "Number && EmptyList",
+        "result": []
+      },
+      {
+        "expression": "Number && True",
+        "result": true
+      },
+      {
+        "expression": "EmptyList && True",
+        "result": []
+      },
+      {
+        "expression": "EmptyList && False",
+        "result": []
+      },
+      {
+        "expression": "True || False",
+        "result": true
+      },
+      {
+        "expression": "True || True",
+        "result": true
+      },
+      {
+        "expression": "False || True",
+        "result": true
+      },
+      {
+        "expression": "False || False",
+        "result": false
+      },
+      {
+        "expression": "Number || EmptyList",
+        "result": 5
+      },
+      {
+        "expression": "Number || True",
+        "result": 5
+      },
+      {
+        "expression": "Number || True && False",
+        "result": 5
+      },
+      {
+        "expression": "(Number || True) && False",
+        "result": false
+      },
+      {
+        "expression": "Number || (True && False)",
+        "result": 5
+      },
+      {
+        "expression": "!True",
+        "result": false
+      },
+      {
+        "expression": "!False",
+        "result": true
+      },
+      {
+        "expression": "!Number",
+        "result": false
+      },
+      {
+        "expression": "!EmptyList",
+        "result": true
+      },
+      {
+        "expression": "True && !False",
+        "result": true
+      },
+      {
+        "expression": "True && !EmptyList",
+        "result": true
+      },
+      {
+        "expression": "!False && !EmptyList",
+        "result": true
+      },
+      {
+        "expression": "!(True && False)",
+        "result": true
+      },
+      {
+        "expression": "!Zero",
+        "result": false
+      },
+      {
+        "expression": "!!Zero",
+        "result": true
+      }
+    ]
+  },
+  {
+    "given": {
+      "one": 1,
+      "two": 2,
+      "three": 3
+    },
+    "cases": [
+      {
+        "expression": "one < two",
+        "result": true
+      },
+      {
+        "expression": "one <= two",
+        "result": true
+      },
+      {
+        "expression": "one == one",
+        "result": true
+      },
+      {
+        "expression": "one == two",
+        "result": false
+      },
+      {
+        "expression": "one > two",
+        "result": false
+      },
+      {
+        "expression": "one >= two",
+        "result": false
+      },
+      {
+        "expression": "one != two",
+        "result": true
+      },
+      {
+        "expression": "one < two && three > one",
+        "result": true
+      },
+      {
+        "expression": "one < two || three > one",
+        "result": true
+      },
+      {
+        "expression": "one < two || three < one",
+        "result": true
+      },
+      {
+        "expression": "two < one || three < one",
+        "result": false
+      }
+    ]
+  }
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/current.json b/vendor/github.com/jmespath/go-jmespath/compliance/current.json
new file mode 100644
index 00000000..0c26248d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/current.json
@@ -0,0 +1,25 @@
+[
+    {
+        "given": {
+            "foo": [{"name": "a"}, {"name": "b"}],
+            "bar": {"baz": "qux"}
+        },
+        "cases": [
+            {
+                "expression": "@",
+                "result": {
+                    "foo": [{"name": "a"}, {"name": "b"}],
+                    "bar": {"baz": "qux"}
+                }
+            },
+            {
+                "expression": "@.bar",
+                "result": {"baz": "qux"}
+            },
+            {
+                "expression": "@.foo[0]",
+                "result": {"name": "a"}
+            }
+        ]
+    }
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/escape.json b/vendor/github.com/jmespath/go-jmespath/compliance/escape.json
new file mode 100644
index 00000000..4a62d951
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/escape.json
@@ -0,0 +1,46 @@
+[{
+    "given": {
+        "foo.bar": "dot",
+        "foo bar": "space",
+        "foo\nbar": "newline",
+        "foo\"bar": "doublequote",
+        "c:\\\\windows\\path": "windows",
+        "/unix/path": "unix",
+        "\"\"\"": "threequotes",
+        "bar": {"baz": "qux"}
+     },
+     "cases": [
+         {
+            "expression": "\"foo.bar\"",
+            "result": "dot"
+         },
+         {
+            "expression": "\"foo bar\"",
+            "result": "space"
+         },
+         {
+            "expression": "\"foo\\nbar\"",
+            "result": "newline"
+         },
+         {
+            "expression": "\"foo\\\"bar\"",
+            "result": "doublequote"
+         },
+         {
+            "expression": "\"c:\\\\\\\\windows\\\\path\"",
+            "result": "windows"
+         },
+         {
+            "expression": "\"/unix/path\"",
+            "result": "unix"
+         },
+         {
+            "expression": "\"\\\"\\\"\\\"\"",
+            "result": "threequotes"
+         },
+         {
+            "expression": "\"bar\".\"baz\"",
+            "result": "qux"
+         }
+     ]
+}]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/filters.json b/vendor/github.com/jmespath/go-jmespath/compliance/filters.json
new file mode 100644
index 00000000..5b9f52b1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/filters.json
@@ -0,0 +1,468 @@
+[
+  {
+    "given": {"foo": [{"name": "a"}, {"name": "b"}]},
+    "cases": [
+      {
+        "comment": "Matching a literal",
+        "expression": "foo[?name == 'a']",
+        "result": [{"name": "a"}]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [0, 1], "bar": [2, 3]},
+    "cases": [
+      {
+        "comment": "Matching a literal",
+        "expression": "*[?[0] == `0`]",
+        "result": [[], []]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"first": "foo", "last": "bar"},
+      {"first": "foo", "last": "foo"},
+      {"first": "foo", "last": "baz"}]},
+    "cases": [
+      {
+        "comment": "Matching an expression",
+        "expression": "foo[?first == last]",
+        "result": [{"first": "foo", "last": "foo"}]
+      },
+      {
+        "comment": "Verify projection created from filter",
+        "expression": "foo[?first == last].first",
+        "result": ["foo"]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"age": 20},
+      {"age": 25},
+      {"age": 30}]},
+    "cases": [
+      {
+        "comment": "Greater than with a number",
+        "expression": "foo[?age > `25`]",
+        "result": [{"age": 30}]
+      },
+      {
+        "expression": "foo[?age >= `25`]",
+        "result": [{"age": 25}, {"age": 30}]
+      },
+      {
+        "comment": "Greater than with a number",
+        "expression": "foo[?age > `30`]",
+        "result": []
+      },
+      {
+        "comment": "Greater than with a number",
+        "expression": "foo[?age < `25`]",
+        "result": [{"age": 20}]
+      },
+      {
+        "comment": "Greater than with a number",
+        "expression": "foo[?age <= `25`]",
+        "result": [{"age": 20}, {"age": 25}]
+      },
+      {
+        "comment": "Greater than with a number",
+        "expression": "foo[?age < `20`]",
+        "result": []
+      },
+      {
+        "expression": "foo[?age == `20`]",
+        "result": [{"age": 20}]
+      },
+      {
+        "expression": "foo[?age != `20`]",
+        "result": [{"age": 25}, {"age": 30}]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"top": {"name": "a"}},
+      {"top": {"name": "b"}}]},
+    "cases": [
+      {
+        "comment": "Filter with subexpression",
+        "expression": "foo[?top.name == 'a']",
+        "result": [{"top": {"name": "a"}}]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"top": {"first": "foo", "last": "bar"}},
+      {"top": {"first": "foo", "last": "foo"}},
+      {"top": {"first": "foo", "last": "baz"}}]},
+    "cases": [
+      {
+        "comment": "Matching an expression",
+        "expression": "foo[?top.first == top.last]",
+        "result": [{"top": {"first": "foo", "last": "foo"}}]
+      },
+      {
+        "comment": "Matching a JSON array",
+        "expression": "foo[?top == `{\"first\": \"foo\", \"last\": \"bar\"}`]",
+        "result": [{"top": {"first": "foo", "last": "bar"}}]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [
+      {"key": true},
+      {"key": false},
+      {"key": 0},
+      {"key": 1},
+      {"key": [0]},
+      {"key": {"bar": [0]}},
+      {"key": null},
+      {"key": [1]},
+      {"key": {"a":2}}
+    ]},
+    "cases": [
+      {
+        "expression": "foo[?key == `true`]",
+        "result": [{"key": true}]
+      },
+      {
+        "expression": "foo[?key == `false`]",
+        "result": [{"key": false}]
+      },
+      {
+        "expression": "foo[?key == `0`]",
+        "result": [{"key": 0}]
+      },
+      {
+        "expression": "foo[?key == `1`]",
+        "result": [{"key": 1}]
+      },
+      {
+        "expression": "foo[?key == `[0]`]",
+        "result": [{"key": [0]}]
+      },
+      {
+        "expression": "foo[?key == `{\"bar\": [0]}`]",
+        "result": [{"key": {"bar": [0]}}]
+      },
+      {
+        "expression": "foo[?key == `null`]",
+        "result": [{"key": null}]
+      },
+      {
+        "expression": "foo[?key == `[1]`]",
+        "result": [{"key": [1]}]
+      },
+      {
+        "expression": "foo[?key == `{\"a\":2}`]",
+        "result": [{"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?`true` == key]",
+        "result": [{"key": true}]
+      },
+      {
+        "expression": "foo[?`false` == key]",
+        "result": [{"key": false}]
+      },
+      {
+        "expression": "foo[?`0` == key]",
+        "result": [{"key": 0}]
+      },
+      {
+        "expression": "foo[?`1` == key]",
+        "result": [{"key": 1}]
+      },
+      {
+        "expression": "foo[?`[0]` == key]",
+        "result": [{"key": [0]}]
+      },
+      {
+        "expression": "foo[?`{\"bar\": [0]}` == key]",
+        "result": [{"key": {"bar": [0]}}]
+      },
+      {
+        "expression": "foo[?`null` == key]",
+        "result": [{"key": null}]
+      },
+      {
+        "expression": "foo[?`[1]` == key]",
+        "result": [{"key": [1]}]
+      },
+      {
+        "expression": "foo[?`{\"a\":2}` == key]",
+        "result": [{"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?key != `true`]",
+        "result": [{"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?key != `false`]",
+        "result": [{"key": true}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?key != `0`]",
+        "result": [{"key": true}, {"key": false}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?key != `1`]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?key != `null`]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?key != `[1]`]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?key != `{\"a\":2}`]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}]
+      },
+      {
+        "expression": "foo[?`true` != key]",
+        "result": [{"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?`false` != key]",
+        "result": [{"key": true}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?`0` != key]",
+        "result": [{"key": true}, {"key": false}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?`1` != key]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?`null` != key]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": [1]}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?`[1]` != key]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": {"a":2}}]
+      },
+      {
+        "expression": "foo[?`{\"a\":2}` != key]",
+        "result": [{"key": true}, {"key": false}, {"key": 0}, {"key": 1}, {"key": [0]},
+          {"key": {"bar": [0]}}, {"key": null}, {"key": [1]}]
+      }
+    ]
+  },
+  {
+    "given": {"reservations": [
+      {"instances": [
+        {"foo": 1, "bar": 2}, {"foo": 1, "bar": 3},
+        {"foo": 1, "bar": 2}, {"foo": 2, "bar": 1}]}]},
+    "cases": [
+      {
+        "expression": "reservations[].instances[?bar==`1`]",
+        "result": [[{"foo": 2, "bar": 1}]]
+      },
+      {
+        "expression": "reservations[*].instances[?bar==`1`]",
+        "result": [[{"foo": 2, "bar": 1}]]
+      },
+      {
+        "expression": "reservations[].instances[?bar==`1`][]",
+        "result": [{"foo": 2, "bar": 1}]
+      }
+    ]
+  },
+  {
+    "given": {
+      "baz": "other",
+      "foo": [
+        {"bar": 1}, {"bar": 2}, {"bar": 3}, {"bar": 4}, {"bar": 1, "baz": 2}
+      ]
+    },
+    "cases": [
+      {
+        "expression": "foo[?bar==`1`].bar[0]",
+        "result": []
+      }
+    ]
+  },
+  {
+    "given": {
+      "foo": [
+        {"a": 1, "b": {"c": "x"}},
+	{"a": 1, "b": {"c": "y"}},
+	{"a": 1, "b": {"c": "z"}},
+	{"a": 2, "b": {"c": "z"}},
+	{"a": 1, "baz": 2}
+      ]
+    },
+    "cases": [
+      {
+        "expression": "foo[?a==`1`].b.c",
+        "result": ["x", "y", "z"]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"name": "a"}, {"name": "b"}, {"name": "c"}]},
+    "cases": [
+      {
+        "comment": "Filter with or expression",
+        "expression": "foo[?name == 'a' || name == 'b']",
+        "result": [{"name": "a"}, {"name": "b"}]
+      },
+      {
+        "expression": "foo[?name == 'a' || name == 'e']",
+        "result": [{"name": "a"}]
+      },
+      {
+        "expression": "foo[?name == 'a' || name == 'b' || name == 'c']",
+        "result": [{"name": "a"}, {"name": "b"}, {"name": "c"}]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"a": 1, "b": 2}, {"a": 1, "b": 3}]},
+    "cases": [
+      {
+        "comment": "Filter with and expression",
+        "expression": "foo[?a == `1` && b == `2`]",
+        "result": [{"a": 1, "b": 2}]
+      },
+      {
+        "expression": "foo[?a == `1` && b == `4`]",
+        "result": []
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]},
+    "cases": [
+      {
+        "comment": "Filter with Or and And expressions",
+        "expression": "foo[?c == `3` || a == `1` && b == `4`]",
+        "result": [{"a": 1, "b": 2, "c": 3}]
+      },
+      {
+        "expression": "foo[?b == `2` || a == `3` && b == `4`]",
+        "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]
+      },
+      {
+        "expression": "foo[?a == `3` && b == `4` || b == `2`]",
+        "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]
+      },
+      {
+        "expression": "foo[?(a == `3` && b == `4`) || b == `2`]",
+        "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]
+      },
+      {
+        "expression": "foo[?((a == `3` && b == `4`)) || b == `2`]",
+        "result": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]
+      },
+      {
+        "expression": "foo[?a == `3` && (b == `4` || b == `2`)]",
+        "result": [{"a": 3, "b": 4}]
+      },
+      {
+        "expression": "foo[?a == `3` && ((b == `4` || b == `2`))]",
+        "result": [{"a": 3, "b": 4}]
+      }
+    ]
+  },
+  {
+    "given": {"foo": [{"a": 1, "b": 2, "c": 3}, {"a": 3, "b": 4}]},
+    "cases": [
+      {
+        "comment": "Verify precedence of or/and expressions",
+        "expression": "foo[?a == `1` || b ==`2` && c == `5`]",
+        "result": [{"a": 1, "b": 2, "c": 3}]
+      },
+      {
+        "comment": "Parentheses can alter precedence",
+        "expression": "foo[?(a == `1` || b ==`2`) && c == `5`]",
+        "result": []
+      },
+      {
+        "comment": "Not expressions combined with and/or",
+        "expression": "foo[?!(a == `1` || b ==`2`)]",
+        "result": [{"a": 3, "b": 4}]
+      }
+    ]
+  },
+  {
+    "given": {
+      "foo": [
+        {"key": true},
+        {"key": false},
+        {"key": []},
+        {"key": {}},
+        {"key": [0]},
+        {"key": {"a": "b"}},
+        {"key": 0},
+        {"key": 1},
+        {"key": null},
+        {"notkey": true}
+      ]
+    },
+    "cases": [
+      {
+        "comment": "Unary filter expression",
+        "expression": "foo[?key]",
+        "result": [
+          {"key": true}, {"key": [0]}, {"key": {"a": "b"}},
+          {"key": 0}, {"key": 1}
+        ]
+      },
+      {
+        "comment": "Unary not filter expression",
+        "expression": "foo[?!key]",
+        "result": [
+          {"key": false}, {"key": []}, {"key": {}},
+          {"key": null}, {"notkey": true}
+        ]
+      },
+      {
+        "comment": "Equality with null RHS",
+        "expression": "foo[?key == `null`]",
+        "result": [
+          {"key": null}, {"notkey": true}
+        ]
+      }
+    ]
+  },
+  {
+    "given": {
+      "foo": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    "cases": [
+      {
+        "comment": "Using @ in a filter expression",
+        "expression": "foo[?@ < `5`]",
+        "result": [0, 1, 2, 3, 4]
+      },
+      {
+        "comment": "Using @ in a filter expression",
+        "expression": "foo[?`5` > @]",
+        "result": [0, 1, 2, 3, 4]
+      },
+      {
+        "comment": "Using @ in a filter expression",
+        "expression": "foo[?@ == @]",
+        "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+      }
+    ]
+  }
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/functions.json b/vendor/github.com/jmespath/go-jmespath/compliance/functions.json
new file mode 100644
index 00000000..8b8db363
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/functions.json
@@ -0,0 +1,825 @@
+[{
+  "given":
+  {
+    "foo": -1,
+    "zero": 0,
+    "numbers": [-1, 3, 4, 5],
+    "array": [-1, 3, 4, 5, "a", "100"],
+    "strings": ["a", "b", "c"],
+    "decimals": [1.01, 1.2, -1.5],
+    "str": "Str",
+    "false": false,
+    "empty_list": [],
+    "empty_hash": {},
+    "objects": {"foo": "bar", "bar": "baz"},
+    "null_key": null
+  },
+  "cases": [
+    {
+      "expression": "abs(foo)",
+      "result": 1
+    },
+    {
+      "expression": "abs(foo)",
+      "result": 1
+    },
+    {
+      "expression": "abs(str)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "abs(array[1])",
+      "result": 3
+    },
+    {
+      "expression": "abs(array[1])",
+      "result": 3
+    },
+    {
+      "expression": "abs(`false`)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "abs(`-24`)",
+      "result": 24
+    },
+    {
+      "expression": "abs(`-24`)",
+      "result": 24
+    },
+    {
+      "expression": "abs(`1`, `2`)",
+      "error": "invalid-arity"
+    },
+    {
+      "expression": "abs()",
+      "error": "invalid-arity"
+    },
+    {
+      "expression": "unknown_function(`1`, `2`)",
+      "error": "unknown-function"
+    },
+    {
+      "expression": "avg(numbers)",
+      "result": 2.75
+    },
+    {
+      "expression": "avg(array)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "avg('abc')",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "avg(foo)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "avg(@)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "avg(strings)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "ceil(`1.2`)",
+      "result": 2
+    },
+    {
+      "expression": "ceil(decimals[0])",
+      "result": 2
+    },
+    {
+      "expression": "ceil(decimals[1])",
+      "result": 2
+    },
+    {
+      "expression": "ceil(decimals[2])",
+      "result": -1
+    },
+    {
+      "expression": "ceil('string')",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "contains('abc', 'a')",
+      "result": true
+    },
+    {
+      "expression": "contains('abc', 'd')",
+      "result": false
+    },
+    {
+      "expression": "contains(`false`, 'd')",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "contains(strings, 'a')",
+      "result": true
+    },
+    {
+      "expression": "contains(decimals, `1.2`)",
+      "result": true
+    },
+    {
+      "expression": "contains(decimals, `false`)",
+      "result": false
+    },
+    {
+      "expression": "ends_with(str, 'r')",
+      "result": true
+    },
+    {
+      "expression": "ends_with(str, 'tr')",
+      "result": true
+    },
+    {
+      "expression": "ends_with(str, 'Str')",
+      "result": true
+    },
+    {
+      "expression": "ends_with(str, 'SStr')",
+      "result": false
+    },
+    {
+      "expression": "ends_with(str, 'foo')",
+      "result": false
+    },
+    {
+      "expression": "ends_with(str, `0`)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "floor(`1.2`)",
+      "result": 1
+    },
+    {
+      "expression": "floor('string')",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "floor(decimals[0])",
+      "result": 1
+    },
+    {
+      "expression": "floor(foo)",
+      "result": -1
+    },
+    {
+      "expression": "floor(str)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "length('abc')",
+      "result": 3
+    },
+    {
+      "expression": "length('✓foo')",
+      "result": 4
+    },
+    {
+      "expression": "length('')",
+      "result": 0
+    },
+    {
+      "expression": "length(@)",
+      "result": 12
+    },
+    {
+      "expression": "length(strings[0])",
+      "result": 1
+    },
+    {
+      "expression": "length(str)",
+      "result": 3
+    },
+    {
+      "expression": "length(array)",
+      "result": 6
+    },
+    {
+      "expression": "length(objects)",
+      "result": 2
+    },
+    {
+      "expression": "length(`false`)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "length(foo)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "length(strings[0])",
+      "result": 1
+    },
+    {
+      "expression": "max(numbers)",
+      "result": 5
+    },
+    {
+      "expression": "max(decimals)",
+      "result": 1.2
+    },
+    {
+      "expression": "max(strings)",
+      "result": "c"
+    },
+    {
+      "expression": "max(abc)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "max(array)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "max(decimals)",
+      "result": 1.2
+    },
+    {
+      "expression": "max(empty_list)",
+      "result": null
+    },
+    {
+      "expression": "merge(`{}`)",
+      "result": {}
+    },
+    {
+      "expression": "merge(`{}`, `{}`)",
+      "result": {}
+    },
+    {
+      "expression": "merge(`{\"a\": 1}`, `{\"b\": 2}`)",
+      "result": {"a": 1, "b": 2}
+    },
+    {
+      "expression": "merge(`{\"a\": 1}`, `{\"a\": 2}`)",
+      "result": {"a": 2}
+    },
+    {
+      "expression": "merge(`{\"a\": 1, \"b\": 2}`, `{\"a\": 2, \"c\": 3}`, `{\"d\": 4}`)",
+      "result": {"a": 2, "b": 2, "c": 3, "d": 4}
+    },
+    {
+      "expression": "min(numbers)",
+      "result": -1
+    },
+    {
+      "expression": "min(decimals)",
+      "result": -1.5
+    },
+    {
+      "expression": "min(abc)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "min(array)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "min(empty_list)",
+      "result": null
+    },
+    {
+      "expression": "min(decimals)",
+      "result": -1.5
+    },
+    {
+      "expression": "min(strings)",
+      "result": "a"
+    },
+    {
+      "expression": "type('abc')",
+      "result": "string"
+    },
+    {
+      "expression": "type(`1.0`)",
+      "result": "number"
+    },
+    {
+      "expression": "type(`2`)",
+      "result": "number"
+    },
+    {
+      "expression": "type(`true`)",
+      "result": "boolean"
+    },
+    {
+      "expression": "type(`false`)",
+      "result": "boolean"
+    },
+    {
+      "expression": "type(`null`)",
+      "result": "null"
+    },
+    {
+      "expression": "type(`[0]`)",
+      "result": "array"
+    },
+    {
+      "expression": "type(`{\"a\": \"b\"}`)",
+      "result": "object"
+    },
+    {
+      "expression": "type(@)",
+      "result": "object"
+    },
+    {
+      "expression": "sort(keys(objects))",
+      "result": ["bar", "foo"]
+    },
+    {
+      "expression": "keys(foo)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "keys(strings)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "keys(`false`)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sort(values(objects))",
+      "result": ["bar", "baz"]
+    },
+    {
+      "expression": "keys(empty_hash)",
+      "result": []
+    },
+    {
+      "expression": "values(foo)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "join(', ', strings)",
+      "result": "a, b, c"
+    },
+    {
+      "expression": "join(', ', strings)",
+      "result": "a, b, c"
+    },
+    {
+      "expression": "join(',', `[\"a\", \"b\"]`)",
+      "result": "a,b"
+    },
+    {
+      "expression": "join(',', `[\"a\", 0]`)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "join(', ', str)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "join('|', strings)",
+      "result": "a|b|c"
+    },
+    {
+      "expression": "join(`2`, strings)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "join('|', decimals)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "join('|', decimals[].to_string(@))",
+      "result": "1.01|1.2|-1.5"
+    },
+    {
+      "expression": "join('|', empty_list)",
+      "result": ""
+    },
+    {
+      "expression": "reverse(numbers)",
+      "result": [5, 4, 3, -1]
+    },
+    {
+      "expression": "reverse(array)",
+      "result": ["100", "a", 5, 4, 3, -1]
+    },
+    {
+      "expression": "reverse(`[]`)",
+      "result": []
+    },
+    {
+      "expression": "reverse('')",
+      "result": ""
+    },
+    {
+      "expression": "reverse('hello world')",
+      "result": "dlrow olleh"
+    },
+    {
+      "expression": "starts_with(str, 'S')",
+      "result": true
+    },
+    {
+      "expression": "starts_with(str, 'St')",
+      "result": true
+    },
+    {
+      "expression": "starts_with(str, 'Str')",
+      "result": true
+    },
+    {
+      "expression": "starts_with(str, 'String')",
+      "result": false
+    },
+    {
+      "expression": "starts_with(str, `0`)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sum(numbers)",
+      "result": 11
+    },
+    {
+      "expression": "sum(decimals)",
+      "result": 0.71
+    },
+    {
+      "expression": "sum(array)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sum(array[].to_number(@))",
+      "result": 111
+    },
+    {
+      "expression": "sum(`[]`)",
+      "result": 0
+    },
+    {
+      "expression": "to_array('foo')",
+      "result": ["foo"]
+    },
+    {
+      "expression": "to_array(`0`)",
+      "result": [0]
+    },
+    {
+      "expression": "to_array(objects)",
+      "result": [{"foo": "bar", "bar": "baz"}]
+    },
+    {
+      "expression": "to_array(`[1, 2, 3]`)",
+      "result": [1, 2, 3]
+    },
+    {
+      "expression": "to_array(false)",
+      "result": [false]
+    },
+    {
+      "expression": "to_string('foo')",
+      "result": "foo"
+    },
+    {
+      "expression": "to_string(`1.2`)",
+      "result": "1.2"
+    },
+    {
+      "expression": "to_string(`[0, 1]`)",
+      "result": "[0,1]"
+    },
+    {
+      "expression": "to_number('1.0')",
+      "result": 1.0
+    },
+    {
+      "expression": "to_number('1.1')",
+      "result": 1.1
+    },
+    {
+      "expression": "to_number('4')",
+      "result": 4
+    },
+    {
+      "expression": "to_number('notanumber')",
+      "result": null
+    },
+    {
+      "expression": "to_number(`false`)",
+      "result": null
+    },
+    {
+      "expression": "to_number(`null`)",
+      "result": null
+    },
+    {
+      "expression": "to_number(`[0]`)",
+      "result": null
+    },
+    {
+      "expression": "to_number(`{\"foo\": 0}`)",
+      "result": null
+    },
+    {
+      "expression": "\"to_string\"(`1.0`)",
+      "error": "syntax"
+    },
+    {
+      "expression": "sort(numbers)",
+      "result": [-1, 3, 4, 5]
+    },
+    {
+      "expression": "sort(strings)",
+      "result": ["a", "b", "c"]
+    },
+    {
+      "expression": "sort(decimals)",
+      "result": [-1.5, 1.01, 1.2]
+    },
+    {
+      "expression": "sort(array)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sort(abc)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sort(empty_list)",
+      "result": []
+    },
+    {
+      "expression": "sort(@)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "not_null(unknown_key, str)",
+      "result": "Str"
+    },
+    {
+      "expression": "not_null(unknown_key, foo.bar, empty_list, str)",
+      "result": []
+    },
+    {
+      "expression": "not_null(unknown_key, null_key, empty_list, str)",
+      "result": []
+    },
+    {
+      "expression": "not_null(all, expressions, are_null)",
+      "result": null
+    },
+    {
+      "expression": "not_null()",
+      "error": "invalid-arity"
+    },
+    {
+      "description": "function projection on single arg function",
+      "expression": "numbers[].to_string(@)",
+      "result": ["-1", "3", "4", "5"]
+    },
+    {
+      "description": "function projection on single arg function",
+      "expression": "array[].to_number(@)",
+      "result": [-1, 3, 4, 5, 100]
+    }
+  ]
+}, {
+  "given":
+  {
+    "foo": [
+         {"b": "b", "a": "a"},
+         {"c": "c", "b": "b"},
+         {"d": "d", "c": "c"},
+         {"e": "e", "d": "d"},
+         {"f": "f", "e": "e"}
+    ]
+  },
+  "cases": [
+    {
+      "description": "function projection on variadic function",
+      "expression": "foo[].not_null(f, e, d, c, b, a)",
+      "result": ["b", "c", "d", "e", "f"]
+    }
+  ]
+}, {
+  "given":
+  {
+    "people": [
+         {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"},
+         {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"},
+         {"age": 30, "age_str": "30", "bool": true, "name": "c"},
+         {"age": 50, "age_str": "50", "bool": false, "name": "d"},
+         {"age": 10, "age_str": "10", "bool": true, "name": 3}
+    ]
+  },
+  "cases": [
+    {
+      "description": "sort by field expression",
+      "expression": "sort_by(people, &age)",
+      "result": [
+         {"age": 10, "age_str": "10", "bool": true, "name": 3},
+         {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"},
+         {"age": 30, "age_str": "30", "bool": true, "name": "c"},
+         {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"},
+         {"age": 50, "age_str": "50", "bool": false, "name": "d"}
+      ]
+    },
+    {
+      "expression": "sort_by(people, &age_str)",
+      "result": [
+         {"age": 10, "age_str": "10", "bool": true, "name": 3},
+         {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"},
+         {"age": 30, "age_str": "30", "bool": true, "name": "c"},
+         {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"},
+         {"age": 50, "age_str": "50", "bool": false, "name": "d"}
+      ]
+    },
+    {
+      "description": "sort by function expression",
+      "expression": "sort_by(people, &to_number(age_str))",
+      "result": [
+         {"age": 10, "age_str": "10", "bool": true, "name": 3},
+         {"age": 20, "age_str": "20", "bool": true, "name": "a", "extra": "foo"},
+         {"age": 30, "age_str": "30", "bool": true, "name": "c"},
+         {"age": 40, "age_str": "40", "bool": false, "name": "b", "extra": "bar"},
+         {"age": 50, "age_str": "50", "bool": false, "name": "d"}
+      ]
+    },
+    {
+      "description": "function projection on sort_by function",
+      "expression": "sort_by(people, &age)[].name",
+      "result": [3, "a", "c", "b", "d"]
+    },
+    {
+      "expression": "sort_by(people, &extra)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sort_by(people, &bool)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sort_by(people, &name)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sort_by(people, name)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "sort_by(people, &age)[].extra",
+      "result": ["foo", "bar"]
+    },
+    {
+      "expression": "sort_by(`[]`, &age)",
+      "result": []
+    },
+    {
+      "expression": "max_by(people, &age)",
+      "result": {"age": 50, "age_str": "50", "bool": false, "name": "d"}
+    },
+    {
+      "expression": "max_by(people, &age_str)",
+      "result": {"age": 50, "age_str": "50", "bool": false, "name": "d"}
+    },
+    {
+      "expression": "max_by(people, &bool)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "max_by(people, &extra)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "max_by(people, &to_number(age_str))",
+      "result": {"age": 50, "age_str": "50", "bool": false, "name": "d"}
+    },
+    {
+      "expression": "min_by(people, &age)",
+      "result": {"age": 10, "age_str": "10", "bool": true, "name": 3}
+    },
+    {
+      "expression": "min_by(people, &age_str)",
+      "result": {"age": 10, "age_str": "10", "bool": true, "name": 3}
+    },
+    {
+      "expression": "min_by(people, &bool)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "min_by(people, &extra)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "min_by(people, &to_number(age_str))",
+      "result": {"age": 10, "age_str": "10", "bool": true, "name": 3}
+    }
+  ]
+}, {
+  "given":
+  {
+    "people": [
+         {"age": 10, "order": "1"},
+         {"age": 10, "order": "2"},
+         {"age": 10, "order": "3"},
+         {"age": 10, "order": "4"},
+         {"age": 10, "order": "5"},
+         {"age": 10, "order": "6"},
+         {"age": 10, "order": "7"},
+         {"age": 10, "order": "8"},
+         {"age": 10, "order": "9"},
+         {"age": 10, "order": "10"},
+         {"age": 10, "order": "11"}
+    ]
+  },
+  "cases": [
+    {
+      "description": "stable sort order",
+      "expression": "sort_by(people, &age)",
+      "result": [
+         {"age": 10, "order": "1"},
+         {"age": 10, "order": "2"},
+         {"age": 10, "order": "3"},
+         {"age": 10, "order": "4"},
+         {"age": 10, "order": "5"},
+         {"age": 10, "order": "6"},
+         {"age": 10, "order": "7"},
+         {"age": 10, "order": "8"},
+         {"age": 10, "order": "9"},
+         {"age": 10, "order": "10"},
+         {"age": 10, "order": "11"}
+      ]
+    }
+  ]
+}, {
+  "given":
+  {
+    "people": [
+         {"a": 10, "b": 1, "c": "z"},
+         {"a": 10, "b": 2, "c": null},
+         {"a": 10, "b": 3},
+         {"a": 10, "b": 4, "c": "z"},
+         {"a": 10, "b": 5, "c": null},
+         {"a": 10, "b": 6},
+         {"a": 10, "b": 7, "c": "z"},
+         {"a": 10, "b": 8, "c": null},
+         {"a": 10, "b": 9}
+    ],
+    "empty": []
+  },
+  "cases": [
+    {
+      "expression": "map(&a, people)",
+      "result": [10, 10, 10, 10, 10, 10, 10, 10, 10]
+    },
+    {
+      "expression": "map(&c, people)",
+      "result": ["z", null, null, "z", null, null, "z", null, null]
+    },
+    {
+      "expression": "map(&a, badkey)",
+      "error": "invalid-type"
+    },
+    {
+      "expression": "map(&foo, empty)",
+      "result": []
+    }
+  ]
+}, {
+  "given": {
+    "array": [
+      {
+          "foo": {"bar": "yes1"}
+      },
+      {
+          "foo": {"bar": "yes2"}
+      },
+      {
+          "foo1": {"bar": "no"}
+      }
+  ]},
+  "cases": [
+    {
+      "expression": "map(&foo.bar, array)",
+      "result": ["yes1", "yes2", null]
+    },
+    {
+      "expression": "map(&foo1.bar, array)",
+      "result": [null, null, "no"]
+    },
+    {
+      "expression": "map(&foo.bar.baz, array)",
+      "result": [null, null, null]
+    }
+  ]
+}, {
+  "given": {
+    "array": [[1, 2, 3, [4]], [5, 6, 7, [8, 9]]]
+  },
+  "cases": [
+    {
+      "expression": "map(&[], array)",
+      "result": [[1, 2, 3, 4], [5, 6, 7, 8, 9]]
+    }
+  ]
+}
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/identifiers.json b/vendor/github.com/jmespath/go-jmespath/compliance/identifiers.json
new file mode 100644
index 00000000..7998a41a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/identifiers.json
@@ -0,0 +1,1377 @@
+[
+    {
+        "given": {
+            "__L": true
+        },
+        "cases": [
+            {
+                "expression": "__L",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "!\r": true
+        },
+        "cases": [
+            {
+                "expression": "\"!\\r\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Y_1623": true
+        },
+        "cases": [
+            {
+                "expression": "Y_1623",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "x": true
+        },
+        "cases": [
+            {
+                "expression": "x",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\tF\uCebb": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\tF\\uCebb\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            " \t": true
+        },
+        "cases": [
+            {
+                "expression": "\" \\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            " ": true
+        },
+        "cases": [
+            {
+                "expression": "\" \"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "v2": true
+        },
+        "cases": [
+            {
+                "expression": "v2",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\t": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_X": true
+        },
+        "cases": [
+            {
+                "expression": "_X",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\t4\ud9da\udd15": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\t4\\ud9da\\udd15\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "v24_W": true
+        },
+        "cases": [
+            {
+                "expression": "v24_W",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "H": true
+        },
+        "cases": [
+            {
+                "expression": "\"H\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\f": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\f\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "E4": true
+        },
+        "cases": [
+            {
+                "expression": "\"E4\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "!": true
+        },
+        "cases": [
+            {
+                "expression": "\"!\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "tM": true
+        },
+        "cases": [
+            {
+                "expression": "tM",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            " [": true
+        },
+        "cases": [
+            {
+                "expression": "\" [\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "R!": true
+        },
+        "cases": [
+            {
+                "expression": "\"R!\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_6W": true
+        },
+        "cases": [
+            {
+                "expression": "_6W",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\uaBA1\r": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\uaBA1\\r\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "tL7": true
+        },
+        "cases": [
+            {
+                "expression": "tL7",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "<<U\t": true
+        },
+        "cases": [
+            {
+                "expression": "\"<<U\\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\ubBcE\ufAfB": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\ubBcE\\ufAfB\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "sNA_": true
+        },
+        "cases": [
+            {
+                "expression": "sNA_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "9": true
+        },
+        "cases": [
+            {
+                "expression": "\"9\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\\\b\ud8cb\udc83": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\\\\b\\ud8cb\\udc83\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "r": true
+        },
+        "cases": [
+            {
+                "expression": "\"r\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Q": true
+        },
+        "cases": [
+            {
+                "expression": "Q",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_Q__7GL8": true
+        },
+        "cases": [
+            {
+                "expression": "_Q__7GL8",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\\": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\\\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "RR9_": true
+        },
+        "cases": [
+            {
+                "expression": "RR9_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\r\f:": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\r\\f:\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "r7": true
+        },
+        "cases": [
+            {
+                "expression": "r7",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "-": true
+        },
+        "cases": [
+            {
+                "expression": "\"-\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "p9": true
+        },
+        "cases": [
+            {
+                "expression": "p9",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "__": true
+        },
+        "cases": [
+            {
+                "expression": "__",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\b\t": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\b\\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "O_": true
+        },
+        "cases": [
+            {
+                "expression": "O_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_r_8": true
+        },
+        "cases": [
+            {
+                "expression": "_r_8",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_j": true
+        },
+        "cases": [
+            {
+                "expression": "_j",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            ":": true
+        },
+        "cases": [
+            {
+                "expression": "\":\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\rB": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\rB\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Obf": true
+        },
+        "cases": [
+            {
+                "expression": "Obf",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\n": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\n\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\f\udb54\udf33": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\f\udb54\udf33\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\\\u4FDc": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\\\\u4FDc\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\r": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\r\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "m_": true
+        },
+        "cases": [
+            {
+                "expression": "m_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\r\fB ": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\r\\fB \"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "+\"\"": true
+        },
+        "cases": [
+            {
+                "expression": "\"+\\\"\\\"\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Mg": true
+        },
+        "cases": [
+            {
+                "expression": "Mg",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\"!\/": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\"!\\/\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "7\"": true
+        },
+        "cases": [
+            {
+                "expression": "\"7\\\"\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\\\udb3a\udca4S": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\\\udb3a\udca4S\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\"": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\"\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Kl": true
+        },
+        "cases": [
+            {
+                "expression": "Kl",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\b\b": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\b\\b\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            ">": true
+        },
+        "cases": [
+            {
+                "expression": "\">\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "hvu": true
+        },
+        "cases": [
+            {
+                "expression": "hvu",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "; !": true
+        },
+        "cases": [
+            {
+                "expression": "\"; !\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "hU": true
+        },
+        "cases": [
+            {
+                "expression": "hU",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "!I\n\/": true
+        },
+        "cases": [
+            {
+                "expression": "\"!I\\n\\/\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\uEEbF": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\uEEbF\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "U)\t": true
+        },
+        "cases": [
+            {
+                "expression": "\"U)\\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "fa0_9": true
+        },
+        "cases": [
+            {
+                "expression": "fa0_9",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "/": true
+        },
+        "cases": [
+            {
+                "expression": "\"/\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Gy": true
+        },
+        "cases": [
+            {
+                "expression": "Gy",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\b": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\b\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "<": true
+        },
+        "cases": [
+            {
+                "expression": "\"<\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\t": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\t&\\\r": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\t&\\\\\\r\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "#": true
+        },
+        "cases": [
+            {
+                "expression": "\"#\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "B__": true
+        },
+        "cases": [
+            {
+                "expression": "B__",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\nS \n": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\nS \\n\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Bp": true
+        },
+        "cases": [
+            {
+                "expression": "Bp",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            ",\t;": true
+        },
+        "cases": [
+            {
+                "expression": "\",\\t;\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "B_q": true
+        },
+        "cases": [
+            {
+                "expression": "B_q",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\/+\t\n\b!Z": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\/+\\t\\n\\b!Z\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\udadd\udfc7\\ueFAc": true
+        },
+        "cases": [
+            {
+                "expression": "\"\udadd\udfc7\\\\ueFAc\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            ":\f": true
+        },
+        "cases": [
+            {
+                "expression": "\":\\f\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\/": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\/\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_BW_6Hg_Gl": true
+        },
+        "cases": [
+            {
+                "expression": "_BW_6Hg_Gl",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\udbcf\udc02": true
+        },
+        "cases": [
+            {
+                "expression": "\"\udbcf\udc02\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "zs1DC": true
+        },
+        "cases": [
+            {
+                "expression": "zs1DC",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "__434": true
+        },
+        "cases": [
+            {
+                "expression": "__434",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\udb94\udd41": true
+        },
+        "cases": [
+            {
+                "expression": "\"\udb94\udd41\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Z_5": true
+        },
+        "cases": [
+            {
+                "expression": "Z_5",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "z_M_": true
+        },
+        "cases": [
+            {
+                "expression": "z_M_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "YU_2": true
+        },
+        "cases": [
+            {
+                "expression": "YU_2",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_0": true
+        },
+        "cases": [
+            {
+                "expression": "_0",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\b+": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\b+\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\"": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\"\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "D7": true
+        },
+        "cases": [
+            {
+                "expression": "D7",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_62L": true
+        },
+        "cases": [
+            {
+                "expression": "_62L",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\tK\t": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\tK\\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\n\\\f": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\n\\\\\\f\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "I_": true
+        },
+        "cases": [
+            {
+                "expression": "I_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "W_a0_": true
+        },
+        "cases": [
+            {
+                "expression": "W_a0_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "BQ": true
+        },
+        "cases": [
+            {
+                "expression": "BQ",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\tX$\uABBb": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\tX$\\uABBb\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Z9": true
+        },
+        "cases": [
+            {
+                "expression": "Z9",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\b%\"\uda38\udd0f": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\b%\\\"\uda38\udd0f\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_F": true
+        },
+        "cases": [
+            {
+                "expression": "_F",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "!,": true
+        },
+        "cases": [
+            {
+                "expression": "\"!,\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\"!": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\"!\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "Hh": true
+        },
+        "cases": [
+            {
+                "expression": "Hh",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "&": true
+        },
+        "cases": [
+            {
+                "expression": "\"&\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "9\r\\R": true
+        },
+        "cases": [
+            {
+                "expression": "\"9\\r\\\\R\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "M_k": true
+        },
+        "cases": [
+            {
+                "expression": "M_k",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "!\b\n\udb06\ude52\"\"": true
+        },
+        "cases": [
+            {
+                "expression": "\"!\\b\\n\udb06\ude52\\\"\\\"\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "6": true
+        },
+        "cases": [
+            {
+                "expression": "\"6\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_7": true
+        },
+        "cases": [
+            {
+                "expression": "_7",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "0": true
+        },
+        "cases": [
+            {
+                "expression": "\"0\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\\8\\": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\\\8\\\\\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "b7eo": true
+        },
+        "cases": [
+            {
+                "expression": "b7eo",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "xIUo9": true
+        },
+        "cases": [
+            {
+                "expression": "xIUo9",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "5": true
+        },
+        "cases": [
+            {
+                "expression": "\"5\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "?": true
+        },
+        "cases": [
+            {
+                "expression": "\"?\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "sU": true
+        },
+        "cases": [
+            {
+                "expression": "sU",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "VH2&H\\\/": true
+        },
+        "cases": [
+            {
+                "expression": "\"VH2&H\\\\\\/\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_C": true
+        },
+        "cases": [
+            {
+                "expression": "_C",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "_": true
+        },
+        "cases": [
+            {
+                "expression": "_",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "<\t": true
+        },
+        "cases": [
+            {
+                "expression": "\"<\\t\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {
+            "\uD834\uDD1E": true
+        },
+        "cases": [
+            {
+                "expression": "\"\\uD834\\uDD1E\"",
+                "result": true
+            }
+        ]
+    }
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/indices.json b/vendor/github.com/jmespath/go-jmespath/compliance/indices.json
new file mode 100644
index 00000000..aa03b35d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/indices.json
@@ -0,0 +1,346 @@
+[{
+    "given":
+        {"foo": {"bar": ["zero", "one", "two"]}},
+     "cases": [
+         {
+            "expression": "foo.bar[0]",
+            "result": "zero"
+         },
+         {
+            "expression": "foo.bar[1]",
+            "result": "one"
+         },
+         {
+            "expression": "foo.bar[2]",
+            "result": "two"
+         },
+         {
+            "expression": "foo.bar[3]",
+            "result": null
+         },
+         {
+            "expression": "foo.bar[-1]",
+            "result": "two"
+         },
+         {
+            "expression": "foo.bar[-2]",
+            "result": "one"
+         },
+         {
+            "expression": "foo.bar[-3]",
+            "result": "zero"
+         },
+         {
+            "expression": "foo.bar[-4]",
+            "result": null
+         }
+     ]
+},
+{
+    "given":
+        {"foo": [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}]},
+     "cases": [
+         {
+            "expression": "foo.bar",
+            "result": null
+         },
+         {
+            "expression": "foo[0].bar",
+            "result": "one"
+         },
+         {
+            "expression": "foo[1].bar",
+            "result": "two"
+         },
+         {
+            "expression": "foo[2].bar",
+            "result": "three"
+         },
+         {
+            "expression": "foo[3].notbar",
+            "result": "four"
+         },
+         {
+            "expression": "foo[3].bar",
+            "result": null
+         },
+         {
+            "expression": "foo[0]",
+            "result": {"bar": "one"}
+         },
+         {
+            "expression": "foo[1]",
+            "result": {"bar": "two"}
+         },
+         {
+            "expression": "foo[2]",
+            "result": {"bar": "three"}
+         },
+         {
+            "expression": "foo[3]",
+            "result": {"notbar": "four"}
+         },
+         {
+            "expression": "foo[4]",
+            "result": null
+         }
+     ]
+},
+{
+    "given": [
+        "one", "two", "three"
+    ],
+     "cases": [
+         {
+            "expression": "[0]",
+            "result": "one"
+         },
+         {
+            "expression": "[1]",
+            "result": "two"
+         },
+         {
+            "expression": "[2]",
+            "result": "three"
+         },
+         {
+            "expression": "[-1]",
+            "result": "three"
+         },
+         {
+            "expression": "[-2]",
+            "result": "two"
+         },
+         {
+            "expression": "[-3]",
+            "result": "one"
+         }
+     ]
+},
+{
+    "given": {"reservations": [
+        {"instances": [{"foo": 1}, {"foo": 2}]}
+    ]},
+    "cases": [
+        {
+           "expression": "reservations[].instances[].foo",
+           "result": [1, 2]
+        },
+        {
+           "expression": "reservations[].instances[].bar",
+           "result": []
+        },
+        {
+           "expression": "reservations[].notinstances[].foo",
+           "result": []
+        },
+        {
+           "expression": "reservations[].notinstances[].foo",
+           "result": []
+        }
+    ]
+},
+{
+    "given": {"reservations": [{
+        "instances": [
+            {"foo": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]},
+            {"foo": [{"bar": 5}, {"bar": 6}, {"notbar": [7]}, {"bar": 8}]},
+            {"foo": "bar"},
+            {"notfoo": [{"bar": 20}, {"bar": 21}, {"notbar": [7]}, {"bar": 22}]},
+            {"bar": [{"baz": [1]}, {"baz": [2]}, {"baz": [3]}, {"baz": [4]}]},
+            {"baz": [{"baz": [1, 2]}, {"baz": []}, {"baz": []}, {"baz": [3, 4]}]},
+            {"qux": [{"baz": []}, {"baz": [1, 2, 3]}, {"baz": [4]}, {"baz": []}]}
+        ],
+        "otherkey": {"foo": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]}
+      }, {
+        "instances": [
+            {"a": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]},
+            {"b": [{"bar": 5}, {"bar": 6}, {"notbar": [7]}, {"bar": 8}]},
+            {"c": "bar"},
+            {"notfoo": [{"bar": 23}, {"bar": 24}, {"notbar": [7]}, {"bar": 25}]},
+            {"qux": [{"baz": []}, {"baz": [1, 2, 3]}, {"baz": [4]}, {"baz": []}]}
+        ],
+        "otherkey": {"foo": [{"bar": 1}, {"bar": 2}, {"notbar": 3}, {"bar": 4}]}
+      }
+    ]},
+    "cases": [
+        {
+           "expression": "reservations[].instances[].foo[].bar",
+           "result": [1, 2, 4, 5, 6, 8]
+        },
+        {
+           "expression": "reservations[].instances[].foo[].baz",
+           "result": []
+        },
+        {
+           "expression": "reservations[].instances[].notfoo[].bar",
+           "result": [20, 21, 22, 23, 24, 25]
+        },
+        {
+           "expression": "reservations[].instances[].notfoo[].notbar",
+           "result": [[7], [7]]
+        },
+        {
+           "expression": "reservations[].notinstances[].foo",
+           "result": []
+        },
+        {
+           "expression": "reservations[].instances[].foo[].notbar",
+           "result": [3, [7]]
+        },
+        {
+           "expression": "reservations[].instances[].bar[].baz",
+           "result": [[1], [2], [3], [4]]
+        },
+        {
+           "expression": "reservations[].instances[].baz[].baz",
+           "result": [[1, 2], [], [], [3, 4]]
+        },
+        {
+           "expression": "reservations[].instances[].qux[].baz",
+           "result": [[], [1, 2, 3], [4], [], [], [1, 2, 3], [4], []]
+        },
+        {
+           "expression": "reservations[].instances[].qux[].baz[]",
+           "result": [1, 2, 3, 4, 1, 2, 3, 4]
+        }
+    ]
+},
+{
+    "given": {
+        "foo": [
+            [["one", "two"], ["three", "four"]],
+            [["five", "six"], ["seven", "eight"]],
+            [["nine"], ["ten"]]
+        ]
+     },
+    "cases": [
+        {
+           "expression": "foo[]",
+           "result": [["one", "two"], ["three", "four"], ["five", "six"],
+                      ["seven", "eight"], ["nine"], ["ten"]]
+        },
+        {
+           "expression": "foo[][0]",
+           "result": ["one", "three", "five", "seven", "nine", "ten"]
+        },
+        {
+           "expression": "foo[][1]",
+           "result": ["two", "four", "six", "eight"]
+        },
+        {
+           "expression": "foo[][0][0]",
+           "result": []
+        },
+         {
+            "expression": "foo[][2][2]",
+            "result": []
+         },
+         {
+            "expression": "foo[][0][0][100]",
+            "result": []
+         }
+    ]
+},
+{
+    "given": {
+      "foo": [{
+          "bar": [
+            {
+              "qux": 2,
+              "baz": 1
+            },
+            {
+              "qux": 4,
+              "baz": 3
+            }
+          ]
+        },
+        {
+          "bar": [
+            {
+              "qux": 6,
+              "baz": 5
+            },
+            {
+              "qux": 8,
+              "baz": 7
+            }
+          ]
+        }
+      ]
+    },
+    "cases": [
+        {
+           "expression": "foo",
+           "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]},
+                      {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}]
+        },
+        {
+           "expression": "foo[]",
+           "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]},
+                      {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}]
+        },
+        {
+           "expression": "foo[].bar",
+           "result": [[{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}],
+                      [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]]
+        },
+        {
+           "expression": "foo[].bar[]",
+           "result": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3},
+                      {"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]
+        },
+        {
+           "expression": "foo[].bar[].baz",
+           "result": [1, 3, 5, 7]
+        }
+    ]
+},
+{
+    "given": {
+        "string": "string",
+        "hash": {"foo": "bar", "bar": "baz"},
+        "number": 23,
+        "nullvalue": null
+     },
+     "cases": [
+         {
+            "expression": "string[]",
+            "result": null
+         },
+         {
+            "expression": "hash[]",
+            "result": null
+         },
+         {
+            "expression": "number[]",
+            "result": null
+         },
+         {
+            "expression": "nullvalue[]",
+            "result": null
+         },
+         {
+            "expression": "string[].foo",
+            "result": null
+         },
+         {
+            "expression": "hash[].foo",
+            "result": null
+         },
+         {
+            "expression": "number[].foo",
+            "result": null
+         },
+         {
+            "expression": "nullvalue[].foo",
+            "result": null
+         },
+         {
+            "expression": "nullvalue[].foo[].bar",
+            "result": null
+         }
+     ]
+}
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/literal.json b/vendor/github.com/jmespath/go-jmespath/compliance/literal.json
new file mode 100644
index 00000000..c6706b97
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/literal.json
@@ -0,0 +1,185 @@
+[
+    {
+        "given": {
+            "foo": [{"name": "a"}, {"name": "b"}],
+            "bar": {"baz": "qux"}
+        },
+        "cases": [
+            {
+                "expression": "`\"foo\"`",
+                "result": "foo"
+            },
+            {
+                "comment": "Interpret escaped unicode.",
+                "expression": "`\"\\u03a6\"`",
+                "result": "Φ"
+            },
+            {
+                "expression": "`\"✓\"`",
+                "result": "✓"
+            },
+            {
+                "expression": "`[1, 2, 3]`",
+                "result": [1, 2, 3]
+            },
+            {
+                "expression": "`{\"a\": \"b\"}`",
+                "result": {"a": "b"}
+            },
+            {
+                "expression": "`true`",
+                "result": true
+            },
+            {
+                "expression": "`false`",
+                "result": false
+            },
+            {
+                "expression": "`null`",
+                "result": null
+            },
+            {
+                "expression": "`0`",
+                "result": 0
+            },
+            {
+                "expression": "`1`",
+                "result": 1
+            },
+            {
+                "expression": "`2`",
+                "result": 2
+            },
+            {
+                "expression": "`3`",
+                "result": 3
+            },
+            {
+                "expression": "`4`",
+                "result": 4
+            },
+            {
+                "expression": "`5`",
+                "result": 5
+            },
+            {
+                "expression": "`6`",
+                "result": 6
+            },
+            {
+                "expression": "`7`",
+                "result": 7
+            },
+            {
+                "expression": "`8`",
+                "result": 8
+            },
+            {
+                "expression": "`9`",
+                "result": 9
+            },
+            {
+                "comment": "Escaping a backtick in quotes",
+                "expression": "`\"foo\\`bar\"`",
+                "result": "foo`bar"
+            },
+            {
+                "comment": "Double quote in literal",
+                "expression": "`\"foo\\\"bar\"`",
+                "result": "foo\"bar"
+            },
+            {
+                "expression": "`\"1\\`\"`",
+                "result": "1`"
+            },
+            {
+                "comment": "Multiple literal expressions with escapes",
+                "expression": "`\"\\\\\"`.{a:`\"b\"`}",
+                "result": {"a": "b"}
+            },
+            {
+                "comment": "literal . identifier",
+                "expression": "`{\"a\": \"b\"}`.a",
+                "result": "b"
+            },
+            {
+                "comment": "literal . identifier . identifier",
+                "expression": "`{\"a\": {\"b\": \"c\"}}`.a.b",
+                "result": "c"
+            },
+            {
+                "comment": "literal . identifier bracket-expr",
+                "expression": "`[0, 1, 2]`[1]",
+                "result": 1
+            }
+        ]
+    },
+    {
+      "comment": "Literals",
+      "given": {"type": "object"},
+      "cases": [
+        {
+          "comment": "Literal with leading whitespace",
+          "expression": "`  {\"foo\": true}`",
+          "result": {"foo": true}
+        },
+        {
+          "comment": "Literal with trailing whitespace",
+          "expression": "`{\"foo\": true}   `",
+          "result": {"foo": true}
+        },
+        {
+          "comment": "Literal on RHS of subexpr not allowed",
+          "expression": "foo.`\"bar\"`",
+          "error": "syntax"
+        }
+      ]
+    },
+    {
+      "comment": "Raw String Literals",
+      "given": {},
+      "cases": [
+        {
+          "expression": "'foo'",
+          "result": "foo"
+        },
+        {
+          "expression": "'  foo  '",
+          "result": "  foo  "
+        },
+        {
+          "expression": "'0'",
+          "result": "0"
+        },
+        {
+          "expression": "'newline\n'",
+          "result": "newline\n"
+        },
+        {
+          "expression": "'\n'",
+          "result": "\n"
+        },
+        {
+          "expression": "'✓'",
+	  "result": "✓"
+        },
+        {
+          "expression": "'𝄞'",
+	  "result": "𝄞"
+        },
+        {
+          "expression": "'  [foo]  '",
+          "result": "  [foo]  "
+        },
+        {
+          "expression": "'[foo]'",
+          "result": "[foo]"
+        },
+        {
+          "comment": "Do not interpret escaped unicode.",
+          "expression": "'\\u03a6'",
+          "result": "\\u03a6"
+        }
+      ]
+    }
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/multiselect.json b/vendor/github.com/jmespath/go-jmespath/compliance/multiselect.json
new file mode 100644
index 00000000..8f2a481e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/multiselect.json
@@ -0,0 +1,393 @@
+[{
+    "given": {
+      "foo": {
+        "bar": "bar",
+        "baz": "baz",
+        "qux": "qux",
+        "nested": {
+          "one": {
+            "a": "first",
+            "b": "second",
+            "c": "third"
+          },
+          "two": {
+            "a": "first",
+            "b": "second",
+            "c": "third"
+          },
+          "three": {
+            "a": "first",
+            "b": "second",
+            "c": {"inner": "third"}
+          }
+        }
+      },
+      "bar": 1,
+      "baz": 2,
+      "qux\"": 3
+    },
+     "cases": [
+         {
+            "expression": "foo.{bar: bar}",
+            "result": {"bar": "bar"}
+         },
+         {
+            "expression": "foo.{\"bar\": bar}",
+            "result": {"bar": "bar"}
+         },
+         {
+            "expression": "foo.{\"foo.bar\": bar}",
+            "result": {"foo.bar": "bar"}
+         },
+         {
+            "expression": "foo.{bar: bar, baz: baz}",
+            "result": {"bar": "bar", "baz": "baz"}
+         },
+         {
+            "expression": "foo.{\"bar\": bar, \"baz\": baz}",
+            "result": {"bar": "bar", "baz": "baz"}
+         },
+         {
+            "expression": "{\"baz\": baz, \"qux\\\"\": \"qux\\\"\"}",
+            "result": {"baz": 2, "qux\"": 3}
+         },
+         {
+            "expression": "foo.{bar:bar,baz:baz}",
+            "result": {"bar": "bar", "baz": "baz"}
+         },
+         {
+            "expression": "foo.{bar: bar,qux: qux}",
+            "result": {"bar": "bar", "qux": "qux"}
+         },
+         {
+            "expression": "foo.{bar: bar, noexist: noexist}",
+            "result": {"bar": "bar", "noexist": null}
+         },
+         {
+            "expression": "foo.{noexist: noexist, alsonoexist: alsonoexist}",
+            "result": {"noexist": null, "alsonoexist": null}
+         },
+         {
+            "expression": "foo.badkey.{nokey: nokey, alsonokey: alsonokey}",
+            "result": null
+         },
+         {
+            "expression": "foo.nested.*.{a: a,b: b}",
+            "result": [{"a": "first", "b": "second"},
+                       {"a": "first", "b": "second"},
+                       {"a": "first", "b": "second"}]
+         },
+         {
+            "expression": "foo.nested.three.{a: a, cinner: c.inner}",
+            "result": {"a": "first", "cinner": "third"}
+         },
+         {
+            "expression": "foo.nested.three.{a: a, c: c.inner.bad.key}",
+            "result": {"a": "first", "c": null}
+         },
+         {
+            "expression": "foo.{a: nested.one.a, b: nested.two.b}",
+            "result": {"a": "first", "b": "second"}
+         },
+         {
+            "expression": "{bar: bar, baz: baz}",
+            "result": {"bar": 1, "baz": 2}
+         },
+         {
+            "expression": "{bar: bar}",
+            "result": {"bar": 1}
+         },
+         {
+            "expression": "{otherkey: bar}",
+            "result": {"otherkey": 1}
+         },
+         {
+            "expression": "{no: no, exist: exist}",
+            "result": {"no": null, "exist": null}
+         },
+         {
+            "expression": "foo.[bar]",
+            "result": ["bar"]
+         },
+         {
+            "expression": "foo.[bar,baz]",
+            "result": ["bar", "baz"]
+         },
+         {
+            "expression": "foo.[bar,qux]",
+            "result": ["bar", "qux"]
+         },
+         {
+            "expression": "foo.[bar,noexist]",
+            "result": ["bar", null]
+         },
+         {
+            "expression": "foo.[noexist,alsonoexist]",
+            "result": [null, null]
+         }
+     ]
+}, {
+    "given": {
+      "foo": {"bar": 1, "baz": [2, 3, 4]}
+    },
+    "cases": [
+         {
+            "expression": "foo.{bar:bar,baz:baz}",
+            "result": {"bar": 1, "baz": [2, 3, 4]}
+         },
+         {
+            "expression": "foo.[bar,baz[0]]",
+            "result": [1, 2]
+         },
+         {
+            "expression": "foo.[bar,baz[1]]",
+            "result": [1, 3]
+         },
+         {
+            "expression": "foo.[bar,baz[2]]",
+            "result": [1, 4]
+         },
+         {
+            "expression": "foo.[bar,baz[3]]",
+            "result": [1, null]
+         },
+         {
+            "expression": "foo.[bar[0],baz[3]]",
+            "result": [null, null]
+         }
+    ]
+}, {
+    "given": {
+      "foo": {"bar": 1, "baz": 2}
+    },
+    "cases": [
+         {
+            "expression": "foo.{bar: bar, baz: baz}",
+            "result": {"bar": 1, "baz": 2}
+         },
+         {
+            "expression": "foo.[bar,baz]",
+            "result": [1, 2]
+         }
+    ]
+}, {
+    "given": {
+      "foo": {
+          "bar": {"baz": [{"common": "first", "one": 1},
+                          {"common": "second", "two": 2}]},
+          "ignoreme": 1,
+          "includeme": true
+      }
+    },
+    "cases": [
+         {
+            "expression": "foo.{bar: bar.baz[1],includeme: includeme}",
+            "result": {"bar": {"common": "second", "two": 2}, "includeme": true}
+         },
+         {
+            "expression": "foo.{\"bar.baz.two\": bar.baz[1].two, includeme: includeme}",
+            "result": {"bar.baz.two": 2, "includeme": true}
+         },
+         {
+            "expression": "foo.[includeme, bar.baz[*].common]",
+            "result": [true, ["first", "second"]]
+         },
+         {
+            "expression": "foo.[includeme, bar.baz[*].none]",
+            "result": [true, []]
+         },
+         {
+            "expression": "foo.[includeme, bar.baz[].common]",
+            "result": [true, ["first", "second"]]
+         }
+    ]
+}, {
+    "given": {
+      "reservations": [{
+          "instances": [
+              {"id": "id1",
+               "name": "first"},
+              {"id": "id2",
+               "name": "second"}
+          ]}, {
+          "instances": [
+              {"id": "id3",
+               "name": "third"},
+              {"id": "id4",
+               "name": "fourth"}
+          ]}
+      ]},
+    "cases": [
+         {
+            "expression": "reservations[*].instances[*].{id: id, name: name}",
+            "result": [[{"id": "id1", "name": "first"}, {"id": "id2", "name": "second"}],
+                       [{"id": "id3", "name": "third"}, {"id": "id4", "name": "fourth"}]]
+         },
+         {
+            "expression": "reservations[].instances[].{id: id, name: name}",
+            "result": [{"id": "id1", "name": "first"},
+                       {"id": "id2", "name": "second"},
+                       {"id": "id3", "name": "third"},
+                       {"id": "id4", "name": "fourth"}]
+         },
+         {
+            "expression": "reservations[].instances[].[id, name]",
+            "result": [["id1", "first"],
+                       ["id2", "second"],
+                       ["id3", "third"],
+                       ["id4", "fourth"]]
+         }
+    ]
+},
+{
+    "given": {
+      "foo": [{
+          "bar": [
+            {
+              "qux": 2,
+              "baz": 1
+            },
+            {
+              "qux": 4,
+              "baz": 3
+            }
+          ]
+        },
+        {
+          "bar": [
+            {
+              "qux": 6,
+              "baz": 5
+            },
+            {
+              "qux": 8,
+              "baz": 7
+            }
+          ]
+        }
+      ]
+    },
+    "cases": [
+        {
+           "expression": "foo",
+           "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]},
+                      {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}]
+        },
+        {
+           "expression": "foo[]",
+           "result": [{"bar": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}]},
+                      {"bar": [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]}]
+        },
+        {
+           "expression": "foo[].bar",
+           "result": [[{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3}],
+                      [{"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]]
+        },
+        {
+           "expression": "foo[].bar[]",
+           "result": [{"qux": 2, "baz": 1}, {"qux": 4, "baz": 3},
+                      {"qux": 6, "baz": 5}, {"qux": 8, "baz": 7}]
+        },
+        {
+           "expression": "foo[].bar[].[baz, qux]",
+           "result": [[1, 2], [3, 4], [5, 6], [7, 8]]
+        },
+        {
+           "expression": "foo[].bar[].[baz]",
+           "result": [[1], [3], [5], [7]]
+        },
+        {
+           "expression": "foo[].bar[].[baz, qux][]",
+           "result": [1, 2, 3, 4, 5, 6, 7, 8]
+        }
+    ]
+},
+{
+    "given": {
+        "foo": {
+            "baz": [
+                {
+                    "bar": "abc"
+                }, {
+                    "bar": "def"
+                }
+            ],
+            "qux": ["zero"]
+        }
+    },
+    "cases": [
+        {
+           "expression": "foo.[baz[*].bar, qux[0]]",
+           "result": [["abc", "def"], "zero"]
+        }
+    ]
+},
+{
+    "given": {
+        "foo": {
+            "baz": [
+                {
+                    "bar": "a",
+                    "bam": "b",
+                    "boo": "c"
+                }, {
+                    "bar": "d",
+                    "bam": "e",
+                    "boo": "f"
+                }
+            ],
+            "qux": ["zero"]
+        }
+    },
+    "cases": [
+        {
+           "expression": "foo.[baz[*].[bar, boo], qux[0]]",
+           "result": [[["a", "c" ], ["d", "f" ]], "zero"]
+        }
+    ]
+},
+{
+    "given": {
+        "foo": {
+            "baz": [
+                {
+                    "bar": "a",
+                    "bam": "b",
+                    "boo": "c"
+                }, {
+                    "bar": "d",
+                    "bam": "e",
+                    "boo": "f"
+                }
+            ],
+            "qux": ["zero"]
+        }
+    },
+    "cases": [
+        {
+           "expression": "foo.[baz[*].not_there || baz[*].bar, qux[0]]",
+           "result": [["a", "d"], "zero"]
+        }
+    ]
+},
+{
+    "given": {"type": "object"},
+    "cases": [
+        {
+          "comment": "Nested multiselect",
+          "expression": "[[*],*]",
+          "result": [null, ["object"]]
+        }
+    ]
+},
+{
+    "given": [],
+    "cases": [
+        {
+          "comment": "Nested multiselect",
+          "expression": "[[*]]",
+          "result": [[]]
+        }
+    ]
+}
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/ormatch.json b/vendor/github.com/jmespath/go-jmespath/compliance/ormatch.json
new file mode 100644
index 00000000..2127cf44
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/ormatch.json
@@ -0,0 +1,59 @@
+[{
+    "given":
+        {"outer": {"foo": "foo", "bar": "bar", "baz": "baz"}},
+     "cases": [
+         {
+            "expression": "outer.foo || outer.bar",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.foo||outer.bar",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.bar || outer.baz",
+            "result": "bar"
+         },
+         {
+            "expression": "outer.bar||outer.baz",
+            "result": "bar"
+         },
+         {
+            "expression": "outer.bad || outer.foo",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.bad||outer.foo",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.foo || outer.bad",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.foo||outer.bad",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.bad || outer.alsobad",
+            "result": null
+         },
+         {
+            "expression": "outer.bad||outer.alsobad",
+            "result": null
+         }
+     ]
+}, {
+    "given":
+        {"outer": {"foo": "foo", "bool": false, "empty_list": [], "empty_string": ""}},
+     "cases": [
+         {
+            "expression": "outer.empty_string || outer.foo",
+            "result": "foo"
+         },
+         {
+            "expression": "outer.nokey || outer.bool || outer.empty_list || outer.empty_string || outer.foo",
+            "result": "foo"
+         }
+     ]
+}]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/pipe.json b/vendor/github.com/jmespath/go-jmespath/compliance/pipe.json
new file mode 100644
index 00000000..b10c0a49
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/pipe.json
@@ -0,0 +1,131 @@
+[{
+  "given": {
+    "foo": {
+      "bar": {
+        "baz": "subkey"
+      },
+      "other": {
+        "baz": "subkey"
+      },
+      "other2": {
+        "baz": "subkey"
+      },
+      "other3": {
+        "notbaz": ["a", "b", "c"]
+      },
+      "other4": {
+        "notbaz": ["a", "b", "c"]
+      }
+    }
+  },
+  "cases": [
+    {
+      "expression": "foo.*.baz | [0]",
+      "result": "subkey"
+    },
+    {
+      "expression": "foo.*.baz | [1]",
+      "result": "subkey"
+    },
+    {
+      "expression": "foo.*.baz | [2]",
+      "result": "subkey"
+    },
+    {
+      "expression": "foo.bar.* | [0]",
+      "result": "subkey"
+    },
+    {
+      "expression": "foo.*.notbaz | [*]",
+      "result": [["a", "b", "c"], ["a", "b", "c"]]
+    },
+    {
+      "expression": "{\"a\": foo.bar, \"b\": foo.other} | *.baz",
+      "result": ["subkey", "subkey"]
+    }
+  ]
+}, {
+  "given": {
+    "foo": {
+      "bar": {
+        "baz": "one"
+      },
+      "other": {
+        "baz": "two"
+      },
+      "other2": {
+        "baz": "three"
+      },
+      "other3": {
+        "notbaz": ["a", "b", "c"]
+      },
+      "other4": {
+        "notbaz": ["d", "e", "f"]
+      }
+    }
+  },
+  "cases": [
+    {
+      "expression": "foo | bar",
+      "result": {"baz": "one"}
+    },
+    {
+      "expression": "foo | bar | baz",
+      "result": "one"
+    },
+    {
+      "expression": "foo|bar| baz",
+      "result": "one"
+    },
+    {
+      "expression": "not_there | [0]",
+      "result": null
+    },
+    {
+      "expression": "not_there | [0]",
+      "result": null
+    },
+    {
+      "expression": "[foo.bar, foo.other] | [0]",
+      "result": {"baz": "one"}
+    },
+    {
+      "expression": "{\"a\": foo.bar, \"b\": foo.other} | a",
+      "result": {"baz": "one"}
+    },
+    {
+      "expression": "{\"a\": foo.bar, \"b\": foo.other} | b",
+      "result": {"baz": "two"}
+    },
+    {
+      "expression": "foo.bam || foo.bar | baz",
+      "result": "one"
+    },
+    {
+      "expression": "foo | not_there || bar",
+      "result": {"baz": "one"}
+    }
+  ]
+}, {
+  "given": {
+    "foo": [{
+      "bar": [{
+        "baz": "one"
+      }, {
+        "baz": "two"
+      }]
+    }, {
+      "bar": [{
+        "baz": "three"
+      }, {
+        "baz": "four"
+      }]
+    }]
+  },
+  "cases": [
+    {
+      "expression": "foo[*].bar[*] | [0][0]",
+      "result": {"baz": "one"}
+    }
+  ]
+}]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/slice.json b/vendor/github.com/jmespath/go-jmespath/compliance/slice.json
new file mode 100644
index 00000000..35947727
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/slice.json
@@ -0,0 +1,187 @@
+[{
+  "given": {
+    "foo": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    "bar": {
+      "baz": 1
+    }
+  },
+  "cases": [
+    {
+      "expression": "bar[0:10]",
+      "result": null
+    },
+    {
+      "expression": "foo[0:10:1]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[0:10]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[0:10:]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[0::1]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[0::]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[0:]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[:10:1]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[::1]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[:10:]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[::]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[:]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[1:9]",
+      "result": [1, 2, 3, 4, 5, 6, 7, 8]
+    },
+    {
+      "expression": "foo[0:10:2]",
+      "result": [0, 2, 4, 6, 8]
+    },
+    {
+      "expression": "foo[5:]",
+      "result": [5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[5::2]",
+      "result": [5, 7, 9]
+    },
+    {
+      "expression": "foo[::2]",
+      "result": [0, 2, 4, 6, 8]
+    },
+    {
+      "expression": "foo[::-1]",
+      "result": [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+    },
+    {
+      "expression": "foo[1::2]",
+      "result": [1, 3, 5, 7, 9]
+    },
+    {
+      "expression": "foo[10:0:-1]",
+      "result": [9, 8, 7, 6, 5, 4, 3, 2, 1]
+    },
+    {
+      "expression": "foo[10:5:-1]",
+      "result": [9, 8, 7, 6]
+    },
+    {
+      "expression": "foo[8:2:-2]",
+      "result": [8, 6, 4]
+    },
+    {
+      "expression": "foo[0:20]",
+      "result": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    },
+    {
+      "expression": "foo[10:-20:-1]",
+      "result": [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
+    },
+    {
+      "expression": "foo[10:-20]",
+      "result": []
+    },
+    {
+      "expression": "foo[-4:-1]",
+      "result": [6, 7, 8]
+    },
+    {
+      "expression": "foo[:-5:-1]",
+      "result": [9, 8, 7, 6]
+    },
+    {
+      "expression": "foo[8:2:0]",
+      "error": "invalid-value"
+    },
+    {
+      "expression": "foo[8:2:0:1]",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo[8:2&]",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo[2:a:3]",
+      "error": "syntax"
+    }
+  ]
+}, {
+  "given": {
+    "foo": [{"a": 1}, {"a": 2}, {"a": 3}],
+    "bar": [{"a": {"b": 1}}, {"a": {"b": 2}},
+	    {"a": {"b": 3}}],
+    "baz": 50
+  },
+  "cases": [
+    {
+      "expression": "foo[:2].a",
+      "result": [1, 2]
+    },
+    {
+      "expression": "foo[:2].b",
+      "result": []
+    },
+    {
+      "expression": "foo[:2].a.b",
+      "result": []
+    },
+    {
+      "expression": "bar[::-1].a.b",
+      "result": [3, 2, 1]
+    },
+    {
+      "expression": "bar[:2].a.b",
+      "result": [1, 2]
+    },
+    {
+      "expression": "baz[:2].a",
+      "result": null
+    }
+  ]
+}, {
+  "given": [{"a": 1}, {"a": 2}, {"a": 3}],
+  "cases": [
+    {
+      "expression": "[:]",
+      "result": [{"a": 1}, {"a": 2}, {"a": 3}]
+    },
+    {
+      "expression": "[:2].a",
+      "result": [1, 2]
+    },
+    {
+      "expression": "[::-1].a",
+      "result": [3, 2, 1]
+    },
+    {
+      "expression": "[:2].b",
+      "result": []
+    }
+  ]
+}]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/syntax.json b/vendor/github.com/jmespath/go-jmespath/compliance/syntax.json
new file mode 100644
index 00000000..003c2945
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/syntax.json
@@ -0,0 +1,616 @@
+[{
+  "comment": "Dot syntax",
+  "given": {"type": "object"},
+  "cases": [
+    {
+      "expression": "foo.bar",
+      "result": null
+    },
+    {
+      "expression": "foo.1",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo.-11",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo",
+      "result": null
+    },
+    {
+      "expression": "foo.",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo.",
+      "error": "syntax"
+    },
+    {
+      "expression": ".foo",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo..bar",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo.bar.",
+      "error": "syntax"
+    },
+    {
+      "expression": "foo[.]",
+      "error": "syntax"
+    }
+  ]
+},
+  {
+    "comment": "Simple token errors",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": ".",
+        "error": "syntax"
+      },
+      {
+        "expression": ":",
+        "error": "syntax"
+      },
+      {
+        "expression": ",",
+        "error": "syntax"
+      },
+      {
+        "expression": "]",
+        "error": "syntax"
+      },
+      {
+        "expression": "[",
+        "error": "syntax"
+      },
+      {
+        "expression": "}",
+        "error": "syntax"
+      },
+      {
+        "expression": "{",
+        "error": "syntax"
+      },
+      {
+        "expression": ")",
+        "error": "syntax"
+      },
+      {
+        "expression": "(",
+        "error": "syntax"
+      },
+      {
+        "expression": "((&",
+        "error": "syntax"
+      },
+      {
+        "expression": "a[",
+        "error": "syntax"
+      },
+      {
+        "expression": "a]",
+        "error": "syntax"
+      },
+      {
+        "expression": "a][",
+        "error": "syntax"
+      },
+      {
+        "expression": "!",
+        "error": "syntax"
+      }
+    ]
+  },
+  {
+    "comment": "Boolean syntax errors",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "![!(!",
+        "error": "syntax"
+      }
+    ]
+  },
+  {
+    "comment": "Wildcard syntax",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "*",
+        "result": ["object"]
+      },
+      {
+        "expression": "*.*",
+        "result": []
+      },
+      {
+        "expression": "*.foo",
+        "result": []
+      },
+      {
+        "expression": "*[0]",
+        "result": []
+      },
+      {
+        "expression": ".*",
+        "error": "syntax"
+      },
+      {
+        "expression": "*foo",
+        "error": "syntax"
+      },
+      {
+        "expression": "*0",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[*]bar",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[*]*",
+        "error": "syntax"
+      }
+    ]
+  },
+  {
+    "comment": "Flatten syntax",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "[]",
+        "result": null
+      }
+    ]
+  },
+  {
+    "comment": "Simple bracket syntax",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "[0]",
+        "result": null
+      },
+      {
+        "expression": "[*]",
+        "result": null
+      },
+      {
+        "expression": "*.[0]",
+        "error": "syntax"
+      },
+      {
+        "expression": "*.[\"0\"]",
+        "result": [[null]]
+      },
+      {
+        "expression": "[*].bar",
+        "result": null
+      },
+      {
+        "expression": "[*][0]",
+        "result": null
+      },
+      {
+        "expression": "foo[#]",
+        "error": "syntax"
+      }
+    ]
+  },
+  {
+    "comment": "Multi-select list syntax",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "foo[0]",
+        "result": null
+      },
+      {
+        "comment": "Valid multi-select of a list",
+        "expression": "foo[0, 1]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo.[0]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo.[*]",
+        "result": null
+      },
+      {
+        "comment": "Multi-select of a list with trailing comma",
+        "expression": "foo[0, ]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a list with trailing comma and no close",
+        "expression": "foo[0,",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a list with trailing comma and no close",
+        "expression": "foo.[a",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a list with extra comma",
+        "expression": "foo[0,, 1]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a list using an identifier index",
+        "expression": "foo[abc]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a list using identifier indices",
+        "expression": "foo[abc, def]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a list using an identifier index",
+        "expression": "foo[abc, 1]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a list using an identifier index with trailing comma",
+        "expression": "foo[abc, ]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Valid multi-select of a hash using an identifier index",
+        "expression": "foo.[abc]",
+        "result": null
+      },
+      {
+        "comment": "Valid multi-select of a hash",
+        "expression": "foo.[abc, def]",
+        "result": null
+      },
+      {
+        "comment": "Multi-select of a hash using a numeric index",
+        "expression": "foo.[abc, 1]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a hash with a trailing comma",
+        "expression": "foo.[abc, ]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a hash with extra commas",
+        "expression": "foo.[abc,, def]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Multi-select of a hash using number indices",
+        "expression": "foo.[0, 1]",
+        "error": "syntax"
+      }
+    ]
+  },
+  {
+    "comment": "Multi-select hash syntax",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "comment": "No key or value",
+        "expression": "a{}",
+        "error": "syntax"
+      },
+      {
+        "comment": "No closing token",
+        "expression": "a{",
+        "error": "syntax"
+      },
+      {
+        "comment": "Not a key value pair",
+        "expression": "a{foo}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing value and closing character",
+        "expression": "a{foo:",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing closing character",
+        "expression": "a{foo: 0",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing value",
+        "expression": "a{foo:}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Trailing comma and no closing character",
+        "expression": "a{foo: 0, ",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing value with trailing comma",
+        "expression": "a{foo: ,}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Accessing Array using an identifier",
+        "expression": "a{foo: bar}",
+        "error": "syntax"
+      },
+      {
+        "expression": "a{foo: 0}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing key-value pair",
+        "expression": "a.{}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Not a key-value pair",
+        "expression": "a.{foo}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing value",
+        "expression": "a.{foo:}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing value with trailing comma",
+        "expression": "a.{foo: ,}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Valid multi-select hash extraction",
+        "expression": "a.{foo: bar}",
+        "result": null
+      },
+      {
+        "comment": "Valid multi-select hash extraction",
+        "expression": "a.{foo: bar, baz: bam}",
+        "result": null
+      },
+      {
+        "comment": "Trailing comma",
+        "expression": "a.{foo: bar, }",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing key in second key-value pair",
+        "expression": "a.{foo: bar, baz}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Missing value in second key-value pair",
+        "expression": "a.{foo: bar, baz:}",
+        "error": "syntax"
+      },
+      {
+        "comment": "Trailing comma",
+        "expression": "a.{foo: bar, baz: bam, }",
+        "error": "syntax"
+      },
+      {
+        "comment": "Nested multi select",
+        "expression": "{\"\\\\\":{\" \":*}}",
+        "result": {"\\": {" ": ["object"]}}
+      }
+    ]
+  },
+  {
+    "comment": "Or expressions",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "foo || bar",
+        "result": null
+      },
+      {
+        "expression": "foo ||",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo.|| bar",
+        "error": "syntax"
+      },
+      {
+        "expression": " || foo",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo || || foo",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo.[a || b]",
+        "result": null
+      },
+      {
+        "expression": "foo.[a ||]",
+        "error": "syntax"
+      },
+      {
+        "expression": "\"foo",
+        "error": "syntax"
+      }
+    ]
+  },
+  {
+    "comment": "Filter expressions",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "foo[?bar==`\"baz\"`]",
+        "result": null
+      },
+      {
+        "expression": "foo[? bar == `\"baz\"` ]",
+        "result": null
+      },
+      {
+        "expression": "foo[ ?bar==`\"baz\"`]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[?bar==]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[?==]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[?==bar]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[?bar==baz?]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[?a.b.c==d.e.f]",
+        "result": null
+      },
+      {
+        "expression": "foo[?bar==`[0, 1, 2]`]",
+        "result": null
+      },
+      {
+        "expression": "foo[?bar==`[\"a\", \"b\", \"c\"]`]",
+        "result": null
+      },
+      {
+        "comment": "Literal char not escaped",
+        "expression": "foo[?bar==`[\"foo`bar\"]`]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Literal char escaped",
+        "expression": "foo[?bar==`[\"foo\\`bar\"]`]",
+        "result": null
+      },
+      {
+        "comment": "Unknown comparator",
+        "expression": "foo[?bar<>baz]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Unknown comparator",
+        "expression": "foo[?bar^baz]",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[bar==baz]",
+        "error": "syntax"
+      },
+      {
+        "comment": "Quoted identifier in filter expression no spaces",
+        "expression": "[?\"\\\\\">`\"foo\"`]",
+        "result": null
+      },
+      {
+        "comment": "Quoted identifier in filter expression with spaces",
+        "expression": "[?\"\\\\\" > `\"foo\"`]",
+        "result": null
+      }
+    ]
+  },
+  {
+    "comment": "Filter expression errors",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "bar.`\"anything\"`",
+        "error": "syntax"
+      },
+      {
+        "expression": "bar.baz.noexists.`\"literal\"`",
+        "error": "syntax"
+      },
+      {
+        "comment": "Literal wildcard projection",
+        "expression": "foo[*].`\"literal\"`",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[*].name.`\"literal\"`",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[].name.`\"literal\"`",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[].name.`\"literal\"`.`\"subliteral\"`",
+        "error": "syntax"
+      },
+      {
+        "comment": "Projecting a literal onto an empty list",
+        "expression": "foo[*].name.noexist.`\"literal\"`",
+        "error": "syntax"
+      },
+      {
+        "expression": "foo[].name.noexist.`\"literal\"`",
+        "error": "syntax"
+      },
+      {
+        "expression": "twolen[*].`\"foo\"`",
+        "error": "syntax"
+      },
+      {
+        "comment": "Two level projection of a literal",
+        "expression": "twolen[*].threelen[*].`\"bar\"`",
+        "error": "syntax"
+      },
+      {
+        "comment": "Two level flattened projection of a literal",
+        "expression": "twolen[].threelen[].`\"bar\"`",
+        "error": "syntax"
+      }
+    ]
+  },
+  {
+    "comment": "Identifiers",
+    "given": {"type": "object"},
+    "cases": [
+      {
+        "expression": "foo",
+        "result": null
+      },
+      {
+        "expression": "\"foo\"",
+        "result": null
+      },
+      {
+        "expression": "\"\\\\\"",
+        "result": null
+      }
+    ]
+  },
+  {
+    "comment": "Combined syntax",
+    "given": [],
+    "cases": [
+        {
+          "expression": "*||*|*|*",
+          "result": null
+        },
+        {
+          "expression": "*[]||[*]",
+          "result": []
+        },
+        {
+          "expression": "[*.*]",
+          "result": [null]
+        }
+    ]
+  }
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/unicode.json b/vendor/github.com/jmespath/go-jmespath/compliance/unicode.json
new file mode 100644
index 00000000..6b07b0b6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/unicode.json
@@ -0,0 +1,38 @@
+[
+    {
+        "given": {"foo": [{"✓": "✓"}, {"✓": "✗"}]},
+        "cases": [
+            {
+                "expression": "foo[].\"✓\"",
+                "result": ["✓", "✗"]
+            }
+        ]
+    },
+    {
+        "given": {"☯": true},
+        "cases": [
+            {
+                "expression": "\"☯\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪": true},
+        "cases": [
+            {
+                "expression": "\"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪\"",
+                "result": true
+            }
+        ]
+    },
+    {
+        "given": {"☃": true},
+        "cases": [
+            {
+                "expression": "\"☃\"",
+                "result": true
+            }
+        ]
+    }
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance/wildcard.json b/vendor/github.com/jmespath/go-jmespath/compliance/wildcard.json
new file mode 100644
index 00000000..3bcec302
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance/wildcard.json
@@ -0,0 +1,460 @@
+[{
+    "given": {
+        "foo": {
+            "bar": {
+                "baz": "val"
+            },
+            "other": {
+                "baz": "val"
+            },
+            "other2": {
+                "baz": "val"
+            },
+            "other3": {
+                "notbaz": ["a", "b", "c"]
+            },
+            "other4": {
+                "notbaz": ["a", "b", "c"]
+            },
+            "other5": {
+                "other": {
+                    "a": 1,
+                    "b": 1,
+                    "c": 1
+                }
+            }
+        }
+    },
+    "cases": [
+         {
+            "expression": "foo.*.baz",
+            "result": ["val", "val", "val"]
+         },
+         {
+            "expression": "foo.bar.*",
+            "result": ["val"]
+         },
+         {
+            "expression": "foo.*.notbaz",
+            "result": [["a", "b", "c"], ["a", "b", "c"]]
+         },
+         {
+            "expression": "foo.*.notbaz[0]",
+            "result": ["a", "a"]
+         },
+         {
+            "expression": "foo.*.notbaz[-1]",
+            "result": ["c", "c"]
+         }
+    ]
+}, {
+    "given": {
+        "foo": {
+            "first-1": {
+                "second-1": "val"
+            },
+            "first-2": {
+                "second-1": "val"
+            },
+            "first-3": {
+                "second-1": "val"
+            }
+        }
+    },
+    "cases": [
+         {
+            "expression": "foo.*",
+            "result": [{"second-1": "val"}, {"second-1": "val"},
+                       {"second-1": "val"}]
+         },
+         {
+            "expression": "foo.*.*",
+            "result": [["val"], ["val"], ["val"]]
+         },
+         {
+            "expression": "foo.*.*.*",
+            "result": [[], [], []]
+         },
+         {
+            "expression": "foo.*.*.*.*",
+            "result": [[], [], []]
+         }
+    ]
+}, {
+    "given": {
+        "foo": {
+            "bar": "one"
+        },
+        "other": {
+            "bar": "one"
+        },
+        "nomatch": {
+            "notbar": "three"
+        }
+    },
+    "cases": [
+         {
+            "expression": "*.bar",
+            "result": ["one", "one"]
+         }
+    ]
+}, {
+    "given": {
+        "top1": {
+            "sub1": {"foo": "one"}
+        },
+        "top2": {
+            "sub1": {"foo": "one"}
+        }
+    },
+    "cases": [
+         {
+            "expression": "*",
+            "result": [{"sub1": {"foo": "one"}},
+                       {"sub1": {"foo": "one"}}]
+         },
+         {
+            "expression": "*.sub1",
+            "result": [{"foo": "one"},
+                       {"foo": "one"}]
+         },
+         {
+            "expression": "*.*",
+            "result": [[{"foo": "one"}],
+                       [{"foo": "one"}]]
+         },
+         {
+            "expression": "*.*.foo[]",
+            "result": ["one", "one"]
+         },
+         {
+            "expression": "*.sub1.foo",
+            "result": ["one", "one"]
+         }
+    ]
+},
+{
+    "given":
+        {"foo": [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}]},
+     "cases": [
+         {
+            "expression": "foo[*].bar",
+            "result": ["one", "two", "three"]
+         },
+         {
+            "expression": "foo[*].notbar",
+            "result": ["four"]
+         }
+     ]
+},
+{
+    "given":
+        [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}],
+     "cases": [
+         {
+            "expression": "[*]",
+            "result": [{"bar": "one"}, {"bar": "two"}, {"bar": "three"}, {"notbar": "four"}]
+         },
+         {
+            "expression": "[*].bar",
+            "result": ["one", "two", "three"]
+         },
+         {
+            "expression": "[*].notbar",
+            "result": ["four"]
+         }
+     ]
+},
+{
+    "given": {
+        "foo": {
+            "bar": [
+                {"baz": ["one", "two", "three"]},
+                {"baz": ["four", "five", "six"]},
+                {"baz": ["seven", "eight", "nine"]}
+            ]
+        }
+    },
+     "cases": [
+         {
+            "expression": "foo.bar[*].baz",
+            "result": [["one", "two", "three"], ["four", "five", "six"], ["seven", "eight", "nine"]]
+         },
+         {
+            "expression": "foo.bar[*].baz[0]",
+            "result": ["one", "four", "seven"]
+         },
+         {
+            "expression": "foo.bar[*].baz[1]",
+            "result": ["two", "five", "eight"]
+         },
+         {
+            "expression": "foo.bar[*].baz[2]",
+            "result": ["three", "six", "nine"]
+         },
+         {
+            "expression": "foo.bar[*].baz[3]",
+            "result": []
+         }
+     ]
+},
+{
+    "given": {
+        "foo": {
+            "bar": [["one", "two"], ["three", "four"]]
+        }
+    },
+     "cases": [
+         {
+            "expression": "foo.bar[*]",
+            "result": [["one", "two"], ["three", "four"]]
+         },
+         {
+            "expression": "foo.bar[0]",
+            "result": ["one", "two"]
+         },
+         {
+            "expression": "foo.bar[0][0]",
+            "result": "one"
+         },
+         {
+            "expression": "foo.bar[0][0][0]",
+            "result": null
+         },
+         {
+            "expression": "foo.bar[0][0][0][0]",
+            "result": null
+         },
+         {
+            "expression": "foo[0][0]",
+            "result": null
+         }
+     ]
+},
+{
+    "given": {
+        "foo": [
+            {"bar": [{"kind": "basic"}, {"kind": "intermediate"}]},
+            {"bar": [{"kind": "advanced"}, {"kind": "expert"}]},
+            {"bar": "string"}
+        ]
+
+     },
+     "cases": [
+         {
+            "expression": "foo[*].bar[*].kind",
+            "result": [["basic", "intermediate"], ["advanced", "expert"]]
+         },
+         {
+            "expression": "foo[*].bar[0].kind",
+            "result": ["basic", "advanced"]
+         }
+     ]
+},
+{
+    "given": {
+        "foo": [
+            {"bar": {"kind": "basic"}},
+            {"bar": {"kind": "intermediate"}},
+            {"bar": {"kind": "advanced"}},
+            {"bar": {"kind": "expert"}},
+            {"bar": "string"}
+        ]
+     },
+     "cases": [
+         {
+            "expression": "foo[*].bar.kind",
+            "result": ["basic", "intermediate", "advanced", "expert"]
+         }
+     ]
+},
+{
+    "given": {
+        "foo": [{"bar": ["one", "two"]}, {"bar": ["three", "four"]}, {"bar": ["five"]}]
+     },
+     "cases": [
+         {
+            "expression": "foo[*].bar[0]",
+            "result": ["one", "three", "five"]
+         },
+         {
+            "expression": "foo[*].bar[1]",
+            "result": ["two", "four"]
+         },
+         {
+            "expression": "foo[*].bar[2]",
+            "result": []
+         }
+     ]
+},
+{
+    "given": {
+        "foo": [{"bar": []}, {"bar": []}, {"bar": []}]
+     },
+     "cases": [
+         {
+            "expression": "foo[*].bar[0]",
+            "result": []
+         }
+     ]
+},
+{
+    "given": {
+        "foo": [["one", "two"], ["three", "four"], ["five"]]
+     },
+     "cases": [
+         {
+            "expression": "foo[*][0]",
+            "result": ["one", "three", "five"]
+         },
+         {
+            "expression": "foo[*][1]",
+            "result": ["two", "four"]
+         }
+     ]
+},
+{
+    "given": {
+        "foo": [
+            [
+                ["one", "two"], ["three", "four"]
+            ], [
+                ["five", "six"], ["seven", "eight"]
+            ], [
+                ["nine"], ["ten"]
+            ]
+        ]
+     },
+     "cases": [
+         {
+            "expression": "foo[*][0]",
+            "result": [["one", "two"], ["five", "six"], ["nine"]]
+         },
+         {
+            "expression": "foo[*][1]",
+            "result": [["three", "four"], ["seven", "eight"], ["ten"]]
+         },
+         {
+            "expression": "foo[*][0][0]",
+            "result": ["one", "five", "nine"]
+         },
+         {
+            "expression": "foo[*][1][0]",
+            "result": ["three", "seven", "ten"]
+         },
+         {
+            "expression": "foo[*][0][1]",
+            "result": ["two", "six"]
+         },
+         {
+            "expression": "foo[*][1][1]",
+            "result": ["four", "eight"]
+         },
+         {
+            "expression": "foo[*][2]",
+            "result": []
+         },
+         {
+            "expression": "foo[*][2][2]",
+            "result": []
+         },
+         {
+            "expression": "bar[*]",
+            "result": null
+         },
+         {
+            "expression": "bar[*].baz[*]",
+            "result": null
+         }
+     ]
+},
+{
+    "given": {
+        "string": "string",
+        "hash": {"foo": "bar", "bar": "baz"},
+        "number": 23,
+        "nullvalue": null
+     },
+     "cases": [
+         {
+            "expression": "string[*]",
+            "result": null
+         },
+         {
+            "expression": "hash[*]",
+            "result": null
+         },
+         {
+            "expression": "number[*]",
+            "result": null
+         },
+         {
+            "expression": "nullvalue[*]",
+            "result": null
+         },
+         {
+            "expression": "string[*].foo",
+            "result": null
+         },
+         {
+            "expression": "hash[*].foo",
+            "result": null
+         },
+         {
+            "expression": "number[*].foo",
+            "result": null
+         },
+         {
+            "expression": "nullvalue[*].foo",
+            "result": null
+         },
+         {
+            "expression": "nullvalue[*].foo[*].bar",
+            "result": null
+         }
+     ]
+},
+{
+    "given": {
+        "string": "string",
+        "hash": {"foo": "val", "bar": "val"},
+        "number": 23,
+        "array": [1, 2, 3],
+        "nullvalue": null
+     },
+     "cases": [
+         {
+            "expression": "string.*",
+            "result": null
+         },
+         {
+            "expression": "hash.*",
+            "result": ["val", "val"]
+         },
+         {
+            "expression": "number.*",
+            "result": null
+         },
+         {
+            "expression": "array.*",
+            "result": null
+         },
+         {
+            "expression": "nullvalue.*",
+            "result": null
+         }
+     ]
+},
+{
+    "given": {
+        "a": [0, 1, 2],
+        "b": [0, 1, 2]
+     },
+     "cases": [
+         {
+            "expression": "*[0]",
+            "result": [0, 0]
+         }
+     ]
+}
+]
diff --git a/vendor/github.com/jmespath/go-jmespath/compliance_test.go b/vendor/github.com/jmespath/go-jmespath/compliance_test.go
new file mode 100644
index 00000000..4ee9c959
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/compliance_test.go
@@ -0,0 +1,123 @@
+package jmespath
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type TestSuite struct {
+	Given     interface{}
+	TestCases []TestCase `json:"cases"`
+	Comment   string
+}
+type TestCase struct {
+	Comment    string
+	Expression string
+	Result     interface{}
+	Error      string
+}
+
+var whiteListed = []string{
+	"compliance/basic.json",
+	"compliance/current.json",
+	"compliance/escape.json",
+	"compliance/filters.json",
+	"compliance/functions.json",
+	"compliance/identifiers.json",
+	"compliance/indices.json",
+	"compliance/literal.json",
+	"compliance/multiselect.json",
+	"compliance/ormatch.json",
+	"compliance/pipe.json",
+	"compliance/slice.json",
+	"compliance/syntax.json",
+	"compliance/unicode.json",
+	"compliance/wildcard.json",
+	"compliance/boolean.json",
+}
+
+func allowed(path string) bool {
+	for _, el := range whiteListed {
+		if el == path {
+			return true
+		}
+	}
+	return false
+}
+
+func TestCompliance(t *testing.T) {
+	assert := assert.New(t)
+
+	var complianceFiles []string
+	err := filepath.Walk("compliance", func(path string, _ os.FileInfo, _ error) error {
+		//if strings.HasSuffix(path, ".json") {
+		if allowed(path) {
+			complianceFiles = append(complianceFiles, path)
+		}
+		return nil
+	})
+	if assert.Nil(err) {
+		for _, filename := range complianceFiles {
+			runComplianceTest(assert, filename)
+		}
+	}
+}
+
+func runComplianceTest(assert *assert.Assertions, filename string) {
+	var testSuites []TestSuite
+	data, err := ioutil.ReadFile(filename)
+	if assert.Nil(err) {
+		err := json.Unmarshal(data, &testSuites)
+		if assert.Nil(err) {
+			for _, testsuite := range testSuites {
+				runTestSuite(assert, testsuite, filename)
+			}
+		}
+	}
+}
+
+func runTestSuite(assert *assert.Assertions, testsuite TestSuite, filename string) {
+	for _, testcase := range testsuite.TestCases {
+		if testcase.Error != "" {
+			// This is a test case that verifies we error out properly.
+			runSyntaxTestCase(assert, testsuite.Given, testcase, filename)
+		} else {
+			runTestCase(assert, testsuite.Given, testcase, filename)
+		}
+	}
+}
+
+func runSyntaxTestCase(assert *assert.Assertions, given interface{}, testcase TestCase, filename string) {
+	// Anything with an .Error means that we expect that JMESPath should return
+	// an error when we try to evaluate the expression.
+	_, err := Search(testcase.Expression, given)
+	assert.NotNil(err, fmt.Sprintf("Expression: %s", testcase.Expression))
+}
+
+func runTestCase(assert *assert.Assertions, given interface{}, testcase TestCase, filename string) {
+	lexer := NewLexer()
+	var err error
+	_, err = lexer.tokenize(testcase.Expression)
+	if err != nil {
+		errMsg := fmt.Sprintf("(%s) Could not lex expression: %s -- %s", filename, testcase.Expression, err.Error())
+		assert.Fail(errMsg)
+		return
+	}
+	parser := NewParser()
+	_, err = parser.Parse(testcase.Expression)
+	if err != nil {
+		errMsg := fmt.Sprintf("(%s) Could not parse expression: %s -- %s", filename, testcase.Expression, err.Error())
+		assert.Fail(errMsg)
+		return
+	}
+	actual, err := Search(testcase.Expression, given)
+	if assert.Nil(err, fmt.Sprintf("Expression: %s", testcase.Expression)) {
+		assert.Equal(testcase.Result, actual, fmt.Sprintf("Expression: %s", testcase.Expression))
+	}
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/functions.go b/vendor/github.com/jmespath/go-jmespath/functions.go
new file mode 100644
index 00000000..9b7cd89b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/functions.go
@@ -0,0 +1,842 @@
+package jmespath
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+type jpFunction func(arguments []interface{}) (interface{}, error)
+
+type jpType string
+
+const (
+	jpUnknown     jpType = "unknown"
+	jpNumber      jpType = "number"
+	jpString      jpType = "string"
+	jpArray       jpType = "array"
+	jpObject      jpType = "object"
+	jpArrayNumber jpType = "array[number]"
+	jpArrayString jpType = "array[string]"
+	jpExpref      jpType = "expref"
+	jpAny         jpType = "any"
+)
+
+type functionEntry struct {
+	name      string
+	arguments []argSpec
+	handler   jpFunction
+	hasExpRef bool
+}
+
+type argSpec struct {
+	types    []jpType
+	variadic bool
+}
+
+type byExprString struct {
+	intr     *treeInterpreter
+	node     ASTNode
+	items    []interface{}
+	hasError bool
+}
+
+func (a *byExprString) Len() int {
+	return len(a.items)
+}
+func (a *byExprString) Swap(i, j int) {
+	a.items[i], a.items[j] = a.items[j], a.items[i]
+}
+func (a *byExprString) Less(i, j int) bool {
+	first, err := a.intr.Execute(a.node, a.items[i])
+	if err != nil {
+		a.hasError = true
+		// Return a dummy value.
+		return true
+	}
+	ith, ok := first.(string)
+	if !ok {
+		a.hasError = true
+		return true
+	}
+	second, err := a.intr.Execute(a.node, a.items[j])
+	if err != nil {
+		a.hasError = true
+		// Return a dummy value.
+		return true
+	}
+	jth, ok := second.(string)
+	if !ok {
+		a.hasError = true
+		return true
+	}
+	return ith < jth
+}
+
+type byExprFloat struct {
+	intr     *treeInterpreter
+	node     ASTNode
+	items    []interface{}
+	hasError bool
+}
+
+func (a *byExprFloat) Len() int {
+	return len(a.items)
+}
+func (a *byExprFloat) Swap(i, j int) {
+	a.items[i], a.items[j] = a.items[j], a.items[i]
+}
+func (a *byExprFloat) Less(i, j int) bool {
+	first, err := a.intr.Execute(a.node, a.items[i])
+	if err != nil {
+		a.hasError = true
+		// Return a dummy value.
+		return true
+	}
+	ith, ok := first.(float64)
+	if !ok {
+		a.hasError = true
+		return true
+	}
+	second, err := a.intr.Execute(a.node, a.items[j])
+	if err != nil {
+		a.hasError = true
+		// Return a dummy value.
+		return true
+	}
+	jth, ok := second.(float64)
+	if !ok {
+		a.hasError = true
+		return true
+	}
+	return ith < jth
+}
+
+type functionCaller struct {
+	functionTable map[string]functionEntry
+}
+
+func newFunctionCaller() *functionCaller {
+	caller := &functionCaller{}
+	caller.functionTable = map[string]functionEntry{
+		"length": {
+			name: "length",
+			arguments: []argSpec{
+				{types: []jpType{jpString, jpArray, jpObject}},
+			},
+			handler: jpfLength,
+		},
+		"starts_with": {
+			name: "starts_with",
+			arguments: []argSpec{
+				{types: []jpType{jpString}},
+				{types: []jpType{jpString}},
+			},
+			handler: jpfStartsWith,
+		},
+		"abs": {
+			name: "abs",
+			arguments: []argSpec{
+				{types: []jpType{jpNumber}},
+			},
+			handler: jpfAbs,
+		},
+		"avg": {
+			name: "avg",
+			arguments: []argSpec{
+				{types: []jpType{jpArrayNumber}},
+			},
+			handler: jpfAvg,
+		},
+		"ceil": {
+			name: "ceil",
+			arguments: []argSpec{
+				{types: []jpType{jpNumber}},
+			},
+			handler: jpfCeil,
+		},
+		"contains": {
+			name: "contains",
+			arguments: []argSpec{
+				{types: []jpType{jpArray, jpString}},
+				{types: []jpType{jpAny}},
+			},
+			handler: jpfContains,
+		},
+		"ends_with": {
+			name: "ends_with",
+			arguments: []argSpec{
+				{types: []jpType{jpString}},
+				{types: []jpType{jpString}},
+			},
+			handler: jpfEndsWith,
+		},
+		"floor": {
+			name: "floor",
+			arguments: []argSpec{
+				{types: []jpType{jpNumber}},
+			},
+			handler: jpfFloor,
+		},
+		"map": {
+			name: "amp",
+			arguments: []argSpec{
+				{types: []jpType{jpExpref}},
+				{types: []jpType{jpArray}},
+			},
+			handler:   jpfMap,
+			hasExpRef: true,
+		},
+		"max": {
+			name: "max",
+			arguments: []argSpec{
+				{types: []jpType{jpArrayNumber, jpArrayString}},
+			},
+			handler: jpfMax,
+		},
+		"merge": {
+			name: "merge",
+			arguments: []argSpec{
+				{types: []jpType{jpObject}, variadic: true},
+			},
+			handler: jpfMerge,
+		},
+		"max_by": {
+			name: "max_by",
+			arguments: []argSpec{
+				{types: []jpType{jpArray}},
+				{types: []jpType{jpExpref}},
+			},
+			handler:   jpfMaxBy,
+			hasExpRef: true,
+		},
+		"sum": {
+			name: "sum",
+			arguments: []argSpec{
+				{types: []jpType{jpArrayNumber}},
+			},
+			handler: jpfSum,
+		},
+		"min": {
+			name: "min",
+			arguments: []argSpec{
+				{types: []jpType{jpArrayNumber, jpArrayString}},
+			},
+			handler: jpfMin,
+		},
+		"min_by": {
+			name: "min_by",
+			arguments: []argSpec{
+				{types: []jpType{jpArray}},
+				{types: []jpType{jpExpref}},
+			},
+			handler:   jpfMinBy,
+			hasExpRef: true,
+		},
+		"type": {
+			name: "type",
+			arguments: []argSpec{
+				{types: []jpType{jpAny}},
+			},
+			handler: jpfType,
+		},
+		"keys": {
+			name: "keys",
+			arguments: []argSpec{
+				{types: []jpType{jpObject}},
+			},
+			handler: jpfKeys,
+		},
+		"values": {
+			name: "values",
+			arguments: []argSpec{
+				{types: []jpType{jpObject}},
+			},
+			handler: jpfValues,
+		},
+		"sort": {
+			name: "sort",
+			arguments: []argSpec{
+				{types: []jpType{jpArrayString, jpArrayNumber}},
+			},
+			handler: jpfSort,
+		},
+		"sort_by": {
+			name: "sort_by",
+			arguments: []argSpec{
+				{types: []jpType{jpArray}},
+				{types: []jpType{jpExpref}},
+			},
+			handler:   jpfSortBy,
+			hasExpRef: true,
+		},
+		"join": {
+			name: "join",
+			arguments: []argSpec{
+				{types: []jpType{jpString}},
+				{types: []jpType{jpArrayString}},
+			},
+			handler: jpfJoin,
+		},
+		"reverse": {
+			name: "reverse",
+			arguments: []argSpec{
+				{types: []jpType{jpArray, jpString}},
+			},
+			handler: jpfReverse,
+		},
+		"to_array": {
+			name: "to_array",
+			arguments: []argSpec{
+				{types: []jpType{jpAny}},
+			},
+			handler: jpfToArray,
+		},
+		"to_string": {
+			name: "to_string",
+			arguments: []argSpec{
+				{types: []jpType{jpAny}},
+			},
+			handler: jpfToString,
+		},
+		"to_number": {
+			name: "to_number",
+			arguments: []argSpec{
+				{types: []jpType{jpAny}},
+			},
+			handler: jpfToNumber,
+		},
+		"not_null": {
+			name: "not_null",
+			arguments: []argSpec{
+				{types: []jpType{jpAny}, variadic: true},
+			},
+			handler: jpfNotNull,
+		},
+	}
+	return caller
+}
+
+func (e *functionEntry) resolveArgs(arguments []interface{}) ([]interface{}, error) {
+	if len(e.arguments) == 0 {
+		return arguments, nil
+	}
+	if !e.arguments[len(e.arguments)-1].variadic {
+		if len(e.arguments) != len(arguments) {
+			return nil, errors.New("incorrect number of args")
+		}
+		for i, spec := range e.arguments {
+			userArg := arguments[i]
+			err := spec.typeCheck(userArg)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return arguments, nil
+	}
+	if len(arguments) < len(e.arguments) {
+		return nil, errors.New("Invalid arity.")
+	}
+	return arguments, nil
+}
+
+func (a *argSpec) typeCheck(arg interface{}) error {
+	for _, t := range a.types {
+		switch t {
+		case jpNumber:
+			if _, ok := arg.(float64); ok {
+				return nil
+			}
+		case jpString:
+			if _, ok := arg.(string); ok {
+				return nil
+			}
+		case jpArray:
+			if isSliceType(arg) {
+				return nil
+			}
+		case jpObject:
+			if _, ok := arg.(map[string]interface{}); ok {
+				return nil
+			}
+		case jpArrayNumber:
+			if _, ok := toArrayNum(arg); ok {
+				return nil
+			}
+		case jpArrayString:
+			if _, ok := toArrayStr(arg); ok {
+				return nil
+			}
+		case jpAny:
+			return nil
+		case jpExpref:
+			if _, ok := arg.(expRef); ok {
+				return nil
+			}
+		}
+	}
+	return fmt.Errorf("Invalid type for: %v, expected: %#v", arg, a.types)
+}
+
+func (f *functionCaller) CallFunction(name string, arguments []interface{}, intr *treeInterpreter) (interface{}, error) {
+	entry, ok := f.functionTable[name]
+	if !ok {
+		return nil, errors.New("unknown function: " + name)
+	}
+	resolvedArgs, err := entry.resolveArgs(arguments)
+	if err != nil {
+		return nil, err
+	}
+	if entry.hasExpRef {
+		var extra []interface{}
+		extra = append(extra, intr)
+		resolvedArgs = append(extra, resolvedArgs...)
+	}
+	return entry.handler(resolvedArgs)
+}
+
+func jpfAbs(arguments []interface{}) (interface{}, error) {
+	num := arguments[0].(float64)
+	return math.Abs(num), nil
+}
+
+func jpfLength(arguments []interface{}) (interface{}, error) {
+	arg := arguments[0]
+	if c, ok := arg.(string); ok {
+		return float64(utf8.RuneCountInString(c)), nil
+	} else if isSliceType(arg) {
+		v := reflect.ValueOf(arg)
+		return float64(v.Len()), nil
+	} else if c, ok := arg.(map[string]interface{}); ok {
+		return float64(len(c)), nil
+	}
+	return nil, errors.New("could not compute length()")
+}
+
+func jpfStartsWith(arguments []interface{}) (interface{}, error) {
+	search := arguments[0].(string)
+	prefix := arguments[1].(string)
+	return strings.HasPrefix(search, prefix), nil
+}
+
+func jpfAvg(arguments []interface{}) (interface{}, error) {
+	// We've already type checked the value so we can safely use
+	// type assertions.
+	args := arguments[0].([]interface{})
+	length := float64(len(args))
+	numerator := 0.0
+	for _, n := range args {
+		numerator += n.(float64)
+	}
+	return numerator / length, nil
+}
+func jpfCeil(arguments []interface{}) (interface{}, error) {
+	val := arguments[0].(float64)
+	return math.Ceil(val), nil
+}
+func jpfContains(arguments []interface{}) (interface{}, error) {
+	search := arguments[0]
+	el := arguments[1]
+	if searchStr, ok := search.(string); ok {
+		if elStr, ok := el.(string); ok {
+			return strings.Index(searchStr, elStr) != -1, nil
+		}
+		return false, nil
+	}
+	// Otherwise this is a generic contains for []interface{}
+	general := search.([]interface{})
+	for _, item := range general {
+		if item == el {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+func jpfEndsWith(arguments []interface{}) (interface{}, error) {
+	search := arguments[0].(string)
+	suffix := arguments[1].(string)
+	return strings.HasSuffix(search, suffix), nil
+}
+func jpfFloor(arguments []interface{}) (interface{}, error) {
+	val := arguments[0].(float64)
+	return math.Floor(val), nil
+}
+func jpfMap(arguments []interface{}) (interface{}, error) {
+	intr := arguments[0].(*treeInterpreter)
+	exp := arguments[1].(expRef)
+	node := exp.ref
+	arr := arguments[2].([]interface{})
+	mapped := make([]interface{}, 0, len(arr))
+	for _, value := range arr {
+		current, err := intr.Execute(node, value)
+		if err != nil {
+			return nil, err
+		}
+		mapped = append(mapped, current)
+	}
+	return mapped, nil
+}
+func jpfMax(arguments []interface{}) (interface{}, error) {
+	if items, ok := toArrayNum(arguments[0]); ok {
+		if len(items) == 0 {
+			return nil, nil
+		}
+		if len(items) == 1 {
+			return items[0], nil
+		}
+		best := items[0]
+		for _, item := range items[1:] {
+			if item > best {
+				best = item
+			}
+		}
+		return best, nil
+	}
+	// Otherwise we're dealing with a max() of strings.
+	items, _ := toArrayStr(arguments[0])
+	if len(items) == 0 {
+		return nil, nil
+	}
+	if len(items) == 1 {
+		return items[0], nil
+	}
+	best := items[0]
+	for _, item := range items[1:] {
+		if item > best {
+			best = item
+		}
+	}
+	return best, nil
+}
+func jpfMerge(arguments []interface{}) (interface{}, error) {
+	final := make(map[string]interface{})
+	for _, m := range arguments {
+		mapped := m.(map[string]interface{})
+		for key, value := range mapped {
+			final[key] = value
+		}
+	}
+	return final, nil
+}
+func jpfMaxBy(arguments []interface{}) (interface{}, error) {
+	intr := arguments[0].(*treeInterpreter)
+	arr := arguments[1].([]interface{})
+	exp := arguments[2].(expRef)
+	node := exp.ref
+	if len(arr) == 0 {
+		return nil, nil
+	} else if len(arr) == 1 {
+		return arr[0], nil
+	}
+	start, err := intr.Execute(node, arr[0])
+	if err != nil {
+		return nil, err
+	}
+	switch t := start.(type) {
+	case float64:
+		bestVal := t
+		bestItem := arr[0]
+		for _, item := range arr[1:] {
+			result, err := intr.Execute(node, item)
+			if err != nil {
+				return nil, err
+			}
+			current, ok := result.(float64)
+			if !ok {
+				return nil, errors.New("invalid type, must be number")
+			}
+			if current > bestVal {
+				bestVal = current
+				bestItem = item
+			}
+		}
+		return bestItem, nil
+	case string:
+		bestVal := t
+		bestItem := arr[0]
+		for _, item := range arr[1:] {
+			result, err := intr.Execute(node, item)
+			if err != nil {
+				return nil, err
+			}
+			current, ok := result.(string)
+			if !ok {
+				return nil, errors.New("invalid type, must be string")
+			}
+			if current > bestVal {
+				bestVal = current
+				bestItem = item
+			}
+		}
+		return bestItem, nil
+	default:
+		return nil, errors.New("invalid type, must be number of string")
+	}
+}
+func jpfSum(arguments []interface{}) (interface{}, error) {
+	items, _ := toArrayNum(arguments[0])
+	sum := 0.0
+	for _, item := range items {
+		sum += item
+	}
+	return sum, nil
+}
+
+func jpfMin(arguments []interface{}) (interface{}, error) {
+	if items, ok := toArrayNum(arguments[0]); ok {
+		if len(items) == 0 {
+			return nil, nil
+		}
+		if len(items) == 1 {
+			return items[0], nil
+		}
+		best := items[0]
+		for _, item := range items[1:] {
+			if item < best {
+				best = item
+			}
+		}
+		return best, nil
+	}
+	items, _ := toArrayStr(arguments[0])
+	if len(items) == 0 {
+		return nil, nil
+	}
+	if len(items) == 1 {
+		return items[0], nil
+	}
+	best := items[0]
+	for _, item := range items[1:] {
+		if item < best {
+			best = item
+		}
+	}
+	return best, nil
+}
+
+func jpfMinBy(arguments []interface{}) (interface{}, error) {
+	intr := arguments[0].(*treeInterpreter)
+	arr := arguments[1].([]interface{})
+	exp := arguments[2].(expRef)
+	node := exp.ref
+	if len(arr) == 0 {
+		return nil, nil
+	} else if len(arr) == 1 {
+		return arr[0], nil
+	}
+	start, err := intr.Execute(node, arr[0])
+	if err != nil {
+		return nil, err
+	}
+	if t, ok := start.(float64); ok {
+		bestVal := t
+		bestItem := arr[0]
+		for _, item := range arr[1:] {
+			result, err := intr.Execute(node, item)
+			if err != nil {
+				return nil, err
+			}
+			current, ok := result.(float64)
+			if !ok {
+				return nil, errors.New("invalid type, must be number")
+			}
+			if current < bestVal {
+				bestVal = current
+				bestItem = item
+			}
+		}
+		return bestItem, nil
+	} else if t, ok := start.(string); ok {
+		bestVal := t
+		bestItem := arr[0]
+		for _, item := range arr[1:] {
+			result, err := intr.Execute(node, item)
+			if err != nil {
+				return nil, err
+			}
+			current, ok := result.(string)
+			if !ok {
+				return nil, errors.New("invalid type, must be string")
+			}
+			if current < bestVal {
+				bestVal = current
+				bestItem = item
+			}
+		}
+		return bestItem, nil
+	} else {
+		return nil, errors.New("invalid type, must be number of string")
+	}
+}
+func jpfType(arguments []interface{}) (interface{}, error) {
+	arg := arguments[0]
+	if _, ok := arg.(float64); ok {
+		return "number", nil
+	}
+	if _, ok := arg.(string); ok {
+		return "string", nil
+	}
+	if _, ok := arg.([]interface{}); ok {
+		return "array", nil
+	}
+	if _, ok := arg.(map[string]interface{}); ok {
+		return "object", nil
+	}
+	if arg == nil {
+		return "null", nil
+	}
+	if arg == true || arg == false {
+		return "boolean", nil
+	}
+	return nil, errors.New("unknown type")
+}
+func jpfKeys(arguments []interface{}) (interface{}, error) {
+	arg := arguments[0].(map[string]interface{})
+	collected := make([]interface{}, 0, len(arg))
+	for key := range arg {
+		collected = append(collected, key)
+	}
+	return collected, nil
+}
+func jpfValues(arguments []interface{}) (interface{}, error) {
+	arg := arguments[0].(map[string]interface{})
+	collected := make([]interface{}, 0, len(arg))
+	for _, value := range arg {
+		collected = append(collected, value)
+	}
+	return collected, nil
+}
+func jpfSort(arguments []interface{}) (interface{}, error) {
+	if items, ok := toArrayNum(arguments[0]); ok {
+		d := sort.Float64Slice(items)
+		sort.Stable(d)
+		final := make([]interface{}, len(d))
+		for i, val := range d {
+			final[i] = val
+		}
+		return final, nil
+	}
+	// Otherwise we're dealing with sort()'ing strings.
+	items, _ := toArrayStr(arguments[0])
+	d := sort.StringSlice(items)
+	sort.Stable(d)
+	final := make([]interface{}, len(d))
+	for i, val := range d {
+		final[i] = val
+	}
+	return final, nil
+}
+func jpfSortBy(arguments []interface{}) (interface{}, error) {
+	intr := arguments[0].(*treeInterpreter)
+	arr := arguments[1].([]interface{})
+	exp := arguments[2].(expRef)
+	node := exp.ref
+	if len(arr) == 0 {
+		return arr, nil
+	} else if len(arr) == 1 {
+		return arr, nil
+	}
+	start, err := intr.Execute(node, arr[0])
+	if err != nil {
+		return nil, err
+	}
+	if _, ok := start.(float64); ok {
+		sortable := &byExprFloat{intr, node, arr, false}
+		sort.Stable(sortable)
+		if sortable.hasError {
+			return nil, errors.New("error in sort_by comparison")
+		}
+		return arr, nil
+	} else if _, ok := start.(string); ok {
+		sortable := &byExprString{intr, node, arr, false}
+		sort.Stable(sortable)
+		if sortable.hasError {
+			return nil, errors.New("error in sort_by comparison")
+		}
+		return arr, nil
+	} else {
+		return nil, errors.New("invalid type, must be number of string")
+	}
+}
+func jpfJoin(arguments []interface{}) (interface{}, error) {
+	sep := arguments[0].(string)
+	// We can't just do arguments[1].([]string), we have to
+	// manually convert each item to a string.
+	arrayStr := []string{}
+	for _, item := range arguments[1].([]interface{}) {
+		arrayStr = append(arrayStr, item.(string))
+	}
+	return strings.Join(arrayStr, sep), nil
+}
+func jpfReverse(arguments []interface{}) (interface{}, error) {
+	if s, ok := arguments[0].(string); ok {
+		r := []rune(s)
+		for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
+			r[i], r[j] = r[j], r[i]
+		}
+		return string(r), nil
+	}
+	items := arguments[0].([]interface{})
+	length := len(items)
+	reversed := make([]interface{}, length)
+	for i, item := range items {
+		reversed[length-(i+1)] = item
+	}
+	return reversed, nil
+}
+func jpfToArray(arguments []interface{}) (interface{}, error) {
+	if _, ok := arguments[0].([]interface{}); ok {
+		return arguments[0], nil
+	}
+	return arguments[:1:1], nil
+}
+func jpfToString(arguments []interface{}) (interface{}, error) {
+	if v, ok := arguments[0].(string); ok {
+		return v, nil
+	}
+	result, err := json.Marshal(arguments[0])
+	if err != nil {
+		return nil, err
+	}
+	return string(result), nil
+}
+func jpfToNumber(arguments []interface{}) (interface{}, error) {
+	arg := arguments[0]
+	if v, ok := arg.(float64); ok {
+		return v, nil
+	}
+	if v, ok := arg.(string); ok {
+		conv, err := strconv.ParseFloat(v, 64)
+		if err != nil {
+			return nil, nil
+		}
+		return conv, nil
+	}
+	if _, ok := arg.([]interface{}); ok {
+		return nil, nil
+	}
+	if _, ok := arg.(map[string]interface{}); ok {
+		return nil, nil
+	}
+	if arg == nil {
+		return nil, nil
+	}
+	if arg == true || arg == false {
+		return nil, nil
+	}
+	return nil, errors.New("unknown type")
+}
+func jpfNotNull(arguments []interface{}) (interface{}, error) {
+	for _, arg := range arguments {
+		if arg != nil {
+			return arg, nil
+		}
+	}
+	return nil, nil
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/jmespath.go b/vendor/github.com/jmespath/go-jmespath/fuzz/jmespath.go
new file mode 100644
index 00000000..c7df0878
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/jmespath.go
@@ -0,0 +1,13 @@
+package jmespath
+
+import "github.com/jmespath/go-jmespath"
+
+// Fuzz will fuzz test the JMESPath parser.
+func Fuzz(data []byte) int {
+	p := jmespath.NewParser()
+	_, err := p.Parse(string(data))
+	if err != nil {
+		return 1
+	}
+	return 0
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-1 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-1
new file mode 100644
index 00000000..19102815
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-1
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-10 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-10
new file mode 100644
index 00000000..4d5f9756
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-10
@@ -0,0 +1 @@
+foo.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-100 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-100
new file mode 100644
index 00000000..bc4f6a3f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-100
@@ -0,0 +1 @@
+ends_with(str, 'SStr')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-101 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-101
new file mode 100644
index 00000000..81bf07a7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-101
@@ -0,0 +1 @@
+ends_with(str, 'foo')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-102 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-102
new file mode 100644
index 00000000..3225de91
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-102
@@ -0,0 +1 @@
+floor(`1.2`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-103 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-103
new file mode 100644
index 00000000..8cac9595
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-103
@@ -0,0 +1 @@
+floor(decimals[0])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-104 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-104
new file mode 100644
index 00000000..bd76f47e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-104
@@ -0,0 +1 @@
+floor(foo)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-105 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-105
new file mode 100644
index 00000000..c719add3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-105
@@ -0,0 +1 @@
+length('abc')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-106 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-106
new file mode 100644
index 00000000..ff12f04f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-106
@@ -0,0 +1 @@
+length('')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-107 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-107
new file mode 100644
index 00000000..0eccba1d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-107
@@ -0,0 +1 @@
+length(@)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-108 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-108
new file mode 100644
index 00000000..ab14b0fa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-108
@@ -0,0 +1 @@
+length(strings[0])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-109 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-109
new file mode 100644
index 00000000..f1514bb7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-109
@@ -0,0 +1 @@
+length(str)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-110 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-110
new file mode 100644
index 00000000..09276059
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-110
@@ -0,0 +1 @@
+length(array)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-112 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-112
new file mode 100644
index 00000000..ab14b0fa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-112
@@ -0,0 +1 @@
+length(strings[0])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-115 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-115
new file mode 100644
index 00000000..bfb41ae9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-115
@@ -0,0 +1 @@
+max(strings)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-118 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-118
new file mode 100644
index 00000000..915ec172
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-118
@@ -0,0 +1 @@
+merge(`{}`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-119 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-119
new file mode 100644
index 00000000..5b74e9b5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-119
@@ -0,0 +1 @@
+merge(`{}`, `{}`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-12 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-12
new file mode 100644
index 00000000..64c5e588
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-12
@@ -0,0 +1 @@
+two
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-120 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-120
new file mode 100644
index 00000000..f34dcd8f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-120
@@ -0,0 +1 @@
+merge(`{"a": 1}`, `{"b": 2}`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-121 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-121
new file mode 100644
index 00000000..e335dc96
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-121
@@ -0,0 +1 @@
+merge(`{"a": 1}`, `{"a": 2}`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-122 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-122
new file mode 100644
index 00000000..aac28fff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-122
@@ -0,0 +1 @@
+merge(`{"a": 1, "b": 2}`, `{"a": 2, "c": 3}`, `{"d": 4}`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-123 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-123
new file mode 100644
index 00000000..1c6fd671
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-123
@@ -0,0 +1 @@
+min(numbers)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-126 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-126
new file mode 100644
index 00000000..93e68db7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-126
@@ -0,0 +1 @@
+min(decimals)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-128 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-128
new file mode 100644
index 00000000..554601ea
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-128
@@ -0,0 +1 @@
+type('abc')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-129 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-129
new file mode 100644
index 00000000..1ab2d983
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-129
@@ -0,0 +1 @@
+type(`1.0`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-13 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-13
new file mode 100644
index 00000000..1d19714f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-13
@@ -0,0 +1 @@
+three
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-130 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-130
new file mode 100644
index 00000000..3cee2f56
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-130
@@ -0,0 +1 @@
+type(`2`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-131 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-131
new file mode 100644
index 00000000..4821f9ae
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-131
@@ -0,0 +1 @@
+type(`true`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-132 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-132
new file mode 100644
index 00000000..40b6913a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-132
@@ -0,0 +1 @@
+type(`false`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-133 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-133
new file mode 100644
index 00000000..c711252b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-133
@@ -0,0 +1 @@
+type(`null`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-134 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-134
new file mode 100644
index 00000000..ec5d07e9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-134
@@ -0,0 +1 @@
+type(`[0]`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-135 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-135
new file mode 100644
index 00000000..2080401e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-135
@@ -0,0 +1 @@
+type(`{"a": "b"}`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-136 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-136
new file mode 100644
index 00000000..c5ee2ba5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-136
@@ -0,0 +1 @@
+type(@)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-137 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-137
new file mode 100644
index 00000000..1814ca17
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-137
@@ -0,0 +1 @@
+keys(objects)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-138 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-138
new file mode 100644
index 00000000..e03cdb0d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-138
@@ -0,0 +1 @@
+values(objects)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-139 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-139
new file mode 100644
index 00000000..7fea8d2c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-139
@@ -0,0 +1 @@
+keys(empty_hash)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-14 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-14
new file mode 100644
index 00000000..a17c92f5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-14
@@ -0,0 +1 @@
+one.two
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-140 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-140
new file mode 100644
index 00000000..4f1d882a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-140
@@ -0,0 +1 @@
+join(', ', strings)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-141 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-141
new file mode 100644
index 00000000..4f1d882a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-141
@@ -0,0 +1 @@
+join(', ', strings)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-142 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-142
new file mode 100644
index 00000000..19ec1fe0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-142
@@ -0,0 +1 @@
+join(',', `["a", "b"]`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-143 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-143
new file mode 100644
index 00000000..761c68a6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-143
@@ -0,0 +1 @@
+join('|', strings)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-144 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-144
new file mode 100644
index 00000000..a0dd68ea
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-144
@@ -0,0 +1 @@
+join('|', decimals[].to_string(@))
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-145 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-145
new file mode 100644
index 00000000..a4190b2b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-145
@@ -0,0 +1 @@
+join('|', empty_list)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-146 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-146
new file mode 100644
index 00000000..f5033c30
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-146
@@ -0,0 +1 @@
+reverse(numbers)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-147 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-147
new file mode 100644
index 00000000..822f054d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-147
@@ -0,0 +1 @@
+reverse(array)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-148 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-148
new file mode 100644
index 00000000..a584adcc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-148
@@ -0,0 +1 @@
+reverse(`[]`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-149 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-149
new file mode 100644
index 00000000..fb4cc5dc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-149
@@ -0,0 +1 @@
+reverse('')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-15 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-15
new file mode 100644
index 00000000..693f9549
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-15
@@ -0,0 +1 @@
+foo."1"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-150 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-150
new file mode 100644
index 00000000..aa260fab
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-150
@@ -0,0 +1 @@
+reverse('hello world')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-151 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-151
new file mode 100644
index 00000000..d8c58826
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-151
@@ -0,0 +1 @@
+starts_with(str, 'S')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-152 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-152
new file mode 100644
index 00000000..32e16b7b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-152
@@ -0,0 +1 @@
+starts_with(str, 'St')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-153 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-153
new file mode 100644
index 00000000..5f575ae7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-153
@@ -0,0 +1 @@
+starts_with(str, 'Str')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-155 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-155
new file mode 100644
index 00000000..f31551c6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-155
@@ -0,0 +1 @@
+sum(numbers)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-156 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-156
new file mode 100644
index 00000000..18b90446
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-156
@@ -0,0 +1 @@
+sum(decimals)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-157 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-157
new file mode 100644
index 00000000..def4d0bc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-157
@@ -0,0 +1 @@
+sum(array[].to_number(@))
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-158 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-158
new file mode 100644
index 00000000..48e4a770
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-158
@@ -0,0 +1 @@
+sum(`[]`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-159 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-159
new file mode 100644
index 00000000..9fb939a0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-159
@@ -0,0 +1 @@
+to_array('foo')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-16 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-16
new file mode 100644
index 00000000..86155ed7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-16
@@ -0,0 +1 @@
+foo."1"[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-160 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-160
new file mode 100644
index 00000000..74ba7cc6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-160
@@ -0,0 +1 @@
+to_array(`0`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-161 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-161
new file mode 100644
index 00000000..57f8b983
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-161
@@ -0,0 +1 @@
+to_array(objects)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-162 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-162
new file mode 100644
index 00000000..d17c7345
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-162
@@ -0,0 +1 @@
+to_array(`[1, 2, 3]`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-163 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-163
new file mode 100644
index 00000000..15f70f78
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-163
@@ -0,0 +1 @@
+to_array(false)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-164 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-164
new file mode 100644
index 00000000..9b227529
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-164
@@ -0,0 +1 @@
+to_string('foo')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-165 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-165
new file mode 100644
index 00000000..489a4293
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-165
@@ -0,0 +1 @@
+to_string(`1.2`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-166 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-166
new file mode 100644
index 00000000..d17106a0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-166
@@ -0,0 +1 @@
+to_string(`[0, 1]`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-167 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-167
new file mode 100644
index 00000000..4f4ae9e6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-167
@@ -0,0 +1 @@
+to_number('1.0')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-168 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-168
new file mode 100644
index 00000000..ce932e2e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-168
@@ -0,0 +1 @@
+to_number('1.1')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-169 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-169
new file mode 100644
index 00000000..e246fa4d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-169
@@ -0,0 +1 @@
+to_number('4')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-17 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-17
new file mode 100644
index 00000000..de0b4c39
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-17
@@ -0,0 +1 @@
+foo."-1"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-170 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-170
new file mode 100644
index 00000000..f8c26474
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-170
@@ -0,0 +1 @@
+to_number('notanumber')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-171 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-171
new file mode 100644
index 00000000..7d423b1c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-171
@@ -0,0 +1 @@
+to_number(`false`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-172 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-172
new file mode 100644
index 00000000..503716b6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-172
@@ -0,0 +1 @@
+to_number(`null`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-173 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-173
new file mode 100644
index 00000000..7f61dfa1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-173
@@ -0,0 +1 @@
+to_number(`[0]`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-174 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-174
new file mode 100644
index 00000000..ee72a8c0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-174
@@ -0,0 +1 @@
+to_number(`{"foo": 0}`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-175 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-175
new file mode 100644
index 00000000..8d8f1f75
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-175
@@ -0,0 +1 @@
+sort(numbers)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-178 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-178
new file mode 100644
index 00000000..8cb54ba4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-178
@@ -0,0 +1 @@
+sort(empty_list)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-179 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-179
new file mode 100644
index 00000000..cf2c9b1d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-179
@@ -0,0 +1 @@
+not_null(unknown_key, str)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-18 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-18
new file mode 100644
index 00000000..b516b2c4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-18
@@ -0,0 +1 @@
+@
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-180 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-180
new file mode 100644
index 00000000..e047d486
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-180
@@ -0,0 +1 @@
+not_null(unknown_key, foo.bar, empty_list, str)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-181 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-181
new file mode 100644
index 00000000..c4cc87b9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-181
@@ -0,0 +1 @@
+not_null(unknown_key, null_key, empty_list, str)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-182 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-182
new file mode 100644
index 00000000..2c7fa0a9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-182
@@ -0,0 +1 @@
+not_null(all, expressions, are_null)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-183 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-183
new file mode 100644
index 00000000..eb096e61
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-183
@@ -0,0 +1 @@
+numbers[].to_string(@)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-184 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-184
new file mode 100644
index 00000000..4958abae
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-184
@@ -0,0 +1 @@
+array[].to_number(@)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-185 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-185
new file mode 100644
index 00000000..10270847
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-185
@@ -0,0 +1 @@
+foo[].not_null(f, e, d, c, b, a)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-186 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-186
new file mode 100644
index 00000000..83cb9161
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-186
@@ -0,0 +1 @@
+sort_by(people, &age)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-187 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-187
new file mode 100644
index 00000000..a494d6c4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-187
@@ -0,0 +1 @@
+sort_by(people, &to_number(age_str))
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-188 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-188
new file mode 100644
index 00000000..2294fc54
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-188
@@ -0,0 +1 @@
+sort_by(people, &age)[].name
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-189 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-189
new file mode 100644
index 00000000..bb8c2b46
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-189
@@ -0,0 +1 @@
+sort_by(people, &age)[].extra
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-19 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-19
new file mode 100644
index 00000000..e3ed49ac
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-19
@@ -0,0 +1 @@
+@.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-190 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-190
new file mode 100644
index 00000000..3ab02903
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-190
@@ -0,0 +1 @@
+sort_by(`[]`, &age)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-191 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-191
new file mode 100644
index 00000000..97db56f7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-191
@@ -0,0 +1 @@
+max_by(people, &age)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-192 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-192
new file mode 100644
index 00000000..a7e648de
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-192
@@ -0,0 +1 @@
+max_by(people, &age_str)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-193 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-193
new file mode 100644
index 00000000..be4348d0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-193
@@ -0,0 +1 @@
+max_by(people, &to_number(age_str))
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-194 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-194
new file mode 100644
index 00000000..a707283d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-194
@@ -0,0 +1 @@
+min_by(people, &age)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-195 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-195
new file mode 100644
index 00000000..2cd6618d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-195
@@ -0,0 +1 @@
+min_by(people, &age_str)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-196 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-196
new file mode 100644
index 00000000..833e6837
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-196
@@ -0,0 +1 @@
+min_by(people, &to_number(age_str))
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-198 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-198
new file mode 100644
index 00000000..706dbda8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-198
@@ -0,0 +1 @@
+__L
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-199 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-199
new file mode 100644
index 00000000..ca593ca9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-199
@@ -0,0 +1 @@
+"!\r"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-2 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-2
new file mode 100644
index 00000000..4d5f9756
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-2
@@ -0,0 +1 @@
+foo.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-20 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-20
new file mode 100644
index 00000000..f300ab91
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-20
@@ -0,0 +1 @@
+@.foo[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-200 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-200
new file mode 100644
index 00000000..9c938435
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-200
@@ -0,0 +1 @@
+Y_1623
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-201 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-201
new file mode 100644
index 00000000..c1b0730e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-201
@@ -0,0 +1 @@
+x
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-202 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-202
new file mode 100644
index 00000000..1552ec63
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-202
@@ -0,0 +1 @@
+"\tF\uCebb"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-203 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-203
new file mode 100644
index 00000000..04704127
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-203
@@ -0,0 +1 @@
+" \t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-204 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-204
new file mode 100644
index 00000000..efd782cc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-204
@@ -0,0 +1 @@
+" "
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-205 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-205
new file mode 100644
index 00000000..8494ac27
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-205
@@ -0,0 +1 @@
+v2
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-206 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-206
new file mode 100644
index 00000000..c61f7f7e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-206
@@ -0,0 +1 @@
+"\t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-207 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-207
new file mode 100644
index 00000000..f6055f18
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-207
@@ -0,0 +1 @@
+_X
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-208 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-208
new file mode 100644
index 00000000..4f58e0e7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-208
@@ -0,0 +1 @@
+"\t4\ud9da\udd15"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-209 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-209
new file mode 100644
index 00000000..f536bfbf
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-209
@@ -0,0 +1 @@
+v24_W
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-21 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-21
new file mode 100644
index 00000000..ef47ff2c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-21
@@ -0,0 +1 @@
+"foo.bar"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-210 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-210
new file mode 100644
index 00000000..69759281
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-210
@@ -0,0 +1 @@
+"H"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-211 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-211
new file mode 100644
index 00000000..c3e8b592
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-211
@@ -0,0 +1 @@
+"\f"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-212 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-212
new file mode 100644
index 00000000..24ecc222
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-212
@@ -0,0 +1 @@
+"E4"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-213 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-213
new file mode 100644
index 00000000..5693009d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-213
@@ -0,0 +1 @@
+"!"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-214 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-214
new file mode 100644
index 00000000..62dd220e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-214
@@ -0,0 +1 @@
+tM
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-215 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-215
new file mode 100644
index 00000000..3c1e81f5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-215
@@ -0,0 +1 @@
+" ["
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-216 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-216
new file mode 100644
index 00000000..493daa67
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-216
@@ -0,0 +1 @@
+"R!"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-217 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-217
new file mode 100644
index 00000000..116b50ab
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-217
@@ -0,0 +1 @@
+_6W
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-218 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-218
new file mode 100644
index 00000000..0073fac4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-218
@@ -0,0 +1 @@
+"\uaBA1\r"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-219 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-219
new file mode 100644
index 00000000..00d8fa37
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-219
@@ -0,0 +1 @@
+tL7
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-22 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-22
new file mode 100644
index 00000000..661ebcfa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-22
@@ -0,0 +1 @@
+"foo bar"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-220 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-220
new file mode 100644
index 00000000..c14f16e0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-220
@@ -0,0 +1 @@
+"<<U\t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-221 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-221
new file mode 100644
index 00000000..080e5bb0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-221
@@ -0,0 +1 @@
+"\ubBcE\ufAfB"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-222 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-222
new file mode 100644
index 00000000..a42a6b01
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-222
@@ -0,0 +1 @@
+sNA_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-223 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-223
new file mode 100644
index 00000000..099b20fa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-223
@@ -0,0 +1 @@
+"9"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-224 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-224
new file mode 100644
index 00000000..8c57e792
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-224
@@ -0,0 +1 @@
+"\\\b\ud8cb\udc83"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-225 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-225
new file mode 100644
index 00000000..9fc53f26
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-225
@@ -0,0 +1 @@
+"r"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-226 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-226
new file mode 100644
index 00000000..866ad474
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-226
@@ -0,0 +1 @@
+Q
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-227 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-227
new file mode 100644
index 00000000..999d2f61
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-227
@@ -0,0 +1 @@
+_Q__7GL8
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-228 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-228
new file mode 100644
index 00000000..d58ac16b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-228
@@ -0,0 +1 @@
+"\\"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-229 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-229
new file mode 100644
index 00000000..b140e324
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-229
@@ -0,0 +1 @@
+RR9_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-23 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-23
new file mode 100644
index 00000000..9fccfa41
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-23
@@ -0,0 +1 @@
+"foo\nbar"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-230 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-230
new file mode 100644
index 00000000..131f27f7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-230
@@ -0,0 +1 @@
+"\r\f:"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-231 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-231
new file mode 100644
index 00000000..094c0377
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-231
@@ -0,0 +1 @@
+r7
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-232 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-232
new file mode 100644
index 00000000..08ff0d95
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-232
@@ -0,0 +1 @@
+"-"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-233 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-233
new file mode 100644
index 00000000..ddba9ae3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-233
@@ -0,0 +1 @@
+p9
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-234 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-234
new file mode 100644
index 00000000..9b4441c8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-234
@@ -0,0 +1 @@
+__
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-235 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-235
new file mode 100644
index 00000000..9b485826
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-235
@@ -0,0 +1 @@
+"\b\t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-236 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-236
new file mode 100644
index 00000000..6e0c0871
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-236
@@ -0,0 +1 @@
+O_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-237 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-237
new file mode 100644
index 00000000..a7b2218b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-237
@@ -0,0 +1 @@
+_r_8
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-238 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-238
new file mode 100644
index 00000000..7df5b82a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-238
@@ -0,0 +1 @@
+_j
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-239 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-239
new file mode 100644
index 00000000..62540bff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-239
@@ -0,0 +1 @@
+":"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-24 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-24
new file mode 100644
index 00000000..4ca810c5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-24
@@ -0,0 +1 @@
+"foo\"bar"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-240 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-240
new file mode 100644
index 00000000..34bdf712
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-240
@@ -0,0 +1 @@
+"\rB"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-241 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-241
new file mode 100644
index 00000000..a1af1502
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-241
@@ -0,0 +1 @@
+Obf
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-242 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-242
new file mode 100644
index 00000000..5a373848
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-242
@@ -0,0 +1 @@
+"\n"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-243 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-243
new file mode 100644
index 00000000..8ac9c199
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-243
@@ -0,0 +1 @@
+"\f󥌳"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-244 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-244
new file mode 100644
index 00000000..423a7b02
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-244
@@ -0,0 +1 @@
+"\\\u4FDc"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-245 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-245
new file mode 100644
index 00000000..c9d13372
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-245
@@ -0,0 +1 @@
+"\r"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-246 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-246
new file mode 100644
index 00000000..2da77934
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-246
@@ -0,0 +1 @@
+m_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-247 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-247
new file mode 100644
index 00000000..92169e98
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-247
@@ -0,0 +1 @@
+"\r\fB "
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-248 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-248
new file mode 100644
index 00000000..9d7ed401
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-248
@@ -0,0 +1 @@
+"+\"\""
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-249 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-249
new file mode 100644
index 00000000..f5582b7a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-249
@@ -0,0 +1 @@
+Mg
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-25 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-25
new file mode 100644
index 00000000..e4754ec8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-25
@@ -0,0 +1 @@
+"c:\\\\windows\\path"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-250 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-250
new file mode 100644
index 00000000..f38d52e5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-250
@@ -0,0 +1 @@
+"\"!\/"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-251 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-251
new file mode 100644
index 00000000..01cee572
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-251
@@ -0,0 +1 @@
+"7\""
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-252 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-252
new file mode 100644
index 00000000..3582a4ee
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-252
@@ -0,0 +1 @@
+"\\󞢤S"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-253 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-253
new file mode 100644
index 00000000..a3ec2ed7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-253
@@ -0,0 +1 @@
+"\""
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-254 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-254
new file mode 100644
index 00000000..a6320e8d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-254
@@ -0,0 +1 @@
+Kl
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-255 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-255
new file mode 100644
index 00000000..265a6b0f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-255
@@ -0,0 +1 @@
+"\b\b"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-256 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-256
new file mode 100644
index 00000000..addaff95
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-256
@@ -0,0 +1 @@
+">"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-257 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-257
new file mode 100644
index 00000000..8a2443e6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-257
@@ -0,0 +1 @@
+hvu
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-258 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-258
new file mode 100644
index 00000000..c9ddacbb
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-258
@@ -0,0 +1 @@
+"; !"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-259 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-259
new file mode 100644
index 00000000..d0209c6d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-259
@@ -0,0 +1 @@
+hU
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-26 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-26
new file mode 100644
index 00000000..82649bd2
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-26
@@ -0,0 +1 @@
+"/unix/path"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-260 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-260
new file mode 100644
index 00000000..c07242aa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-260
@@ -0,0 +1 @@
+"!I\n\/"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-261 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-261
new file mode 100644
index 00000000..7aae4eff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-261
@@ -0,0 +1 @@
+"\uEEbF"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-262 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-262
new file mode 100644
index 00000000..c1574f35
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-262
@@ -0,0 +1 @@
+"U)\t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-263 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-263
new file mode 100644
index 00000000..5197e3a2
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-263
@@ -0,0 +1 @@
+fa0_9
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-264 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-264
new file mode 100644
index 00000000..320558b0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-264
@@ -0,0 +1 @@
+"/"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-265 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-265
new file mode 100644
index 00000000..4a2cb086
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-265
@@ -0,0 +1 @@
+Gy
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-266 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-266
new file mode 100644
index 00000000..9524c838
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-266
@@ -0,0 +1 @@
+"\b"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-267 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-267
new file mode 100644
index 00000000..066b8d98
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-267
@@ -0,0 +1 @@
+"<"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-268 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-268
new file mode 100644
index 00000000..c61f7f7e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-268
@@ -0,0 +1 @@
+"\t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-269 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-269
new file mode 100644
index 00000000..a582f62d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-269
@@ -0,0 +1 @@
+"\t&\\\r"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-27 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-27
new file mode 100644
index 00000000..a1d50731
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-27
@@ -0,0 +1 @@
+"\"\"\""
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-270 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-270
new file mode 100644
index 00000000..e3c5eede
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-270
@@ -0,0 +1 @@
+"#"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-271 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-271
new file mode 100644
index 00000000..e75309a5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-271
@@ -0,0 +1 @@
+B__
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-272 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-272
new file mode 100644
index 00000000..02717727
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-272
@@ -0,0 +1 @@
+"\nS \n"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-273 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-273
new file mode 100644
index 00000000..99432276
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-273
@@ -0,0 +1 @@
+Bp
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-274 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-274
new file mode 100644
index 00000000..d4f8a788
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-274
@@ -0,0 +1 @@
+",\t;"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-275 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-275
new file mode 100644
index 00000000..56c384f7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-275
@@ -0,0 +1 @@
+B_q
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-276 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-276
new file mode 100644
index 00000000..f093d2aa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-276
@@ -0,0 +1 @@
+"\/+\t\n\b!Z"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-277 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-277
new file mode 100644
index 00000000..11e1229d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-277
@@ -0,0 +1 @@
+"󇟇\\ueFAc"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-278 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-278
new file mode 100644
index 00000000..90dbfcfc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-278
@@ -0,0 +1 @@
+":\f"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-279 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-279
new file mode 100644
index 00000000..b06b8302
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-279
@@ -0,0 +1 @@
+"\/"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-28 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-28
new file mode 100644
index 00000000..5f55d73a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-28
@@ -0,0 +1 @@
+"bar"."baz"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-280 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-280
new file mode 100644
index 00000000..0e4bf7c1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-280
@@ -0,0 +1 @@
+_BW_6Hg_Gl
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-281 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-281
new file mode 100644
index 00000000..81bb45f8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-281
@@ -0,0 +1 @@
+"􃰂"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-282 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-282
new file mode 100644
index 00000000..d0b4de14
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-282
@@ -0,0 +1 @@
+zs1DC
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-283 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-283
new file mode 100644
index 00000000..68797580
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-283
@@ -0,0 +1 @@
+__434
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-284 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-284
new file mode 100644
index 00000000..e61be91c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-284
@@ -0,0 +1 @@
+"󵅁"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-285 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-285
new file mode 100644
index 00000000..026cb9cb
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-285
@@ -0,0 +1 @@
+Z_5
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-286 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-286
new file mode 100644
index 00000000..ca9587d0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-286
@@ -0,0 +1 @@
+z_M_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-287 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-287
new file mode 100644
index 00000000..67f6d9c4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-287
@@ -0,0 +1 @@
+YU_2
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-288 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-288
new file mode 100644
index 00000000..927ab653
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-288
@@ -0,0 +1 @@
+_0
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-289 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-289
new file mode 100644
index 00000000..39307ab9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-289
@@ -0,0 +1 @@
+"\b+"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-29 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-29
new file mode 100644
index 00000000..8b0c5b41
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-29
@@ -0,0 +1 @@
+foo[?name == 'a']
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-290 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-290
new file mode 100644
index 00000000..a3ec2ed7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-290
@@ -0,0 +1 @@
+"\""
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-291 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-291
new file mode 100644
index 00000000..26bf7e12
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-291
@@ -0,0 +1 @@
+D7
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-292 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-292
new file mode 100644
index 00000000..d595c9f4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-292
@@ -0,0 +1 @@
+_62L
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-293 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-293
new file mode 100644
index 00000000..f6869694
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-293
@@ -0,0 +1 @@
+"\tK\t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-294 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-294
new file mode 100644
index 00000000..f3a9b7ed
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-294
@@ -0,0 +1 @@
+"\n\\\f"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-295 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-295
new file mode 100644
index 00000000..455f00ff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-295
@@ -0,0 +1 @@
+I_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-296 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-296
new file mode 100644
index 00000000..ccd5968f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-296
@@ -0,0 +1 @@
+W_a0_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-297 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-297
new file mode 100644
index 00000000..ee55c16f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-297
@@ -0,0 +1 @@
+BQ
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-298 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-298
new file mode 100644
index 00000000..0d1a169a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-298
@@ -0,0 +1 @@
+"\tX$\uABBb"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-299 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-299
new file mode 100644
index 00000000..0573cfd7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-299
@@ -0,0 +1 @@
+Z9
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-3 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-3
new file mode 100644
index 00000000..f0fcbd8e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-3
@@ -0,0 +1 @@
+foo.bar.baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-30 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-30
new file mode 100644
index 00000000..4f8e6a17
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-30
@@ -0,0 +1 @@
+*[?[0] == `0`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-300 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-300
new file mode 100644
index 00000000..a0db02be
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-300
@@ -0,0 +1 @@
+"\b%\"򞄏"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-301 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-301
new file mode 100644
index 00000000..56032f7a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-301
@@ -0,0 +1 @@
+_F
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-302 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-302
new file mode 100644
index 00000000..4a8a3cff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-302
@@ -0,0 +1 @@
+"!,"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-303 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-303
new file mode 100644
index 00000000..7c1efac0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-303
@@ -0,0 +1 @@
+"\"!"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-304 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-304
new file mode 100644
index 00000000..a0f489d5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-304
@@ -0,0 +1 @@
+Hh
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-305 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-305
new file mode 100644
index 00000000..c64e8d5a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-305
@@ -0,0 +1 @@
+"&"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-306 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-306
new file mode 100644
index 00000000..0567e992
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-306
@@ -0,0 +1 @@
+"9\r\\R"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-307 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-307
new file mode 100644
index 00000000..ce8245c5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-307
@@ -0,0 +1 @@
+M_k
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-308 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-308
new file mode 100644
index 00000000..8f16a5ac
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-308
@@ -0,0 +1 @@
+"!\b\n󑩒\"\""
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-309 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-309
new file mode 100644
index 00000000..504ff5ae
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-309
@@ -0,0 +1 @@
+"6"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-31 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-31
new file mode 100644
index 00000000..07fb5723
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-31
@@ -0,0 +1 @@
+foo[?first == last]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-310 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-310
new file mode 100644
index 00000000..533dd8e5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-310
@@ -0,0 +1 @@
+_7
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-311 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-311
new file mode 100644
index 00000000..1e4a3a34
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-311
@@ -0,0 +1 @@
+"0"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-312 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-312
new file mode 100644
index 00000000..37961f6c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-312
@@ -0,0 +1 @@
+"\\8\\"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-313 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-313
new file mode 100644
index 00000000..23480cff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-313
@@ -0,0 +1 @@
+b7eo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-314 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-314
new file mode 100644
index 00000000..e609f81a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-314
@@ -0,0 +1 @@
+xIUo9
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-315 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-315
new file mode 100644
index 00000000..d89a25f0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-315
@@ -0,0 +1 @@
+"5"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-316 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-316
new file mode 100644
index 00000000..5adcf5e7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-316
@@ -0,0 +1 @@
+"?"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-317 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-317
new file mode 100644
index 00000000..ace4a897
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-317
@@ -0,0 +1 @@
+sU
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-318 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-318
new file mode 100644
index 00000000..feffb706
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-318
@@ -0,0 +1 @@
+"VH2&H\\\/"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-319 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-319
new file mode 100644
index 00000000..8223f1e5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-319
@@ -0,0 +1 @@
+_C
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-32 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-32
new file mode 100644
index 00000000..7e85c4bd
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-32
@@ -0,0 +1 @@
+foo[?first == last].first
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-320 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-320
new file mode 100644
index 00000000..c9cdc63b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-320
@@ -0,0 +1 @@
+_
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-321 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-321
new file mode 100644
index 00000000..c82f7982
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-321
@@ -0,0 +1 @@
+"<\t"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-322 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-322
new file mode 100644
index 00000000..dae65c51
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-322
@@ -0,0 +1 @@
+"\uD834\uDD1E"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-323 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-323
new file mode 100644
index 00000000..b6b36954
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-323
@@ -0,0 +1 @@
+foo.bar[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-324 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-324
new file mode 100644
index 00000000..bf06e678
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-324
@@ -0,0 +1 @@
+foo.bar[1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-325 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-325
new file mode 100644
index 00000000..5d48e020
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-325
@@ -0,0 +1 @@
+foo.bar[2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-326 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-326
new file mode 100644
index 00000000..de3af723
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-326
@@ -0,0 +1 @@
+foo.bar[3]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-327 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-327
new file mode 100644
index 00000000..a1c33350
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-327
@@ -0,0 +1 @@
+foo.bar[-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-328 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-328
new file mode 100644
index 00000000..ad0fef91
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-328
@@ -0,0 +1 @@
+foo.bar[-2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-329 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-329
new file mode 100644
index 00000000..3e83c6f7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-329
@@ -0,0 +1 @@
+foo.bar[-3]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-33 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-33
new file mode 100644
index 00000000..72fc0a53
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-33
@@ -0,0 +1 @@
+foo[?age > `25`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-330 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-330
new file mode 100644
index 00000000..433a737d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-330
@@ -0,0 +1 @@
+foo.bar[-4]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-331 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-331
new file mode 100644
index 00000000..4d5f9756
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-331
@@ -0,0 +1 @@
+foo.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-332 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-332
new file mode 100644
index 00000000..5e0d9b71
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-332
@@ -0,0 +1 @@
+foo[0].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-333 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-333
new file mode 100644
index 00000000..3cd7e946
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-333
@@ -0,0 +1 @@
+foo[1].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-334 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-334
new file mode 100644
index 00000000..74cb1765
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-334
@@ -0,0 +1 @@
+foo[2].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-335 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-335
new file mode 100644
index 00000000..3cf2007f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-335
@@ -0,0 +1 @@
+foo[3].notbar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-336 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-336
new file mode 100644
index 00000000..9674d880
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-336
@@ -0,0 +1 @@
+foo[3].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-337 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-337
new file mode 100644
index 00000000..9b0b2f81
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-337
@@ -0,0 +1 @@
+foo[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-338 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-338
new file mode 100644
index 00000000..83c639a1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-338
@@ -0,0 +1 @@
+foo[1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-339 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-339
new file mode 100644
index 00000000..3b76c9f6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-339
@@ -0,0 +1 @@
+foo[2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-34 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-34
new file mode 100644
index 00000000..9a2b0184
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-34
@@ -0,0 +1 @@
+foo[?age >= `25`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-340 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-340
new file mode 100644
index 00000000..ff99e045
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-340
@@ -0,0 +1 @@
+foo[3]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-341 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-341
new file mode 100644
index 00000000..040ecb24
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-341
@@ -0,0 +1 @@
+foo[4]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-342 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-342
new file mode 100644
index 00000000..6e7ea636
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-342
@@ -0,0 +1 @@
+[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-343 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-343
new file mode 100644
index 00000000..bace2a0b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-343
@@ -0,0 +1 @@
+[1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-344 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-344
new file mode 100644
index 00000000..5d50c80c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-344
@@ -0,0 +1 @@
+[2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-345 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-345
new file mode 100644
index 00000000..99d21a2a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-345
@@ -0,0 +1 @@
+[-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-346 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-346
new file mode 100644
index 00000000..133a9c62
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-346
@@ -0,0 +1 @@
+[-2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-347 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-347
new file mode 100644
index 00000000..b7f78c5d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-347
@@ -0,0 +1 @@
+[-3]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-348 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-348
new file mode 100644
index 00000000..bd9de815
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-348
@@ -0,0 +1 @@
+reservations[].instances[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-349 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-349
new file mode 100644
index 00000000..55e62573
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-349
@@ -0,0 +1 @@
+reservations[].instances[].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-35 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-35
new file mode 100644
index 00000000..fa83f1da
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-35
@@ -0,0 +1 @@
+foo[?age > `30`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-350 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-350
new file mode 100644
index 00000000..1661747c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-350
@@ -0,0 +1 @@
+reservations[].notinstances[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-351 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-351
new file mode 100644
index 00000000..1661747c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-351
@@ -0,0 +1 @@
+reservations[].notinstances[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-352 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-352
new file mode 100644
index 00000000..3debc70f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-352
@@ -0,0 +1 @@
+reservations[].instances[].foo[].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-353 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-353
new file mode 100644
index 00000000..75af2fda
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-353
@@ -0,0 +1 @@
+reservations[].instances[].foo[].baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-354 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-354
new file mode 100644
index 00000000..4a70cd8a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-354
@@ -0,0 +1 @@
+reservations[].instances[].notfoo[].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-355 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-355
new file mode 100644
index 00000000..987985b0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-355
@@ -0,0 +1 @@
+reservations[].instances[].notfoo[].notbar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-356 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-356
new file mode 100644
index 00000000..1661747c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-356
@@ -0,0 +1 @@
+reservations[].notinstances[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-357 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-357
new file mode 100644
index 00000000..634f937e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-357
@@ -0,0 +1 @@
+reservations[].instances[].foo[].notbar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-358 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-358
new file mode 100644
index 00000000..09cb7b8b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-358
@@ -0,0 +1 @@
+reservations[].instances[].bar[].baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-359 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-359
new file mode 100644
index 00000000..f5d9ac5b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-359
@@ -0,0 +1 @@
+reservations[].instances[].baz[].baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-36 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-36
new file mode 100644
index 00000000..463a2a54
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-36
@@ -0,0 +1 @@
+foo[?age < `25`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-360 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-360
new file mode 100644
index 00000000..d1016d6e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-360
@@ -0,0 +1 @@
+reservations[].instances[].qux[].baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-361 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-361
new file mode 100644
index 00000000..ef54cf52
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-361
@@ -0,0 +1 @@
+reservations[].instances[].qux[].baz[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-362 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-362
new file mode 100644
index 00000000..bea506ff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-362
@@ -0,0 +1 @@
+foo[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-363 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-363
new file mode 100644
index 00000000..20dd081e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-363
@@ -0,0 +1 @@
+foo[][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-364 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-364
new file mode 100644
index 00000000..4803734b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-364
@@ -0,0 +1 @@
+foo[][1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-365 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-365
new file mode 100644
index 00000000..1be56598
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-365
@@ -0,0 +1 @@
+foo[][0][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-366 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-366
new file mode 100644
index 00000000..d2cf6da5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-366
@@ -0,0 +1 @@
+foo[][2][2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-367 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-367
new file mode 100644
index 00000000..c609ca64
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-367
@@ -0,0 +1 @@
+foo[][0][0][100]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-368 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-368
new file mode 100644
index 00000000..19102815
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-368
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-369 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-369
new file mode 100644
index 00000000..bea506ff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-369
@@ -0,0 +1 @@
+foo[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-37 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-37
new file mode 100644
index 00000000..10ed5d3f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-37
@@ -0,0 +1 @@
+foo[?age <= `25`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-370 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-370
new file mode 100644
index 00000000..13f2c4a0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-370
@@ -0,0 +1 @@
+foo[].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-371 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-371
new file mode 100644
index 00000000..edf3d927
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-371
@@ -0,0 +1 @@
+foo[].bar[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-372 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-372
new file mode 100644
index 00000000..2a3b993a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-372
@@ -0,0 +1 @@
+foo[].bar[].baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-373 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-373
new file mode 100644
index 00000000..d5ca878a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-373
@@ -0,0 +1 @@
+string[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-374 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-374
new file mode 100644
index 00000000..fcd255f5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-374
@@ -0,0 +1 @@
+hash[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-375 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-375
new file mode 100644
index 00000000..2d53bd7c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-375
@@ -0,0 +1 @@
+number[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-376 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-376
new file mode 100644
index 00000000..cb10d249
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-376
@@ -0,0 +1 @@
+nullvalue[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-377 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-377
new file mode 100644
index 00000000..f6c79ca8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-377
@@ -0,0 +1 @@
+string[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-378 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-378
new file mode 100644
index 00000000..09bf36e8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-378
@@ -0,0 +1 @@
+hash[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-379 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-379
new file mode 100644
index 00000000..4c357818
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-379
@@ -0,0 +1 @@
+number[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-38 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-38
new file mode 100644
index 00000000..16a4c36a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-38
@@ -0,0 +1 @@
+foo[?age < `20`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-380 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-380
new file mode 100644
index 00000000..2dd8ae21
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-380
@@ -0,0 +1 @@
+nullvalue[].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-381 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-381
new file mode 100644
index 00000000..dfed8160
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-381
@@ -0,0 +1 @@
+nullvalue[].foo[].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-382 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-382
new file mode 100644
index 00000000..d7628e64
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-382
@@ -0,0 +1 @@
+`"foo"`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-383 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-383
new file mode 100644
index 00000000..49c5269b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-383
@@ -0,0 +1 @@
+`"\u03a6"`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-384 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-384
new file mode 100644
index 00000000..d5db721d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-384
@@ -0,0 +1 @@
+`"✓"`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-385 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-385
new file mode 100644
index 00000000..a2b6e4ec
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-385
@@ -0,0 +1 @@
+`[1, 2, 3]`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-386 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-386
new file mode 100644
index 00000000..f5801bdd
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-386
@@ -0,0 +1 @@
+`{"a": "b"}`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-387 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-387
new file mode 100644
index 00000000..f87db59a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-387
@@ -0,0 +1 @@
+`true`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-388 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-388
new file mode 100644
index 00000000..3b20d905
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-388
@@ -0,0 +1 @@
+`false`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-389 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-389
new file mode 100644
index 00000000..70bcd29a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-389
@@ -0,0 +1 @@
+`null`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-39 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-39
new file mode 100644
index 00000000..351054d3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-39
@@ -0,0 +1 @@
+foo[?age == `20`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-390 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-390
new file mode 100644
index 00000000..0918d415
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-390
@@ -0,0 +1 @@
+`0`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-391 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-391
new file mode 100644
index 00000000..ef70c4c1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-391
@@ -0,0 +1 @@
+`1`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-392 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-392
new file mode 100644
index 00000000..b39a922f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-392
@@ -0,0 +1 @@
+`2`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-393 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-393
new file mode 100644
index 00000000..7e65687d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-393
@@ -0,0 +1 @@
+`3`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-394 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-394
new file mode 100644
index 00000000..770d1ece
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-394
@@ -0,0 +1 @@
+`4`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-395 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-395
new file mode 100644
index 00000000..a8b81985
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-395
@@ -0,0 +1 @@
+`5`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-396 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-396
new file mode 100644
index 00000000..7f086106
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-396
@@ -0,0 +1 @@
+`6`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-397 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-397
new file mode 100644
index 00000000..495114d9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-397
@@ -0,0 +1 @@
+`7`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-398 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-398
new file mode 100644
index 00000000..94f355c4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-398
@@ -0,0 +1 @@
+`8`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-399 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-399
new file mode 100644
index 00000000..600d2aa3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-399
@@ -0,0 +1 @@
+`9`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-4 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-4
new file mode 100644
index 00000000..31485223
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-4
@@ -0,0 +1 @@
+foo.bar.baz.bad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-40 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-40
new file mode 100644
index 00000000..99d9258a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-40
@@ -0,0 +1 @@
+foo[?age != `20`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-400 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-400
new file mode 100644
index 00000000..637015b5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-400
@@ -0,0 +1 @@
+`"foo\`bar"`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-401 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-401
new file mode 100644
index 00000000..6fa7557b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-401
@@ -0,0 +1 @@
+`"foo\"bar"`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-402 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-402
new file mode 100644
index 00000000..5aabeec3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-402
@@ -0,0 +1 @@
+`"1\`"`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-403 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-403
new file mode 100644
index 00000000..8302ea19
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-403
@@ -0,0 +1 @@
+`"\\"`.{a:`"b"`}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-404 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-404
new file mode 100644
index 00000000..d88d014a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-404
@@ -0,0 +1 @@
+`{"a": "b"}`.a
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-405 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-405
new file mode 100644
index 00000000..47152ddd
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-405
@@ -0,0 +1 @@
+`{"a": {"b": "c"}}`.a.b
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-406 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-406
new file mode 100644
index 00000000..895d4293
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-406
@@ -0,0 +1 @@
+`[0, 1, 2]`[1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-407 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-407
new file mode 100644
index 00000000..42500a36
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-407
@@ -0,0 +1 @@
+`  {"foo": true}`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-408 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-408
new file mode 100644
index 00000000..08b944da
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-408
@@ -0,0 +1 @@
+`{"foo": true}   `
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-409 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-409
new file mode 100644
index 00000000..6de163f8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-409
@@ -0,0 +1 @@
+'foo'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-41 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-41
new file mode 100644
index 00000000..5bc357d9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-41
@@ -0,0 +1 @@
+foo[?top.name == 'a']
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-410 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-410
new file mode 100644
index 00000000..b84bbdb2
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-410
@@ -0,0 +1 @@
+'  foo  '
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-411 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-411
new file mode 100644
index 00000000..bf6a07ac
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-411
@@ -0,0 +1 @@
+'0'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-412 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-412
new file mode 100644
index 00000000..c742f5b0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-412
@@ -0,0 +1,2 @@
+'newline
+'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-413 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-413
new file mode 100644
index 00000000..04e9b3ad
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-413
@@ -0,0 +1,2 @@
+'
+'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-414 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-414
new file mode 100644
index 00000000..ebdaf120
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-414
@@ -0,0 +1 @@
+'✓'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-415 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-415
new file mode 100644
index 00000000..d0ba5d7f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-415
@@ -0,0 +1 @@
+'𝄞'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-416 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-416
new file mode 100644
index 00000000..19c2e2ef
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-416
@@ -0,0 +1 @@
+'  [foo]  '
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-417 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-417
new file mode 100644
index 00000000..5faa483b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-417
@@ -0,0 +1 @@
+'[foo]'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-418 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-418
new file mode 100644
index 00000000..e3c05c16
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-418
@@ -0,0 +1 @@
+'\u03a6'
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-419 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-419
new file mode 100644
index 00000000..7c13861a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-419
@@ -0,0 +1 @@
+foo.{bar: bar}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-42 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-42
new file mode 100644
index 00000000..d037a0a4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-42
@@ -0,0 +1 @@
+foo[?top.first == top.last]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-420 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-420
new file mode 100644
index 00000000..f795c255
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-420
@@ -0,0 +1 @@
+foo.{"bar": bar}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-421 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-421
new file mode 100644
index 00000000..772c4563
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-421
@@ -0,0 +1 @@
+foo.{"foo.bar": bar}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-422 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-422
new file mode 100644
index 00000000..8808e92b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-422
@@ -0,0 +1 @@
+foo.{bar: bar, baz: baz}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-423 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-423
new file mode 100644
index 00000000..3f13757a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-423
@@ -0,0 +1 @@
+foo.{"bar": bar, "baz": baz}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-424 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-424
new file mode 100644
index 00000000..23cd8903
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-424
@@ -0,0 +1 @@
+{"baz": baz, "qux\"": "qux\""}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-425 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-425
new file mode 100644
index 00000000..fabb6da4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-425
@@ -0,0 +1 @@
+foo.{bar:bar,baz:baz}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-426 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-426
new file mode 100644
index 00000000..4c3f615b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-426
@@ -0,0 +1 @@
+foo.{bar: bar,qux: qux}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-427 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-427
new file mode 100644
index 00000000..8bc46535
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-427
@@ -0,0 +1 @@
+foo.{bar: bar, noexist: noexist}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-428 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-428
new file mode 100644
index 00000000..2024b6f1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-428
@@ -0,0 +1 @@
+foo.{noexist: noexist, alsonoexist: alsonoexist}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-429 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-429
new file mode 100644
index 00000000..b52191d1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-429
@@ -0,0 +1 @@
+foo.badkey.{nokey: nokey, alsonokey: alsonokey}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-43 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-43
new file mode 100644
index 00000000..8534a5ca
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-43
@@ -0,0 +1 @@
+foo[?top == `{"first": "foo", "last": "bar"}`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-430 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-430
new file mode 100644
index 00000000..5cd310b6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-430
@@ -0,0 +1 @@
+foo.nested.*.{a: a,b: b}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-431 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-431
new file mode 100644
index 00000000..0b24ef53
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-431
@@ -0,0 +1 @@
+foo.nested.three.{a: a, cinner: c.inner}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-432 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-432
new file mode 100644
index 00000000..473c1c35
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-432
@@ -0,0 +1 @@
+foo.nested.three.{a: a, c: c.inner.bad.key}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-433 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-433
new file mode 100644
index 00000000..44ba735a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-433
@@ -0,0 +1 @@
+foo.{a: nested.one.a, b: nested.two.b}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-434 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-434
new file mode 100644
index 00000000..f5f89b12
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-434
@@ -0,0 +1 @@
+{bar: bar, baz: baz}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-435 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-435
new file mode 100644
index 00000000..697764cb
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-435
@@ -0,0 +1 @@
+{bar: bar}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-436 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-436
new file mode 100644
index 00000000..20447fb1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-436
@@ -0,0 +1 @@
+{otherkey: bar}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-437 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-437
new file mode 100644
index 00000000..310b9b1d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-437
@@ -0,0 +1 @@
+{no: no, exist: exist}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-438 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-438
new file mode 100644
index 00000000..c79b2e24
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-438
@@ -0,0 +1 @@
+foo.[bar]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-439 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-439
new file mode 100644
index 00000000..ab498ef6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-439
@@ -0,0 +1 @@
+foo.[bar,baz]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-44 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-44
new file mode 100644
index 00000000..71307c40
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-44
@@ -0,0 +1 @@
+foo[?key == `true`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-440 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-440
new file mode 100644
index 00000000..4b8f39a4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-440
@@ -0,0 +1 @@
+foo.[bar,qux]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-441 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-441
new file mode 100644
index 00000000..b8f9020f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-441
@@ -0,0 +1 @@
+foo.[bar,noexist]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-442 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-442
new file mode 100644
index 00000000..b7c7b3f6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-442
@@ -0,0 +1 @@
+foo.[noexist,alsonoexist]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-443 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-443
new file mode 100644
index 00000000..fabb6da4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-443
@@ -0,0 +1 @@
+foo.{bar:bar,baz:baz}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-444 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-444
new file mode 100644
index 00000000..c15c39f8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-444
@@ -0,0 +1 @@
+foo.[bar,baz[0]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-445 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-445
new file mode 100644
index 00000000..9cebd898
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-445
@@ -0,0 +1 @@
+foo.[bar,baz[1]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-446 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-446
new file mode 100644
index 00000000..c5bbfbf8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-446
@@ -0,0 +1 @@
+foo.[bar,baz[2]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-447 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-447
new file mode 100644
index 00000000..d81cb2b9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-447
@@ -0,0 +1 @@
+foo.[bar,baz[3]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-448 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-448
new file mode 100644
index 00000000..3a65aa7d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-448
@@ -0,0 +1 @@
+foo.[bar[0],baz[3]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-449 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-449
new file mode 100644
index 00000000..8808e92b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-449
@@ -0,0 +1 @@
+foo.{bar: bar, baz: baz}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-45 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-45
new file mode 100644
index 00000000..e142b22a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-45
@@ -0,0 +1 @@
+foo[?key == `false`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-450 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-450
new file mode 100644
index 00000000..ab498ef6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-450
@@ -0,0 +1 @@
+foo.[bar,baz]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-451 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-451
new file mode 100644
index 00000000..8e3d22dc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-451
@@ -0,0 +1 @@
+foo.{bar: bar.baz[1],includeme: includeme}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-452 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-452
new file mode 100644
index 00000000..398c7f8b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-452
@@ -0,0 +1 @@
+foo.{"bar.baz.two": bar.baz[1].two, includeme: includeme}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-453 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-453
new file mode 100644
index 00000000..a1764448
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-453
@@ -0,0 +1 @@
+foo.[includeme, bar.baz[*].common]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-454 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-454
new file mode 100644
index 00000000..da5225dd
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-454
@@ -0,0 +1 @@
+foo.[includeme, bar.baz[*].none]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-455 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-455
new file mode 100644
index 00000000..a8870b22
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-455
@@ -0,0 +1 @@
+foo.[includeme, bar.baz[].common]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-456 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-456
new file mode 100644
index 00000000..420b1a57
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-456
@@ -0,0 +1 @@
+reservations[*].instances[*].{id: id, name: name}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-457 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-457
new file mode 100644
index 00000000..0761ee16
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-457
@@ -0,0 +1 @@
+reservations[].instances[].{id: id, name: name}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-458 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-458
new file mode 100644
index 00000000..aa1191a4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-458
@@ -0,0 +1 @@
+reservations[].instances[].[id, name]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-459 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-459
new file mode 100644
index 00000000..19102815
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-459
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-46 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-46
new file mode 100644
index 00000000..9a24a464
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-46
@@ -0,0 +1 @@
+foo[?key == `0`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-460 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-460
new file mode 100644
index 00000000..bea506ff
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-460
@@ -0,0 +1 @@
+foo[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-461 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-461
new file mode 100644
index 00000000..13f2c4a0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-461
@@ -0,0 +1 @@
+foo[].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-462 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-462
new file mode 100644
index 00000000..edf3d927
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-462
@@ -0,0 +1 @@
+foo[].bar[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-463 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-463
new file mode 100644
index 00000000..d965466e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-463
@@ -0,0 +1 @@
+foo[].bar[].[baz, qux]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-464 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-464
new file mode 100644
index 00000000..f1822a17
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-464
@@ -0,0 +1 @@
+foo[].bar[].[baz]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-465 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-465
new file mode 100644
index 00000000..c6f77b80
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-465
@@ -0,0 +1 @@
+foo[].bar[].[baz, qux][]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-466 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-466
new file mode 100644
index 00000000..db56262a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-466
@@ -0,0 +1 @@
+foo.[baz[*].bar, qux[0]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-467 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-467
new file mode 100644
index 00000000..b901067d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-467
@@ -0,0 +1 @@
+foo.[baz[*].[bar, boo], qux[0]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-468 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-468
new file mode 100644
index 00000000..738479fa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-468
@@ -0,0 +1 @@
+foo.[baz[*].not_there || baz[*].bar, qux[0]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-469 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-469
new file mode 100644
index 00000000..6926996a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-469
@@ -0,0 +1 @@
+[[*],*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-47 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-47
new file mode 100644
index 00000000..6d33cc72
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-47
@@ -0,0 +1 @@
+foo[?key == `1`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-470 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-470
new file mode 100644
index 00000000..736be0a3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-470
@@ -0,0 +1 @@
+[[*]]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-471 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-471
new file mode 100644
index 00000000..29e1fb20
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-471
@@ -0,0 +1 @@
+outer.foo || outer.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-472 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-472
new file mode 100644
index 00000000..c0070ba7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-472
@@ -0,0 +1 @@
+outer.foo||outer.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-473 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-473
new file mode 100644
index 00000000..661b0bec
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-473
@@ -0,0 +1 @@
+outer.bar || outer.baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-474 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-474
new file mode 100644
index 00000000..296d5aee
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-474
@@ -0,0 +1 @@
+outer.bar||outer.baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-475 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-475
new file mode 100644
index 00000000..ca140f8a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-475
@@ -0,0 +1 @@
+outer.bad || outer.foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-476 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-476
new file mode 100644
index 00000000..15d30924
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-476
@@ -0,0 +1 @@
+outer.bad||outer.foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-477 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-477
new file mode 100644
index 00000000..56148d95
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-477
@@ -0,0 +1 @@
+outer.foo || outer.bad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-478 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-478
new file mode 100644
index 00000000..6d3cf6d9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-478
@@ -0,0 +1 @@
+outer.foo||outer.bad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-479 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-479
new file mode 100644
index 00000000..100fa833
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-479
@@ -0,0 +1 @@
+outer.bad || outer.alsobad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-48 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-48
new file mode 100644
index 00000000..de56fc04
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-48
@@ -0,0 +1 @@
+foo[?key == `[0]`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-480 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-480
new file mode 100644
index 00000000..64490352
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-480
@@ -0,0 +1 @@
+outer.bad||outer.alsobad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-481 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-481
new file mode 100644
index 00000000..af901bde
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-481
@@ -0,0 +1 @@
+outer.empty_string || outer.foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-482 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-482
new file mode 100644
index 00000000..36b63e46
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-482
@@ -0,0 +1 @@
+outer.nokey || outer.bool || outer.empty_list || outer.empty_string || outer.foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-483 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-483
new file mode 100644
index 00000000..aba584f9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-483
@@ -0,0 +1 @@
+foo.*.baz | [0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-484 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-484
new file mode 100644
index 00000000..4234ac01
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-484
@@ -0,0 +1 @@
+foo.*.baz | [1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-485 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-485
new file mode 100644
index 00000000..12330d99
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-485
@@ -0,0 +1 @@
+foo.*.baz | [2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-486 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-486
new file mode 100644
index 00000000..1b2d93e1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-486
@@ -0,0 +1 @@
+foo.bar.* | [0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-487 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-487
new file mode 100644
index 00000000..c371fc64
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-487
@@ -0,0 +1 @@
+foo.*.notbaz | [*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-488 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-488
new file mode 100644
index 00000000..3c835642
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-488
@@ -0,0 +1 @@
+foo | bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-489 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-489
new file mode 100644
index 00000000..decaa042
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-489
@@ -0,0 +1 @@
+foo | bar | baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-49 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-49
new file mode 100644
index 00000000..49d9c63a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-49
@@ -0,0 +1 @@
+foo[?key == `{"bar": [0]}`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-490 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-490
new file mode 100644
index 00000000..b9106803
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-490
@@ -0,0 +1 @@
+foo|bar| baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-491 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-491
new file mode 100644
index 00000000..11df74d8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-491
@@ -0,0 +1 @@
+not_there | [0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-492 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-492
new file mode 100644
index 00000000..11df74d8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-492
@@ -0,0 +1 @@
+not_there | [0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-493 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-493
new file mode 100644
index 00000000..37da9fc0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-493
@@ -0,0 +1 @@
+[foo.bar, foo.other] | [0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-494 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-494
new file mode 100644
index 00000000..1f4fc943
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-494
@@ -0,0 +1 @@
+{"a": foo.bar, "b": foo.other} | a
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-495 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-495
new file mode 100644
index 00000000..67c7ea9c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-495
@@ -0,0 +1 @@
+{"a": foo.bar, "b": foo.other} | b
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-496 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-496
new file mode 100644
index 00000000..d87f9bba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-496
@@ -0,0 +1 @@
+{"a": foo.bar, "b": foo.other} | *.baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-497 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-497
new file mode 100644
index 00000000..ebf8e271
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-497
@@ -0,0 +1 @@
+foo.bam || foo.bar | baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-498 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-498
new file mode 100644
index 00000000..f32bc6db
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-498
@@ -0,0 +1 @@
+foo | not_there || bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-499 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-499
new file mode 100644
index 00000000..d04459d9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-499
@@ -0,0 +1 @@
+foo[*].bar[*] | [0][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-5 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-5
new file mode 100644
index 00000000..b537264a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-5
@@ -0,0 +1 @@
+foo.bar.bad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-50 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-50
new file mode 100644
index 00000000..c17c1df1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-50
@@ -0,0 +1 @@
+foo[?key == `null`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-500 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-500
new file mode 100644
index 00000000..3eb869f4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-500
@@ -0,0 +1 @@
+bar[0:10]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-501 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-501
new file mode 100644
index 00000000..aa5d6be5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-501
@@ -0,0 +1 @@
+foo[0:10:1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-502 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-502
new file mode 100644
index 00000000..1a4d1682
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-502
@@ -0,0 +1 @@
+foo[0:10]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-503 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-503
new file mode 100644
index 00000000..5925a578
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-503
@@ -0,0 +1 @@
+foo[0:10:]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-504 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-504
new file mode 100644
index 00000000..081e93ab
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-504
@@ -0,0 +1 @@
+foo[0::1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-505 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-505
new file mode 100644
index 00000000..92270014
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-505
@@ -0,0 +1 @@
+foo[0::]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-506 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-506
new file mode 100644
index 00000000..fd2294d6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-506
@@ -0,0 +1 @@
+foo[0:]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-507 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-507
new file mode 100644
index 00000000..c6b551d5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-507
@@ -0,0 +1 @@
+foo[:10:1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-508 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-508
new file mode 100644
index 00000000..503f58da
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-508
@@ -0,0 +1 @@
+foo[::1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-509 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-509
new file mode 100644
index 00000000..f78bb770
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-509
@@ -0,0 +1 @@
+foo[:10:]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-51 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-51
new file mode 100644
index 00000000..589a214f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-51
@@ -0,0 +1 @@
+foo[?key == `[1]`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-510 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-510
new file mode 100644
index 00000000..eb9d2ba8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-510
@@ -0,0 +1 @@
+foo[::]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-511 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-511
new file mode 100644
index 00000000..1921a3d9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-511
@@ -0,0 +1 @@
+foo[:]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-512 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-512
new file mode 100644
index 00000000..a87afcb1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-512
@@ -0,0 +1 @@
+foo[1:9]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-513 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-513
new file mode 100644
index 00000000..dbf51d8c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-513
@@ -0,0 +1 @@
+foo[0:10:2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-514 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-514
new file mode 100644
index 00000000..f7288763
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-514
@@ -0,0 +1 @@
+foo[5:]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-515 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-515
new file mode 100644
index 00000000..64395761
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-515
@@ -0,0 +1 @@
+foo[5::2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-516 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-516
new file mode 100644
index 00000000..706bb14d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-516
@@ -0,0 +1 @@
+foo[::2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-517 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-517
new file mode 100644
index 00000000..8fcfaee9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-517
@@ -0,0 +1 @@
+foo[::-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-518 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-518
new file mode 100644
index 00000000..f6a00bf9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-518
@@ -0,0 +1 @@
+foo[1::2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-519 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-519
new file mode 100644
index 00000000..ea068ee0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-519
@@ -0,0 +1 @@
+foo[10:0:-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-52 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-52
new file mode 100644
index 00000000..214917ac
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-52
@@ -0,0 +1 @@
+foo[?key == `{"a":2}`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-520 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-520
new file mode 100644
index 00000000..1fe14258
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-520
@@ -0,0 +1 @@
+foo[10:5:-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-521 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-521
new file mode 100644
index 00000000..4ba0e130
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-521
@@ -0,0 +1 @@
+foo[8:2:-2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-522 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-522
new file mode 100644
index 00000000..25db439f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-522
@@ -0,0 +1 @@
+foo[0:20]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-523 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-523
new file mode 100644
index 00000000..8a965920
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-523
@@ -0,0 +1 @@
+foo[10:-20:-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-524 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-524
new file mode 100644
index 00000000..b1e5ba37
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-524
@@ -0,0 +1 @@
+foo[10:-20]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-525 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-525
new file mode 100644
index 00000000..06253112
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-525
@@ -0,0 +1 @@
+foo[-4:-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-526 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-526
new file mode 100644
index 00000000..1e14a6a4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-526
@@ -0,0 +1 @@
+foo[:-5:-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-527 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-527
new file mode 100644
index 00000000..aef5c274
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-527
@@ -0,0 +1 @@
+foo[:2].a
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-528 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-528
new file mode 100644
index 00000000..93c95fcf
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-528
@@ -0,0 +1 @@
+foo[:2].b
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-529 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-529
new file mode 100644
index 00000000..7e0733e5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-529
@@ -0,0 +1 @@
+foo[:2].a.b
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-53 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-53
new file mode 100644
index 00000000..4c002ed8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-53
@@ -0,0 +1 @@
+foo[?`true` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-530 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-530
new file mode 100644
index 00000000..2438b257
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-530
@@ -0,0 +1 @@
+bar[::-1].a.b
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-531 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-531
new file mode 100644
index 00000000..549994b6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-531
@@ -0,0 +1 @@
+bar[:2].a.b
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-532 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-532
new file mode 100644
index 00000000..ab98292b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-532
@@ -0,0 +1 @@
+baz[:2].a
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-533 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-533
new file mode 100644
index 00000000..65fca968
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-533
@@ -0,0 +1 @@
+[:]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-534 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-534
new file mode 100644
index 00000000..18c5daf7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-534
@@ -0,0 +1 @@
+[:2].a
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-535 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-535
new file mode 100644
index 00000000..1bb84f7d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-535
@@ -0,0 +1 @@
+[::-1].a
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-536 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-536
new file mode 100644
index 00000000..7a0416f0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-536
@@ -0,0 +1 @@
+[:2].b
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-537 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-537
new file mode 100644
index 00000000..4d5f9756
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-537
@@ -0,0 +1 @@
+foo.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-538 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-538
new file mode 100644
index 00000000..19102815
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-538
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-539 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-539
new file mode 100644
index 00000000..f59ec20a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-539
@@ -0,0 +1 @@
+*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-54 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-54
new file mode 100644
index 00000000..23d27073
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-54
@@ -0,0 +1 @@
+foo[?`false` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-540 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-540
new file mode 100644
index 00000000..dee56957
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-540
@@ -0,0 +1 @@
+*.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-541 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-541
new file mode 100644
index 00000000..1a16f741
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-541
@@ -0,0 +1 @@
+*.foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-542 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-542
new file mode 100644
index 00000000..7e8066d3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-542
@@ -0,0 +1 @@
+*[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-543 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-543
new file mode 100644
index 00000000..0637a088
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-543
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-544 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-544
new file mode 100644
index 00000000..6e7ea636
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-544
@@ -0,0 +1 @@
+[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-545 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-545
new file mode 100644
index 00000000..5a519464
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-545
@@ -0,0 +1 @@
+[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-546 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-546
new file mode 100644
index 00000000..41612742
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-546
@@ -0,0 +1 @@
+*.["0"]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-547 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-547
new file mode 100644
index 00000000..cd9fb6ba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-547
@@ -0,0 +1 @@
+[*].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-548 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-548
new file mode 100644
index 00000000..9f3ada48
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-548
@@ -0,0 +1 @@
+[*][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-549 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-549
new file mode 100644
index 00000000..9b0b2f81
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-549
@@ -0,0 +1 @@
+foo[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-55 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-55
new file mode 100644
index 00000000..6d840ee5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-55
@@ -0,0 +1 @@
+foo[?`0` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-550 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-550
new file mode 100644
index 00000000..b23413b9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-550
@@ -0,0 +1 @@
+foo.[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-551 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-551
new file mode 100644
index 00000000..08ab2e1c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-551
@@ -0,0 +1 @@
+foo.[abc]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-552 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-552
new file mode 100644
index 00000000..78b05a5c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-552
@@ -0,0 +1 @@
+foo.[abc, def]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-553 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-553
new file mode 100644
index 00000000..1e7b886e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-553
@@ -0,0 +1 @@
+a.{foo: bar}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-554 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-554
new file mode 100644
index 00000000..91b4c989
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-554
@@ -0,0 +1 @@
+a.{foo: bar, baz: bam}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-555 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-555
new file mode 100644
index 00000000..8301ef98
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-555
@@ -0,0 +1 @@
+{"\\":{" ":*}}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-556 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-556
new file mode 100644
index 00000000..8f75cc91
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-556
@@ -0,0 +1 @@
+foo || bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-557 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-557
new file mode 100644
index 00000000..e5f122c5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-557
@@ -0,0 +1 @@
+foo.[a || b]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-558 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-558
new file mode 100644
index 00000000..39d19143
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-558
@@ -0,0 +1 @@
+foo[?bar==`"baz"`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-559 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-559
new file mode 100644
index 00000000..d08bbe25
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-559
@@ -0,0 +1 @@
+foo[? bar == `"baz"` ]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-56 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-56
new file mode 100644
index 00000000..addaf204
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-56
@@ -0,0 +1 @@
+foo[?`1` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-560 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-560
new file mode 100644
index 00000000..a77f3558
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-560
@@ -0,0 +1 @@
+foo[?a.b.c==d.e.f]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-561 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-561
new file mode 100644
index 00000000..c9697aa4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-561
@@ -0,0 +1 @@
+foo[?bar==`[0, 1, 2]`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-562 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-562
new file mode 100644
index 00000000..fd7064a0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-562
@@ -0,0 +1 @@
+foo[?bar==`["a", "b", "c"]`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-563 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-563
new file mode 100644
index 00000000..61e5e1b8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-563
@@ -0,0 +1 @@
+foo[?bar==`["foo\`bar"]`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-564 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-564
new file mode 100644
index 00000000..bc9d8af1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-564
@@ -0,0 +1 @@
+[?"\\">`"foo"`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-565 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-565
new file mode 100644
index 00000000..2dd54dc3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-565
@@ -0,0 +1 @@
+[?"\\" > `"foo"`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-566 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-566
new file mode 100644
index 00000000..19102815
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-566
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-567 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-567
new file mode 100644
index 00000000..7e9668e7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-567
@@ -0,0 +1 @@
+"foo"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-568 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-568
new file mode 100644
index 00000000..d58ac16b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-568
@@ -0,0 +1 @@
+"\\"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-569 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-569
new file mode 100644
index 00000000..33ac9fba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-569
@@ -0,0 +1 @@
+*||*|*|*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-57 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-57
new file mode 100644
index 00000000..acf2435c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-57
@@ -0,0 +1 @@
+foo[?`[0]` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-570 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-570
new file mode 100644
index 00000000..99e19638
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-570
@@ -0,0 +1 @@
+*[]||[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-571 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-571
new file mode 100644
index 00000000..be084501
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-571
@@ -0,0 +1 @@
+[*.*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-572 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-572
new file mode 100644
index 00000000..a84b51e1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-572
@@ -0,0 +1 @@
+foo[]."✓"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-573 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-573
new file mode 100644
index 00000000..c2de5581
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-573
@@ -0,0 +1 @@
+"☯"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-574 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-574
new file mode 100644
index 00000000..dc2dda0b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-574
@@ -0,0 +1 @@
+"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-575 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-575
new file mode 100644
index 00000000..a2d3d5f6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-575
@@ -0,0 +1 @@
+"☃"
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-576 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-576
new file mode 100644
index 00000000..0971c37e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-576
@@ -0,0 +1 @@
+foo.*.baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-577 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-577
new file mode 100644
index 00000000..0e39dfd6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-577
@@ -0,0 +1 @@
+foo.bar.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-578 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-578
new file mode 100644
index 00000000..89c1ce22
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-578
@@ -0,0 +1 @@
+foo.*.notbaz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-579 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-579
new file mode 100644
index 00000000..5199b9f9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-579
@@ -0,0 +1 @@
+foo.*.notbaz[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-58 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-58
new file mode 100644
index 00000000..99fe382c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-58
@@ -0,0 +1 @@
+foo[?`{"bar": [0]}` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-580 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-580
new file mode 100644
index 00000000..5bb6d4ae
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-580
@@ -0,0 +1 @@
+foo.*.notbaz[-1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-581 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-581
new file mode 100644
index 00000000..edac7318
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-581
@@ -0,0 +1 @@
+foo.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-582 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-582
new file mode 100644
index 00000000..458d0a6d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-582
@@ -0,0 +1 @@
+foo.*.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-583 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-583
new file mode 100644
index 00000000..f757fd53
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-583
@@ -0,0 +1 @@
+foo.*.*.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-584 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-584
new file mode 100644
index 00000000..670049d9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-584
@@ -0,0 +1 @@
+foo.*.*.*.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-585 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-585
new file mode 100644
index 00000000..3c88caaf
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-585
@@ -0,0 +1 @@
+*.bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-586 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-586
new file mode 100644
index 00000000..f59ec20a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-586
@@ -0,0 +1 @@
+*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-587 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-587
new file mode 100644
index 00000000..0852fcc7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-587
@@ -0,0 +1 @@
+*.sub1
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-588 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-588
new file mode 100644
index 00000000..dee56957
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-588
@@ -0,0 +1 @@
+*.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-589 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-589
new file mode 100644
index 00000000..66781bba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-589
@@ -0,0 +1 @@
+*.*.foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-59 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-59
new file mode 100644
index 00000000..4aad20ae
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-59
@@ -0,0 +1 @@
+foo[?`null` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-590 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-590
new file mode 100644
index 00000000..0db15d97
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-590
@@ -0,0 +1 @@
+*.sub1.foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-591 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-591
new file mode 100644
index 00000000..b24be9d7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-591
@@ -0,0 +1 @@
+foo[*].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-592 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-592
new file mode 100644
index 00000000..e6efe133
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-592
@@ -0,0 +1 @@
+foo[*].notbar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-593 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-593
new file mode 100644
index 00000000..5a519464
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-593
@@ -0,0 +1 @@
+[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-594 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-594
new file mode 100644
index 00000000..cd9fb6ba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-594
@@ -0,0 +1 @@
+[*].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-595 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-595
new file mode 100644
index 00000000..cbf1a5d5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-595
@@ -0,0 +1 @@
+[*].notbar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-596 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-596
new file mode 100644
index 00000000..8bd13b7e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-596
@@ -0,0 +1 @@
+foo.bar[*].baz
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-597 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-597
new file mode 100644
index 00000000..7239f3e8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-597
@@ -0,0 +1 @@
+foo.bar[*].baz[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-598 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-598
new file mode 100644
index 00000000..f5e431d9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-598
@@ -0,0 +1 @@
+foo.bar[*].baz[1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-599 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-599
new file mode 100644
index 00000000..d0c25953
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-599
@@ -0,0 +1 @@
+foo.bar[*].baz[2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-6 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-6
new file mode 100644
index 00000000..b9749b74
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-6
@@ -0,0 +1 @@
+foo.bad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-60 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-60
new file mode 100644
index 00000000..dac67509
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-60
@@ -0,0 +1 @@
+foo[?`[1]` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-600 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-600
new file mode 100644
index 00000000..a6388271
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-600
@@ -0,0 +1 @@
+foo.bar[*].baz[3]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-601 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-601
new file mode 100644
index 00000000..2a66ffe9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-601
@@ -0,0 +1 @@
+foo.bar[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-602 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-602
new file mode 100644
index 00000000..b6b36954
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-602
@@ -0,0 +1 @@
+foo.bar[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-603 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-603
new file mode 100644
index 00000000..7e57f9e7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-603
@@ -0,0 +1 @@
+foo.bar[0][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-604 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-604
new file mode 100644
index 00000000..c5f8bef0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-604
@@ -0,0 +1 @@
+foo.bar[0][0][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-605 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-605
new file mode 100644
index 00000000..3decf080
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-605
@@ -0,0 +1 @@
+foo.bar[0][0][0][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-606 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-606
new file mode 100644
index 00000000..655e2959
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-606
@@ -0,0 +1 @@
+foo[0][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-607 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-607
new file mode 100644
index 00000000..2aa15971
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-607
@@ -0,0 +1 @@
+foo[*].bar[*].kind
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-608 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-608
new file mode 100644
index 00000000..556b380b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-608
@@ -0,0 +1 @@
+foo[*].bar[0].kind
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-609 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-609
new file mode 100644
index 00000000..0de3229b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-609
@@ -0,0 +1 @@
+foo[*].bar.kind
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-61 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-61
new file mode 100644
index 00000000..130ed3b3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-61
@@ -0,0 +1 @@
+foo[?`{"a":2}` == key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-610 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-610
new file mode 100644
index 00000000..3b511f13
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-610
@@ -0,0 +1 @@
+foo[*].bar[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-611 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-611
new file mode 100644
index 00000000..c8dfa16e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-611
@@ -0,0 +1 @@
+foo[*].bar[1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-612 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-612
new file mode 100644
index 00000000..69f04ee2
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-612
@@ -0,0 +1 @@
+foo[*].bar[2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-613 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-613
new file mode 100644
index 00000000..3b511f13
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-613
@@ -0,0 +1 @@
+foo[*].bar[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-614 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-614
new file mode 100644
index 00000000..03e0c0cb
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-614
@@ -0,0 +1 @@
+foo[*][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-615 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-615
new file mode 100644
index 00000000..ac1c8966
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-615
@@ -0,0 +1 @@
+foo[*][1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-616 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-616
new file mode 100644
index 00000000..03e0c0cb
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-616
@@ -0,0 +1 @@
+foo[*][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-617 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-617
new file mode 100644
index 00000000..ac1c8966
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-617
@@ -0,0 +1 @@
+foo[*][1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-618 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-618
new file mode 100644
index 00000000..6494cf1c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-618
@@ -0,0 +1 @@
+foo[*][0][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-619 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-619
new file mode 100644
index 00000000..1406be57
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-619
@@ -0,0 +1 @@
+foo[*][1][0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-62 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-62
new file mode 100644
index 00000000..3d15fcc1
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-62
@@ -0,0 +1 @@
+foo[?key != `true`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-620 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-620
new file mode 100644
index 00000000..72b5aa28
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-620
@@ -0,0 +1 @@
+foo[*][0][1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-621 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-621
new file mode 100644
index 00000000..02a26491
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-621
@@ -0,0 +1 @@
+foo[*][1][1]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-622 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-622
new file mode 100644
index 00000000..cb08037e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-622
@@ -0,0 +1 @@
+foo[*][2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-623 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-623
new file mode 100644
index 00000000..91d69599
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-623
@@ -0,0 +1 @@
+foo[*][2][2]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-624 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-624
new file mode 100644
index 00000000..f40f261a
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-624
@@ -0,0 +1 @@
+bar[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-625 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-625
new file mode 100644
index 00000000..03904b1d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-625
@@ -0,0 +1 @@
+bar[*].baz[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-626 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-626
new file mode 100644
index 00000000..fd7c21c3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-626
@@ -0,0 +1 @@
+string[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-627 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-627
new file mode 100644
index 00000000..d7ca4719
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-627
@@ -0,0 +1 @@
+hash[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-628 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-628
new file mode 100644
index 00000000..b3ddffe3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-628
@@ -0,0 +1 @@
+number[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-629 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-629
new file mode 100644
index 00000000..c03cd39e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-629
@@ -0,0 +1 @@
+nullvalue[*]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-63 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-63
new file mode 100644
index 00000000..08731af6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-63
@@ -0,0 +1 @@
+foo[?key != `false`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-630 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-630
new file mode 100644
index 00000000..b3c40cd5
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-630
@@ -0,0 +1 @@
+string[*].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-631 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-631
new file mode 100644
index 00000000..c5930d54
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-631
@@ -0,0 +1 @@
+hash[*].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-632 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-632
new file mode 100644
index 00000000..cc0b1a48
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-632
@@ -0,0 +1 @@
+number[*].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-633 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-633
new file mode 100644
index 00000000..d677b965
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-633
@@ -0,0 +1 @@
+nullvalue[*].foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-634 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-634
new file mode 100644
index 00000000..c1166640
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-634
@@ -0,0 +1 @@
+nullvalue[*].foo[*].bar
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-635 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-635
new file mode 100644
index 00000000..e3399771
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-635
@@ -0,0 +1 @@
+string.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-636 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-636
new file mode 100644
index 00000000..76f53453
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-636
@@ -0,0 +1 @@
+hash.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-637 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-637
new file mode 100644
index 00000000..dd485072
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-637
@@ -0,0 +1 @@
+number.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-638 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-638
new file mode 100644
index 00000000..16000c00
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-638
@@ -0,0 +1 @@
+array.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-639 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-639
new file mode 100644
index 00000000..1d0d03ed
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-639
@@ -0,0 +1 @@
+nullvalue.*
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-64 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-64
new file mode 100644
index 00000000..b67aebe9
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-64
@@ -0,0 +1 @@
+foo[?key != `0`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-640 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-640
new file mode 100644
index 00000000..7e8066d3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-640
@@ -0,0 +1 @@
+*[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-641 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-641
new file mode 100644
index 00000000..41ebe5ba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-641
@@ -0,0 +1 @@
+`foo`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-642 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-642
new file mode 100644
index 00000000..fe039799
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-642
@@ -0,0 +1 @@
+`foo\"quote`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-643 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-643
new file mode 100644
index 00000000..1a27fd80
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-643
@@ -0,0 +1 @@
+`✓`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-644 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-644
new file mode 100644
index 00000000..559a1345
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-644
@@ -0,0 +1 @@
+`foo\"bar`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-645 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-645
new file mode 100644
index 00000000..e31621b4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-645
@@ -0,0 +1 @@
+`1\``
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-646 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-646
new file mode 100644
index 00000000..6bf7a103
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-646
@@ -0,0 +1 @@
+`\\`.{a:`b`}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-647 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-647
new file mode 100644
index 00000000..41ebe5ba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-647
@@ -0,0 +1 @@
+`foo`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-648 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-648
new file mode 100644
index 00000000..28b9bcbb
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-648
@@ -0,0 +1 @@
+`      foo`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-649 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-649
new file mode 100644
index 00000000..41ebe5ba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-649
@@ -0,0 +1 @@
+`foo`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-65 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-65
new file mode 100644
index 00000000..d3ac793b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-65
@@ -0,0 +1 @@
+foo[?key != `1`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-650 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-650
new file mode 100644
index 00000000..fe039799
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-650
@@ -0,0 +1 @@
+`foo\"quote`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-651 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-651
new file mode 100644
index 00000000..1a27fd80
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-651
@@ -0,0 +1 @@
+`✓`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-652 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-652
new file mode 100644
index 00000000..559a1345
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-652
@@ -0,0 +1 @@
+`foo\"bar`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-653 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-653
new file mode 100644
index 00000000..e31621b4
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-653
@@ -0,0 +1 @@
+`1\``
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-654 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-654
new file mode 100644
index 00000000..6bf7a103
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-654
@@ -0,0 +1 @@
+`\\`.{a:`b`}
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-655 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-655
new file mode 100644
index 00000000..41ebe5ba
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-655
@@ -0,0 +1 @@
+`foo`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-656 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-656
new file mode 100644
index 00000000..28b9bcbb
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-656
@@ -0,0 +1 @@
+`      foo`
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-66 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-66
new file mode 100644
index 00000000..065295bc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-66
@@ -0,0 +1 @@
+foo[?key != `null`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-67 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-67
new file mode 100644
index 00000000..43d16492
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-67
@@ -0,0 +1 @@
+foo[?key != `[1]`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-68 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-68
new file mode 100644
index 00000000..6b884fa8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-68
@@ -0,0 +1 @@
+foo[?key != `{"a":2}`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-69 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-69
new file mode 100644
index 00000000..d85c779d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-69
@@ -0,0 +1 @@
+foo[?`true` != key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-7 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-7
new file mode 100644
index 00000000..44d6628c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-7
@@ -0,0 +1 @@
+bad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-70 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-70
new file mode 100644
index 00000000..3e6dcf30
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-70
@@ -0,0 +1 @@
+foo[?`false` != key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-71 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-71
new file mode 100644
index 00000000..bdb820b3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-71
@@ -0,0 +1 @@
+foo[?`0` != key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-72 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-72
new file mode 100644
index 00000000..3f3048a0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-72
@@ -0,0 +1 @@
+foo[?`1` != key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-73 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-73
new file mode 100644
index 00000000..dacc2572
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-73
@@ -0,0 +1 @@
+foo[?`null` != key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-74 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-74
new file mode 100644
index 00000000..32ebae88
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-74
@@ -0,0 +1 @@
+foo[?`[1]` != key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-75 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-75
new file mode 100644
index 00000000..dcd023e0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-75
@@ -0,0 +1 @@
+foo[?`{"a":2}` != key]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-76 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-76
new file mode 100644
index 00000000..e08cc13c
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-76
@@ -0,0 +1 @@
+reservations[].instances[?bar==`1`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-77 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-77
new file mode 100644
index 00000000..1ec43f45
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-77
@@ -0,0 +1 @@
+reservations[*].instances[?bar==`1`]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-78 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-78
new file mode 100644
index 00000000..30387116
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-78
@@ -0,0 +1 @@
+reservations[].instances[?bar==`1`][]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-79 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-79
new file mode 100644
index 00000000..e3875746
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-79
@@ -0,0 +1 @@
+foo[?bar==`1`].bar[0]
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-8 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-8
new file mode 100644
index 00000000..da7bc1cc
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-8
@@ -0,0 +1 @@
+bad.morebad.morebad
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-80 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-80
new file mode 100644
index 00000000..5c3d6835
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-80
@@ -0,0 +1 @@
+foo[?a==`1`].b.c
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-81 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-81
new file mode 100644
index 00000000..6232808f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-81
@@ -0,0 +1 @@
+abs(foo)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-82 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-82
new file mode 100644
index 00000000..6232808f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-82
@@ -0,0 +1 @@
+abs(foo)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-83 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-83
new file mode 100644
index 00000000..29497f4f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-83
@@ -0,0 +1 @@
+abs(array[1])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-84 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-84
new file mode 100644
index 00000000..29497f4f
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-84
@@ -0,0 +1 @@
+abs(array[1])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-85 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-85
new file mode 100644
index 00000000..34669656
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-85
@@ -0,0 +1 @@
+abs(`-24`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-86 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-86
new file mode 100644
index 00000000..34669656
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-86
@@ -0,0 +1 @@
+abs(`-24`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-87 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-87
new file mode 100644
index 00000000..c6268f84
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-87
@@ -0,0 +1 @@
+avg(numbers)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-88 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-88
new file mode 100644
index 00000000..7ce70369
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-88
@@ -0,0 +1 @@
+ceil(`1.2`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-89 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-89
new file mode 100644
index 00000000..0561bc26
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-89
@@ -0,0 +1 @@
+ceil(decimals[0])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-9 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-9
new file mode 100644
index 00000000..19102815
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-9
@@ -0,0 +1 @@
+foo
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-90 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-90
new file mode 100644
index 00000000..c78c1fc3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-90
@@ -0,0 +1 @@
+ceil(decimals[1])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-91 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-91
new file mode 100644
index 00000000..ebcb4bbd
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-91
@@ -0,0 +1 @@
+ceil(decimals[2])
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-92 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-92
new file mode 100644
index 00000000..6edbf1af
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-92
@@ -0,0 +1 @@
+contains('abc', 'a')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-93 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-93
new file mode 100644
index 00000000..d2b2f070
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-93
@@ -0,0 +1 @@
+contains('abc', 'd')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-94 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-94
new file mode 100644
index 00000000..3535da2e
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-94
@@ -0,0 +1 @@
+contains(strings, 'a')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-95 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-95
new file mode 100644
index 00000000..ba839fe6
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-95
@@ -0,0 +1 @@
+contains(decimals, `1.2`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-96 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-96
new file mode 100644
index 00000000..f4358186
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-96
@@ -0,0 +1 @@
+contains(decimals, `false`)
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-97 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-97
new file mode 100644
index 00000000..adb65fc0
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-97
@@ -0,0 +1 @@
+ends_with(str, 'r')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-98 b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-98
new file mode 100644
index 00000000..93d6901b
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/fuzz/testdata/expr-98
@@ -0,0 +1 @@
+ends_with(str, 'tr')
\ No newline at end of file
diff --git a/vendor/github.com/jmespath/go-jmespath/interpreter.go b/vendor/github.com/jmespath/go-jmespath/interpreter.go
new file mode 100644
index 00000000..13c74604
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/interpreter.go
@@ -0,0 +1,418 @@
+package jmespath
+
+import (
+	"errors"
+	"reflect"
+	"unicode"
+	"unicode/utf8"
+)
+
+/* This is a tree based interpreter.  It walks the AST and directly
+   interprets the AST to search through a JSON document.
+*/
+
+type treeInterpreter struct {
+	fCall *functionCaller
+}
+
+func newInterpreter() *treeInterpreter {
+	interpreter := treeInterpreter{}
+	interpreter.fCall = newFunctionCaller()
+	return &interpreter
+}
+
+type expRef struct {
+	ref ASTNode
+}
+
+// Execute takes an ASTNode and input data and interprets the AST directly.
+// It will produce the result of applying the JMESPath expression associated
+// with the ASTNode to the input data "value".
+func (intr *treeInterpreter) Execute(node ASTNode, value interface{}) (interface{}, error) {
+	switch node.nodeType {
+	case ASTComparator:
+		left, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, err
+		}
+		right, err := intr.Execute(node.children[1], value)
+		if err != nil {
+			return nil, err
+		}
+		switch node.value {
+		case tEQ:
+			return objsEqual(left, right), nil
+		case tNE:
+			return !objsEqual(left, right), nil
+		}
+		leftNum, ok := left.(float64)
+		if !ok {
+			return nil, nil
+		}
+		rightNum, ok := right.(float64)
+		if !ok {
+			return nil, nil
+		}
+		switch node.value {
+		case tGT:
+			return leftNum > rightNum, nil
+		case tGTE:
+			return leftNum >= rightNum, nil
+		case tLT:
+			return leftNum < rightNum, nil
+		case tLTE:
+			return leftNum <= rightNum, nil
+		}
+	case ASTExpRef:
+		return expRef{ref: node.children[0]}, nil
+	case ASTFunctionExpression:
+		resolvedArgs := []interface{}{}
+		for _, arg := range node.children {
+			current, err := intr.Execute(arg, value)
+			if err != nil {
+				return nil, err
+			}
+			resolvedArgs = append(resolvedArgs, current)
+		}
+		return intr.fCall.CallFunction(node.value.(string), resolvedArgs, intr)
+	case ASTField:
+		if m, ok := value.(map[string]interface{}); ok {
+			key := node.value.(string)
+			return m[key], nil
+		}
+		return intr.fieldFromStruct(node.value.(string), value)
+	case ASTFilterProjection:
+		left, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, nil
+		}
+		sliceType, ok := left.([]interface{})
+		if !ok {
+			if isSliceType(left) {
+				return intr.filterProjectionWithReflection(node, left)
+			}
+			return nil, nil
+		}
+		compareNode := node.children[2]
+		collected := []interface{}{}
+		for _, element := range sliceType {
+			result, err := intr.Execute(compareNode, element)
+			if err != nil {
+				return nil, err
+			}
+			if !isFalse(result) {
+				current, err := intr.Execute(node.children[1], element)
+				if err != nil {
+					return nil, err
+				}
+				if current != nil {
+					collected = append(collected, current)
+				}
+			}
+		}
+		return collected, nil
+	case ASTFlatten:
+		left, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, nil
+		}
+		sliceType, ok := left.([]interface{})
+		if !ok {
+			// If we can't type convert to []interface{}, there's
+			// a chance this could still work via reflection if we're
+			// dealing with user provided types.
+			if isSliceType(left) {
+				return intr.flattenWithReflection(left)
+			}
+			return nil, nil
+		}
+		flattened := []interface{}{}
+		for _, element := range sliceType {
+			if elementSlice, ok := element.([]interface{}); ok {
+				flattened = append(flattened, elementSlice...)
+			} else if isSliceType(element) {
+				reflectFlat := []interface{}{}
+				v := reflect.ValueOf(element)
+				for i := 0; i < v.Len(); i++ {
+					reflectFlat = append(reflectFlat, v.Index(i).Interface())
+				}
+				flattened = append(flattened, reflectFlat...)
+			} else {
+				flattened = append(flattened, element)
+			}
+		}
+		return flattened, nil
+	case ASTIdentity, ASTCurrentNode:
+		return value, nil
+	case ASTIndex:
+		if sliceType, ok := value.([]interface{}); ok {
+			index := node.value.(int)
+			if index < 0 {
+				index += len(sliceType)
+			}
+			if index < len(sliceType) && index >= 0 {
+				return sliceType[index], nil
+			}
+			return nil, nil
+		}
+		// Otherwise try via reflection.
+		rv := reflect.ValueOf(value)
+		if rv.Kind() == reflect.Slice {
+			index := node.value.(int)
+			if index < 0 {
+				index += rv.Len()
+			}
+			if index < rv.Len() && index >= 0 {
+				v := rv.Index(index)
+				return v.Interface(), nil
+			}
+		}
+		return nil, nil
+	case ASTKeyValPair:
+		return intr.Execute(node.children[0], value)
+	case ASTLiteral:
+		return node.value, nil
+	case ASTMultiSelectHash:
+		if value == nil {
+			return nil, nil
+		}
+		collected := make(map[string]interface{})
+		for _, child := range node.children {
+			current, err := intr.Execute(child, value)
+			if err != nil {
+				return nil, err
+			}
+			key := child.value.(string)
+			collected[key] = current
+		}
+		return collected, nil
+	case ASTMultiSelectList:
+		if value == nil {
+			return nil, nil
+		}
+		collected := []interface{}{}
+		for _, child := range node.children {
+			current, err := intr.Execute(child, value)
+			if err != nil {
+				return nil, err
+			}
+			collected = append(collected, current)
+		}
+		return collected, nil
+	case ASTOrExpression:
+		matched, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, err
+		}
+		if isFalse(matched) {
+			matched, err = intr.Execute(node.children[1], value)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return matched, nil
+	case ASTAndExpression:
+		matched, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, err
+		}
+		if isFalse(matched) {
+			return matched, nil
+		}
+		return intr.Execute(node.children[1], value)
+	case ASTNotExpression:
+		matched, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, err
+		}
+		if isFalse(matched) {
+			return true, nil
+		}
+		return false, nil
+	case ASTPipe:
+		result := value
+		var err error
+		for _, child := range node.children {
+			result, err = intr.Execute(child, result)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return result, nil
+	case ASTProjection:
+		left, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, err
+		}
+		sliceType, ok := left.([]interface{})
+		if !ok {
+			if isSliceType(left) {
+				return intr.projectWithReflection(node, left)
+			}
+			return nil, nil
+		}
+		collected := []interface{}{}
+		var current interface{}
+		for _, element := range sliceType {
+			current, err = intr.Execute(node.children[1], element)
+			if err != nil {
+				return nil, err
+			}
+			if current != nil {
+				collected = append(collected, current)
+			}
+		}
+		return collected, nil
+	case ASTSubexpression, ASTIndexExpression:
+		left, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, err
+		}
+		return intr.Execute(node.children[1], left)
+	case ASTSlice:
+		sliceType, ok := value.([]interface{})
+		if !ok {
+			if isSliceType(value) {
+				return intr.sliceWithReflection(node, value)
+			}
+			return nil, nil
+		}
+		parts := node.value.([]*int)
+		sliceParams := make([]sliceParam, 3)
+		for i, part := range parts {
+			if part != nil {
+				sliceParams[i].Specified = true
+				sliceParams[i].N = *part
+			}
+		}
+		return slice(sliceType, sliceParams)
+	case ASTValueProjection:
+		left, err := intr.Execute(node.children[0], value)
+		if err != nil {
+			return nil, nil
+		}
+		mapType, ok := left.(map[string]interface{})
+		if !ok {
+			return nil, nil
+		}
+		values := make([]interface{}, len(mapType))
+		for _, value := range mapType {
+			values = append(values, value)
+		}
+		collected := []interface{}{}
+		for _, element := range values {
+			current, err := intr.Execute(node.children[1], element)
+			if err != nil {
+				return nil, err
+			}
+			if current != nil {
+				collected = append(collected, current)
+			}
+		}
+		return collected, nil
+	}
+	return nil, errors.New("Unknown AST node: " + node.nodeType.String())
+}
+
+func (intr *treeInterpreter) fieldFromStruct(key string, value interface{}) (interface{}, error) {
+	rv := reflect.ValueOf(value)
+	first, n := utf8.DecodeRuneInString(key)
+	fieldName := string(unicode.ToUpper(first)) + key[n:]
+	if rv.Kind() == reflect.Struct {
+		v := rv.FieldByName(fieldName)
+		if !v.IsValid() {
+			return nil, nil
+		}
+		return v.Interface(), nil
+	} else if rv.Kind() == reflect.Ptr {
+		// Handle multiple levels of indirection?
+		if rv.IsNil() {
+			return nil, nil
+		}
+		rv = rv.Elem()
+		v := rv.FieldByName(fieldName)
+		if !v.IsValid() {
+			return nil, nil
+		}
+		return v.Interface(), nil
+	}
+	return nil, nil
+}
+
+func (intr *treeInterpreter) flattenWithReflection(value interface{}) (interface{}, error) {
+	v := reflect.ValueOf(value)
+	flattened := []interface{}{}
+	for i := 0; i < v.Len(); i++ {
+		element := v.Index(i).Interface()
+		if reflect.TypeOf(element).Kind() == reflect.Slice {
+			// Then insert the contents of the element
+			// slice into the flattened slice,
+			// i.e flattened = append(flattened, mySlice...)
+			elementV := reflect.ValueOf(element)
+			for j := 0; j < elementV.Len(); j++ {
+				flattened = append(
+					flattened, elementV.Index(j).Interface())
+			}
+		} else {
+			flattened = append(flattened, element)
+		}
+	}
+	return flattened, nil
+}
+
+func (intr *treeInterpreter) sliceWithReflection(node ASTNode, value interface{}) (interface{}, error) {
+	v := reflect.ValueOf(value)
+	parts := node.value.([]*int)
+	sliceParams := make([]sliceParam, 3)
+	for i, part := range parts {
+		if part != nil {
+			sliceParams[i].Specified = true
+			sliceParams[i].N = *part
+		}
+	}
+	final := []interface{}{}
+	for i := 0; i < v.Len(); i++ {
+		element := v.Index(i).Interface()
+		final = append(final, element)
+	}
+	return slice(final, sliceParams)
+}
+
+func (intr *treeInterpreter) filterProjectionWithReflection(node ASTNode, value interface{}) (interface{}, error) {
+	compareNode := node.children[2]
+	collected := []interface{}{}
+	v := reflect.ValueOf(value)
+	for i := 0; i < v.Len(); i++ {
+		element := v.Index(i).Interface()
+		result, err := intr.Execute(compareNode, element)
+		if err != nil {
+			return nil, err
+		}
+		if !isFalse(result) {
+			current, err := intr.Execute(node.children[1], element)
+			if err != nil {
+				return nil, err
+			}
+			if current != nil {
+				collected = append(collected, current)
+			}
+		}
+	}
+	return collected, nil
+}
+
+func (intr *treeInterpreter) projectWithReflection(node ASTNode, value interface{}) (interface{}, error) {
+	collected := []interface{}{}
+	v := reflect.ValueOf(value)
+	for i := 0; i < v.Len(); i++ {
+		element := v.Index(i).Interface()
+		result, err := intr.Execute(node.children[1], element)
+		if err != nil {
+			return nil, err
+		}
+		if result != nil {
+			collected = append(collected, result)
+		}
+	}
+	return collected, nil
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/interpreter_test.go b/vendor/github.com/jmespath/go-jmespath/interpreter_test.go
new file mode 100644
index 00000000..11c6d0aa
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/interpreter_test.go
@@ -0,0 +1,221 @@
+package jmespath
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type scalars struct {
+	Foo string
+	Bar string
+}
+
+type sliceType struct {
+	A string
+	B []scalars
+	C []*scalars
+}
+
+type benchmarkStruct struct {
+	Fooasdfasdfasdfasdf string
+}
+
+type benchmarkNested struct {
+	Fooasdfasdfasdfasdf nestedA
+}
+
+type nestedA struct {
+	Fooasdfasdfasdfasdf nestedB
+}
+
+type nestedB struct {
+	Fooasdfasdfasdfasdf nestedC
+}
+
+type nestedC struct {
+	Fooasdfasdfasdfasdf string
+}
+
+type nestedSlice struct {
+	A []sliceType
+}
+
+func TestCanSupportEmptyInterface(t *testing.T) {
+	assert := assert.New(t)
+	data := make(map[string]interface{})
+	data["foo"] = "bar"
+	result, err := Search("foo", data)
+	assert.Nil(err)
+	assert.Equal("bar", result)
+}
+
+func TestCanSupportUserDefinedStructsValue(t *testing.T) {
+	assert := assert.New(t)
+	s := scalars{Foo: "one", Bar: "bar"}
+	result, err := Search("Foo", s)
+	assert.Nil(err)
+	assert.Equal("one", result)
+}
+
+func TestCanSupportUserDefinedStructsRef(t *testing.T) {
+	assert := assert.New(t)
+	s := scalars{Foo: "one", Bar: "bar"}
+	result, err := Search("Foo", &s)
+	assert.Nil(err)
+	assert.Equal("one", result)
+}
+
+func TestCanSupportStructWithSliceAll(t *testing.T) {
+	assert := assert.New(t)
+	data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}}
+	result, err := Search("B[].Foo", data)
+	assert.Nil(err)
+	assert.Equal([]interface{}{"f1", "correct"}, result)
+}
+
+func TestCanSupportStructWithSlicingExpression(t *testing.T) {
+	assert := assert.New(t)
+	data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}}
+	result, err := Search("B[:].Foo", data)
+	assert.Nil(err)
+	assert.Equal([]interface{}{"f1", "correct"}, result)
+}
+
+func TestCanSupportStructWithFilterProjection(t *testing.T) {
+	assert := assert.New(t)
+	data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}}
+	result, err := Search("B[? `true` ].Foo", data)
+	assert.Nil(err)
+	assert.Equal([]interface{}{"f1", "correct"}, result)
+}
+
+func TestCanSupportStructWithSlice(t *testing.T) {
+	assert := assert.New(t)
+	data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}}
+	result, err := Search("B[-1].Foo", data)
+	assert.Nil(err)
+	assert.Equal("correct", result)
+}
+
+func TestCanSupportStructWithOrExpressions(t *testing.T) {
+	assert := assert.New(t)
+	data := sliceType{A: "foo", C: nil}
+	result, err := Search("C || A", data)
+	assert.Nil(err)
+	assert.Equal("foo", result)
+}
+
+func TestCanSupportStructWithSlicePointer(t *testing.T) {
+	assert := assert.New(t)
+	data := sliceType{A: "foo", C: []*scalars{{"f1", "b1"}, {"correct", "b2"}}}
+	result, err := Search("C[-1].Foo", data)
+	assert.Nil(err)
+	assert.Equal("correct", result)
+}
+
+func TestWillAutomaticallyCapitalizeFieldNames(t *testing.T) {
+	assert := assert.New(t)
+	s := scalars{Foo: "one", Bar: "bar"}
+	// Note that there's a lower cased "foo" instead of "Foo",
+	// but it should still correspond to the Foo field in the
+	// scalars struct
+	result, err := Search("foo", &s)
+	assert.Nil(err)
+	assert.Equal("one", result)
+}
+
+func TestCanSupportStructWithSliceLowerCased(t *testing.T) {
+	assert := assert.New(t)
+	data := sliceType{A: "foo", B: []scalars{{"f1", "b1"}, {"correct", "b2"}}}
+	result, err := Search("b[-1].foo", data)
+	assert.Nil(err)
+	assert.Equal("correct", result)
+}
+
+func TestCanSupportStructWithNestedPointers(t *testing.T) {
+	assert := assert.New(t)
+	data := struct{ A *struct{ B int } }{}
+	result, err := Search("A.B", data)
+	assert.Nil(err)
+	assert.Nil(result)
+}
+
+func TestCanSupportFlattenNestedSlice(t *testing.T) {
+	assert := assert.New(t)
+	data := nestedSlice{A: []sliceType{
+		{B: []scalars{{Foo: "f1a"}, {Foo: "f1b"}}},
+		{B: []scalars{{Foo: "f2a"}, {Foo: "f2b"}}},
+	}}
+	result, err := Search("A[].B[].Foo", data)
+	assert.Nil(err)
+	assert.Equal([]interface{}{"f1a", "f1b", "f2a", "f2b"}, result)
+}
+
+func TestCanSupportFlattenNestedEmptySlice(t *testing.T) {
+	assert := assert.New(t)
+	data := nestedSlice{A: []sliceType{
+		{}, {B: []scalars{{Foo: "a"}}},
+	}}
+	result, err := Search("A[].B[].Foo", data)
+	assert.Nil(err)
+	assert.Equal([]interface{}{"a"}, result)
+}
+
+func TestCanSupportProjectionsWithStructs(t *testing.T) {
+	assert := assert.New(t)
+	data := nestedSlice{A: []sliceType{
+		{A: "first"}, {A: "second"}, {A: "third"},
+	}}
+	result, err := Search("A[*].A", data)
+	assert.Nil(err)
+	assert.Equal([]interface{}{"first", "second", "third"}, result)
+}
+
+func TestCanSupportSliceOfStructsWithFunctions(t *testing.T) {
+	assert := assert.New(t)
+	data := []scalars{scalars{"a1", "b1"}, scalars{"a2", "b2"}}
+	result, err := Search("length(@)", data)
+	assert.Nil(err)
+	assert.Equal(result.(float64), 2.0)
+}
+
+func BenchmarkInterpretSingleFieldStruct(b *testing.B) {
+	intr := newInterpreter()
+	parser := NewParser()
+	ast, _ := parser.Parse("fooasdfasdfasdfasdf")
+	data := benchmarkStruct{"foobarbazqux"}
+	for i := 0; i < b.N; i++ {
+		intr.Execute(ast, &data)
+	}
+}
+
+func BenchmarkInterpretNestedStruct(b *testing.B) {
+	intr := newInterpreter()
+	parser := NewParser()
+	ast, _ := parser.Parse("fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf")
+	data := benchmarkNested{
+		nestedA{
+			nestedB{
+				nestedC{"foobarbazqux"},
+			},
+		},
+	}
+	for i := 0; i < b.N; i++ {
+		intr.Execute(ast, &data)
+	}
+}
+
+func BenchmarkInterpretNestedMaps(b *testing.B) {
+	jsonData := []byte(`{"fooasdfasdfasdfasdf": {"fooasdfasdfasdfasdf": {"fooasdfasdfasdfasdf": {"fooasdfasdfasdfasdf": "foobarbazqux"}}}}`)
+	var data interface{}
+	json.Unmarshal(jsonData, &data)
+
+	intr := newInterpreter()
+	parser := NewParser()
+	ast, _ := parser.Parse("fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf.fooasdfasdfasdfasdf")
+	for i := 0; i < b.N; i++ {
+		intr.Execute(ast, data)
+	}
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/lexer.go b/vendor/github.com/jmespath/go-jmespath/lexer.go
new file mode 100644
index 00000000..817900c8
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/lexer.go
@@ -0,0 +1,420 @@
+package jmespath
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+type token struct {
+	tokenType tokType
+	value     string
+	position  int
+	length    int
+}
+
+type tokType int
+
+const eof = -1
+
+// Lexer contains information about the expression being tokenized.
+type Lexer struct {
+	expression string       // The expression provided by the user.
+	currentPos int          // The current position in the string.
+	lastWidth  int          // The width of the current rune.  This
+	buf        bytes.Buffer // Internal buffer used for building up values.
+}
+
+// SyntaxError is the main error used whenever a lexing or parsing error occurs.
+type SyntaxError struct {
+	msg        string // Error message displayed to user
+	Expression string // Expression that generated a SyntaxError
+	Offset     int    // The location in the string where the error occurred
+}
+
+func (e SyntaxError) Error() string {
+	// In the future, it would be good to underline the specific
+	// location where the error occurred.
+	return "SyntaxError: " + e.msg
+}
+
+// HighlightLocation will show where the syntax error occurred.
+// It will place a "^" character on a line below the expression
+// at the point where the syntax error occurred.
+func (e SyntaxError) HighlightLocation() string {
+	return e.Expression + "\n" + strings.Repeat(" ", e.Offset) + "^"
+}
+
+//go:generate stringer -type=tokType
+const (
+	tUnknown tokType = iota
+	tStar
+	tDot
+	tFilter
+	tFlatten
+	tLparen
+	tRparen
+	tLbracket
+	tRbracket
+	tLbrace
+	tRbrace
+	tOr
+	tPipe
+	tNumber
+	tUnquotedIdentifier
+	tQuotedIdentifier
+	tComma
+	tColon
+	tLT
+	tLTE
+	tGT
+	tGTE
+	tEQ
+	tNE
+	tJSONLiteral
+	tStringLiteral
+	tCurrent
+	tExpref
+	tAnd
+	tNot
+	tEOF
+)
+
+var basicTokens = map[rune]tokType{
+	'.': tDot,
+	'*': tStar,
+	',': tComma,
+	':': tColon,
+	'{': tLbrace,
+	'}': tRbrace,
+	']': tRbracket, // tLbracket not included because it could be "[]"
+	'(': tLparen,
+	')': tRparen,
+	'@': tCurrent,
+}
+
+// Bit mask for [a-zA-Z_] shifted down 64 bits to fit in a single uint64.
+// When using this bitmask just be sure to shift the rune down 64 bits
+// before checking against identifierStartBits.
+const identifierStartBits uint64 = 576460745995190270
+
+// Bit mask for [a-zA-Z0-9], 128 bits -> 2 uint64s.
+var identifierTrailingBits = [2]uint64{287948901175001088, 576460745995190270}
+
+var whiteSpace = map[rune]bool{
+	' ': true, '\t': true, '\n': true, '\r': true,
+}
+
+func (t token) String() string {
+	return fmt.Sprintf("Token{%+v, %s, %d, %d}",
+		t.tokenType, t.value, t.position, t.length)
+}
+
+// NewLexer creates a new JMESPath lexer.
+func NewLexer() *Lexer {
+	lexer := Lexer{}
+	return &lexer
+}
+
+func (lexer *Lexer) next() rune {
+	if lexer.currentPos >= len(lexer.expression) {
+		lexer.lastWidth = 0
+		return eof
+	}
+	r, w := utf8.DecodeRuneInString(lexer.expression[lexer.currentPos:])
+	lexer.lastWidth = w
+	lexer.currentPos += w
+	return r
+}
+
+func (lexer *Lexer) back() {
+	lexer.currentPos -= lexer.lastWidth
+}
+
+func (lexer *Lexer) peek() rune {
+	t := lexer.next()
+	lexer.back()
+	return t
+}
+
+// tokenize takes an expression and returns corresponding tokens.
+func (lexer *Lexer) tokenize(expression string) ([]token, error) {
+	var tokens []token
+	lexer.expression = expression
+	lexer.currentPos = 0
+	lexer.lastWidth = 0
+loop:
+	for {
+		r := lexer.next()
+		if identifierStartBits&(1<<(uint64(r)-64)) > 0 {
+			t := lexer.consumeUnquotedIdentifier()
+			tokens = append(tokens, t)
+		} else if val, ok := basicTokens[r]; ok {
+			// Basic single char token.
+			t := token{
+				tokenType: val,
+				value:     string(r),
+				position:  lexer.currentPos - lexer.lastWidth,
+				length:    1,
+			}
+			tokens = append(tokens, t)
+		} else if r == '-' || (r >= '0' && r <= '9') {
+			t := lexer.consumeNumber()
+			tokens = append(tokens, t)
+		} else if r == '[' {
+			t := lexer.consumeLBracket()
+			tokens = append(tokens, t)
+		} else if r == '"' {
+			t, err := lexer.consumeQuotedIdentifier()
+			if err != nil {
+				return tokens, err
+			}
+			tokens = append(tokens, t)
+		} else if r == '\'' {
+			t, err := lexer.consumeRawStringLiteral()
+			if err != nil {
+				return tokens, err
+			}
+			tokens = append(tokens, t)
+		} else if r == '`' {
+			t, err := lexer.consumeLiteral()
+			if err != nil {
+				return tokens, err
+			}
+			tokens = append(tokens, t)
+		} else if r == '|' {
+			t := lexer.matchOrElse(r, '|', tOr, tPipe)
+			tokens = append(tokens, t)
+		} else if r == '<' {
+			t := lexer.matchOrElse(r, '=', tLTE, tLT)
+			tokens = append(tokens, t)
+		} else if r == '>' {
+			t := lexer.matchOrElse(r, '=', tGTE, tGT)
+			tokens = append(tokens, t)
+		} else if r == '!' {
+			t := lexer.matchOrElse(r, '=', tNE, tNot)
+			tokens = append(tokens, t)
+		} else if r == '=' {
+			t := lexer.matchOrElse(r, '=', tEQ, tUnknown)
+			tokens = append(tokens, t)
+		} else if r == '&' {
+			t := lexer.matchOrElse(r, '&', tAnd, tExpref)
+			tokens = append(tokens, t)
+		} else if r == eof {
+			break loop
+		} else if _, ok := whiteSpace[r]; ok {
+			// Ignore whitespace
+		} else {
+			return tokens, lexer.syntaxError(fmt.Sprintf("Unknown char: %s", strconv.QuoteRuneToASCII(r)))
+		}
+	}
+	tokens = append(tokens, token{tEOF, "", len(lexer.expression), 0})
+	return tokens, nil
+}
+
+// Consume characters until the ending rune "r" is reached.
+// If the end of the expression is reached before seeing the
+// terminating rune "r", then an error is returned.
+// If no error occurs then the matching substring is returned.
+// The returned string will not include the ending rune.
+func (lexer *Lexer) consumeUntil(end rune) (string, error) {
+	start := lexer.currentPos
+	current := lexer.next()
+	for current != end && current != eof {
+		if current == '\\' && lexer.peek() != eof {
+			lexer.next()
+		}
+		current = lexer.next()
+	}
+	if lexer.lastWidth == 0 {
+		// Then we hit an EOF so we never reached the closing
+		// delimiter.
+		return "", SyntaxError{
+			msg:        "Unclosed delimiter: " + string(end),
+			Expression: lexer.expression,
+			Offset:     len(lexer.expression),
+		}
+	}
+	return lexer.expression[start : lexer.currentPos-lexer.lastWidth], nil
+}
+
+func (lexer *Lexer) consumeLiteral() (token, error) {
+	start := lexer.currentPos
+	value, err := lexer.consumeUntil('`')
+	if err != nil {
+		return token{}, err
+	}
+	value = strings.Replace(value, "\\`", "`", -1)
+	return token{
+		tokenType: tJSONLiteral,
+		value:     value,
+		position:  start,
+		length:    len(value),
+	}, nil
+}
+
+func (lexer *Lexer) consumeRawStringLiteral() (token, error) {
+	start := lexer.currentPos
+	currentIndex := start
+	current := lexer.next()
+	for current != '\'' && lexer.peek() != eof {
+		if current == '\\' && lexer.peek() == '\'' {
+			chunk := lexer.expression[currentIndex : lexer.currentPos-1]
+			lexer.buf.WriteString(chunk)
+			lexer.buf.WriteString("'")
+			lexer.next()
+			currentIndex = lexer.currentPos
+		}
+		current = lexer.next()
+	}
+	if lexer.lastWidth == 0 {
+		// Then we hit an EOF so we never reached the closing
+		// delimiter.
+		return token{}, SyntaxError{
+			msg:        "Unclosed delimiter: '",
+			Expression: lexer.expression,
+			Offset:     len(lexer.expression),
+		}
+	}
+	if currentIndex < lexer.currentPos {
+		lexer.buf.WriteString(lexer.expression[currentIndex : lexer.currentPos-1])
+	}
+	value := lexer.buf.String()
+	// Reset the buffer so it can reused again.
+	lexer.buf.Reset()
+	return token{
+		tokenType: tStringLiteral,
+		value:     value,
+		position:  start,
+		length:    len(value),
+	}, nil
+}
+
+func (lexer *Lexer) syntaxError(msg string) SyntaxError {
+	return SyntaxError{
+		msg:        msg,
+		Expression: lexer.expression,
+		Offset:     lexer.currentPos - 1,
+	}
+}
+
+// Checks for a two char token, otherwise matches a single character
+// token. This is used whenever a two char token overlaps a single
+// char token, e.g. "||" -> tPipe, "|" -> tOr.
+func (lexer *Lexer) matchOrElse(first rune, second rune, matchedType tokType, singleCharType tokType) token {
+	start := lexer.currentPos - lexer.lastWidth
+	nextRune := lexer.next()
+	var t token
+	if nextRune == second {
+		t = token{
+			tokenType: matchedType,
+			value:     string(first) + string(second),
+			position:  start,
+			length:    2,
+		}
+	} else {
+		lexer.back()
+		t = token{
+			tokenType: singleCharType,
+			value:     string(first),
+			position:  start,
+			length:    1,
+		}
+	}
+	return t
+}
+
+func (lexer *Lexer) consumeLBracket() token {
+	// There's three options here:
+	// 1. A filter expression "[?"
+	// 2. A flatten operator "[]"
+	// 3. A bare rbracket "["
+	start := lexer.currentPos - lexer.lastWidth
+	nextRune := lexer.next()
+	var t token
+	if nextRune == '?' {
+		t = token{
+			tokenType: tFilter,
+			value:     "[?",
+			position:  start,
+			length:    2,
+		}
+	} else if nextRune == ']' {
+		t = token{
+			tokenType: tFlatten,
+			value:     "[]",
+			position:  start,
+			length:    2,
+		}
+	} else {
+		t = token{
+			tokenType: tLbracket,
+			value:     "[",
+			position:  start,
+			length:    1,
+		}
+		lexer.back()
+	}
+	return t
+}
+
+func (lexer *Lexer) consumeQuotedIdentifier() (token, error) {
+	start := lexer.currentPos
+	value, err := lexer.consumeUntil('"')
+	if err != nil {
+		return token{}, err
+	}
+	var decoded string
+	asJSON := []byte("\"" + value + "\"")
+	if err := json.Unmarshal([]byte(asJSON), &decoded); err != nil {
+		return token{}, err
+	}
+	return token{
+		tokenType: tQuotedIdentifier,
+		value:     decoded,
+		position:  start - 1,
+		length:    len(decoded),
+	}, nil
+}
+
+func (lexer *Lexer) consumeUnquotedIdentifier() token {
+	// Consume runes until we reach the end of an unquoted
+	// identifier.
+	start := lexer.currentPos - lexer.lastWidth
+	for {
+		r := lexer.next()
+		if r < 0 || r > 128 || identifierTrailingBits[uint64(r)/64]&(1<<(uint64(r)%64)) == 0 {
+			lexer.back()
+			break
+		}
+	}
+	value := lexer.expression[start:lexer.currentPos]
+	return token{
+		tokenType: tUnquotedIdentifier,
+		value:     value,
+		position:  start,
+		length:    lexer.currentPos - start,
+	}
+}
+
+func (lexer *Lexer) consumeNumber() token {
+	// Consume runes until we reach something that's not a number.
+	start := lexer.currentPos - lexer.lastWidth
+	for {
+		r := lexer.next()
+		if r < '0' || r > '9' {
+			lexer.back()
+			break
+		}
+	}
+	value := lexer.expression[start:lexer.currentPos]
+	return token{
+		tokenType: tNumber,
+		value:     value,
+		position:  start,
+		length:    lexer.currentPos - start,
+	}
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/lexer_test.go b/vendor/github.com/jmespath/go-jmespath/lexer_test.go
new file mode 100644
index 00000000..d13a042d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/lexer_test.go
@@ -0,0 +1,161 @@
+package jmespath
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var lexingTests = []struct {
+	expression string
+	expected   []token
+}{
+	{"*", []token{{tStar, "*", 0, 1}}},
+	{".", []token{{tDot, ".", 0, 1}}},
+	{"[?", []token{{tFilter, "[?", 0, 2}}},
+	{"[]", []token{{tFlatten, "[]", 0, 2}}},
+	{"(", []token{{tLparen, "(", 0, 1}}},
+	{")", []token{{tRparen, ")", 0, 1}}},
+	{"[", []token{{tLbracket, "[", 0, 1}}},
+	{"]", []token{{tRbracket, "]", 0, 1}}},
+	{"{", []token{{tLbrace, "{", 0, 1}}},
+	{"}", []token{{tRbrace, "}", 0, 1}}},
+	{"||", []token{{tOr, "||", 0, 2}}},
+	{"|", []token{{tPipe, "|", 0, 1}}},
+	{"29", []token{{tNumber, "29", 0, 2}}},
+	{"2", []token{{tNumber, "2", 0, 1}}},
+	{"0", []token{{tNumber, "0", 0, 1}}},
+	{"-20", []token{{tNumber, "-20", 0, 3}}},
+	{"foo", []token{{tUnquotedIdentifier, "foo", 0, 3}}},
+	{`"bar"`, []token{{tQuotedIdentifier, "bar", 0, 3}}},
+	// Escaping the delimiter
+	{`"bar\"baz"`, []token{{tQuotedIdentifier, `bar"baz`, 0, 7}}},
+	{",", []token{{tComma, ",", 0, 1}}},
+	{":", []token{{tColon, ":", 0, 1}}},
+	{"<", []token{{tLT, "<", 0, 1}}},
+	{"<=", []token{{tLTE, "<=", 0, 2}}},
+	{">", []token{{tGT, ">", 0, 1}}},
+	{">=", []token{{tGTE, ">=", 0, 2}}},
+	{"==", []token{{tEQ, "==", 0, 2}}},
+	{"!=", []token{{tNE, "!=", 0, 2}}},
+	{"`[0, 1, 2]`", []token{{tJSONLiteral, "[0, 1, 2]", 1, 9}}},
+	{"'foo'", []token{{tStringLiteral, "foo", 1, 3}}},
+	{"'a'", []token{{tStringLiteral, "a", 1, 1}}},
+	{`'foo\'bar'`, []token{{tStringLiteral, "foo'bar", 1, 7}}},
+	{"@", []token{{tCurrent, "@", 0, 1}}},
+	{"&", []token{{tExpref, "&", 0, 1}}},
+	// Quoted identifier unicode escape sequences
+	{`"\u2713"`, []token{{tQuotedIdentifier, "✓", 0, 3}}},
+	{`"\\"`, []token{{tQuotedIdentifier, `\`, 0, 1}}},
+	{"`\"foo\"`", []token{{tJSONLiteral, "\"foo\"", 1, 5}}},
+	// Combinations of tokens.
+	{"foo.bar", []token{
+		{tUnquotedIdentifier, "foo", 0, 3},
+		{tDot, ".", 3, 1},
+		{tUnquotedIdentifier, "bar", 4, 3},
+	}},
+	{"foo[0]", []token{
+		{tUnquotedIdentifier, "foo", 0, 3},
+		{tLbracket, "[", 3, 1},
+		{tNumber, "0", 4, 1},
+		{tRbracket, "]", 5, 1},
+	}},
+	{"foo[?a<b]", []token{
+		{tUnquotedIdentifier, "foo", 0, 3},
+		{tFilter, "[?", 3, 2},
+		{tUnquotedIdentifier, "a", 5, 1},
+		{tLT, "<", 6, 1},
+		{tUnquotedIdentifier, "b", 7, 1},
+		{tRbracket, "]", 8, 1},
+	}},
+}
+
+func TestCanLexTokens(t *testing.T) {
+	assert := assert.New(t)
+	lexer := NewLexer()
+	for _, tt := range lexingTests {
+		tokens, err := lexer.tokenize(tt.expression)
+		if assert.Nil(err) {
+			errMsg := fmt.Sprintf("Mismatch expected number of tokens: (expected: %s, actual: %s)",
+				tt.expected, tokens)
+			tt.expected = append(tt.expected, token{tEOF, "", len(tt.expression), 0})
+			if assert.Equal(len(tt.expected), len(tokens), errMsg) {
+				for i, token := range tokens {
+					expected := tt.expected[i]
+					assert.Equal(expected, token, "Token not equal")
+				}
+			}
+		}
+	}
+}
+
+var lexingErrorTests = []struct {
+	expression string
+	msg        string
+}{
+	{"'foo", "Missing closing single quote"},
+	{"[?foo==bar?]", "Unknown char '?'"},
+}
+
+func TestLexingErrors(t *testing.T) {
+	assert := assert.New(t)
+	lexer := NewLexer()
+	for _, tt := range lexingErrorTests {
+		_, err := lexer.tokenize(tt.expression)
+		assert.NotNil(err, fmt.Sprintf("Expected lexing error: %s", tt.msg))
+	}
+}
+
+var exprIdentifier = "abcdefghijklmnopqrstuvwxyz"
+var exprSubexpr = "abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz"
+var deeplyNested50 = "j49.j48.j47.j46.j45.j44.j43.j42.j41.j40.j39.j38.j37.j36.j35.j34.j33.j32.j31.j30.j29.j28.j27.j26.j25.j24.j23.j22.j21.j20.j19.j18.j17.j16.j15.j14.j13.j12.j11.j10.j9.j8.j7.j6.j5.j4.j3.j2.j1.j0"
+var deeplyNested50Pipe = "j49|j48|j47|j46|j45|j44|j43|j42|j41|j40|j39|j38|j37|j36|j35|j34|j33|j32|j31|j30|j29|j28|j27|j26|j25|j24|j23|j22|j21|j20|j19|j18|j17|j16|j15|j14|j13|j12|j11|j10|j9|j8|j7|j6|j5|j4|j3|j2|j1|j0"
+var deeplyNested50Index = "[49][48][47][46][45][44][43][42][41][40][39][38][37][36][35][34][33][32][31][30][29][28][27][26][25][24][23][22][21][20][19][18][17][16][15][14][13][12][11][10][9][8][7][6][5][4][3][2][1][0]"
+var deepProjection104 = "a[*].b[*].c[*].d[*].e[*].f[*].g[*].h[*].i[*].j[*].k[*].l[*].m[*].n[*].o[*].p[*].q[*].r[*].s[*].t[*].u[*].v[*].w[*].x[*].y[*].z[*].a[*].b[*].c[*].d[*].e[*].f[*].g[*].h[*].i[*].j[*].k[*].l[*].m[*].n[*].o[*].p[*].q[*].r[*].s[*].t[*].u[*].v[*].w[*].x[*].y[*].z[*].a[*].b[*].c[*].d[*].e[*].f[*].g[*].h[*].i[*].j[*].k[*].l[*].m[*].n[*].o[*].p[*].q[*].r[*].s[*].t[*].u[*].v[*].w[*].x[*].y[*].z[*].a[*].b[*].c[*].d[*].e[*].f[*].g[*].h[*].i[*].j[*].k[*].l[*].m[*].n[*].o[*].p[*].q[*].r[*].s[*].t[*].u[*].v[*].w[*].x[*].y[*].z[*]"
+var exprQuotedIdentifier = `"abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz"`
+var quotedIdentifierEscapes = `"\n\r\b\t\n\r\b\t\n\r\b\t\n\r\b\t\n\r\b\t\n\r\b\t\n\r\b\t"`
+var rawStringLiteral = `'abcdefghijklmnopqrstuvwxyz.abcdefghijklmnopqrstuvwxyz'`
+
+func BenchmarkLexIdentifier(b *testing.B) {
+	runLexBenchmark(b, exprIdentifier)
+}
+
+func BenchmarkLexSubexpression(b *testing.B) {
+	runLexBenchmark(b, exprSubexpr)
+}
+
+func BenchmarkLexDeeplyNested50(b *testing.B) {
+	runLexBenchmark(b, deeplyNested50)
+}
+
+func BenchmarkLexDeepNested50Pipe(b *testing.B) {
+	runLexBenchmark(b, deeplyNested50Pipe)
+}
+
+func BenchmarkLexDeepNested50Index(b *testing.B) {
+	runLexBenchmark(b, deeplyNested50Index)
+}
+
+func BenchmarkLexQuotedIdentifier(b *testing.B) {
+	runLexBenchmark(b, exprQuotedIdentifier)
+}
+
+func BenchmarkLexQuotedIdentifierEscapes(b *testing.B) {
+	runLexBenchmark(b, quotedIdentifierEscapes)
+}
+
+func BenchmarkLexRawStringLiteral(b *testing.B) {
+	runLexBenchmark(b, rawStringLiteral)
+}
+
+func BenchmarkLexDeepProjection104(b *testing.B) {
+	runLexBenchmark(b, deepProjection104)
+}
+
+func runLexBenchmark(b *testing.B, expression string) {
+	lexer := NewLexer()
+	for i := 0; i < b.N; i++ {
+		lexer.tokenize(expression)
+	}
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/parser.go b/vendor/github.com/jmespath/go-jmespath/parser.go
new file mode 100644
index 00000000..1240a175
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/parser.go
@@ -0,0 +1,603 @@
+package jmespath
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type astNodeType int
+
+//go:generate stringer -type astNodeType
+const (
+	ASTEmpty astNodeType = iota
+	ASTComparator
+	ASTCurrentNode
+	ASTExpRef
+	ASTFunctionExpression
+	ASTField
+	ASTFilterProjection
+	ASTFlatten
+	ASTIdentity
+	ASTIndex
+	ASTIndexExpression
+	ASTKeyValPair
+	ASTLiteral
+	ASTMultiSelectHash
+	ASTMultiSelectList
+	ASTOrExpression
+	ASTAndExpression
+	ASTNotExpression
+	ASTPipe
+	ASTProjection
+	ASTSubexpression
+	ASTSlice
+	ASTValueProjection
+)
+
+// ASTNode represents the abstract syntax tree of a JMESPath expression.
+type ASTNode struct {
+	nodeType astNodeType
+	value    interface{}
+	children []ASTNode
+}
+
+func (node ASTNode) String() string {
+	return node.PrettyPrint(0)
+}
+
+// PrettyPrint will pretty print the parsed AST.
+// The AST is an implementation detail and this pretty print
+// function is provided as a convenience method to help with
+// debugging.  You should not rely on its output as the internal
+// structure of the AST may change at any time.
+func (node ASTNode) PrettyPrint(indent int) string {
+	spaces := strings.Repeat(" ", indent)
+	output := fmt.Sprintf("%s%s {\n", spaces, node.nodeType)
+	nextIndent := indent + 2
+	if node.value != nil {
+		if converted, ok := node.value.(fmt.Stringer); ok {
+			// Account for things like comparator nodes
+			// that are enums with a String() method.
+			output += fmt.Sprintf("%svalue: %s\n", strings.Repeat(" ", nextIndent), converted.String())
+		} else {
+			output += fmt.Sprintf("%svalue: %#v\n", strings.Repeat(" ", nextIndent), node.value)
+		}
+	}
+	lastIndex := len(node.children)
+	if lastIndex > 0 {
+		output += fmt.Sprintf("%schildren: {\n", strings.Repeat(" ", nextIndent))
+		childIndent := nextIndent + 2
+		for _, elem := range node.children {
+			output += elem.PrettyPrint(childIndent)
+		}
+	}
+	output += fmt.Sprintf("%s}\n", spaces)
+	return output
+}
+
+var bindingPowers = map[tokType]int{
+	tEOF:                0,
+	tUnquotedIdentifier: 0,
+	tQuotedIdentifier:   0,
+	tRbracket:           0,
+	tRparen:             0,
+	tComma:              0,
+	tRbrace:             0,
+	tNumber:             0,
+	tCurrent:            0,
+	tExpref:             0,
+	tColon:              0,
+	tPipe:               1,
+	tOr:                 2,
+	tAnd:                3,
+	tEQ:                 5,
+	tLT:                 5,
+	tLTE:                5,
+	tGT:                 5,
+	tGTE:                5,
+	tNE:                 5,
+	tFlatten:            9,
+	tStar:               20,
+	tFilter:             21,
+	tDot:                40,
+	tNot:                45,
+	tLbrace:             50,
+	tLbracket:           55,
+	tLparen:             60,
+}
+
+// Parser holds state about the current expression being parsed.
+type Parser struct {
+	expression string
+	tokens     []token
+	index      int
+}
+
+// NewParser creates a new JMESPath parser.
+func NewParser() *Parser {
+	p := Parser{}
+	return &p
+}
+
+// Parse will compile a JMESPath expression.
+func (p *Parser) Parse(expression string) (ASTNode, error) {
+	lexer := NewLexer()
+	p.expression = expression
+	p.index = 0
+	tokens, err := lexer.tokenize(expression)
+	if err != nil {
+		return ASTNode{}, err
+	}
+	p.tokens = tokens
+	parsed, err := p.parseExpression(0)
+	if err != nil {
+		return ASTNode{}, err
+	}
+	if p.current() != tEOF {
+		return ASTNode{}, p.syntaxError(fmt.Sprintf(
+			"Unexpected token at the end of the expresssion: %s", p.current()))
+	}
+	return parsed, nil
+}
+
+func (p *Parser) parseExpression(bindingPower int) (ASTNode, error) {
+	var err error
+	leftToken := p.lookaheadToken(0)
+	p.advance()
+	leftNode, err := p.nud(leftToken)
+	if err != nil {
+		return ASTNode{}, err
+	}
+	currentToken := p.current()
+	for bindingPower < bindingPowers[currentToken] {
+		p.advance()
+		leftNode, err = p.led(currentToken, leftNode)
+		if err != nil {
+			return ASTNode{}, err
+		}
+		currentToken = p.current()
+	}
+	return leftNode, nil
+}
+
+func (p *Parser) parseIndexExpression() (ASTNode, error) {
+	if p.lookahead(0) == tColon || p.lookahead(1) == tColon {
+		return p.parseSliceExpression()
+	}
+	indexStr := p.lookaheadToken(0).value
+	parsedInt, err := strconv.Atoi(indexStr)
+	if err != nil {
+		return ASTNode{}, err
+	}
+	indexNode := ASTNode{nodeType: ASTIndex, value: parsedInt}
+	p.advance()
+	if err := p.match(tRbracket); err != nil {
+		return ASTNode{}, err
+	}
+	return indexNode, nil
+}
+
+func (p *Parser) parseSliceExpression() (ASTNode, error) {
+	parts := []*int{nil, nil, nil}
+	index := 0
+	current := p.current()
+	for current != tRbracket && index < 3 {
+		if current == tColon {
+			index++
+			p.advance()
+		} else if current == tNumber {
+			parsedInt, err := strconv.Atoi(p.lookaheadToken(0).value)
+			if err != nil {
+				return ASTNode{}, err
+			}
+			parts[index] = &parsedInt
+			p.advance()
+		} else {
+			return ASTNode{}, p.syntaxError(
+				"Expected tColon or tNumber" + ", received: " + p.current().String())
+		}
+		current = p.current()
+	}
+	if err := p.match(tRbracket); err != nil {
+		return ASTNode{}, err
+	}
+	return ASTNode{
+		nodeType: ASTSlice,
+		value:    parts,
+	}, nil
+}
+
+func (p *Parser) match(tokenType tokType) error {
+	if p.current() == tokenType {
+		p.advance()
+		return nil
+	}
+	return p.syntaxError("Expected " + tokenType.String() + ", received: " + p.current().String())
+}
+
+func (p *Parser) led(tokenType tokType, node ASTNode) (ASTNode, error) {
+	switch tokenType {
+	case tDot:
+		if p.current() != tStar {
+			right, err := p.parseDotRHS(bindingPowers[tDot])
+			return ASTNode{
+				nodeType: ASTSubexpression,
+				children: []ASTNode{node, right},
+			}, err
+		}
+		p.advance()
+		right, err := p.parseProjectionRHS(bindingPowers[tDot])
+		return ASTNode{
+			nodeType: ASTValueProjection,
+			children: []ASTNode{node, right},
+		}, err
+	case tPipe:
+		right, err := p.parseExpression(bindingPowers[tPipe])
+		return ASTNode{nodeType: ASTPipe, children: []ASTNode{node, right}}, err
+	case tOr:
+		right, err := p.parseExpression(bindingPowers[tOr])
+		return ASTNode{nodeType: ASTOrExpression, children: []ASTNode{node, right}}, err
+	case tAnd:
+		right, err := p.parseExpression(bindingPowers[tAnd])
+		return ASTNode{nodeType: ASTAndExpression, children: []ASTNode{node, right}}, err
+	case tLparen:
+		name := node.value
+		var args []ASTNode
+		for p.current() != tRparen {
+			expression, err := p.parseExpression(0)
+			if err != nil {
+				return ASTNode{}, err
+			}
+			if p.current() == tComma {
+				if err := p.match(tComma); err != nil {
+					return ASTNode{}, err
+				}
+			}
+			args = append(args, expression)
+		}
+		if err := p.match(tRparen); err != nil {
+			return ASTNode{}, err
+		}
+		return ASTNode{
+			nodeType: ASTFunctionExpression,
+			value:    name,
+			children: args,
+		}, nil
+	case tFilter:
+		return p.parseFilter(node)
+	case tFlatten:
+		left := ASTNode{nodeType: ASTFlatten, children: []ASTNode{node}}
+		right, err := p.parseProjectionRHS(bindingPowers[tFlatten])
+		return ASTNode{
+			nodeType: ASTProjection,
+			children: []ASTNode{left, right},
+		}, err
+	case tEQ, tNE, tGT, tGTE, tLT, tLTE:
+		right, err := p.parseExpression(bindingPowers[tokenType])
+		if err != nil {
+			return ASTNode{}, err
+		}
+		return ASTNode{
+			nodeType: ASTComparator,
+			value:    tokenType,
+			children: []ASTNode{node, right},
+		}, nil
+	case tLbracket:
+		tokenType := p.current()
+		var right ASTNode
+		var err error
+		if tokenType == tNumber || tokenType == tColon {
+			right, err = p.parseIndexExpression()
+			if err != nil {
+				return ASTNode{}, err
+			}
+			return p.projectIfSlice(node, right)
+		}
+		// Otherwise this is a projection.
+		if err := p.match(tStar); err != nil {
+			return ASTNode{}, err
+		}
+		if err := p.match(tRbracket); err != nil {
+			return ASTNode{}, err
+		}
+		right, err = p.parseProjectionRHS(bindingPowers[tStar])
+		if err != nil {
+			return ASTNode{}, err
+		}
+		return ASTNode{
+			nodeType: ASTProjection,
+			children: []ASTNode{node, right},
+		}, nil
+	}
+	return ASTNode{}, p.syntaxError("Unexpected token: " + tokenType.String())
+}
+
+func (p *Parser) nud(token token) (ASTNode, error) {
+	switch token.tokenType {
+	case tJSONLiteral:
+		var parsed interface{}
+		err := json.Unmarshal([]byte(token.value), &parsed)
+		if err != nil {
+			return ASTNode{}, err
+		}
+		return ASTNode{nodeType: ASTLiteral, value: parsed}, nil
+	case tStringLiteral:
+		return ASTNode{nodeType: ASTLiteral, value: token.value}, nil
+	case tUnquotedIdentifier:
+		return ASTNode{
+			nodeType: ASTField,
+			value:    token.value,
+		}, nil
+	case tQuotedIdentifier:
+		node := ASTNode{nodeType: ASTField, value: token.value}
+		if p.current() == tLparen {
+			return ASTNode{}, p.syntaxErrorToken("Can't have quoted identifier as function name.", token)
+		}
+		return node, nil
+	case tStar:
+		left := ASTNode{nodeType: ASTIdentity}
+		var right ASTNode
+		var err error
+		if p.current() == tRbracket {
+			right = ASTNode{nodeType: ASTIdentity}
+		} else {
+			right, err = p.parseProjectionRHS(bindingPowers[tStar])
+		}
+		return ASTNode{nodeType: ASTValueProjection, children: []ASTNode{left, right}}, err
+	case tFilter:
+		return p.parseFilter(ASTNode{nodeType: ASTIdentity})
+	case tLbrace:
+		return p.parseMultiSelectHash()
+	case tFlatten:
+		left := ASTNode{
+			nodeType: ASTFlatten,
+			children: []ASTNode{{nodeType: ASTIdentity}},
+		}
+		right, err := p.parseProjectionRHS(bindingPowers[tFlatten])
+		if err != nil {
+			return ASTNode{}, err
+		}
+		return ASTNode{nodeType: ASTProjection, children: []ASTNode{left, right}}, nil
+	case tLbracket:
+		tokenType := p.current()
+		//var right ASTNode
+		if tokenType == tNumber || tokenType == tColon {
+			right, err := p.parseIndexExpression()
+			if err != nil {
+				return ASTNode{}, nil
+			}
+			return p.projectIfSlice(ASTNode{nodeType: ASTIdentity}, right)
+		} else if tokenType == tStar && p.lookahead(1) == tRbracket {
+			p.advance()
+			p.advance()
+			right, err := p.parseProjectionRHS(bindingPowers[tStar])
+			if err != nil {
+				return ASTNode{}, err
+			}
+			return ASTNode{
+				nodeType: ASTProjection,
+				children: []ASTNode{{nodeType: ASTIdentity}, right},
+			}, nil
+		} else {
+			return p.parseMultiSelectList()
+		}
+	case tCurrent:
+		return ASTNode{nodeType: ASTCurrentNode}, nil
+	case tExpref:
+		expression, err := p.parseExpression(bindingPowers[tExpref])
+		if err != nil {
+			return ASTNode{}, err
+		}
+		return ASTNode{nodeType: ASTExpRef, children: []ASTNode{expression}}, nil
+	case tNot:
+		expression, err := p.parseExpression(bindingPowers[tNot])
+		if err != nil {
+			return ASTNode{}, err
+		}
+		return ASTNode{nodeType: ASTNotExpression, children: []ASTNode{expression}}, nil
+	case tLparen:
+		expression, err := p.parseExpression(0)
+		if err != nil {
+			return ASTNode{}, err
+		}
+		if err := p.match(tRparen); err != nil {
+			return ASTNode{}, err
+		}
+		return expression, nil
+	case tEOF:
+		return ASTNode{}, p.syntaxErrorToken("Incomplete expression", token)
+	}
+
+	return ASTNode{}, p.syntaxErrorToken("Invalid token: "+token.tokenType.String(), token)
+}
+
+func (p *Parser) parseMultiSelectList() (ASTNode, error) {
+	var expressions []ASTNode
+	for {
+		expression, err := p.parseExpression(0)
+		if err != nil {
+			return ASTNode{}, err
+		}
+		expressions = append(expressions, expression)
+		if p.current() == tRbracket {
+			break
+		}
+		err = p.match(tComma)
+		if err != nil {
+			return ASTNode{}, err
+		}
+	}
+	err := p.match(tRbracket)
+	if err != nil {
+		return ASTNode{}, err
+	}
+	return ASTNode{
+		nodeType: ASTMultiSelectList,
+		children: expressions,
+	}, nil
+}
+
+func (p *Parser) parseMultiSelectHash() (ASTNode, error) {
+	var children []ASTNode
+	for {
+		keyToken := p.lookaheadToken(0)
+		if err := p.match(tUnquotedIdentifier); err != nil {
+			if err := p.match(tQuotedIdentifier); err != nil {
+				return ASTNode{}, p.syntaxError("Expected tQuotedIdentifier or tUnquotedIdentifier")
+			}
+		}
+		keyName := keyToken.value
+		err := p.match(tColon)
+		if err != nil {
+			return ASTNode{}, err
+		}
+		value, err := p.parseExpression(0)
+		if err != nil {
+			return ASTNode{}, err
+		}
+		node := ASTNode{
+			nodeType: ASTKeyValPair,
+			value:    keyName,
+			children: []ASTNode{value},
+		}
+		children = append(children, node)
+		if p.current() == tComma {
+			err := p.match(tComma)
+			if err != nil {
+				return ASTNode{}, nil
+			}
+		} else if p.current() == tRbrace {
+			err := p.match(tRbrace)
+			if err != nil {
+				return ASTNode{}, nil
+			}
+			break
+		}
+	}
+	return ASTNode{
+		nodeType: ASTMultiSelectHash,
+		children: children,
+	}, nil
+}
+
+func (p *Parser) projectIfSlice(left ASTNode, right ASTNode) (ASTNode, error) {
+	indexExpr := ASTNode{
+		nodeType: ASTIndexExpression,
+		children: []ASTNode{left, right},
+	}
+	if right.nodeType == ASTSlice {
+		right, err := p.parseProjectionRHS(bindingPowers[tStar])
+		return ASTNode{
+			nodeType: ASTProjection,
+			children: []ASTNode{indexExpr, right},
+		}, err
+	}
+	return indexExpr, nil
+}
+func (p *Parser) parseFilter(node ASTNode) (ASTNode, error) {
+	var right, condition ASTNode
+	var err error
+	condition, err = p.parseExpression(0)
+	if err != nil {
+		return ASTNode{}, err
+	}
+	if err := p.match(tRbracket); err != nil {
+		return ASTNode{}, err
+	}
+	if p.current() == tFlatten {
+		right = ASTNode{nodeType: ASTIdentity}
+	} else {
+		right, err = p.parseProjectionRHS(bindingPowers[tFilter])
+		if err != nil {
+			return ASTNode{}, err
+		}
+	}
+
+	return ASTNode{
+		nodeType: ASTFilterProjection,
+		children: []ASTNode{node, right, condition},
+	}, nil
+}
+
+func (p *Parser) parseDotRHS(bindingPower int) (ASTNode, error) {
+	lookahead := p.current()
+	if tokensOneOf([]tokType{tQuotedIdentifier, tUnquotedIdentifier, tStar}, lookahead) {
+		return p.parseExpression(bindingPower)
+	} else if lookahead == tLbracket {
+		if err := p.match(tLbracket); err != nil {
+			return ASTNode{}, err
+		}
+		return p.parseMultiSelectList()
+	} else if lookahead == tLbrace {
+		if err := p.match(tLbrace); err != nil {
+			return ASTNode{}, err
+		}
+		return p.parseMultiSelectHash()
+	}
+	return ASTNode{}, p.syntaxError("Expected identifier, lbracket, or lbrace")
+}
+
+func (p *Parser) parseProjectionRHS(bindingPower int) (ASTNode, error) {
+	current := p.current()
+	if bindingPowers[current] < 10 {
+		return ASTNode{nodeType: ASTIdentity}, nil
+	} else if current == tLbracket {
+		return p.parseExpression(bindingPower)
+	} else if current == tFilter {
+		return p.parseExpression(bindingPower)
+	} else if current == tDot {
+		err := p.match(tDot)
+		if err != nil {
+			return ASTNode{}, err
+		}
+		return p.parseDotRHS(bindingPower)
+	} else {
+		return ASTNode{}, p.syntaxError("Error")
+	}
+}
+
+func (p *Parser) lookahead(number int) tokType {
+	return p.lookaheadToken(number).tokenType
+}
+
+func (p *Parser) current() tokType {
+	return p.lookahead(0)
+}
+
+func (p *Parser) lookaheadToken(number int) token {
+	return p.tokens[p.index+number]
+}
+
+func (p *Parser) advance() {
+	p.index++
+}
+
+func tokensOneOf(elements []tokType, token tokType) bool {
+	for _, elem := range elements {
+		if elem == token {
+			return true
+		}
+	}
+	return false
+}
+
+func (p *Parser) syntaxError(msg string) SyntaxError {
+	return SyntaxError{
+		msg:        msg,
+		Expression: p.expression,
+		Offset:     p.lookaheadToken(0).position,
+	}
+}
+
+// Create a SyntaxError based on the provided token.
+// This differs from syntaxError() which creates a SyntaxError
+// based on the current lookahead token.
+func (p *Parser) syntaxErrorToken(msg string, t token) SyntaxError {
+	return SyntaxError{
+		msg:        msg,
+		Expression: p.expression,
+		Offset:     t.position,
+	}
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/parser_test.go b/vendor/github.com/jmespath/go-jmespath/parser_test.go
new file mode 100644
index 00000000..997a0f4d
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/parser_test.go
@@ -0,0 +1,136 @@
+package jmespath
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var parsingErrorTests = []struct {
+	expression string
+	msg        string
+}{
+	{"foo.", "Incopmlete expression"},
+	{"[foo", "Incopmlete expression"},
+	{"]", "Invalid"},
+	{")", "Invalid"},
+	{"}", "Invalid"},
+	{"foo..bar", "Invalid"},
+	{`foo."bar`, "Forwards lexer errors"},
+	{`{foo: bar`, "Incomplete expression"},
+	{`{foo bar}`, "Invalid"},
+	{`[foo bar]`, "Invalid"},
+	{`foo@`, "Invalid"},
+	{`&&&&&&&&&&&&t(`, "Invalid"},
+	{`[*][`, "Invalid"},
+}
+
+func TestParsingErrors(t *testing.T) {
+	assert := assert.New(t)
+	parser := NewParser()
+	for _, tt := range parsingErrorTests {
+		_, err := parser.Parse(tt.expression)
+		assert.NotNil(err, fmt.Sprintf("Expected parsing error: %s, for expression: %s", tt.msg, tt.expression))
+	}
+}
+
+var prettyPrinted = `ASTProjection {
+  children: {
+    ASTField {
+      value: "foo"
+    }
+    ASTSubexpression {
+      children: {
+        ASTSubexpression {
+          children: {
+            ASTField {
+              value: "bar"
+            }
+            ASTField {
+              value: "baz"
+            }
+        }
+        ASTField {
+          value: "qux"
+        }
+    }
+}
+`
+
+var prettyPrintedCompNode = `ASTFilterProjection {
+  children: {
+    ASTField {
+      value: "a"
+    }
+    ASTIdentity {
+    }
+    ASTComparator {
+      value: tLTE
+      children: {
+        ASTField {
+          value: "b"
+        }
+        ASTField {
+          value: "c"
+        }
+    }
+}
+`
+
+func TestPrettyPrintedAST(t *testing.T) {
+	assert := assert.New(t)
+	parser := NewParser()
+	parsed, _ := parser.Parse("foo[*].bar.baz.qux")
+	assert.Equal(parsed.PrettyPrint(0), prettyPrinted)
+}
+
+func TestPrettyPrintedCompNode(t *testing.T) {
+	assert := assert.New(t)
+	parser := NewParser()
+	parsed, _ := parser.Parse("a[?b<=c]")
+	assert.Equal(parsed.PrettyPrint(0), prettyPrintedCompNode)
+}
+
+func BenchmarkParseIdentifier(b *testing.B) {
+	runParseBenchmark(b, exprIdentifier)
+}
+
+func BenchmarkParseSubexpression(b *testing.B) {
+	runParseBenchmark(b, exprSubexpr)
+}
+
+func BenchmarkParseDeeplyNested50(b *testing.B) {
+	runParseBenchmark(b, deeplyNested50)
+}
+
+func BenchmarkParseDeepNested50Pipe(b *testing.B) {
+	runParseBenchmark(b, deeplyNested50Pipe)
+}
+
+func BenchmarkParseDeepNested50Index(b *testing.B) {
+	runParseBenchmark(b, deeplyNested50Index)
+}
+
+func BenchmarkParseQuotedIdentifier(b *testing.B) {
+	runParseBenchmark(b, exprQuotedIdentifier)
+}
+
+func BenchmarkParseQuotedIdentifierEscapes(b *testing.B) {
+	runParseBenchmark(b, quotedIdentifierEscapes)
+}
+
+func BenchmarkParseRawStringLiteral(b *testing.B) {
+	runParseBenchmark(b, rawStringLiteral)
+}
+
+func BenchmarkParseDeepProjection104(b *testing.B) {
+	runParseBenchmark(b, deepProjection104)
+}
+
+func runParseBenchmark(b *testing.B, expression string) {
+	parser := NewParser()
+	for i := 0; i < b.N; i++ {
+		parser.Parse(expression)
+	}
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/toktype_string.go b/vendor/github.com/jmespath/go-jmespath/toktype_string.go
new file mode 100644
index 00000000..dae79cbd
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/toktype_string.go
@@ -0,0 +1,16 @@
+// generated by stringer -type=tokType; DO NOT EDIT
+
+package jmespath
+
+import "fmt"
+
+const _tokType_name = "tUnknowntStartDottFiltertFlattentLparentRparentLbrackettRbrackettLbracetRbracetOrtPipetNumbertUnquotedIdentifiertQuotedIdentifiertCommatColontLTtLTEtGTtGTEtEQtNEtJSONLiteraltStringLiteraltCurrenttExpreftAndtNottEOF"
+
+var _tokType_index = [...]uint8{0, 8, 13, 17, 24, 32, 39, 46, 55, 64, 71, 78, 81, 86, 93, 112, 129, 135, 141, 144, 148, 151, 155, 158, 161, 173, 187, 195, 202, 206, 210, 214}
+
+func (i tokType) String() string {
+	if i < 0 || i >= tokType(len(_tokType_index)-1) {
+		return fmt.Sprintf("tokType(%d)", i)
+	}
+	return _tokType_name[_tokType_index[i]:_tokType_index[i+1]]
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/util.go b/vendor/github.com/jmespath/go-jmespath/util.go
new file mode 100644
index 00000000..ddc1b7d7
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/util.go
@@ -0,0 +1,185 @@
+package jmespath
+
+import (
+	"errors"
+	"reflect"
+)
+
+// IsFalse determines if an object is false based on the JMESPath spec.
+// JMESPath defines false values to be any of:
+// - An empty string array, or hash.
+// - The boolean value false.
+// - nil
+func isFalse(value interface{}) bool {
+	switch v := value.(type) {
+	case bool:
+		return !v
+	case []interface{}:
+		return len(v) == 0
+	case map[string]interface{}:
+		return len(v) == 0
+	case string:
+		return len(v) == 0
+	case nil:
+		return true
+	}
+	// Try the reflection cases before returning false.
+	rv := reflect.ValueOf(value)
+	switch rv.Kind() {
+	case reflect.Struct:
+		// A struct type will never be false, even if
+		// all of its values are the zero type.
+		return false
+	case reflect.Slice, reflect.Map:
+		return rv.Len() == 0
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return true
+		}
+		// If it's a pointer type, we'll try to deref the pointer
+		// and evaluate the pointer value for isFalse.
+		element := rv.Elem()
+		return isFalse(element.Interface())
+	}
+	return false
+}
+
+// ObjsEqual is a generic object equality check.
+// It will take two arbitrary objects and recursively determine
+// if they are equal.
+func objsEqual(left interface{}, right interface{}) bool {
+	return reflect.DeepEqual(left, right)
+}
+
+// SliceParam refers to a single part of a slice.
+// A slice consists of a start, a stop, and a step, similar to
+// python slices.
+type sliceParam struct {
+	N         int
+	Specified bool
+}
+
+// Slice supports [start:stop:step] style slicing that's supported in JMESPath.
+func slice(slice []interface{}, parts []sliceParam) ([]interface{}, error) {
+	computed, err := computeSliceParams(len(slice), parts)
+	if err != nil {
+		return nil, err
+	}
+	start, stop, step := computed[0], computed[1], computed[2]
+	result := []interface{}{}
+	if step > 0 {
+		for i := start; i < stop; i += step {
+			result = append(result, slice[i])
+		}
+	} else {
+		for i := start; i > stop; i += step {
+			result = append(result, slice[i])
+		}
+	}
+	return result, nil
+}
+
+func computeSliceParams(length int, parts []sliceParam) ([]int, error) {
+	var start, stop, step int
+	if !parts[2].Specified {
+		step = 1
+	} else if parts[2].N == 0 {
+		return nil, errors.New("Invalid slice, step cannot be 0")
+	} else {
+		step = parts[2].N
+	}
+	var stepValueNegative bool
+	if step < 0 {
+		stepValueNegative = true
+	} else {
+		stepValueNegative = false
+	}
+
+	if !parts[0].Specified {
+		if stepValueNegative {
+			start = length - 1
+		} else {
+			start = 0
+		}
+	} else {
+		start = capSlice(length, parts[0].N, step)
+	}
+
+	if !parts[1].Specified {
+		if stepValueNegative {
+			stop = -1
+		} else {
+			stop = length
+		}
+	} else {
+		stop = capSlice(length, parts[1].N, step)
+	}
+	return []int{start, stop, step}, nil
+}
+
+func capSlice(length int, actual int, step int) int {
+	if actual < 0 {
+		actual += length
+		if actual < 0 {
+			if step < 0 {
+				actual = -1
+			} else {
+				actual = 0
+			}
+		}
+	} else if actual >= length {
+		if step < 0 {
+			actual = length - 1
+		} else {
+			actual = length
+		}
+	}
+	return actual
+}
+
+// ToArrayNum converts an empty interface type to a slice of float64.
+// If any element in the array cannot be converted, then nil is returned
+// along with a second value of false.
+func toArrayNum(data interface{}) ([]float64, bool) {
+	// Is there a better way to do this with reflect?
+	if d, ok := data.([]interface{}); ok {
+		result := make([]float64, len(d))
+		for i, el := range d {
+			item, ok := el.(float64)
+			if !ok {
+				return nil, false
+			}
+			result[i] = item
+		}
+		return result, true
+	}
+	return nil, false
+}
+
+// ToArrayStr converts an empty interface type to a slice of strings.
+// If any element in the array cannot be converted, then nil is returned
+// along with a second value of false.  If the input data could be entirely
+// converted, then the converted data, along with a second value of true,
+// will be returned.
+func toArrayStr(data interface{}) ([]string, bool) {
+	// Is there a better way to do this with reflect?
+	if d, ok := data.([]interface{}); ok {
+		result := make([]string, len(d))
+		for i, el := range d {
+			item, ok := el.(string)
+			if !ok {
+				return nil, false
+			}
+			result[i] = item
+		}
+		return result, true
+	}
+	return nil, false
+}
+
+func isSliceType(v interface{}) bool {
+	if v == nil {
+		return false
+	}
+	return reflect.TypeOf(v).Kind() == reflect.Slice
+}
diff --git a/vendor/github.com/jmespath/go-jmespath/util_test.go b/vendor/github.com/jmespath/go-jmespath/util_test.go
new file mode 100644
index 00000000..1754b5d3
--- /dev/null
+++ b/vendor/github.com/jmespath/go-jmespath/util_test.go
@@ -0,0 +1,73 @@
+package jmespath
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestSlicePositiveStep(t *testing.T) {
+	assert := assert.New(t)
+	input := make([]interface{}, 5)
+	input[0] = 0
+	input[1] = 1
+	input[2] = 2
+	input[3] = 3
+	input[4] = 4
+	result, err := slice(input, []sliceParam{{0, true}, {3, true}, {1, true}})
+	assert.Nil(err)
+	assert.Equal(input[:3], result)
+}
+
+func TestIsFalseJSONTypes(t *testing.T) {
+	assert := assert.New(t)
+	assert.True(isFalse(false))
+	assert.True(isFalse(""))
+	var empty []interface{}
+	assert.True(isFalse(empty))
+	m := make(map[string]interface{})
+	assert.True(isFalse(m))
+	assert.True(isFalse(nil))
+
+}
+
+func TestIsFalseWithUserDefinedStructs(t *testing.T) {
+	assert := assert.New(t)
+	type nilStructType struct {
+		SliceOfPointers []*string
+	}
+	nilStruct := nilStructType{SliceOfPointers: nil}
+	assert.True(isFalse(nilStruct.SliceOfPointers))
+
+	// A user defined struct will never be false though,
+	// even if it's fields are the zero type.
+	assert.False(isFalse(nilStruct))
+}
+
+func TestIsFalseWithNilInterface(t *testing.T) {
+	assert := assert.New(t)
+	var a *int = nil
+	var nilInterface interface{}
+	nilInterface = a
+	assert.True(isFalse(nilInterface))
+}
+
+func TestIsFalseWithMapOfUserStructs(t *testing.T) {
+	assert := assert.New(t)
+	type foo struct {
+		Bar string
+		Baz string
+	}
+	m := make(map[int]foo)
+	assert.True(isFalse(m))
+}
+
+func TestObjsEqual(t *testing.T) {
+	assert := assert.New(t)
+	assert.True(objsEqual("foo", "foo"))
+	assert.True(objsEqual(20, 20))
+	assert.True(objsEqual([]int{1, 2, 3}, []int{1, 2, 3}))
+	assert.True(objsEqual(nil, nil))
+	assert.True(!objsEqual(nil, "foo"))
+	assert.True(objsEqual([]int{}, []int{}))
+	assert.True(!objsEqual([]int{}, nil))
+}