support dep

Signed-off-by: gaort <rutong.grt@alibaba-inc.com>

Gopkg.lock

@@ -0,0 +1,44 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  name = "github.com/jmespath/go-jmespath"
+  packages = ["."]
+  revision = "3433f3ea46d9f8019119e7dd41274e112a2359a9"
+  version = "0.2.2"
+
+[[projects]]
+  name = "github.com/json-iterator/go"
+  packages = ["."]
+  revision = "f7279a603edee96fe7764d3de9c6ff8cf9970994"
+  version = "1.0.4"
+
+[[projects]]
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  revision = "d8ed2627bdf02c080bf22230dbb337003b7aba2d"
+
+[[projects]]
+  name = "github.com/satori/go.uuid"
+  packages = ["."]
+  revision = "879c5887cd475cd7864858769793b2ceb0d44feb"
+  version = "v1.1.0"
+
+[[projects]]
+  name = "github.com/stretchr/testify"
+  packages = ["assert"]
+  revision = "b91bfb9ebec76498946beb6af7c0230c7cc7ba6c"
+  version = "v1.2.0"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "5efcb858de37371dee78e5421ff3756fafe43502bea86ae16e3ff3bdf2d692f4"
+  solver-name = "gps-cdcl"
+  solver-version = 1

vendor/github.com/stretchr/testify/Gopkg.toml → Gopkg.toml

@@ -1,4 +1,3 @@
-
 # Gopkg.toml example
 #
 # Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
@@ -17,10 +16,31 @@
 #   source = "github.com/myfork/project2"
 #
 # [[override]]
-#  name = "github.com/x/y"
-#  version = "2.4.0"
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
 
 
 [[constraint]]
-  name = "github.com/davecgh/go-spew"
-  version = ">=1.0.0, <=3.0.0-g6d21280"
+  name = "github.com/jmespath/go-jmespath"
+  version = "0.2.2"
+
+[[constraint]]
+  name = "github.com/json-iterator/go"
+  version = "1.0.4"
+
+[[constraint]]
+  name = "github.com/satori/go.uuid"
+  version = "1.1.0"
+
+[[constraint]]
+  name = "github.com/stretchr/testify"
+  version = "1.1.4"
+
+[prune]
+  go-tests = true
+  unused-packages = true

vendor/github.com/jmespath/go-jmespath/compliance/basic.json

@@ -1,96 +0,0 @@
-[{
-    "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"
-         }
-    ]
-}
-]

vendor/github.com/jmespath/go-jmespath/compliance/boolean.json

@@ -1,257 +0,0 @@
-[
-  {
-    "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
-      }
-    ]
-  }
-]

vendor/github.com/jmespath/go-jmespath/compliance/current.json

@@ -1,25 +0,0 @@
-[
-    {
-        "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"}
-            }
-        ]
-    }
-]

vendor/github.com/jmespath/go-jmespath/compliance/escape.json

@@ -1,46 +0,0 @@
-[{
-    "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"
-         }
-     ]
-}]

vendor/github.com/jmespath/go-jmespath/compliance/filters.json

@@ -1,468 +0,0 @@
-[
-  {
-    "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]
-      }
-    ]
-  }
-]

vendor/github.com/jmespath/go-jmespath/compliance/functions.json

@@ -1,825 +0,0 @@
-[{
-  "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]]
-    }
-  ]
-}
-]

vendor/github.com/jmespath/go-jmespath/compliance/identifiers.json

@@ -1,1377 +0,0 @@
-[
-    {
-        "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
-            }
-        ]
-    }
-]

vendor/github.com/jmespath/go-jmespath/compliance/indices.json

@@ -1,346 +0,0 @@
-[{
-    "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
-         }
-     ]
-}
-]

vendor/github.com/jmespath/go-jmespath/compliance/literal.json

@@ -1,185 +0,0 @@
-[
-    {
-        "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"
-        }
-      ]
-    }
-]

vendor/github.com/jmespath/go-jmespath/compliance/multiselect.json

@@ -1,393 +0,0 @@
-[{
-    "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": [[]]
-        }
-    ]
-}
-]

vendor/github.com/jmespath/go-jmespath/compliance/ormatch.json

@@ -1,59 +0,0 @@
-[{
-    "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"
-         }
-     ]
-}]

vendor/github.com/jmespath/go-jmespath/compliance/pipe.json

@@ -1,131 +0,0 @@
-[{
-  "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"}
-    }
-  ]
-}]

vendor/github.com/jmespath/go-jmespath/compliance/slice.json

@@ -1,187 +0,0 @@
-[{
-  "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": []
-    }
-  ]
-}]

vendor/github.com/jmespath/go-jmespath/compliance/syntax.json

@@ -1,616 +0,0 @@
-[{
-  "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]
-        }
-    ]
-  }
-]

vendor/github.com/jmespath/go-jmespath/compliance/unicode.json

@@ -1,38 +0,0 @@
-[
-    {
-        "given": {"foo": [{"✓": "✓"}, {"✓": "✗"}]},
-        "cases": [
-            {
-                "expression": "foo[].\"✓\"",
-                "result": ["✓", "✗"]
-            }
-        ]
-    },
-    {
-        "given": {"☯": true},
-        "cases": [
-            {
-                "expression": "\"☯\"",
-                "result": true
-            }
-        ]
-    },
-    {
-        "given": {"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪": true},
-        "cases": [
-            {
-                "expression": "\"♪♫•*¨*•.¸¸❤¸¸.•*¨*•♫♪\"",
-                "result": true
-            }
-        ]
-    },
-    {
-        "given": {"☃": true},
-        "cases": [
-            {
-                "expression": "\"☃\"",
-                "result": true
-            }
-        ]
-    }
-]

vendor/github.com/jmespath/go-jmespath/compliance/wildcard.json

@@ -1,460 +0,0 @@
-[{
-    "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]
-         }
-     ]
-}
-]

vendor/github.com/jmespath/go-jmespath/compliance_test.go

@@ -1,123 +0,0 @@
-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))
-	}
-}

vendor/github.com/jmespath/go-jmespath/functions.go

@@ -124,197 +124,197 @@ type functionCaller struct {
 func newFunctionCaller() *functionCaller {
 	caller := &functionCaller{}
 	caller.functionTable = map[string]functionEntry{
-		"length": {
+		"length": functionEntry{
 			name: "length",
 			arguments: []argSpec{
-				{types: []jpType{jpString, jpArray, jpObject}},
+				argSpec{types: []jpType{jpString, jpArray, jpObject}},
 			},
 			handler: jpfLength,
 		},
-		"starts_with": {
+		"starts_with": functionEntry{
 			name: "starts_with",
 			arguments: []argSpec{
-				{types: []jpType{jpString}},
-				{types: []jpType{jpString}},
+				argSpec{types: []jpType{jpString}},
+				argSpec{types: []jpType{jpString}},
 			},
 			handler: jpfStartsWith,
 		},
-		"abs": {
+		"abs": functionEntry{
 			name: "abs",
 			arguments: []argSpec{
-				{types: []jpType{jpNumber}},
+				argSpec{types: []jpType{jpNumber}},
 			},
 			handler: jpfAbs,
 		},
-		"avg": {
+		"avg": functionEntry{
 			name: "avg",
 			arguments: []argSpec{
-				{types: []jpType{jpArrayNumber}},
+				argSpec{types: []jpType{jpArrayNumber}},
 			},
 			handler: jpfAvg,
 		},
-		"ceil": {
+		"ceil": functionEntry{
 			name: "ceil",
 			arguments: []argSpec{
-				{types: []jpType{jpNumber}},
+				argSpec{types: []jpType{jpNumber}},
 			},
 			handler: jpfCeil,
 		},
-		"contains": {
+		"contains": functionEntry{
 			name: "contains",
 			arguments: []argSpec{
-				{types: []jpType{jpArray, jpString}},
-				{types: []jpType{jpAny}},
+				argSpec{types: []jpType{jpArray, jpString}},
+				argSpec{types: []jpType{jpAny}},
 			},
 			handler: jpfContains,
 		},
-		"ends_with": {
+		"ends_with": functionEntry{
 			name: "ends_with",
 			arguments: []argSpec{
-				{types: []jpType{jpString}},
-				{types: []jpType{jpString}},
+				argSpec{types: []jpType{jpString}},
+				argSpec{types: []jpType{jpString}},
 			},
 			handler: jpfEndsWith,
 		},
-		"floor": {
+		"floor": functionEntry{
 			name: "floor",
 			arguments: []argSpec{
-				{types: []jpType{jpNumber}},
+				argSpec{types: []jpType{jpNumber}},
 			},
 			handler: jpfFloor,
 		},
-		"map": {
+		"map": functionEntry{
 			name: "amp",
 			arguments: []argSpec{
-				{types: []jpType{jpExpref}},
-				{types: []jpType{jpArray}},
+				argSpec{types: []jpType{jpExpref}},
+				argSpec{types: []jpType{jpArray}},
 			},
 			handler:   jpfMap,
 			hasExpRef: true,
 		},
-		"max": {
+		"max": functionEntry{
 			name: "max",
 			arguments: []argSpec{
-				{types: []jpType{jpArrayNumber, jpArrayString}},
+				argSpec{types: []jpType{jpArrayNumber, jpArrayString}},
 			},
 			handler: jpfMax,
 		},
-		"merge": {
+		"merge": functionEntry{
 			name: "merge",
 			arguments: []argSpec{
-				{types: []jpType{jpObject}, variadic: true},
+				argSpec{types: []jpType{jpObject}, variadic: true},
 			},
 			handler: jpfMerge,
 		},
-		"max_by": {
+		"max_by": functionEntry{
 			name: "max_by",
 			arguments: []argSpec{
-				{types: []jpType{jpArray}},
-				{types: []jpType{jpExpref}},
+				argSpec{types: []jpType{jpArray}},
+				argSpec{types: []jpType{jpExpref}},
 			},
 			handler:   jpfMaxBy,
 			hasExpRef: true,
 		},
-		"sum": {
+		"sum": functionEntry{
 			name: "sum",
 			arguments: []argSpec{
-				{types: []jpType{jpArrayNumber}},
+				argSpec{types: []jpType{jpArrayNumber}},
 			},
 			handler: jpfSum,
 		},
-		"min": {
+		"min": functionEntry{
 			name: "min",
 			arguments: []argSpec{
-				{types: []jpType{jpArrayNumber, jpArrayString}},
+				argSpec{types: []jpType{jpArrayNumber, jpArrayString}},
 			},
 			handler: jpfMin,
 		},
-		"min_by": {
+		"min_by": functionEntry{
 			name: "min_by",
 			arguments: []argSpec{
-				{types: []jpType{jpArray}},
-				{types: []jpType{jpExpref}},
+				argSpec{types: []jpType{jpArray}},
+				argSpec{types: []jpType{jpExpref}},
 			},
 			handler:   jpfMinBy,
 			hasExpRef: true,
 		},
-		"type": {
+		"type": functionEntry{
 			name: "type",
 			arguments: []argSpec{
-				{types: []jpType{jpAny}},
+				argSpec{types: []jpType{jpAny}},
 			},
 			handler: jpfType,
 		},
-		"keys": {
+		"keys": functionEntry{
 			name: "keys",
 			arguments: []argSpec{
-				{types: []jpType{jpObject}},
+				argSpec{types: []jpType{jpObject}},
 			},
 			handler: jpfKeys,
 		},
-		"values": {
+		"values": functionEntry{
 			name: "values",
 			arguments: []argSpec{
-				{types: []jpType{jpObject}},
+				argSpec{types: []jpType{jpObject}},
 			},
 			handler: jpfValues,
 		},
-		"sort": {
+		"sort": functionEntry{
 			name: "sort",
 			arguments: []argSpec{
-				{types: []jpType{jpArrayString, jpArrayNumber}},
+				argSpec{types: []jpType{jpArrayString, jpArrayNumber}},
 			},
 			handler: jpfSort,
 		},
-		"sort_by": {
+		"sort_by": functionEntry{
 			name: "sort_by",
 			arguments: []argSpec{
-				{types: []jpType{jpArray}},
-				{types: []jpType{jpExpref}},
+				argSpec{types: []jpType{jpArray}},
+				argSpec{types: []jpType{jpExpref}},
 			},
 			handler:   jpfSortBy,
 			hasExpRef: true,
 		},
-		"join": {
+		"join": functionEntry{
 			name: "join",
 			arguments: []argSpec{
-				{types: []jpType{jpString}},
-				{types: []jpType{jpArrayString}},
+				argSpec{types: []jpType{jpString}},
+				argSpec{types: []jpType{jpArrayString}},
 			},
 			handler: jpfJoin,
 		},
-		"reverse": {
+		"reverse": functionEntry{
 			name: "reverse",
 			arguments: []argSpec{
-				{types: []jpType{jpArray, jpString}},
+				argSpec{types: []jpType{jpArray, jpString}},
 			},
 			handler: jpfReverse,
 		},
-		"to_array": {
+		"to_array": functionEntry{
 			name: "to_array",
 			arguments: []argSpec{
-				{types: []jpType{jpAny}},
+				argSpec{types: []jpType{jpAny}},
 			},
 			handler: jpfToArray,
 		},
-		"to_string": {
+		"to_string": functionEntry{
 			name: "to_string",
 			arguments: []argSpec{
-				{types: []jpType{jpAny}},
+				argSpec{types: []jpType{jpAny}},
 			},
 			handler: jpfToString,
 		},
-		"to_number": {
+		"to_number": functionEntry{
 			name: "to_number",
 			arguments: []argSpec{
-				{types: []jpType{jpAny}},
+				argSpec{types: []jpType{jpAny}},
 			},
 			handler: jpfToNumber,
 		},
-		"not_null": {
+		"not_null": functionEntry{
 			name: "not_null",
 			arguments: []argSpec{
-				{types: []jpType{jpAny}, variadic: true},
+				argSpec{types: []jpType{jpAny}, variadic: true},
 			},
 			handler: jpfNotNull,
 		},

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-1

@@ -1 +0,0 @@
-foo

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-10

@@ -1 +0,0 @@
-foo.bar

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-100

@@ -1 +0,0 @@
-ends_with(str, 'SStr')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-101

@@ -1 +0,0 @@
-ends_with(str, 'foo')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-102

@@ -1 +0,0 @@
-floor(`1.2`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-103

@@ -1 +0,0 @@
-floor(decimals[0])

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-104

@@ -1 +0,0 @@
-floor(foo)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-105

@@ -1 +0,0 @@
-length('abc')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-106

@@ -1 +0,0 @@
-length('')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-107

@@ -1 +0,0 @@
-length(@)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-108

@@ -1 +0,0 @@
-length(strings[0])

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-109

@@ -1 +0,0 @@
-length(str)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-110

@@ -1 +0,0 @@
-length(array)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-112

@@ -1 +0,0 @@
-length(strings[0])

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-115

@@ -1 +0,0 @@
-max(strings)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-118

@@ -1 +0,0 @@
-merge(`{}`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-119

@@ -1 +0,0 @@
-merge(`{}`, `{}`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-12

@@ -1 +0,0 @@
-two

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-120

@@ -1 +0,0 @@
-merge(`{"a": 1}`, `{"b": 2}`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-121

@@ -1 +0,0 @@
-merge(`{"a": 1}`, `{"a": 2}`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-122

@@ -1 +0,0 @@
-merge(`{"a": 1, "b": 2}`, `{"a": 2, "c": 3}`, `{"d": 4}`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-123

@@ -1 +0,0 @@
-min(numbers)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-126

@@ -1 +0,0 @@
-min(decimals)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-128

@@ -1 +0,0 @@
-type('abc')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-129

@@ -1 +0,0 @@
-type(`1.0`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-13

@@ -1 +0,0 @@
-three

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-130

@@ -1 +0,0 @@
-type(`2`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-131

@@ -1 +0,0 @@
-type(`true`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-132

@@ -1 +0,0 @@
-type(`false`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-133

@@ -1 +0,0 @@
-type(`null`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-134

@@ -1 +0,0 @@
-type(`[0]`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-135

@@ -1 +0,0 @@
-type(`{"a": "b"}`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-136

@@ -1 +0,0 @@
-type(@)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-137

@@ -1 +0,0 @@
-keys(objects)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-138

@@ -1 +0,0 @@
-values(objects)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-139

@@ -1 +0,0 @@
-keys(empty_hash)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-14

@@ -1 +0,0 @@
-one.two

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-140

@@ -1 +0,0 @@
-join(', ', strings)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-141

@@ -1 +0,0 @@
-join(', ', strings)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-142

@@ -1 +0,0 @@
-join(',', `["a", "b"]`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-143

@@ -1 +0,0 @@
-join('|', strings)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-144

@@ -1 +0,0 @@
-join('|', decimals[].to_string(@))

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-145

@@ -1 +0,0 @@
-join('|', empty_list)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-146

@@ -1 +0,0 @@
-reverse(numbers)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-147

@@ -1 +0,0 @@
-reverse(array)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-148

@@ -1 +0,0 @@
-reverse(`[]`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-149

@@ -1 +0,0 @@
-reverse('')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-15

@@ -1 +0,0 @@
-foo."1"

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-150

@@ -1 +0,0 @@
-reverse('hello world')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-151

@@ -1 +0,0 @@
-starts_with(str, 'S')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-152

@@ -1 +0,0 @@
-starts_with(str, 'St')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-153

@@ -1 +0,0 @@
-starts_with(str, 'Str')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-155

@@ -1 +0,0 @@
-sum(numbers)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-156

@@ -1 +0,0 @@
-sum(decimals)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-157

@@ -1 +0,0 @@
-sum(array[].to_number(@))

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-158

@@ -1 +0,0 @@
-sum(`[]`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-159

@@ -1 +0,0 @@
-to_array('foo')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-16

@@ -1 +0,0 @@
-foo."1"[0]

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-160

@@ -1 +0,0 @@
-to_array(`0`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-161

@@ -1 +0,0 @@
-to_array(objects)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-162

@@ -1 +0,0 @@
-to_array(`[1, 2, 3]`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-163

@@ -1 +0,0 @@
-to_array(false)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-164

@@ -1 +0,0 @@
-to_string('foo')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-165

@@ -1 +0,0 @@
-to_string(`1.2`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-166

@@ -1 +0,0 @@
-to_string(`[0, 1]`)

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-167

@@ -1 +0,0 @@
-to_number('1.0')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-168

@@ -1 +0,0 @@
-to_number('1.1')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-169

@@ -1 +0,0 @@
-to_number('4')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-17

@@ -1 +0,0 @@
-foo."-1"

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-170

@@ -1 +0,0 @@
-to_number('notanumber')

vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-171

@@ -1 +0,0 @@
-to_number(`false`)