feat: connect to spicedb

11 files changed, 1716 insertions, 0 deletions

diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/.yamllint b/vendor/github.com/jzelinskie/cobrautil/v2/.yamllint
new file mode 100644
index 0000000..9c1e7e3
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/.yamllint
@@ -0,0 +1,10 @@
+# vim: ft=yaml
+---
+yaml-files:
+  - "*.yaml"
+  - "*.yml"
+  - ".yamllint"
+extends: "default"
+rules:
+  quoted-strings: "enable"
+  line-length: "disable"
diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/LICENSE b/vendor/github.com/jzelinskie/cobrautil/v2/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/README.md b/vendor/github.com/jzelinskie/cobrautil/v2/README.md
new file mode 100644
index 0000000..9c8af5e
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/README.md
@@ -0,0 +1,14 @@
+# cobrautil
+
+A collection of utility functions when using [Cobra].
+
+Features include:
+
+- Synchronizing [Viper] environment variables
+- "Must" functions to fetch flags and panic if they do not exist
+- Middleware chaining of cobra.Command RunFuncs
+
+[Cobra]: https://github.com/spf13/cobra
+[Viper]: https://github.com/spf13/viper
+
+[See some examples in the documentation.](https://pkg.go.dev/github.com/jzelinskie/cobrautil#pkg-examples)
diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/cobrautil.go b/vendor/github.com/jzelinskie/cobrautil/v2/cobrautil.go
new file mode 100644
index 0000000..4e73e85
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/cobrautil.go
@@ -0,0 +1,93 @@
+package cobrautil
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/go-logr/logr"
+	"github.com/joho/godotenv"
+	"github.com/jzelinskie/stringz"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
+)
+
+// IsBuiltinCommand checks against a hard-coded list of the names of commands
+// that cobra provides out-of-the-box.
+func IsBuiltinCommand(cmd *cobra.Command) bool {
+	return stringz.SliceContains([]string{
+		"help [command]",
+		"completion [command]",
+	},
+		cmd.Use,
+	)
+}
+
+// SyncViperPreRunE returns a CobraRunFunc that synchronizes Viper environment
+// flags with the provided prefix.
+//
+// Thanks to Carolyn Van Slyck: https://github.com/carolynvs/stingoftheviper
+func SyncViperPreRunE(prefix string) CobraRunFunc {
+	prefix = strings.ReplaceAll(strings.ToUpper(prefix), "-", "_")
+	return func(cmd *cobra.Command, args []string) error {
+		if IsBuiltinCommand(cmd) {
+			return nil // No-op for builtins
+		}
+
+		v := viper.New()
+		v.AllowEmptyEnv(true)
+		viper.SetEnvPrefix(prefix)
+
+		cmd.Flags().VisitAll(func(f *pflag.Flag) {
+			suffix := strings.ToUpper(strings.ReplaceAll(f.Name, "-", "_"))
+			_ = v.BindEnv(f.Name, prefix+"_"+suffix)
+
+			if !f.Changed && v.IsSet(f.Name) {
+				val := v.Get(f.Name)
+				_ = cmd.Flags().Set(f.Name, fmt.Sprintf("%v", val))
+			}
+		})
+
+		return nil
+	}
+}
+
+// SyncViperDotEnvPreRunE returns a CobraRunFunc that loads a .dotenv file
+// before synchronizing Viper environment flags with the provided prefix.
+//
+// If empty, envfilePath defaults to ".env".
+// The .dotenv file is loaded first before any additional Viper behavior.
+func SyncViperDotEnvPreRunE(prefix, envfilePath string, l logr.Logger) CobraRunFunc {
+	if err := godotenv.Load(stringz.DefaultEmpty(envfilePath, ".env")); err != nil {
+		l.V(2).Info(
+			"skipped loading dotenv",
+			"path", envfilePath,
+			"err", err,
+		)
+	}
+	return SyncViperPreRunE(prefix)
+}
+
+// CobraRunFunc is the signature of cobra.Command RunFuncs.
+type CobraRunFunc func(cmd *cobra.Command, args []string) error
+
+// CommandStack chains together a collection of CobraCommandFuncs into one.
+func CommandStack(cmdfns ...CobraRunFunc) CobraRunFunc {
+	return func(cmd *cobra.Command, args []string) error {
+		for _, cmdfn := range cmdfns {
+			if err := cmdfn(cmd, args); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+}
+
+// PrefixJoiner joins a list of strings with the "-" separator, including the provided prefix string
+//
+// example: PrefixJoiner("hi")("how", "are", "you") = "hi-how-are-you"
+func PrefixJoiner(prefix string) func(...string) string {
+	return func(xs ...string) string {
+		return stringz.Join("-", append([]string{prefix}, xs...)...)
+	}
+}
diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/cobrazerolog/cobrazerolog.go b/vendor/github.com/jzelinskie/cobrautil/v2/cobrazerolog/cobrazerolog.go
new file mode 100644
index 0000000..04d2cb0
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/cobrazerolog/cobrazerolog.go
@@ -0,0 +1,172 @@
+// Package cobrahttp implements a builder for registering flags and producing
+// a Cobra RunFunc that configures Zerolog.
+package cobrazerolog
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/jzelinskie/cobrautil/v2"
+	"github.com/mattn/go-isatty"
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/diode"
+	"github.com/rs/zerolog/log"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// Option is function used to configure Zerolog within a Cobra RunFunc.
+type Option func(*Builder)
+
+// New creates a Cobra RunFunc Builder for ZeroLog.
+func New(opts ...Option) *Builder {
+	b := &Builder{
+		flagPrefix:  "log",
+		preRunLevel: zerolog.InfoLevel,
+	}
+
+	for _, configure := range opts {
+		configure(b)
+	}
+	return b
+}
+
+// Builder is used to configure Zerolog via Cobra.
+type Builder struct {
+	flagPrefix        string
+	target            func(zerolog.Logger)
+	async             bool
+	asyncSize         int
+	asyncPollInterval time.Duration
+	preRunLevel       zerolog.Level
+}
+
+func (b *Builder) prefix(s string) string {
+	return cobrautil.PrefixJoiner(b.flagPrefix)(s)
+}
+
+// RegisterFlags adds flags for configuring Zerolog.
+//
+// The following flags are added:
+// - "$PREFIX-level"
+// - "$PREFIX-format"
+func (b *Builder) RegisterFlags(flags *pflag.FlagSet) {
+	flags.String(b.prefix("level"), "info", `verbosity of logging ("trace", "debug", "info", "warn", "error")`)
+	flags.String(b.prefix("format"), "auto", `format of logs ("auto", "console", "json")`)
+}
+
+// RegisterFlagCompletion adds completion functions supported flags.
+//
+// The following flags are completed:
+// - "$PREFIX-level"
+// - "$PREFIX-format"
+func (b *Builder) RegisterFlagCompletion(cmd *cobra.Command) error {
+	if err := cmd.RegisterFlagCompletionFunc(b.prefix("level"), func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return []string{"trace", "debug", "info", "warn", "error"}, cobra.ShellCompDirectiveDefault
+	}); err != nil {
+		return err
+	}
+
+	if err := cmd.RegisterFlagCompletionFunc(b.prefix("format"), func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return []string{"auto", "console", "json"}, cobra.ShellCompDirectiveDefault
+	}); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// RunE returns a Cobra RunFunc that configures Zerolog.
+//
+// The required flags can be added to a command by using RegisterFlags().
+func (b *Builder) RunE() cobrautil.CobraRunFunc {
+	return func(cmd *cobra.Command, args []string) error {
+		if cobrautil.IsBuiltinCommand(cmd) {
+			return nil // No-op for builtins
+		}
+
+		var output io.Writer
+
+		format := cobrautil.MustGetString(cmd, b.prefix("format"))
+		if format == "console" || format == "auto" && isatty.IsTerminal(os.Stdout.Fd()) {
+			output = zerolog.ConsoleWriter{Out: os.Stderr}
+		} else {
+			output = os.Stderr
+		}
+
+		if b.async {
+			output = diode.NewWriter(output, 1000, 10*time.Millisecond, func(missed int) {
+				fmt.Printf("Logger Dropped %d messages", missed)
+			})
+		}
+
+		l := zerolog.New(output).With().Timestamp().Logger()
+
+		level := strings.ToLower(cobrautil.MustGetString(cmd, b.prefix("level")))
+		switch level {
+		case "trace":
+			l = l.Level(zerolog.TraceLevel)
+		case "debug":
+			l = l.Level(zerolog.DebugLevel)
+		case "info":
+			l = l.Level(zerolog.InfoLevel)
+		case "warn":
+			l = l.Level(zerolog.WarnLevel)
+		case "error":
+			l = l.Level(zerolog.ErrorLevel)
+		case "fatal":
+			l = l.Level(zerolog.FatalLevel)
+		case "panic":
+			l = l.Level(zerolog.PanicLevel)
+		default:
+			return fmt.Errorf("unknown log level: %s", level)
+		}
+
+		if b.target != nil {
+			b.target(l)
+		} else {
+			log.Logger = l
+		}
+
+		l.WithLevel(b.preRunLevel).
+			Str("format", format).
+			Str("log_level", level).
+			Str("provider", "zerolog").
+			Bool("async", b.async).
+			Msg("configured logging")
+		return nil
+	}
+}
+
+// WithFlagPrefix defines prefix used with the generated flags.
+// Defaults to "log".
+func WithFlagPrefix(flagPrefix string) Option {
+	return func(b *Builder) { b.flagPrefix = flagPrefix }
+}
+
+// WithPreRunLevel defines the logging level used for pre-run log messages.
+// Defaults to "debug".
+func WithPreRunLevel(preRunLevel zerolog.Level) Option {
+	return func(b *Builder) { b.preRunLevel = preRunLevel }
+}
+
+// WithAsync enables non-blocking logging.
+//
+// Size of the buffer and polling interval can be configured.
+// Disabled by default.
+func WithAsync(size int, pollInterval time.Duration) Option {
+	return func(b *Builder) {
+		b.async = true
+		b.asyncSize = size
+		b.asyncPollInterval = pollInterval
+	}
+}
+
+// WithTarget callback that forwards the configured logger.
+// Useful when we want to keep it in a global variable.
+func WithTarget(fn func(zerolog.Logger)) Option {
+	return func(b *Builder) { b.target = fn }
+}
diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/must.go b/vendor/github.com/jzelinskie/cobrautil/v2/must.go
new file mode 100644
index 0000000..0c9d1c7
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/must.go
@@ -0,0 +1,365 @@
+package cobrautil
+
+import (
+	"net"
+	"os"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+// MustGetStringExpanded returns the string value of a flag with the given name,
+// calls os.Expand on it, and panics if that flag was never defined.
+func MustGetStringExpanded(cmd *cobra.Command, name string) string {
+	return os.ExpandEnv(MustGetString(cmd, name))
+}
+
+// MustGetBool returns the bool value of a flag with the given name and panics
+// if that flag was never defined.
+func MustGetBool(cmd *cobra.Command, name string) bool {
+	value, err := cmd.Flags().GetBool(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetBoolSlice returns the []bool value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetBoolSlice(cmd *cobra.Command, name string) []bool {
+	value, err := cmd.Flags().GetBoolSlice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetBytesBase64 returns the []byte value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetBytesBase64(cmd *cobra.Command, name string) []byte {
+	value, err := cmd.Flags().GetBytesBase64(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetBytesHex returns the []byte value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetBytesHex(cmd *cobra.Command, name string) []byte {
+	value, err := cmd.Flags().GetBytesHex(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetCount returns the int value of a flag with the given name and panics
+// if that flag was never defined.
+func MustGetCount(cmd *cobra.Command, name string) int {
+	value, err := cmd.Flags().GetCount(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetDuration returns the time.Duration of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetDuration(cmd *cobra.Command, name string) time.Duration {
+	value, err := cmd.Flags().GetDuration(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetDurationSlice returns the []time.Duration of a flag with the given
+// name and panics if that flag was never defined.
+func MustGetDurationSlice(cmd *cobra.Command, name string) []time.Duration {
+	value, err := cmd.Flags().GetDurationSlice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetFloat32 returns the float32 value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetFloat32(cmd *cobra.Command, name string) float32 {
+	value, err := cmd.Flags().GetFloat32(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetFloat32Slice returns the []float32 value of a flag with the given name
+// and panics if that flag was never defined.
+func MustGetFloat32Slice(cmd *cobra.Command, name string) []float32 {
+	value, err := cmd.Flags().GetFloat32Slice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetFloat64 returns the float64 value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetFloat64(cmd *cobra.Command, name string) float64 {
+	value, err := cmd.Flags().GetFloat64(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetFloat64Slice returns the []float64 value of a flag with the given name
+// and panics if that flag was never defined.
+func MustGetFloat64Slice(cmd *cobra.Command, name string) []float64 {
+	value, err := cmd.Flags().GetFloat64Slice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetIP returns the net.IP value of a flag with the given name and panics
+// if that flag was never defined.
+func MustGetIP(cmd *cobra.Command, name string) net.IP {
+	value, err := cmd.Flags().GetIP(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetIPNet returns the net.IPNet value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetIPNet(cmd *cobra.Command, name string) net.IPNet {
+	value, err := cmd.Flags().GetIPNet(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetIPSlice returns the []net.IP value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetIPSlice(cmd *cobra.Command, name string) []net.IP {
+	value, err := cmd.Flags().GetIPSlice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetIPv4Mask returns the net.IPMask value of a flag with the given name
+// and panics if that flag was never defined.
+func MustGetIPv4Mask(cmd *cobra.Command, name string) net.IPMask {
+	value, err := cmd.Flags().GetIPv4Mask(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetInt returns the int value of a flag with the given name and panics if
+// that flag was never defined.
+func MustGetInt(cmd *cobra.Command, name string) int {
+	value, err := cmd.Flags().GetInt(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetInt16 returns the int16 value of a flag with the given name and panics if
+// that flag was never defined.
+func MustGetInt16(cmd *cobra.Command, name string) int16 {
+	value, err := cmd.Flags().GetInt16(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetInt32 returns the int32 value of a flag with the given name and panics if
+// that flag was never defined.
+func MustGetInt32(cmd *cobra.Command, name string) int32 {
+	value, err := cmd.Flags().GetInt32(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetInt32Slice returns the []int32 value of a flag with the given name and panics if
+// that flag was never defined.
+func MustGetInt32Slice(cmd *cobra.Command, name string) []int32 {
+	value, err := cmd.Flags().GetInt32Slice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetInt64 returns the int64 value of a flag with the given name and panics
+// if that flag was never defined.
+func MustGetInt64(cmd *cobra.Command, name string) int64 {
+	value, err := cmd.Flags().GetInt64(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetInt64Slice returns the []int64 value of a flag with the given name and panics if
+// that flag was never defined.
+func MustGetInt64Slice(cmd *cobra.Command, name string) []int64 {
+	value, err := cmd.Flags().GetInt64Slice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetInt8 returns the int8 value of a flag with the given name and panics
+// if that flag was never defined.
+func MustGetInt8(cmd *cobra.Command, name string) int8 {
+	value, err := cmd.Flags().GetInt8(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetIntSlice returns the []int value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetIntSlice(cmd *cobra.Command, name string) []int {
+	value, err := cmd.Flags().GetIntSlice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetString returns the string value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetString(cmd *cobra.Command, name string) string {
+	value, err := cmd.Flags().GetString(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetStringSlice returns the []string value of a flag with the given name
+// and panics if that flag was never defined.
+func MustGetStringSlice(cmd *cobra.Command, name string) []string {
+	value, err := cmd.Flags().GetStringSlice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetStringSlice returns the []string value of a flag with the given name,
+// calls os.ExpandEnv on values, and panics if that flag was never defined.
+func MustGetStringSliceExpanded(cmd *cobra.Command, name string) []string {
+	slice := MustGetStringSlice(cmd, name)
+	for i, str := range slice {
+		slice[i] = os.ExpandEnv(str)
+	}
+	return slice
+}
+
+// MustGetStringToInt returns the map[string]int value of a flag with the given
+// name and panics if that flag was never defined.
+func MustGetStringToInt(cmd *cobra.Command, name string) map[string]int {
+	value, err := cmd.Flags().GetStringToInt(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetStringToInt64 returns the map[string]int64 value of a flag with the
+// given name and panics if that flag was never defined.
+func MustGetStringToInt64(cmd *cobra.Command, name string) map[string]int64 {
+	value, err := cmd.Flags().GetStringToInt64(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetStringToString returns the map[string]string value of a flag with the
+// given name and panics if that flag was never defined.
+func MustGetStringToString(cmd *cobra.Command, name string) map[string]string {
+	value, err := cmd.Flags().GetStringToString(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetUint returns the uint value of a flag with the given name and panics
+// if that flag was never defined.
+func MustGetUint(cmd *cobra.Command, name string) uint {
+	value, err := cmd.Flags().GetUint(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetUint16 returns the uint16 value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetUint16(cmd *cobra.Command, name string) uint16 {
+	value, err := cmd.Flags().GetUint16(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetUint32 returns the uint32 value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetUint32(cmd *cobra.Command, name string) uint32 {
+	value, err := cmd.Flags().GetUint32(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetUint64 returns the uint64 value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetUint64(cmd *cobra.Command, name string) uint64 {
+	value, err := cmd.Flags().GetUint64(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetUint8 returns the uint8 value of a flag with the given name and panics
+// if that flag was never defined.
+func MustGetUint8(cmd *cobra.Command, name string) uint8 {
+	value, err := cmd.Flags().GetUint8(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
+
+// MustGetUintSlice returns the []uint value of a flag with the given name and
+// panics if that flag was never defined.
+func MustGetUintSlice(cmd *cobra.Command, name string) []uint {
+	value, err := cmd.Flags().GetUintSlice(name)
+	if err != nil {
+		panic("failed to find cobra flag: " + name)
+	}
+	return value
+}
diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/namedflagsets.go b/vendor/github.com/jzelinskie/cobrautil/v2/namedflagsets.go
new file mode 100644
index 0000000..5cfc3df
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/namedflagsets.go
@@ -0,0 +1,169 @@
+package cobrautil
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"math/rand"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+// MarkFlagsHidden is a convenient way to mark flags as hidden in bulk.
+func MarkFlagsHidden(flags *pflag.FlagSet, names ...string) error {
+	for _, name := range names {
+		if err := flags.MarkHidden(name); err != nil {
+			return fmt.Errorf("failed to mark flag as hidden: %w", err)
+		}
+	}
+	return nil
+}
+
+// NewNamedFlagSets creates a new NamedFlagSets and registers it with the
+// provided command.
+func NewNamedFlagSets(cmd *cobra.Command) *NamedFlagSets {
+	nfs := &NamedFlagSets{}
+	nfs.SetUsageTemplate(cmd)
+	return nfs
+}
+
+// SetUsageTemplate overrides the cobra usage template to include the
+// named flags sections.
+func (nfs *NamedFlagSets) SetUsageTemplate(cmd *cobra.Command) {
+	cobra.AddTemplateFunc(nfs.templateFuncName(), nfs.templateFunc)
+	cmd.SetUsageTemplate(nfs.usageTemplate())
+}
+
+// NamedFlagSets stores named flag sets in the order of calling FlagSet.
+//
+// This type is largely adapted from [k8s.io/component-base/cli/flag], but
+// modified to be less brittle by integrating with cobra's templates rather
+// than entirely overriding UsageFuncs and HelpFuncs.
+type NamedFlagSets struct {
+	// Order is an ordered list of flag set names.
+	Order []string
+
+	// FlagSets stores the flag sets by name.
+	FlagSets map[string]*pflag.FlagSet
+
+	// NormalizeNameFunc is the normalize function which used to initialize
+	// FlagSets created by NamedFlagSets.
+	NormalizeNameFunc func(f *pflag.FlagSet, name string) pflag.NormalizedName
+
+	uniqueID int
+}
+
+// templateFuncName generates a random template name so that template, which
+// has to be registered globally, isn't overridden by any other NamedFlagSets.
+func (nfs *NamedFlagSets) templateFuncName() string {
+	if nfs.uniqueID == 0 {
+		nfs.uniqueID = rand.Int()
+	}
+	return fmt.Sprintf("namedFlagSets%d", nfs.uniqueID)
+}
+
+func hasVisibleFlags(flags *pflag.FlagSet) bool {
+	var found bool
+	flags.VisitAll(func(flag *pflag.Flag) {
+		if !flag.Hidden {
+			found = true
+		}
+	})
+	return found
+}
+
+func (nfs *NamedFlagSets) AddFlagSets(cmd *cobra.Command) {
+	for _, name := range nfs.Order {
+		cmd.Flags().AddFlagSet(nfs.FlagSet(name))
+	}
+}
+
+// FlagSet returns the flag set with the given name and adds it to the
+// ordered name list if it is not in there yet.
+func (nfs *NamedFlagSets) FlagSet(name string) *pflag.FlagSet {
+	if nfs.FlagSets == nil {
+		nfs.FlagSets = map[string]*pflag.FlagSet{}
+	}
+	if _, ok := nfs.FlagSets[name]; !ok {
+		flagSet := pflag.NewFlagSet(name, pflag.ExitOnError)
+		flagSet.SetNormalizeFunc(pflag.CommandLine.GetNormalizeFunc())
+		if nfs.NormalizeNameFunc != nil {
+			flagSet.SetNormalizeFunc(nfs.NormalizeNameFunc)
+		}
+		nfs.FlagSets[name] = flagSet
+		nfs.Order = append(nfs.Order, name)
+	}
+	return nfs.FlagSets[name]
+}
+
+// printSections prints the given names flag sets in sections, with the maximal
+// given column number.
+//
+// If cols is zero, lines are not wrapped.
+func (nfs *NamedFlagSets) printSections(w io.Writer, cols int) {
+	for _, name := range nfs.Order {
+		fs := nfs.FlagSets[name]
+		if !hasVisibleFlags(fs) {
+			continue
+		}
+
+		wideFS := pflag.NewFlagSet("", pflag.ExitOnError)
+		wideFS.AddFlagSet(fs)
+
+		var zzz string
+		if cols > 24 {
+			zzz = strings.Repeat("z", cols-24)
+			wideFS.Int(zzz, 0, strings.Repeat("z", cols-24))
+		}
+
+		var buf bytes.Buffer
+		fmt.Fprintf(&buf, "\n%s Flags:\n%s", name, wideFS.FlagUsagesWrapped(cols))
+
+		if cols > 24 {
+			i := strings.Index(buf.String(), zzz)
+			lines := strings.Split(buf.String()[:i], "\n")
+			fmt.Fprint(w, strings.Join(lines[:len(lines)-1], "\n"))
+			fmt.Fprintln(w)
+		} else {
+			fmt.Fprint(w, buf.String())
+		}
+	}
+}
+
+func (nfs *NamedFlagSets) templateFunc() string {
+	var b strings.Builder
+	nfs.printSections(&b, 0)
+	return b.String()
+}
+
+func (nfs *NamedFlagSets) usageTemplate() string {
+	return `Usage:{{if .Runnable}}
+  {{.UseLine}}{{end}}{{if .HasAvailableSubCommands}}
+  {{.CommandPath}} [command]{{end}}{{if gt (len .Aliases) 0}}
+
+Aliases:
+  {{.NameAndAliases}}{{end}}{{if .HasExample}}
+
+Examples:
+{{.Example}}{{end}}{{if .HasAvailableSubCommands}}{{$cmds := .Commands}}{{if eq (len .Groups) 0}}
+
+Available Commands:{{range $cmds}}{{if (or .IsAvailableCommand (eq .Name "help"))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{else}}{{range $group := .Groups}}
+
+{{.Title}}{{range $cmds}}{{if (and (eq .GroupID $group.ID) (or .IsAvailableCommand (eq .Name "help")))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{if not .AllChildCommandsHaveGroup}}
+
+Additional Commands:{{range $cmds}}{{if (and (eq .GroupID "") (or .IsAvailableCommand (eq .Name "help")))}}
+  {{rpad .Name .NamePadding }} {{.Short}}{{end}}{{end}}{{end}}{{end}}{{end}}{{if .HasAvailableLocalFlags}}
+{{` + nfs.templateFuncName() + `}}
+Global Flags:
+{{.InheritedFlags.FlagUsages | trimTrailingWhitespaces}}{{end}}{{if .HasHelpSubCommands}}
+
+Additional help topics:{{range .Commands}}{{if .IsAdditionalHelpTopicCommand}}
+  {{rpad .CommandPath .CommandPathPadding}} {{.Short}}{{end}}{{end}}{{end}}{{if .HasAvailableSubCommands}}
+
+Use "{{.CommandPath}} [command] --help" for more information about a command.{{end}}
+`
+}
diff --git a/vendor/github.com/jzelinskie/cobrautil/v2/version.go b/vendor/github.com/jzelinskie/cobrautil/v2/version.go
new file mode 100644
index 0000000..4ac473a
--- /dev/null
+++ b/vendor/github.com/jzelinskie/cobrautil/v2/version.go
@@ -0,0 +1,88 @@
+package cobrautil
+
+import (
+	"fmt"
+	"runtime"
+	"runtime/debug"
+	"strings"
+
+	"github.com/jzelinskie/stringz"
+	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+)
+
+func findBuildSetting(bi *debug.BuildInfo, key string) string {
+	for _, setting := range bi.Settings {
+		if setting.Key == key {
+			return setting.Value
+		}
+	}
+	return ""
+}
+
+func vcsRevision(bi *debug.BuildInfo) string {
+	revision := findBuildSetting(bi, "vcs.revision")
+	if revision == "" {
+		return ""
+	}
+
+	revision = revision[:12] // Short SHA
+
+	if findBuildSetting(bi, "vcs.modified") == "true" {
+		revision = revision + "-dirty"
+	}
+
+	return revision
+}
+
+// Version is variable that holds program's version string.
+// This should be set with the follow flags to the `go build` command:
+// -ldflags '-X github.com/jzelinskie/cobrautil.Version=$YOUR_VERSION_HERE'
+var Version string
+
+// VersionWithFallbacks returns a string of the program version.
+// If the version wasn't set by ldflags, falls back to the VCS revision, and
+// finally Go module version.
+func VersionWithFallbacks(bi *debug.BuildInfo) string {
+	return stringz.DefaultEmpty(stringz.DefaultEmpty(Version, vcsRevision(bi)), bi.Main.Version)
+}
+
+// UsageVersion introspects the process debug data for Go modules to return a
+// version string.
+func UsageVersion(programName string, includeDeps bool) string {
+	bi, ok := debug.ReadBuildInfo()
+	if !ok {
+		panic("failed to read BuildInfo because the program was compiled with Go " + runtime.Version())
+	}
+
+	version := VersionWithFallbacks(bi)
+
+	if !includeDeps {
+		if Version == "(devel)" {
+			return fmt.Sprintf("%s development build (unknown exact version)", programName)
+		}
+		return fmt.Sprintf("%s %s", programName, version)
+	}
+
+	var b strings.Builder
+	fmt.Fprintf(&b, "%s %s", bi.Path, version)
+	for _, dep := range bi.Deps {
+		fmt.Fprintf(&b, "\n\t%s %s", dep.Path, dep.Version)
+	}
+	return b.String()
+}
+
+// RegisterVersionFlags registers the flags used for the VersionRunFunc.
+func RegisterVersionFlags(flags *pflag.FlagSet) {
+	flags.Bool("include-deps", false, "include dependencies' versions")
+}
+
+// VersionRunFunc provides a generic implementation of a version command that
+// reads its values from ldflags and the internal Go module data stored in a
+// binary.
+func VersionRunFunc(programName string) CobraRunFunc {
+	return func(cmd *cobra.Command, args []string) error {
+		_, err := fmt.Println(UsageVersion(programName, MustGetBool(cmd, "include-deps")))
+		return err
+	}
+}
diff --git a/vendor/github.com/jzelinskie/stringz/LICENSE b/vendor/github.com/jzelinskie/stringz/LICENSE
new file mode 100644
index 0000000..9c8e20a
--- /dev/null
+++ b/vendor/github.com/jzelinskie/stringz/LICENSE
@@ -0,0 +1,191 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2013-2017 Docker, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/jzelinskie/stringz/README.md b/vendor/github.com/jzelinskie/stringz/README.md
new file mode 100644
index 0000000..befa226
--- /dev/null
+++ b/vendor/github.com/jzelinskie/stringz/README.md
@@ -0,0 +1,7 @@
+# stringz
+
+[![Go Report Card](https://goreportcard.com/badge/github.com/jzelinskie/stringz?style=flat-square)](https://goreportcard.com/report/github.com/jzelinskie/stringz)
+[![Godoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](https://godoc.org/github.com/jzelinskie/stringz)
+[![LICENSE](https://img.shields.io/github/license/jzelinskie/stringz.svg?style=flat-square)](https://github.com/jzelinskie/stringz/blob/master/LICENSE)
+
+Package stringz provides string manipulations not found in the standard library.
diff --git a/vendor/github.com/jzelinskie/stringz/stringz.go b/vendor/github.com/jzelinskie/stringz/stringz.go
new file mode 100644
index 0000000..be3cffd
--- /dev/null
+++ b/vendor/github.com/jzelinskie/stringz/stringz.go
@@ -0,0 +1,406 @@
+// Copyright 2019 Jimmy Zelinskie
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package stringz implements a collection of utility functions for
+// manipulating strings and lists of strings.
+package stringz
+
+import (
+	"errors"
+	"strings"
+)
+
+// ErrInconsistentUnpackLen is returned when Unpack is provided two slices
+// without the same length.
+var ErrInconsistentUnpackLen = errors.New("the length of the unpacked is not equal to the provided input")
+
+// SliceContains returns true if the provided string is in the provided string
+// slice.
+func SliceContains(ys []string, x string) bool {
+	for _, y := range ys {
+		if x == y {
+			return true
+		}
+	}
+	return false
+}
+
+// SliceIndex returns the index of the first instance of x in ys, or -1 if it
+// is not present.
+func SliceIndex(ys []string, x string) int {
+	for i, y := range ys {
+		if x == y {
+			return i
+		}
+	}
+	return -1
+}
+
+// Dedup returns a new slice with any duplicates removed.
+func Dedup(xs []string) []string {
+	set := make(map[string]struct{}, 0)
+	ys := make([]string, 0, len(xs))
+	for _, x := range xs {
+		if _, alreadyExists := set[x]; alreadyExists {
+			continue
+		}
+		ys = append(ys, x)
+		set[x] = struct{}{}
+	}
+
+	return ys
+}
+
+// DefaultEmpty returns the fallback when val is empty string.
+//
+// This function is inspired by Python's `dict.get()`.
+func DefaultEmpty(val, fallback string) string {
+	return Default(val, fallback, "")
+}
+
+// Default returns a fallback value when the provided value is equal to any
+// of the zero values.
+func Default(val, fallback string, zeroValues ...string) string {
+	for _, zeroValue := range zeroValues {
+		if val == zeroValue {
+			return fallback
+		}
+	}
+
+	return val
+}
+
+// SliceEqual returns true if two string slices are the same.
+// This function is sensitive to order.
+func SliceEqual(xs, ys []string) bool {
+	if len(xs) != len(ys) {
+		return false
+	}
+
+	for i, x := range xs {
+		if x != ys[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// MatrixEqual returns true if two [][]string are equal.
+// This function is sensitive to order.
+func MatrixEqual(xs, ys [][]string) bool {
+	if len(xs) != len(ys) {
+		return false
+	}
+
+	for i, x := range xs {
+		if !SliceEqual(x, ys[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// TrimPrefixIndex trims everything before the provided index.
+func TrimPrefixIndex(s, index string) string {
+	i := strings.Index(s, index)
+	if i <= 0 {
+		return s
+	}
+	return s[i+len(index):]
+}
+
+// TrimSurrounding returns a string with both a prefix and suffix trimmed from
+// it.
+//
+// Do not confuse this with strings.Trim() which removes characters in a cutset
+// rather than working on prefixes and suffixes.
+func TrimSurrounding(s, surrounding string) string {
+	s = strings.TrimPrefix(s, surrounding)
+	return strings.TrimSuffix(s, surrounding)
+}
+
+// SliceMap is a functional-style mapping function for slices of strings.
+//
+// This is particularly useful when you would normally use a for-loop, but want
+// `defer` to execute for each iteration.
+func SliceMap(xs []string, fn func(string) error) error {
+	for _, x := range xs {
+		err := fn(x)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Join is strings.Join, but variadic.
+func Join(prefix string, xs ...string) string { return strings.Join(xs, prefix) }
+
+// CopyStringMap returns a new copy of a map of strings.
+func CopyStringMap(xs map[string]string) map[string]string {
+	// Zero allocation path.
+	if xs == nil {
+		return nil
+	}
+
+	ys := make(map[string]string, len(xs))
+	for k, v := range xs {
+		ys[k] = v
+	}
+	return ys
+}
+
+// Unpack assigns a slice into local variables.
+func Unpack(xs []string, vars ...*string) error {
+	if len(xs) != len(vars) {
+		return ErrInconsistentUnpackLen
+	}
+	for i, x := range xs {
+		*vars[i] = x
+	}
+	return nil
+}
+
+// SplitExact splits the string `s` into `len(vars)` number of strings and
+// unpacks them into those vars.
+//
+// Returns ErrInconsistentUnpackLen if len(vars) doesn't match the number of
+// split segments.
+func SplitExact(s, sep string, vars ...*string) error {
+	exploded := strings.Split(s, sep)
+	return Unpack(exploded, vars...)
+}
+
+// SplitInto splits the string `s` into `len(vars)` number of strings and
+// unpacks them into those vars. If there are more substrings that would be
+// split after len(vars), they will be all be put into the final variable.
+//
+// Returns ErrInconsistentUnpackLen if len(vars) is greater than the number
+// of split substrings.
+func SplitInto(s, sep string, vars ...*string) error {
+	exploded := strings.SplitN(s, sep, len(vars))
+	return Unpack(exploded, vars...)
+}
+
+// SlicePermutations returns all permutations of a string slice.
+//
+// It is equivalent to `SliceCombinationsR(xs, len(xs))`.
+func SlicePermutations(xs []string) [][]string {
+	return SlicePermutationsR(xs, len(xs))
+}
+
+// SlicePermutationsR returns successive r-length permutations of elements in
+// the provided string slice.
+//
+// If r is less than 0 or larger than the length of the pool, nil is returned.
+//
+// The permutation tuples are emitted in lexicographic ordering according to
+// the order of the input iterable. So, if the input iterable is sorted, the
+// combination tuples will be produced in sorted order.
+//
+// Elements are treated as unique based on their position, not on their value.
+// So if the input elements are unique, there will be no repeat values in each
+// permutation.
+//
+// This is the algorithm used in Python's itertools library:
+// itertools.permutations(iterable, r=None)
+func SlicePermutationsR(pool []string, r int) [][]string {
+	if r <= 0 || pool == nil || r > len(pool) {
+		return nil
+	}
+	n := len(pool)
+
+	indices := make([]int, n)
+	for i := range pool {
+		indices[i] = i
+	}
+
+	var ys [][]string
+
+	{
+		var y []string
+		for _, i := range indices[:r] {
+			y = append(y, pool[i])
+		}
+		ys = append(ys, y)
+	}
+
+	cycles := make([]int, n-(n-r))
+	for i := range cycles {
+		cycles[i] = n - i
+	}
+
+	for {
+		broke := false
+
+		for i := r - 1; i >= 0; i-- {
+			cycles[i] = cycles[i] - 1
+			if cycles[i] == 0 {
+				indices = append(indices[:i], append(indices[i+1:], indices[i:i+1]...)...)
+				cycles[i] = n - i
+			} else {
+				j := cycles[i]
+				indices[i], indices[len(indices)-j] = indices[len(indices)-j], indices[i]
+
+				var y []string
+				for _, i := range indices[:r] {
+					y = append(y, pool[i])
+				}
+				ys = append(ys, y)
+
+				broke = true
+				break
+			}
+		}
+		if !broke {
+			return ys
+		}
+	}
+}
+
+// SliceCombinationsR returns r-length subsequences of elements from the
+// provided string slice.
+//
+// If r is less than 0 or larger than the length of the pool, nil is returned.
+//
+// The combinations are emitted in lexicographic ordering according to the
+// order of the input iterable. So, if the input iterable is sorted, the
+// combination tuples will be produced in sorted order.
+//
+// Elements are treated as unique based on their position, not on their value.
+// So if the input elements are unique, there will be no repeat values in each
+// combination.
+//
+// This is the algorithm used in Python's itertools library:
+// itertools.combinations(iterable, r)
+func SliceCombinationsR(pool []string, r int) [][]string {
+	if r <= 0 || pool == nil || r > len(pool) {
+		return nil
+	}
+	n := len(pool)
+
+	indices := make([]int, r)
+	for i := range indices {
+		indices[i] = i
+	}
+
+	var ys [][]string
+
+	{
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+
+	for {
+		var i int
+		broke := false
+		for i = r - 1; i >= 0; i-- {
+			if indices[i] != i+n-r {
+				broke = true
+				break
+			}
+		}
+		if !broke {
+			return ys
+		}
+
+		indices[i] = indices[i] + 1
+		for j := i + 1; j < r; j++ {
+			indices[j] = indices[j-1] + 1
+		}
+
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+}
+
+// SliceCombinationsWithReplacement returns r-length subsequences of elements
+// from the provided string slice allowing individual elements to be repeated
+// more than once.
+//
+// If r is less than 0 or larger than the length of the pool, nil is returned.
+//
+// The combination tuples are emitted in lexicographic ordering according to
+// the order of the input iterable. So, if the input iterable is sorted, the
+// combination tuples will be produced in sorted order.
+//
+// Elements are treated as unique based on their position, not on their value.
+// So if the input elements are unique, the generated combinations will also be
+// unique.
+//
+// This is the algorithm used in Python's itertools library:
+// itertools.combinations_with_replacement(iterable, r)
+func SliceCombinationsWithReplacement(pool []string, r int) [][]string {
+	if r <= 0 || pool == nil || r > len(pool) {
+		return nil
+	}
+	n := len(pool)
+
+	indices := make([]int, r)
+	var ys [][]string
+
+	{
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+
+	for {
+		var i int
+		broke := false
+		for i = r - 1; i >= 0; i-- {
+			if indices[i] != n-1 {
+				broke = true
+				break
+			}
+		}
+		if !broke {
+			return ys
+		}
+
+		newIndices := make([]int, r-i)
+		for j := range newIndices {
+			newIndices[j] = indices[i] + 1
+		}
+		indices = append(indices[:i], newIndices...)
+
+		var y []string
+		for _, j := range indices {
+			y = append(y, pool[j])
+		}
+		ys = append(ys, y)
+	}
+}
+
+// LastCut slices s around the last instance of sep,
+// returning the text before and after sep.
+//
+// The found result reports whether sep appears in s.
+// If sep does not appear in s, LastCut returns s, "", false.
+func LastCut(s, sep string) (before, after string, found bool) {
+	if i := strings.LastIndex(s, sep); i >= 0 {
+		return s[:i], s[i+len(sep):], true
+	}
+	return s, "", false
+}