deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules

Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy

19 files changed, 3061 insertions, 0 deletions

diff --git a/vendor/github.com/zclconf/go-cty/cty/function/argument.go b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
new file mode 100644
index 0000000..bfd3015
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Parameter represents a parameter to a function.
+type Parameter struct {
+        // Name is an optional name for the argument. This package ignores this
+        // value, but callers may use it for documentation, etc.
+        Name string
+
+        // A type that any argument for this parameter must conform to.
+        // cty.DynamicPseudoType can be used, either at top-level or nested
+        // in a parameterized type, to indicate that any type should be
+        // permitted, to allow the definition of type-generic functions.
+        Type cty.Type
+
+        // If AllowNull is set then null values may be passed into this
+        // argument's slot in both the type-check function and the implementation
+        // function. If not set, such values are rejected by the built-in
+        // checking rules.
+        AllowNull bool
+
+        // If AllowUnknown is set then unknown values may be passed into this
+        // argument's slot in the implementation function. If not set, any
+        // unknown values will cause the function to immediately return
+        // an unkonwn value without calling the implementation function, thus
+        // freeing the function implementer from dealing with this case.
+        AllowUnknown bool
+
+        // If AllowDynamicType is set then DynamicVal may be passed into this
+        // argument's slot in the implementation function. If not set, any
+        // dynamic values will cause the function to immediately return
+        // DynamicVal value without calling the implementation function, thus
+        // freeing the function implementer from dealing with this case.
+        //
+        // Note that DynamicVal is also unknown, so in order to receive dynamic
+        // *values* it is also necessary to set AllowUnknown.
+        //
+        // However, it is valid to set AllowDynamicType without AllowUnknown, in
+        // which case a dynamic value may be passed to the type checking function
+        // but will not make it to the *implementation* function. Instead, an
+        // unknown value of the type returned by the type-check function will be
+        // returned. This is suggested for functions that have a static return
+        // type since it allows the return value to be typed even if the input
+        // values are not, thus improving the type-check accuracy of derived
+        // values.
+        AllowDynamicType bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
new file mode 100644
index 0000000..393b311
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
@@ -0,0 +1,6 @@
+// Package function builds on the functionality of cty by modeling functions
+// that operate on cty Values.
+//
+// Functions are, at their core, Go anonymous functions. However, this package
+// wraps around them utility functions for parameter type checking, etc.
+package function
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/error.go b/vendor/github.com/zclconf/go-cty/cty/function/error.go
new file mode 100644
index 0000000..2b56779
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/error.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+        "fmt"
+        "runtime/debug"
+)
+
+// ArgError represents an error with one of the arguments in a call. The
+// attribute Index represents the zero-based index of the argument in question.
+//
+// Its error *may* be a cty.PathError, in which case the error actually
+// pertains to a nested value within the data structure passed as the argument.
+type ArgError struct {
+        error
+        Index int
+}
+
+func NewArgErrorf(i int, f string, args ...interface{}) error {
+        return ArgError{
+                error: fmt.Errorf(f, args...),
+                Index: i,
+        }
+}
+
+func NewArgError(i int, err error) error {
+        return ArgError{
+                error: err,
+                Index: i,
+        }
+}
+
+// PanicError indicates that a panic occurred while executing either a
+// function's type or implementation function. This is captured and wrapped
+// into a normal error so that callers (expected to be language runtimes)
+// are freed from having to deal with panics in buggy functions.
+type PanicError struct {
+        Value interface{}
+        Stack []byte
+}
+
+func errorForPanic(val interface{}) error {
+        return PanicError{
+                Value: val,
+                Stack: debug.Stack(),
+        }
+}
+
+func (e PanicError) Error() string {
+        return fmt.Sprintf("panic in function implementation: %s\n%s", e.Value, e.Stack)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/function.go b/vendor/github.com/zclconf/go-cty/cty/function/function.go
new file mode 100644
index 0000000..162f7bf
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/function.go
@@ -0,0 +1,291 @@
+package function
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Function represents a function. This is the main type in this package.
+type Function struct {
+        spec *Spec
+}
+
+// Spec is the specification of a function, used to instantiate
+// a new Function.
+type Spec struct {
+        // Params is a description of the positional parameters for the function.
+        // The standard checking logic rejects any calls that do not provide
+        // arguments conforming to this definition, freeing the function
+        // implementer from dealing with such inconsistencies.
+        Params []Parameter
+
+        // VarParam is an optional specification of additional "varargs" the
+        // function accepts. If this is non-nil then callers may provide an
+        // arbitrary number of additional arguments (after those matching with
+        // the fixed parameters in Params) that conform to the given specification,
+        // which will appear as additional values in the slices of values
+        // provided to the type and implementation functions.
+        VarParam *Parameter
+
+        // Type is the TypeFunc that decides the return type of the function
+        // given its arguments, which may be Unknown. See the documentation
+        // of TypeFunc for more information.
+        //
+        // Use StaticReturnType if the function's return type does not vary
+        // depending on its arguments.
+        Type TypeFunc
+
+        // Impl is the ImplFunc that implements the function's behavior.
+        //
+        // Functions are expected to behave as pure functions, and not create
+        // any visible side-effects.
+        //
+        // If a TypeFunc is also provided, the value returned from Impl *must*
+        // conform to the type it returns, or a call to the function will panic.
+        Impl ImplFunc
+}
+
+// New creates a new function with the given specification.
+//
+// After passing a Spec to this function, the caller must no longer read from
+// or mutate it.
+func New(spec *Spec) Function {
+        f := Function{
+                spec: spec,
+        }
+        return f
+}
+
+// TypeFunc is a callback type for determining the return type of a function
+// given its arguments.
+//
+// Any of the values passed to this function may be unknown, even if the
+// parameters are not configured to accept unknowns.
+//
+// If any of the given values are *not* unknown, the TypeFunc may use the
+// values for pre-validation and for choosing the return type. For example,
+// a hypothetical JSON-unmarshalling function could return
+// cty.DynamicPseudoType if the given JSON string is unknown, but return
+// a concrete type based on the JSON structure if the JSON string is already
+// known.
+type TypeFunc func(args []cty.Value) (cty.Type, error)
+
+// ImplFunc is a callback type for the main implementation of a function.
+//
+// "args" are the values for the arguments, and this slice will always be at
+// least as long as the argument definition slice for the function.
+//
+// "retType" is the type returned from the Type callback, included as a
+// convenience to avoid the need to re-compute the return type for generic
+// functions whose return type is a function of the arguments.
+type ImplFunc func(args []cty.Value, retType cty.Type) (cty.Value, error)
+
+// StaticReturnType returns a TypeFunc that always returns the given type.
+//
+// This is provided as a convenience for defining a function whose return
+// type does not depend on the argument types.
+func StaticReturnType(ty cty.Type) TypeFunc {
+        return func([]cty.Value) (cty.Type, error) {
+                return ty, nil
+        }
+}
+
+// ReturnType returns the return type of a function given a set of candidate
+// argument types, or returns an error if the given types are unacceptable.
+//
+// If the caller already knows values for at least some of the arguments
+// it can be better to call ReturnTypeForValues, since certain functions may
+// determine their return types from their values and return DynamicVal if
+// the values are unknown.
+func (f Function) ReturnType(argTypes []cty.Type) (cty.Type, error) {
+        vals := make([]cty.Value, len(argTypes))
+        for i, ty := range argTypes {
+                vals[i] = cty.UnknownVal(ty)
+        }
+        return f.ReturnTypeForValues(vals)
+}
+
+// ReturnTypeForValues is similar to ReturnType but can be used if the caller
+// already knows the values of some or all of the arguments, in which case
+// the function may be able to determine a more definite result if its
+// return type depends on the argument *values*.
+//
+// For any arguments whose values are not known, pass an Unknown value of
+// the appropriate type.
+func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error) {
+        var posArgs []cty.Value
+        var varArgs []cty.Value
+
+        if f.spec.VarParam == nil {
+                if len(args) != len(f.spec.Params) {
+                        return cty.Type{}, fmt.Errorf(
+                                "wrong number of arguments (%d required; %d given)",
+                                len(f.spec.Params), len(args),
+                        )
+                }
+
+                posArgs = args
+                varArgs = nil
+        } else {
+                if len(args) < len(f.spec.Params) {
+                        return cty.Type{}, fmt.Errorf(
+                                "wrong number of arguments (at least %d required; %d given)",
+                                len(f.spec.Params), len(args),
+                        )
+                }
+
+                posArgs = args[0:len(f.spec.Params)]
+                varArgs = args[len(f.spec.Params):]
+        }
+
+        for i, spec := range f.spec.Params {
+                val := posArgs[i]
+
+                if val.IsNull() && !spec.AllowNull {
+                        return cty.Type{}, NewArgErrorf(i, "must not be null")
+                }
+
+                // AllowUnknown is ignored for type-checking, since we expect to be
+                // able to type check with unknown values. We *do* still need to deal
+                // with DynamicPseudoType here though, since the Type function might
+                // not be ready to deal with that.
+
+                if val.Type() == cty.DynamicPseudoType {
+                        if !spec.AllowDynamicType {
+                                return cty.DynamicPseudoType, nil
+                        }
+                } else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+                        // For now we'll just return the first error in the set, since
+                        // we don't have a good way to return the whole list here.
+                        // Would be good to do something better at some point...
+                        return cty.Type{}, NewArgError(i, errs[0])
+                }
+        }
+
+        if varArgs != nil {
+                spec := f.spec.VarParam
+                for i, val := range varArgs {
+                        realI := i + len(posArgs)
+
+                        if val.IsNull() && !spec.AllowNull {
+                                return cty.Type{}, NewArgErrorf(realI, "must not be null")
+                        }
+
+                        if val.Type() == cty.DynamicPseudoType {
+                                if !spec.AllowDynamicType {
+                                        return cty.DynamicPseudoType, nil
+                                }
+                        } else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+                                // For now we'll just return the first error in the set, since
+                                // we don't have a good way to return the whole list here.
+                                // Would be good to do something better at some point...
+                                return cty.Type{}, NewArgError(i, errs[0])
+                        }
+                }
+        }
+
+        // Intercept any panics from the function and return them as normal errors,
+        // so a calling language runtime doesn't need to deal with panics.
+        defer func() {
+                if r := recover(); r != nil {
+                        ty = cty.NilType
+                        err = errorForPanic(r)
+                }
+        }()
+
+        return f.spec.Type(args)
+}
+
+// Call actually calls the function with the given arguments, which must
+// conform to the function's parameter specification or an error will be
+// returned.
+func (f Function) Call(args []cty.Value) (val cty.Value, err error) {
+        expectedType, err := f.ReturnTypeForValues(args)
+        if err != nil {
+                return cty.NilVal, err
+        }
+
+        // Type checking already dealt with most situations relating to our
+        // parameter specification, but we still need to deal with unknown
+        // values.
+        posArgs := args[:len(f.spec.Params)]
+        varArgs := args[len(f.spec.Params):]
+
+        for i, spec := range f.spec.Params {
+                val := posArgs[i]
+
+                if !val.IsKnown() && !spec.AllowUnknown {
+                        return cty.UnknownVal(expectedType), nil
+                }
+        }
+
+        if f.spec.VarParam != nil {
+                spec := f.spec.VarParam
+                for _, val := range varArgs {
+                        if !val.IsKnown() && !spec.AllowUnknown {
+                                return cty.UnknownVal(expectedType), nil
+                        }
+                }
+        }
+
+        var retVal cty.Value
+        {
+                // Intercept any panics from the function and return them as normal errors,
+                // so a calling language runtime doesn't need to deal with panics.
+                defer func() {
+                        if r := recover(); r != nil {
+                                val = cty.NilVal
+                                err = errorForPanic(r)
+                        }
+                }()
+
+                retVal, err = f.spec.Impl(args, expectedType)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+        }
+
+        // Returned value must conform to what the Type function expected, to
+        // protect callers from having to deal with inconsistencies.
+        if errs := retVal.Type().TestConformance(expectedType); errs != nil {
+                panic(fmt.Errorf(
+                        "returned value %#v does not conform to expected return type %#v: %s",
+                        retVal, expectedType, errs[0],
+                ))
+        }
+
+        return retVal, nil
+}
+
+// ProxyFunc the type returned by the method Function.Proxy.
+type ProxyFunc func(args ...cty.Value) (cty.Value, error)
+
+// Proxy returns a function that can be called with cty.Value arguments
+// to run the function. This is provided as a convenience for when using
+// a function directly within Go code.
+func (f Function) Proxy() ProxyFunc {
+        return func(args ...cty.Value) (cty.Value, error) {
+                return f.Call(args)
+        }
+}
+
+// Params returns information about the function's fixed positional parameters.
+// This does not include information about any variadic arguments accepted;
+// for that, call VarParam.
+func (f Function) Params() []Parameter {
+        new := make([]Parameter, len(f.spec.Params))
+        copy(new, f.spec.Params)
+        return new
+}
+
+// VarParam returns information about the variadic arguments the function
+// expects, or nil if the function is not variadic.
+func (f Function) VarParam() *Parameter {
+        if f.spec.VarParam == nil {
+                return nil
+        }
+
+        ret := *f.spec.VarParam
+        return &ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
new file mode 100644
index 0000000..a473d0e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
@@ -0,0 +1,73 @@
+package stdlib
+
+import (
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var NotFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "val",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Not(), nil
+        },
+})
+
+var AndFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].And(args[1]), nil
+        },
+})
+
+var OrFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Bool,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Or(args[1]), nil
+        },
+})
+
+// Not returns the logical complement of the given boolean value.
+func Not(num cty.Value) (cty.Value, error) {
+        return NotFunc.Call([]cty.Value{num})
+}
+
+// And returns true if and only if both of the given boolean values are true.
+func And(a, b cty.Value) (cty.Value, error) {
+        return AndFunc.Call([]cty.Value{a, b})
+}
+
+// Or returns true if either of the given boolean values are true.
+func Or(a, b cty.Value) (cty.Value, error) {
+        return OrFunc.Call([]cty.Value{a, b})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
new file mode 100644
index 0000000..a132e0c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
@@ -0,0 +1,112 @@
+package stdlib
+
+import (
+        "fmt"
+        "reflect"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/gocty"
+)
+
+// Bytes is a capsule type that can be used with the binary functions to
+// support applications that need to support raw buffers in addition to
+// UTF-8 strings.
+var Bytes = cty.Capsule("bytes", reflect.TypeOf([]byte(nil)))
+
+// BytesVal creates a new Bytes value from the given buffer, which must be
+// non-nil or this function will panic.
+//
+// Once a byte slice has been wrapped in a Bytes capsule, its underlying array
+// must be considered immutable.
+func BytesVal(buf []byte) cty.Value {
+        if buf == nil {
+                panic("can't make Bytes value from nil slice")
+        }
+
+        return cty.CapsuleVal(Bytes, &buf)
+}
+
+// BytesLen is a Function that returns the length of the buffer encapsulated
+// in a Bytes value.
+var BytesLenFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "buf",
+                        Type:             Bytes,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                bufPtr := args[0].EncapsulatedValue().(*[]byte)
+                return cty.NumberIntVal(int64(len(*bufPtr))), nil
+        },
+})
+
+// BytesSlice is a Function that returns a slice of the given Bytes value.
+var BytesSliceFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "buf",
+                        Type:             Bytes,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "offset",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "length",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(Bytes),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                bufPtr := args[0].EncapsulatedValue().(*[]byte)
+
+                var offset, length int
+
+                var err error
+                err = gocty.FromCtyValue(args[1], &offset)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                err = gocty.FromCtyValue(args[2], &length)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+
+                if offset < 0 || length < 0 {
+                        return cty.NilVal, fmt.Errorf("offset and length must be non-negative")
+                }
+
+                if offset > len(*bufPtr) {
+                        return cty.NilVal, fmt.Errorf(
+                                "offset %d is greater than total buffer length %d",
+                                offset, len(*bufPtr),
+                        )
+                }
+
+                end := offset + length
+
+                if end > len(*bufPtr) {
+                        return cty.NilVal, fmt.Errorf(
+                                "offset %d + length %d is greater than total buffer length %d",
+                                offset, length, len(*bufPtr),
+                        )
+                }
+
+                return BytesVal((*bufPtr)[offset:end]), nil
+        },
+})
+
+func BytesLen(buf cty.Value) (cty.Value, error) {
+        return BytesLenFunc.Call([]cty.Value{buf})
+}
+
+func BytesSlice(buf cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+        return BytesSliceFunc.Call([]cty.Value{buf, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
new file mode 100644
index 0000000..967ba03
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
@@ -0,0 +1,140 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/gocty"
+)
+
+var HasIndexFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "collection",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "key",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                collTy := args[0].Type()
+                if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy == cty.DynamicPseudoType) {
+                        return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+                }
+                return cty.Bool, nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].HasIndex(args[1]), nil
+        },
+})
+
+var IndexFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "collection",
+                        Type: cty.DynamicPseudoType,
+                },
+                {
+                        Name:             "key",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                collTy := args[0].Type()
+                key := args[1]
+                keyTy := key.Type()
+                switch {
+                case collTy.IsTupleType():
+                        if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+                                return cty.NilType, fmt.Errorf("key for tuple must be number")
+                        }
+                        if !key.IsKnown() {
+                                return cty.DynamicPseudoType, nil
+                        }
+                        var idx int
+                        err := gocty.FromCtyValue(key, &idx)
+                        if err != nil {
+                                return cty.NilType, fmt.Errorf("invalid key for tuple: %s", err)
+                        }
+
+                        etys := collTy.TupleElementTypes()
+
+                        if idx >= len(etys) || idx < 0 {
+                                return cty.NilType, fmt.Errorf("key must be between 0 and %d inclusive", len(etys))
+                        }
+
+                        return etys[idx], nil
+
+                case collTy.IsListType():
+                        if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+                                return cty.NilType, fmt.Errorf("key for list must be number")
+                        }
+
+                        return collTy.ElementType(), nil
+
+                case collTy.IsMapType():
+                        if keyTy != cty.String && keyTy != cty.DynamicPseudoType {
+                                return cty.NilType, fmt.Errorf("key for map must be string")
+                        }
+
+                        return collTy.ElementType(), nil
+
+                default:
+                        return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+                }
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                has, err := HasIndex(args[0], args[1])
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                if has.False() { // safe because collection and key are guaranteed known here
+                        return cty.NilVal, fmt.Errorf("invalid index")
+                }
+
+                return args[0].Index(args[1]), nil
+        },
+})
+
+var LengthFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "collection",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                collTy := args[0].Type()
+                if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType) {
+                        return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+                }
+                return cty.Number, nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].Length(), nil
+        },
+})
+
+// HasIndex determines whether the given collection can be indexed with the
+// given key.
+func HasIndex(collection cty.Value, key cty.Value) (cty.Value, error) {
+        return HasIndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Index returns an element from the given collection using the given key,
+// or returns an error if there is no element for the given key.
+func Index(collection cty.Value, key cty.Value) (cty.Value, error) {
+        return IndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Length returns the number of elements in the given collection.
+func Length(collection cty.Value) (cty.Value, error) {
+        return LengthFunc.Call([]cty.Value{collection})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
new file mode 100644
index 0000000..5070a5a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/csv.go
@@ -0,0 +1,93 @@
+package stdlib
+
+import (
+        "encoding/csv"
+        "fmt"
+        "io"
+        "strings"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var CSVDecodeFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "str",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                str := args[0]
+                if !str.IsKnown() {
+                        return cty.DynamicPseudoType, nil
+                }
+
+                r := strings.NewReader(str.AsString())
+                cr := csv.NewReader(r)
+                headers, err := cr.Read()
+                if err == io.EOF {
+                        return cty.DynamicPseudoType, fmt.Errorf("missing header line")
+                }
+                if err != nil {
+                        return cty.DynamicPseudoType, err
+                }
+
+                atys := make(map[string]cty.Type, len(headers))
+                for _, name := range headers {
+                        if _, exists := atys[name]; exists {
+                                return cty.DynamicPseudoType, fmt.Errorf("duplicate column name %q", name)
+                        }
+                        atys[name] = cty.String
+                }
+                return cty.List(cty.Object(atys)), nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                ety := retType.ElementType()
+                atys := ety.AttributeTypes()
+                str := args[0]
+                r := strings.NewReader(str.AsString())
+                cr := csv.NewReader(r)
+                cr.FieldsPerRecord = len(atys)
+
+                // Read the header row first, since that'll tell us which indices
+                // map to which attribute names.
+                headers, err := cr.Read()
+                if err != nil {
+                        return cty.DynamicVal, err
+                }
+
+                var rows []cty.Value
+                for {
+                        cols, err := cr.Read()
+                        if err == io.EOF {
+                                break
+                        }
+                        if err != nil {
+                                return cty.DynamicVal, err
+                        }
+
+                        vals := make(map[string]cty.Value, len(cols))
+                        for i, str := range cols {
+                                name := headers[i]
+                                vals[name] = cty.StringVal(str)
+                        }
+                        rows = append(rows, cty.ObjectVal(vals))
+                }
+
+                if len(rows) == 0 {
+                        return cty.ListValEmpty(ety), nil
+                }
+                return cty.ListVal(rows), nil
+        },
+})
+
+// CSVDecode parses the given CSV (RFC 4180) string and, if it is valid,
+// returns a list of objects representing the rows.
+//
+// The result is always a list of some object type. The first row of the
+// input is used to determine the object attributes, and subsequent rows
+// determine the values of those attributes.
+func CSVDecode(str cty.Value) (cty.Value, error) {
+        return CSVDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
new file mode 100644
index 0000000..cfb613e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
@@ -0,0 +1,13 @@
+// Package stdlib is a collection of cty functions that are expected to be
+// generally useful, and are thus factored out into this shared library in
+// the hope that cty-using applications will have consistent behavior when
+// using these functions.
+//
+// See the parent package "function" for more information on the purpose
+// and usage of cty functions.
+//
+// This package contains both Go functions, which provide convenient access
+// to call the functions from Go code, and the Function objects themselves.
+// The latter follow the naming scheme of appending "Func" to the end of
+// the function name.
+package stdlib
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
new file mode 100644
index 0000000..fb24f20
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format.go
@@ -0,0 +1,496 @@
+package stdlib
+
+import (
+        "bytes"
+        "fmt"
+        "math/big"
+        "strings"
+
+        "github.com/apparentlymart/go-textseg/textseg"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/json"
+)
+
+//go:generate ragel -Z format_fsm.rl
+//go:generate gofmt -w format_fsm.go
+
+var FormatFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "format",
+                        Type: cty.String,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:      "args",
+                Type:      cty.DynamicPseudoType,
+                AllowNull: true,
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                for _, arg := range args[1:] {
+                        if !arg.IsWhollyKnown() {
+                                // We require all nested values to be known because the only
+                                // thing we can do for a collection/structural type is print
+                                // it as JSON and that requires it to be wholly known.
+                                return cty.UnknownVal(cty.String), nil
+                        }
+                }
+                str, err := formatFSM(args[0].AsString(), args[1:])
+                return cty.StringVal(str), err
+        },
+})
+
+var FormatListFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "format",
+                        Type: cty.String,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:         "args",
+                Type:         cty.DynamicPseudoType,
+                AllowNull:    true,
+                AllowUnknown: true,
+        },
+        Type: function.StaticReturnType(cty.List(cty.String)),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                fmtVal := args[0]
+                args = args[1:]
+
+                if len(args) == 0 {
+                        // With no arguments, this function is equivalent to Format, but
+                        // returning a single-element list result.
+                        result, err := Format(fmtVal, args...)
+                        return cty.ListVal([]cty.Value{result}), err
+                }
+
+                fmtStr := fmtVal.AsString()
+
+                // Each of our arguments will be dealt with either as an iterator
+                // or as a single value. Iterators are used for sequence-type values
+                // (lists, sets, tuples) while everything else is treated as a
+                // single value. The sequences we iterate over are required to be
+                // all the same length.
+                iterLen := -1
+                lenChooser := -1
+                iterators := make([]cty.ElementIterator, len(args))
+                singleVals := make([]cty.Value, len(args))
+                for i, arg := range args {
+                        argTy := arg.Type()
+                        switch {
+                        case (argTy.IsListType() || argTy.IsSetType() || argTy.IsTupleType()) && !arg.IsNull():
+                                thisLen := arg.LengthInt()
+                                if iterLen == -1 {
+                                        iterLen = thisLen
+                                        lenChooser = i
+                                } else {
+                                        if thisLen != iterLen {
+                                                return cty.NullVal(cty.List(cty.String)), function.NewArgErrorf(
+                                                        i+1,
+                                                        "argument %d has length %d, which is inconsistent with argument %d of length %d",
+                                                        i+1, thisLen,
+                                                        lenChooser+1, iterLen,
+                                                )
+                                        }
+                                }
+                                iterators[i] = arg.ElementIterator()
+                        default:
+                                singleVals[i] = arg
+                        }
+                }
+
+                if iterLen == 0 {
+                        // If our sequences are all empty then our result must be empty.
+                        return cty.ListValEmpty(cty.String), nil
+                }
+
+                if iterLen == -1 {
+                        // If we didn't encounter any iterables at all then we're going
+                        // to just do one iteration with items from singleVals.
+                        iterLen = 1
+                }
+
+                ret := make([]cty.Value, 0, iterLen)
+                fmtArgs := make([]cty.Value, len(iterators))
+        Results:
+                for iterIdx := 0; iterIdx < iterLen; iterIdx++ {
+
+                        // Construct our arguments for a single format call
+                        for i := range fmtArgs {
+                                switch {
+                                case iterators[i] != nil:
+                                        iterator := iterators[i]
+                                        iterator.Next()
+                                        _, val := iterator.Element()
+                                        fmtArgs[i] = val
+                                default:
+                                        fmtArgs[i] = singleVals[i]
+                                }
+
+                                // If any of the arguments to this call would be unknown then
+                                // this particular result is unknown, but we'll keep going
+                                // to see if any other iterations can produce known values.
+                                if !fmtArgs[i].IsWhollyKnown() {
+                                        // We require all nested values to be known because the only
+                                        // thing we can do for a collection/structural type is print
+                                        // it as JSON and that requires it to be wholly known.
+                                        ret = append(ret, cty.UnknownVal(cty.String))
+                                        continue Results
+                                }
+                        }
+
+                        str, err := formatFSM(fmtStr, fmtArgs)
+                        if err != nil {
+                                return cty.NullVal(cty.List(cty.String)), fmt.Errorf(
+                                        "error on format iteration %d: %s", iterIdx, err,
+                                )
+                        }
+
+                        ret = append(ret, cty.StringVal(str))
+                }
+
+                return cty.ListVal(ret), nil
+        },
+})
+
+// Format produces a string representation of zero or more values using a
+// format string similar to the "printf" function in C.
+//
+// It supports the following "verbs":
+//
+//     %%      Literal percent sign, consuming no value
+//     %v      A default formatting of the value based on type, as described below.
+//     %#v     JSON serialization of the value
+//     %t      Converts to boolean and then produces "true" or "false"
+//     %b      Converts to number, requires integer, produces binary representation
+//     %d      Converts to number, requires integer, produces decimal representation
+//     %o      Converts to number, requires integer, produces octal representation
+//     %x      Converts to number, requires integer, produces hexadecimal representation
+//             with lowercase letters
+//     %X      Like %x but with uppercase letters
+//     %e      Converts to number, produces scientific notation like -1.234456e+78
+//     %E      Like %e but with an uppercase "E" representing the exponent
+//     %f      Converts to number, produces decimal representation with fractional
+//             part but no exponent, like 123.456
+//     %g      %e for large exponents or %f otherwise
+//     %G      %E for large exponents or %f otherwise
+//     %s      Converts to string and produces the string's characters
+//     %q      Converts to string and produces JSON-quoted string representation,
+//             like %v.
+//
+// The default format selections made by %v are:
+//
+//     string  %s
+//     number  %g
+//     bool    %t
+//     other   %#v
+//
+// Null values produce the literal keyword "null" for %v and %#v, and produce
+// an error otherwise.
+//
+// Width is specified by an optional decimal number immediately preceding the
+// verb letter. If absent, the width is whatever is necessary to represent the
+// value. Precision is specified after the (optional) width by a period
+// followed by a decimal number. If no period is present, a default precision
+// is used. A period with no following number is invalid.
+// For examples:
+//
+//     %f     default width, default precision
+//     %9f    width 9, default precision
+//     %.2f   default width, precision 2
+//     %9.2f  width 9, precision 2
+//
+// Width and precision are measured in unicode characters (grapheme clusters).
+//
+// For most values, width is the minimum number of characters to output,
+// padding the formatted form with spaces if necessary.
+//
+// For strings, precision limits the length of the input to be formatted (not
+// the size of the output), truncating if necessary.
+//
+// For numbers, width sets the minimum width of the field and precision sets
+// the number of places after the decimal, if appropriate, except that for
+// %g/%G precision sets the total number of significant digits.
+//
+// The following additional symbols can be used immediately after the percent
+// introducer as flags:
+//
+//           (a space) leave a space where the sign would be if number is positive
+//     +     Include a sign for a number even if it is positive (numeric only)
+//     -     Pad with spaces on the left rather than the right
+//     0     Pad with zeros rather than spaces.
+//
+// Flag characters are ignored for verbs that do not support them.
+//
+// By default, % sequences consume successive arguments starting with the first.
+// Introducing a [n] sequence immediately before the verb letter, where n is a
+// decimal integer, explicitly chooses a particular value argument by its
+// one-based index. Subsequent calls without an explicit index will then
+// proceed with n+1, n+2, etc.
+//
+// An error is produced if the format string calls for an impossible conversion
+// or accesses more values than are given. An error is produced also for
+// an unsupported format verb.
+func Format(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+        args := make([]cty.Value, 0, len(vals)+1)
+        args = append(args, format)
+        args = append(args, vals...)
+        return FormatFunc.Call(args)
+}
+
+// FormatList applies the same formatting behavior as Format, but accepts
+// a mixture of list and non-list values as arguments. Any list arguments
+// passed must have the same length, which dictates the length of the
+// resulting list.
+//
+// Any non-list arguments are used repeatedly for each iteration over the
+// list arguments. The list arguments are iterated in order by key, so
+// corresponding items are formatted together.
+func FormatList(format cty.Value, vals ...cty.Value) (cty.Value, error) {
+        args := make([]cty.Value, 0, len(vals)+1)
+        args = append(args, format)
+        args = append(args, vals...)
+        return FormatListFunc.Call(args)
+}
+
+type formatVerb struct {
+        Raw    string
+        Offset int
+
+        ArgNum int
+        Mode   rune
+
+        Zero  bool
+        Sharp bool
+        Plus  bool
+        Minus bool
+        Space bool
+
+        HasPrec bool
+        Prec    int
+
+        HasWidth bool
+        Width    int
+}
+
+// formatAppend is called by formatFSM (generated by format_fsm.rl) for each
+// formatting sequence that is encountered.
+func formatAppend(verb *formatVerb, buf *bytes.Buffer, args []cty.Value) error {
+        argIdx := verb.ArgNum - 1
+        if argIdx >= len(args) {
+                return fmt.Errorf(
+                        "not enough arguments for %q at %d: need index %d but have %d total",
+                        verb.Raw, verb.Offset,
+                        verb.ArgNum, len(args),
+                )
+        }
+        arg := args[argIdx]
+
+        if verb.Mode != 'v' && arg.IsNull() {
+                return fmt.Errorf("unsupported value for %q at %d: null value cannot be formatted", verb.Raw, verb.Offset)
+        }
+
+        // Normalize to make some things easier for downstream formatters
+        if !verb.HasWidth {
+                verb.Width = -1
+        }
+        if !verb.HasPrec {
+                verb.Prec = -1
+        }
+
+        // For our first pass we'll ensure the verb is supported and then fan
+        // out to other functions based on what conversion is needed.
+        switch verb.Mode {
+
+        case 'v':
+                return formatAppendAsIs(verb, buf, arg)
+
+        case 't':
+                return formatAppendBool(verb, buf, arg)
+
+        case 'b', 'd', 'o', 'x', 'X', 'e', 'E', 'f', 'g', 'G':
+                return formatAppendNumber(verb, buf, arg)
+
+        case 's', 'q':
+                return formatAppendString(verb, buf, arg)
+
+        default:
+                return fmt.Errorf("unsupported format verb %q in %q at offset %d", verb.Mode, verb.Raw, verb.Offset)
+        }
+}
+
+func formatAppendAsIs(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+
+        if !verb.Sharp && !arg.IsNull() {
+                // Unless the caller overrode it with the sharp flag, we'll try some
+                // specialized formats before we fall back on JSON.
+                switch arg.Type() {
+                case cty.String:
+                        fmted := arg.AsString()
+                        fmted = formatPadWidth(verb, fmted)
+                        buf.WriteString(fmted)
+                        return nil
+                case cty.Number:
+                        bf := arg.AsBigFloat()
+                        fmted := bf.Text('g', -1)
+                        fmted = formatPadWidth(verb, fmted)
+                        buf.WriteString(fmted)
+                        return nil
+                }
+        }
+
+        jb, err := json.Marshal(arg, arg.Type())
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+        fmted := formatPadWidth(verb, string(jb))
+        buf.WriteString(fmted)
+
+        return nil
+}
+
+func formatAppendBool(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        var err error
+        arg, err = convert.Convert(arg, cty.Bool)
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+
+        if arg.True() {
+                buf.WriteString("true")
+        } else {
+                buf.WriteString("false")
+        }
+        return nil
+}
+
+func formatAppendNumber(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        var err error
+        arg, err = convert.Convert(arg, cty.Number)
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+
+        switch verb.Mode {
+        case 'b', 'd', 'o', 'x', 'X':
+                return formatAppendInteger(verb, buf, arg)
+        default:
+                bf := arg.AsBigFloat()
+
+                // For floats our format syntax is a subset of Go's, so it's
+                // safe for us to just lean on the existing Go implementation.
+                fmtstr := formatStripIndexSegment(verb.Raw)
+                fmted := fmt.Sprintf(fmtstr, bf)
+                buf.WriteString(fmted)
+                return nil
+        }
+}
+
+func formatAppendInteger(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        bf := arg.AsBigFloat()
+        bi, acc := bf.Int(nil)
+        if acc != big.Exact {
+                return fmt.Errorf("unsupported value for %q at %d: an integer is required", verb.Raw, verb.Offset)
+        }
+
+        // For integers our format syntax is a subset of Go's, so it's
+        // safe for us to just lean on the existing Go implementation.
+        fmtstr := formatStripIndexSegment(verb.Raw)
+        fmted := fmt.Sprintf(fmtstr, bi)
+        buf.WriteString(fmted)
+        return nil
+}
+
+func formatAppendString(verb *formatVerb, buf *bytes.Buffer, arg cty.Value) error {
+        var err error
+        arg, err = convert.Convert(arg, cty.String)
+        if err != nil {
+                return fmt.Errorf("unsupported value for %q at %d: %s", verb.Raw, verb.Offset, err)
+        }
+
+        // We _cannot_ directly use the Go fmt.Sprintf implementation for strings
+        // because it measures widths and precisions in runes rather than grapheme
+        // clusters.
+
+        str := arg.AsString()
+        if verb.Prec > 0 {
+                strB := []byte(str)
+                pos := 0
+                wanted := verb.Prec
+                for i := 0; i < wanted; i++ {
+                        next := strB[pos:]
+                        if len(next) == 0 {
+                                // ran out of characters before we hit our max width
+                                break
+                        }
+                        d, _, _ := textseg.ScanGraphemeClusters(strB[pos:], true)
+                        pos += d
+                }
+                str = str[:pos]
+        }
+
+        switch verb.Mode {
+        case 's':
+                fmted := formatPadWidth(verb, str)
+                buf.WriteString(fmted)
+        case 'q':
+                jb, err := json.Marshal(cty.StringVal(str), cty.String)
+                if err != nil {
+                        // Should never happen, since we know this is a known, non-null string
+                        panic(fmt.Errorf("failed to marshal %#v as JSON: %s", arg, err))
+                }
+                fmted := formatPadWidth(verb, string(jb))
+                buf.WriteString(fmted)
+        default:
+                // Should never happen because formatAppend should've already validated
+                panic(fmt.Errorf("invalid string formatting mode %q", verb.Mode))
+        }
+        return nil
+}
+
+func formatPadWidth(verb *formatVerb, fmted string) string {
+        if verb.Width < 0 {
+                return fmted
+        }
+
+        // Safe to ignore errors because ScanGraphemeClusters cannot produce errors
+        givenLen, _ := textseg.TokenCount([]byte(fmted), textseg.ScanGraphemeClusters)
+        wantLen := verb.Width
+        if givenLen >= wantLen {
+                return fmted
+        }
+
+        padLen := wantLen - givenLen
+        padChar := " "
+        if verb.Zero {
+                padChar = "0"
+        }
+        pads := strings.Repeat(padChar, padLen)
+
+        if verb.Minus {
+                return fmted + pads
+        }
+        return pads + fmted
+}
+
+// formatStripIndexSegment strips out any [nnn] segment present in a verb
+// string so that we can pass it through to Go's fmt.Sprintf with a single
+// argument. This is used in cases where we're just leaning on Go's formatter
+// because it's a superset of ours.
+func formatStripIndexSegment(rawVerb string) string {
+        // We assume the string has already been validated here, since we should
+        // only be using this function with strings that were accepted by our
+        // scanner in formatFSM.
+        start := strings.Index(rawVerb, "[")
+        end := strings.Index(rawVerb, "]")
+        if start == -1 || end == -1 {
+                return rawVerb
+        }
+
+        return rawVerb[:start] + rawVerb[end+1:]
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
new file mode 100644
index 0000000..86876ba
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.go
@@ -0,0 +1,358 @@
+// line 1 "format_fsm.rl"
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+
+// line 5 "format_fsm.rl"
+
+package stdlib
+
+import (
+        "bytes"
+        "fmt"
+        "unicode/utf8"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+// line 20 "format_fsm.go"
+var _formatfsm_actions []byte = []byte{
+        0, 1, 0, 1, 1, 1, 2, 1, 4,
+        1, 5, 1, 6, 1, 7, 1, 8,
+        1, 9, 1, 10, 1, 11, 1, 14,
+        1, 16, 1, 17, 1, 18, 2, 3,
+        4, 2, 12, 10, 2, 12, 16, 2,
+        12, 18, 2, 13, 14, 2, 15, 10,
+        2, 15, 18,
+}
+
+var _formatfsm_key_offsets []byte = []byte{
+        0, 0, 14, 27, 34, 36, 39, 43,
+        51,
+}
+
+var _formatfsm_trans_keys []byte = []byte{
+        32, 35, 37, 43, 45, 46, 48, 91,
+        49, 57, 65, 90, 97, 122, 32, 35,
+        43, 45, 46, 48, 91, 49, 57, 65,
+        90, 97, 122, 91, 48, 57, 65, 90,
+        97, 122, 49, 57, 93, 48, 57, 65,
+        90, 97, 122, 46, 91, 48, 57, 65,
+        90, 97, 122, 37,
+}
+
+var _formatfsm_single_lengths []byte = []byte{
+        0, 8, 7, 1, 0, 1, 0, 2,
+        1,
+}
+
+var _formatfsm_range_lengths []byte = []byte{
+        0, 3, 3, 3, 1, 1, 2, 3,
+        0,
+}
+
+var _formatfsm_index_offsets []byte = []byte{
+        0, 0, 12, 23, 28, 30, 33, 36,
+        42,
+}
+
+var _formatfsm_indicies []byte = []byte{
+        1, 2, 3, 4, 5, 6, 7, 10,
+        8, 9, 9, 0, 1, 2, 4, 5,
+        6, 7, 10, 8, 9, 9, 0, 13,
+        11, 12, 12, 0, 14, 0, 15, 14,
+        0, 9, 9, 0, 16, 19, 17, 18,
+        18, 0, 20, 3,
+}
+
+var _formatfsm_trans_targs []byte = []byte{
+        0, 2, 2, 8, 2, 2, 3, 2,
+        7, 8, 4, 3, 8, 4, 5, 6,
+        3, 7, 8, 4, 1,
+}
+
+var _formatfsm_trans_actions []byte = []byte{
+        7, 17, 9, 3, 15, 13, 25, 11,
+        43, 29, 19, 27, 49, 46, 21, 0,
+        37, 23, 40, 34, 1,
+}
+
+var _formatfsm_eof_actions []byte = []byte{
+        0, 31, 31, 31, 31, 31, 31, 31,
+        5,
+}
+
+const formatfsm_start int = 8
+const formatfsm_first_final int = 8
+const formatfsm_error int = 0
+
+const formatfsm_en_main int = 8
+
+// line 19 "format_fsm.rl"
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+        var buf bytes.Buffer
+        data := format
+        nextArg := 1 // arg numbers are 1-based
+        var verb formatVerb
+
+        // line 153 "format_fsm.rl"
+
+        // Ragel state
+        p := 0          // "Pointer" into data
+        pe := len(data) // End-of-data "pointer"
+        cs := 0         // current state (will be initialized by ragel-generated code)
+        ts := 0
+        te := 0
+        eof := pe
+
+        // Keep Go compiler happy even if generated code doesn't use these
+        _ = ts
+        _ = te
+        _ = eof
+
+        // line 121 "format_fsm.go"
+        {
+                cs = formatfsm_start
+        }
+
+        // line 126 "format_fsm.go"
+        {
+                var _klen int
+                var _trans int
+                var _acts int
+                var _nacts uint
+                var _keys int
+                if p == pe {
+                        goto _test_eof
+                }
+                if cs == 0 {
+                        goto _out
+                }
+        _resume:
+                _keys = int(_formatfsm_key_offsets[cs])
+                _trans = int(_formatfsm_index_offsets[cs])
+
+                _klen = int(_formatfsm_single_lengths[cs])
+                if _klen > 0 {
+                        _lower := int(_keys)
+                        var _mid int
+                        _upper := int(_keys + _klen - 1)
+                        for {
+                                if _upper < _lower {
+                                        break
+                                }
+
+                                _mid = _lower + ((_upper - _lower) >> 1)
+                                switch {
+                                case data[p] < _formatfsm_trans_keys[_mid]:
+                                        _upper = _mid - 1
+                                case data[p] > _formatfsm_trans_keys[_mid]:
+                                        _lower = _mid + 1
+                                default:
+                                        _trans += int(_mid - int(_keys))
+                                        goto _match
+                                }
+                        }
+                        _keys += _klen
+                        _trans += _klen
+                }
+
+                _klen = int(_formatfsm_range_lengths[cs])
+                if _klen > 0 {
+                        _lower := int(_keys)
+                        var _mid int
+                        _upper := int(_keys + (_klen << 1) - 2)
+                        for {
+                                if _upper < _lower {
+                                        break
+                                }
+
+                                _mid = _lower + (((_upper - _lower) >> 1) & ^1)
+                                switch {
+                                case data[p] < _formatfsm_trans_keys[_mid]:
+                                        _upper = _mid - 2
+                                case data[p] > _formatfsm_trans_keys[_mid+1]:
+                                        _lower = _mid + 2
+                                default:
+                                        _trans += int((_mid - int(_keys)) >> 1)
+                                        goto _match
+                                }
+                        }
+                        _trans += _klen
+                }
+
+        _match:
+                _trans = int(_formatfsm_indicies[_trans])
+                cs = int(_formatfsm_trans_targs[_trans])
+
+                if _formatfsm_trans_actions[_trans] == 0 {
+                        goto _again
+                }
+
+                _acts = int(_formatfsm_trans_actions[_trans])
+                _nacts = uint(_formatfsm_actions[_acts])
+                _acts++
+                for ; _nacts > 0; _nacts-- {
+                        _acts++
+                        switch _formatfsm_actions[_acts-1] {
+                        case 0:
+                                // line 29 "format_fsm.rl"
+
+                                verb = formatVerb{
+                                        ArgNum: nextArg,
+                                        Prec:   -1,
+                                        Width:  -1,
+                                }
+                                ts = p
+
+                        case 1:
+                                // line 38 "format_fsm.rl"
+
+                                buf.WriteByte(data[p])
+
+                        case 4:
+                                // line 49 "format_fsm.rl"
+
+                                // We'll try to slurp a whole UTF-8 sequence here, to give the user
+                                // better feedback.
+                                r, _ := utf8.DecodeRuneInString(data[p:])
+                                return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+                        case 5:
+                                // line 56 "format_fsm.rl"
+
+                                verb.Sharp = true
+
+                        case 6:
+                                // line 59 "format_fsm.rl"
+
+                                verb.Zero = true
+
+                        case 7:
+                                // line 62 "format_fsm.rl"
+
+                                verb.Minus = true
+
+                        case 8:
+                                // line 65 "format_fsm.rl"
+
+                                verb.Plus = true
+
+                        case 9:
+                                // line 68 "format_fsm.rl"
+
+                                verb.Space = true
+
+                        case 10:
+                                // line 72 "format_fsm.rl"
+
+                                verb.ArgNum = 0
+
+                        case 11:
+                                // line 75 "format_fsm.rl"
+
+                                verb.ArgNum = (10 * verb.ArgNum) + (int(data[p]) - '0')
+
+                        case 12:
+                                // line 79 "format_fsm.rl"
+
+                                verb.HasWidth = true
+
+                        case 13:
+                                // line 82 "format_fsm.rl"
+
+                                verb.Width = 0
+
+                        case 14:
+                                // line 85 "format_fsm.rl"
+
+                                verb.Width = (10 * verb.Width) + (int(data[p]) - '0')
+
+                        case 15:
+                                // line 89 "format_fsm.rl"
+
+                                verb.HasPrec = true
+
+                        case 16:
+                                // line 92 "format_fsm.rl"
+
+                                verb.Prec = 0
+
+                        case 17:
+                                // line 95 "format_fsm.rl"
+
+                                verb.Prec = (10 * verb.Prec) + (int(data[p]) - '0')
+
+                        case 18:
+                                // line 99 "format_fsm.rl"
+
+                                verb.Mode = rune(data[p])
+                                te = p + 1
+                                verb.Raw = data[ts:te]
+                                verb.Offset = ts
+
+                                err := formatAppend(&verb, &buf, a)
+                                if err != nil {
+                                        return buf.String(), err
+                                }
+                                nextArg = verb.ArgNum + 1
+
+                                // line 324 "format_fsm.go"
+                        }
+                }
+
+        _again:
+                if cs == 0 {
+                        goto _out
+                }
+                p++
+                if p != pe {
+                        goto _resume
+                }
+        _test_eof:
+                {
+                }
+                if p == eof {
+                        __acts := _formatfsm_eof_actions[cs]
+                        __nacts := uint(_formatfsm_actions[__acts])
+                        __acts++
+                        for ; __nacts > 0; __nacts-- {
+                                __acts++
+                                switch _formatfsm_actions[__acts-1] {
+                                case 2:
+                                        // line 42 "format_fsm.rl"
+
+                                case 3:
+                                        // line 45 "format_fsm.rl"
+
+                                        return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+
+                                case 4:
+                                        // line 49 "format_fsm.rl"
+
+                                        // We'll try to slurp a whole UTF-8 sequence here, to give the user
+                                        // better feedback.
+                                        r, _ := utf8.DecodeRuneInString(data[p:])
+                                        return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+
+                                        // line 363 "format_fsm.go"
+                                }
+                        }
+                }
+
+        _out:
+                {
+                }
+        }
+
+        // line 171 "format_fsm.rl"
+
+        // If we fall out here without being in a final state then we've
+        // encountered something that the scanner can't match, which should
+        // be impossible (the scanner matches all bytes _somehow_) but we'll
+        // flag it anyway rather than just losing data from the end.
+        if cs < formatfsm_first_final {
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+        }
+
+        return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
new file mode 100644
index 0000000..85d43bb
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/format_fsm.rl
@@ -0,0 +1,182 @@
+// This file is generated from format_fsm.rl. DO NOT EDIT.
+%%{
+        # (except you are actually in scan_tokens.rl here, so edit away!)
+        machine formatfsm;
+}%%
+
+package stdlib
+
+import (
+        "bytes"
+        "fmt"
+        "unicode/utf8"
+
+        "github.com/zclconf/go-cty/cty"
+)
+
+%%{
+        write data;
+}%%
+
+func formatFSM(format string, a []cty.Value) (string, error) {
+        var buf bytes.Buffer
+        data := format
+        nextArg := 1 // arg numbers are 1-based
+        var verb formatVerb
+
+        %%{
+
+        action begin {
+                verb = formatVerb{
+                        ArgNum: nextArg,
+                        Prec:   -1,
+                        Width:  -1,
+                }
+                ts = p
+        }
+
+        action emit {
+                buf.WriteByte(fc);
+        }
+
+        action finish_ok {
+        }
+
+        action finish_err {
+                return buf.String(), fmt.Errorf("invalid format string starting at offset %d", p)
+        }
+
+        action err_char {
+                // We'll try to slurp a whole UTF-8 sequence here, to give the user
+                // better feedback.
+                r, _ := utf8.DecodeRuneInString(data[p:])
+                return buf.String(), fmt.Errorf("unrecognized format character %q at offset %d", r, p)
+        }
+
+        action flag_sharp {
+                verb.Sharp = true
+        }
+        action flag_zero {
+                verb.Zero = true
+        }
+        action flag_minus {
+                verb.Minus = true
+        }
+        action flag_plus {
+                verb.Plus = true
+        }
+        action flag_space {
+                verb.Space = true
+        }
+
+        action argidx_reset {
+                verb.ArgNum = 0
+        }
+        action argidx_num {
+                verb.ArgNum = (10 * verb.ArgNum) + (int(fc) - '0')
+        }
+
+        action has_width {
+                verb.HasWidth = true
+        }
+        action width_reset {
+                verb.Width = 0
+        }
+        action width_num {
+                verb.Width = (10 * verb.Width) + (int(fc) - '0')
+        }
+
+        action has_prec {
+                verb.HasPrec = true
+        }
+        action prec_reset {
+                verb.Prec = 0
+        }
+        action prec_num {
+                verb.Prec = (10 * verb.Prec) + (int(fc) - '0')
+        }
+
+        action mode {
+                verb.Mode = rune(fc)
+                te = p+1
+                verb.Raw = data[ts:te]
+                verb.Offset = ts
+
+                err := formatAppend(&verb, &buf, a)
+                if err != nil {
+                        return buf.String(), err
+                }
+                nextArg = verb.ArgNum + 1
+        }
+
+        # a number that isn't zero and doesn't have a leading zero
+        num = [1-9] [0-9]*;
+
+        flags = (
+                '0' @flag_zero |
+                '#' @flag_sharp |
+                '-' @flag_minus |
+                '+' @flag_plus |
+                ' ' @flag_space
+        )*;
+
+        argidx = ((
+                '[' (num $argidx_num) ']'
+        ) >argidx_reset)?;
+
+        width = (
+                ( num $width_num ) >width_reset %has_width
+        )?;
+
+        precision = (
+                ('.' ( digit* $prec_num )) >prec_reset %has_prec
+        )?;
+
+        # We accept any letter here, but will be more picky in formatAppend
+        mode = ('a'..'z' | 'A'..'Z') @mode;
+
+        fmt_verb = (
+                '%' @begin
+                flags
+                width
+                precision
+                argidx
+                mode
+        );
+
+        main := (
+                [^%] @emit |
+                '%%' @emit |
+                fmt_verb
+        )* @/finish_err %/finish_ok $!err_char;
+
+        }%%
+
+        // Ragel state
+        p := 0  // "Pointer" into data
+        pe := len(data) // End-of-data "pointer"
+        cs := 0 // current state (will be initialized by ragel-generated code)
+        ts := 0
+        te := 0
+        eof := pe
+
+        // Keep Go compiler happy even if generated code doesn't use these
+        _ = ts
+        _ = te
+        _ = eof
+
+        %%{
+                write init;
+                write exec;
+        }%%
+
+        // If we fall out here without being in a final state then we've
+        // encountered something that the scanner can't match, which should
+        // be impossible (the scanner matches all bytes _somehow_) but we'll
+        // flag it anyway rather than just losing data from the end.
+        if cs < formatfsm_first_final {
+                return buf.String(), fmt.Errorf("extraneous characters beginning at offset %i", p)
+        }
+
+        return buf.String(), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
new file mode 100644
index 0000000..6b31f26
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
@@ -0,0 +1,107 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var EqualFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].Equals(args[1]), nil
+        },
+})
+
+var NotEqualFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.DynamicPseudoType,
+                        AllowUnknown:     true,
+                        AllowDynamicType: true,
+                        AllowNull:        true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].Equals(args[1]).Not(), nil
+        },
+})
+
+var CoalesceFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name:             "vals",
+                Type:             cty.DynamicPseudoType,
+                AllowUnknown:     true,
+                AllowDynamicType: true,
+                AllowNull:        true,
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                argTypes := make([]cty.Type, len(args))
+                for i, val := range args {
+                        argTypes[i] = val.Type()
+                }
+                retType, _ := convert.UnifyUnsafe(argTypes)
+                if retType == cty.NilType {
+                        return cty.NilType, fmt.Errorf("all arguments must have the same type")
+                }
+                return retType, nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                for _, argVal := range args {
+                        if !argVal.IsKnown() {
+                                return cty.UnknownVal(retType), nil
+                        }
+                        if argVal.IsNull() {
+                                continue
+                        }
+
+                        return convert.Convert(argVal, retType)
+                }
+                return cty.NilVal, fmt.Errorf("no non-null arguments")
+        },
+})
+
+// Equal determines whether the two given values are equal, returning a
+// bool value.
+func Equal(a cty.Value, b cty.Value) (cty.Value, error) {
+        return EqualFunc.Call([]cty.Value{a, b})
+}
+
+// NotEqual is the opposite of Equal.
+func NotEqual(a cty.Value, b cty.Value) (cty.Value, error) {
+        return NotEqualFunc.Call([]cty.Value{a, b})
+}
+
+// Coalesce returns the first of the given arguments that is not null. If
+// all arguments are null, an error is produced.
+func Coalesce(vals ...cty.Value) (cty.Value, error) {
+        return CoalesceFunc.Call(vals)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
new file mode 100644
index 0000000..07901c6
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
@@ -0,0 +1,72 @@
+package stdlib
+
+import (
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/json"
+)
+
+var JSONEncodeFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "val",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                val := args[0]
+                if !val.IsWhollyKnown() {
+                        // We can't serialize unknowns, so if the value is unknown or
+                        // contains any _nested_ unknowns then our result must be
+                        // unknown.
+                        return cty.UnknownVal(retType), nil
+                }
+
+                buf, err := json.Marshal(val, val.Type())
+                if err != nil {
+                        return cty.NilVal, err
+                }
+
+                return cty.StringVal(string(buf)), nil
+        },
+})
+
+var JSONDecodeFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name: "str",
+                        Type: cty.String,
+                },
+        },
+        Type: func(args []cty.Value) (cty.Type, error) {
+                str := args[0]
+                if !str.IsKnown() {
+                        return cty.DynamicPseudoType, nil
+                }
+
+                buf := []byte(str.AsString())
+                return json.ImpliedType(buf)
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                buf := []byte(args[0].AsString())
+                return json.Unmarshal(buf, retType)
+        },
+})
+
+// JSONEncode returns a JSON serialization of the given value.
+func JSONEncode(val cty.Value) (cty.Value, error) {
+        return JSONEncodeFunc.Call([]cty.Value{val})
+}
+
+// JSONDecode parses the given JSON string and, if it is valid, returns the
+// value it represents.
+//
+// Note that applying JSONDecode to the result of JSONEncode may not produce
+// an identically-typed result, since JSON encoding is lossy for cty Types.
+// The resulting value will consist only of primitive types, object types, and
+// tuple types.
+func JSONDecode(str cty.Value) (cty.Value, error) {
+        return JSONDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
new file mode 100644
index 0000000..bd9b2e5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
@@ -0,0 +1,428 @@
+package stdlib
+
+import (
+        "fmt"
+        "math/big"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var AbsoluteFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "num",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Absolute(), nil
+        },
+})
+
+var AddFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Add can panic if the input values are opposing infinities,
+                // so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't compute sum of opposing infinities")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+                return args[0].Add(args[1]), nil
+        },
+})
+
+var SubtractFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Sub can panic if the input values are infinities,
+                // so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't subtract infinity from itself")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+                return args[0].Subtract(args[1]), nil
+        },
+})
+
+var MultiplyFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Mul can panic if the input values are both zero or both
+                // infinity, so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't multiply zero by infinity")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+
+                return args[0].Multiply(args[1]), nil
+        },
+})
+
+var DivideFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Quo can panic if the input values are both zero or both
+                // infinity, so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't divide zero by zero or infinity by infinity")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+
+                return args[0].Divide(args[1]), nil
+        },
+})
+
+var ModuloFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                // big.Float.Mul can panic if the input values are both zero or both
+                // infinity, so we must catch that here in order to remain within
+                // the cty Function abstraction.
+                defer func() {
+                        if r := recover(); r != nil {
+                                if _, ok := r.(big.ErrNaN); ok {
+                                        ret = cty.NilVal
+                                        err = fmt.Errorf("can't use modulo with zero and infinity")
+                                } else {
+                                        // not a panic we recognize
+                                        panic(r)
+                                }
+                        }
+                }()
+
+                return args[0].Modulo(args[1]), nil
+        },
+})
+
+var GreaterThanFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].GreaterThan(args[1]), nil
+        },
+})
+
+var GreaterThanOrEqualToFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].GreaterThanOrEqualTo(args[1]), nil
+        },
+})
+
+var LessThanFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].LessThan(args[1]), nil
+        },
+})
+
+var LessThanOrEqualToFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].LessThanOrEqualTo(args[1]), nil
+        },
+})
+
+var NegateFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "num",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                return args[0].Negate(), nil
+        },
+})
+
+var MinFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name:             "numbers",
+                Type:             cty.Number,
+                AllowDynamicType: true,
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                if len(args) == 0 {
+                        return cty.NilVal, fmt.Errorf("must pass at least one number")
+                }
+
+                min := cty.PositiveInfinity
+                for _, num := range args {
+                        if num.LessThan(min).True() {
+                                min = num
+                        }
+                }
+
+                return min, nil
+        },
+})
+
+var MaxFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name:             "numbers",
+                Type:             cty.Number,
+                AllowDynamicType: true,
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                if len(args) == 0 {
+                        return cty.NilVal, fmt.Errorf("must pass at least one number")
+                }
+
+                max := cty.NegativeInfinity
+                for _, num := range args {
+                        if num.GreaterThan(max).True() {
+                                max = num
+                        }
+                }
+
+                return max, nil
+        },
+})
+
+var IntFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "num",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                bf := args[0].AsBigFloat()
+                if bf.IsInt() {
+                        return args[0], nil
+                }
+                bi, _ := bf.Int(nil)
+                bf = (&big.Float{}).SetInt(bi)
+                return cty.NumberVal(bf), nil
+        },
+})
+
+// Absolute returns the magnitude of the given number, without its sign.
+// That is, it turns negative values into positive values.
+func Absolute(num cty.Value) (cty.Value, error) {
+        return AbsoluteFunc.Call([]cty.Value{num})
+}
+
+// Add returns the sum of the two given numbers.
+func Add(a cty.Value, b cty.Value) (cty.Value, error) {
+        return AddFunc.Call([]cty.Value{a, b})
+}
+
+// Subtract returns the difference between the two given numbers.
+func Subtract(a cty.Value, b cty.Value) (cty.Value, error) {
+        return SubtractFunc.Call([]cty.Value{a, b})
+}
+
+// Multiply returns the product of the two given numbers.
+func Multiply(a cty.Value, b cty.Value) (cty.Value, error) {
+        return MultiplyFunc.Call([]cty.Value{a, b})
+}
+
+// Divide returns a divided by b, where both a and b are numbers.
+func Divide(a cty.Value, b cty.Value) (cty.Value, error) {
+        return DivideFunc.Call([]cty.Value{a, b})
+}
+
+// Negate returns the given number multipled by -1.
+func Negate(num cty.Value) (cty.Value, error) {
+        return NegateFunc.Call([]cty.Value{num})
+}
+
+// LessThan returns true if a is less than b.
+func LessThan(a cty.Value, b cty.Value) (cty.Value, error) {
+        return LessThanFunc.Call([]cty.Value{a, b})
+}
+
+// LessThanOrEqualTo returns true if a is less than b.
+func LessThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+        return LessThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThan returns true if a is less than b.
+func GreaterThan(a cty.Value, b cty.Value) (cty.Value, error) {
+        return GreaterThanFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThanOrEqualTo returns true if a is less than b.
+func GreaterThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+        return GreaterThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// Modulo returns the remainder of a divided by b under integer division,
+// where both a and b are numbers.
+func Modulo(a cty.Value, b cty.Value) (cty.Value, error) {
+        return ModuloFunc.Call([]cty.Value{a, b})
+}
+
+// Min returns the minimum number from the given numbers.
+func Min(numbers ...cty.Value) (cty.Value, error) {
+        return MinFunc.Call(numbers)
+}
+
+// Max returns the maximum number from the given numbers.
+func Max(numbers ...cty.Value) (cty.Value, error) {
+        return MaxFunc.Call(numbers)
+}
+
+// Int removes the fractional component of the given number returning an
+// integer representing the whole number component, rounding towards zero.
+// For example, -1.5 becomes -1.
+//
+// If an infinity is passed to Int, an error is returned.
+func Int(num cty.Value) (cty.Value, error) {
+        if num == cty.PositiveInfinity || num == cty.NegativeInfinity {
+                return cty.NilVal, fmt.Errorf("can't truncate infinity to an integer")
+        }
+        return IntFunc.Call([]cty.Value{num})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
new file mode 100644
index 0000000..e2c77c5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -0,0 +1,130 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/convert"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var ConcatFunc = function.New(&function.Spec{
+        Params: []function.Parameter{},
+        VarParam: &function.Parameter{
+                Name: "seqs",
+                Type: cty.DynamicPseudoType,
+        },
+        Type: func(args []cty.Value) (ret cty.Type, err error) {
+                if len(args) == 0 {
+                        return cty.NilType, fmt.Errorf("at least one argument is required")
+                }
+
+                if args[0].Type().IsListType() {
+                        // Possibly we're going to return a list, if all of our other
+                        // args are also lists and we can find a common element type.
+                        tys := make([]cty.Type, len(args))
+                        for i, val := range args {
+                                ty := val.Type()
+                                if !ty.IsListType() {
+                                        tys = nil
+                                        break
+                                }
+                                tys[i] = ty
+                        }
+
+                        if tys != nil {
+                                commonType, _ := convert.UnifyUnsafe(tys)
+                                if commonType != cty.NilType {
+                                        return commonType, nil
+                                }
+                        }
+                }
+
+                etys := make([]cty.Type, 0, len(args))
+                for i, val := range args {
+                        ety := val.Type()
+                        switch {
+                        case ety.IsTupleType():
+                                etys = append(etys, ety.TupleElementTypes()...)
+                        case ety.IsListType():
+                                if !val.IsKnown() {
+                                        // We need to know the list to count its elements to
+                                        // build our tuple type, so any concat of an unknown
+                                        // list can't be typed yet.
+                                        return cty.DynamicPseudoType, nil
+                                }
+
+                                l := val.LengthInt()
+                                subEty := ety.ElementType()
+                                for j := 0; j < l; j++ {
+                                        etys = append(etys, subEty)
+                                }
+                        default:
+                                return cty.NilType, function.NewArgErrorf(
+                                        i, "all arguments must be lists or tuples; got %s",
+                                        ety.FriendlyName(),
+                                )
+                        }
+                }
+                return cty.Tuple(etys), nil
+        },
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                switch {
+                case retType.IsListType():
+                        // If retType is a list type then we know that all of the
+                        // given values will be lists and that they will either be of
+                        // retType or of something we can convert to retType.
+                        vals := make([]cty.Value, 0, len(args))
+                        for i, list := range args {
+                                list, err = convert.Convert(list, retType)
+                                if err != nil {
+                                        // Conversion might fail because we used UnifyUnsafe
+                                        // to choose our return type.
+                                        return cty.NilVal, function.NewArgError(i, err)
+                                }
+
+                                it := list.ElementIterator()
+                                for it.Next() {
+                                        _, v := it.Element()
+                                        vals = append(vals, v)
+                                }
+                        }
+                        if len(vals) == 0 {
+                                return cty.ListValEmpty(retType.ElementType()), nil
+                        }
+
+                        return cty.ListVal(vals), nil
+                case retType.IsTupleType():
+                        // If retType is a tuple type then we could have a mixture of
+                        // lists and tuples but we know they all have known values
+                        // (because our params don't AllowUnknown) and we know that
+                        // concatenating them all together will produce a tuple of
+                        // retType because of the work we did in the Type function above.
+                        vals := make([]cty.Value, 0, len(args))
+
+                        for _, seq := range args {
+                                // Both lists and tuples support ElementIterator, so this is easy.
+                                it := seq.ElementIterator()
+                                for it.Next() {
+                                        _, v := it.Element()
+                                        vals = append(vals, v)
+                                }
+                        }
+
+                        return cty.TupleVal(vals), nil
+                default:
+                        // should never happen if Type is working correctly above
+                        panic("unsupported return type")
+                }
+        },
+})
+
+// Concat takes one or more sequences (lists or tuples) and returns the single
+// sequence that results from concatenating them together in order.
+//
+// If all of the given sequences are lists of the same element type then the
+// result is a list of that type. Otherwise, the result is a of a tuple type
+// constructed from the given sequence types.
+func Concat(seqs ...cty.Value) (cty.Value, error) {
+        return ConcatFunc.Call(seqs)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
new file mode 100644
index 0000000..100078f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/set.go
@@ -0,0 +1,195 @@
+package stdlib
+
+import (
+        "fmt"
+
+        "github.com/zclconf/go-cty/cty/convert"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+)
+
+var SetHasElementFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "elem",
+                        Type:             cty.DynamicPseudoType,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Bool),
+        Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                return args[0].HasElement(args[1]), nil
+        },
+})
+
+var SetUnionFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "first_set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:             "other_sets",
+                Type:             cty.Set(cty.DynamicPseudoType),
+                AllowDynamicType: true,
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Union(s2)
+        }),
+})
+
+var SetIntersectionFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "first_set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:             "other_sets",
+                Type:             cty.Set(cty.DynamicPseudoType),
+                AllowDynamicType: true,
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Intersection(s2)
+        }),
+})
+
+var SetSubtractFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "a",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "b",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Subtract(s2)
+        }),
+})
+
+var SetSymmetricDifferenceFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "first_set",
+                        Type:             cty.Set(cty.DynamicPseudoType),
+                        AllowDynamicType: true,
+                },
+        },
+        VarParam: &function.Parameter{
+                Name:             "other_sets",
+                Type:             cty.Set(cty.DynamicPseudoType),
+                AllowDynamicType: true,
+        },
+        Type: setOperationReturnType,
+        Impl: setOperationImpl(func(s1, s2 cty.ValueSet) cty.ValueSet {
+                return s1.Subtract(s2)
+        }),
+})
+
+// SetHasElement determines whether the given set contains the given value as an
+// element.
+func SetHasElement(set cty.Value, elem cty.Value) (cty.Value, error) {
+        return SetHasElementFunc.Call([]cty.Value{set, elem})
+}
+
+// SetUnion returns a new set containing all of the elements from the given
+// sets, which must have element types that can all be converted to some
+// common type using the standard type unification rules. If conversion
+// is not possible, an error is returned.
+//
+// The union operation is performed after type conversion, which may result
+// in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetUnion(sets ...cty.Value) (cty.Value, error) {
+        return SetUnionFunc.Call(sets)
+}
+
+// Intersection returns a new set containing the elements that exist
+// in all of the given sets, which must have element types that can all be
+// converted to some common type using the standard type unification rules.
+// If conversion is not possible, an error is returned.
+//
+// The intersection operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+//
+// At least one set must be provided.
+func SetIntersection(sets ...cty.Value) (cty.Value, error) {
+        return SetIntersectionFunc.Call(sets)
+}
+
+// SetSubtract returns a new set containing the elements from the
+// first set that are not present in the second set. The sets must have
+// element types that can both be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The subtract operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSubtract(a, b cty.Value) (cty.Value, error) {
+        return SetSubtractFunc.Call([]cty.Value{a, b})
+}
+
+// SetSymmetricDifference returns a new set containing elements that appear
+// in any of the given sets but not multiple. The sets must have
+// element types that can all be converted to some common type using the
+// standard type unification rules. If conversion is not possible, an error
+// is returned.
+//
+// The difference operation is performed after type conversion, which may
+// result in some previously-distinct values being conflated.
+func SetSymmetricDifference(sets ...cty.Value) (cty.Value, error) {
+        return SetSymmetricDifferenceFunc.Call(sets)
+}
+
+func setOperationReturnType(args []cty.Value) (ret cty.Type, err error) {
+        var etys []cty.Type
+        for _, arg := range args {
+                etys = append(etys, arg.Type().ElementType())
+        }
+        newEty, _ := convert.UnifyUnsafe(etys)
+        if newEty == cty.NilType {
+                return cty.NilType, fmt.Errorf("given sets must all have compatible element types")
+        }
+        return cty.Set(newEty), nil
+}
+
+func setOperationImpl(f func(s1, s2 cty.ValueSet) cty.ValueSet) function.ImplFunc {
+        return func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+                first := args[0]
+                first, err = convert.Convert(first, retType)
+                if err != nil {
+                        return cty.NilVal, function.NewArgError(0, err)
+                }
+
+                set := first.AsValueSet()
+                for i, arg := range args[1:] {
+                        arg, err := convert.Convert(arg, retType)
+                        if err != nil {
+                                return cty.NilVal, function.NewArgError(i+1, err)
+                        }
+
+                        argSet := arg.AsValueSet()
+                        set = f(set, argSet)
+                }
+                return cty.SetValFromValueSet(set), nil
+        }
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
new file mode 100644
index 0000000..d7c89fa
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
@@ -0,0 +1,234 @@
+package stdlib
+
+import (
+        "strings"
+
+        "github.com/zclconf/go-cty/cty"
+        "github.com/zclconf/go-cty/cty/function"
+        "github.com/zclconf/go-cty/cty/gocty"
+        "github.com/apparentlymart/go-textseg/textseg"
+)
+
+var UpperFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := args[0].AsString()
+                out := strings.ToUpper(in)
+                return cty.StringVal(out), nil
+        },
+})
+
+var LowerFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := args[0].AsString()
+                out := strings.ToLower(in)
+                return cty.StringVal(out), nil
+        },
+})
+
+var ReverseFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := []byte(args[0].AsString())
+                out := make([]byte, len(in))
+                pos := len(out)
+
+                inB := []byte(in)
+                for i := 0; i < len(in); {
+                        d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+                        cluster := in[i : i+d]
+                        pos -= len(cluster)
+                        copy(out[pos:], cluster)
+                        i += d
+                }
+
+                return cty.StringVal(string(out)), nil
+        },
+})
+
+var StrlenFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.Number),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := args[0].AsString()
+                l := 0
+
+                inB := []byte(in)
+                for i := 0; i < len(in); {
+                        d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+                        l++
+                        i += d
+                }
+
+                return cty.NumberIntVal(int64(l)), nil
+        },
+})
+
+var SubstrFunc = function.New(&function.Spec{
+        Params: []function.Parameter{
+                {
+                        Name:             "str",
+                        Type:             cty.String,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "offset",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+                {
+                        Name:             "length",
+                        Type:             cty.Number,
+                        AllowDynamicType: true,
+                },
+        },
+        Type: function.StaticReturnType(cty.String),
+        Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+                in := []byte(args[0].AsString())
+                var offset, length int
+
+                var err error
+                err = gocty.FromCtyValue(args[1], &offset)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+                err = gocty.FromCtyValue(args[2], &length)
+                if err != nil {
+                        return cty.NilVal, err
+                }
+
+                if offset < 0 {
+                        totalLenNum, err := Strlen(args[0])
+                        if err != nil {
+                                // should never happen
+                                panic("Stdlen returned an error")
+                        }
+
+                        var totalLen int
+                        err = gocty.FromCtyValue(totalLenNum, &totalLen)
+                        if err != nil {
+                                // should never happen
+                                panic("Stdlen returned a non-int number")
+                        }
+
+                        offset += totalLen
+                }
+
+                sub := in
+                pos := 0
+                var i int
+
+                // First we'll seek forward to our offset
+                if offset > 0 {
+                        for i = 0; i < len(sub); {
+                                d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+                                i += d
+                                pos++
+                                if pos == offset {
+                                        break
+                                }
+                                if i >= len(in) {
+                                        return cty.StringVal(""), nil
+                                }
+                        }
+
+                        sub = sub[i:]
+                }
+
+                if length < 0 {
+                        // Taking the remainder of the string is a fast path since
+                        // we can just return the rest of the buffer verbatim.
+                        return cty.StringVal(string(sub)), nil
+                }
+
+                // Otherwise we need to start seeking forward again until we
+                // reach the length we want.
+                pos = 0
+                for i = 0; i < len(sub); {
+                        d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+                        i += d
+                        pos++
+                        if pos == length {
+                                break
+                        }
+                }
+
+                sub = sub[:i]
+
+                return cty.StringVal(string(sub)), nil
+        },
+})
+
+// Upper is a Function that converts a given string to uppercase.
+func Upper(str cty.Value) (cty.Value, error) {
+        return UpperFunc.Call([]cty.Value{str})
+}
+
+// Lower is a Function that converts a given string to lowercase.
+func Lower(str cty.Value) (cty.Value, error) {
+        return LowerFunc.Call([]cty.Value{str})
+}
+
+// Reverse is a Function that reverses the order of the characters in the
+// given string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Reverse(str cty.Value) (cty.Value, error) {
+        return ReverseFunc.Call([]cty.Value{str})
+}
+
+// Strlen is a Function that returns the length of the given string in
+// characters.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Strlen(str cty.Value) (cty.Value, error) {
+        return StrlenFunc.Call([]cty.Value{str})
+}
+
+// Substr is a Function that extracts a sequence of characters from another
+// string and creates a new string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+//
+// The "offset" index may be negative, in which case it is relative to the
+// end of the given string.
+//
+// The "length" may be -1, in which case the remainder of the string after
+// the given offset will be returned.
+func Substr(str cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+        return SubstrFunc.Call([]cty.Value{str, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go b/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go
new file mode 100644
index 0000000..3495550
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/unpredictable.go
@@ -0,0 +1,31 @@
+package function
+
+import (
+        "github.com/zclconf/go-cty/cty"
+)
+
+// Unpredictable wraps a given function such that it retains the same arguments
+// and type checking behavior but will return an unknown value when called.
+//
+// It is recommended that most functions be "pure", which is to say that they
+// will always produce the same value given particular input. However,
+// sometimes it is necessary to offer functions whose behavior depends on
+// some external state, such as reading a file or determining the current time.
+// In such cases, an unpredictable wrapper might be used to stand in for
+// the function during some sort of prior "checking" phase in order to delay
+// the actual effect until later.
+//
+// While Unpredictable can support a function that isn't pure in its
+// implementation, it still expects a function to be pure in its type checking
+// behavior, except for the special case of returning cty.DynamicPseudoType
+// if it is not yet able to predict its return value based on current argument
+// information.
+func Unpredictable(f Function) Function {
+        newSpec := *f.spec // shallow copy
+        newSpec.Impl = unpredictableImpl
+        return New(&newSpec)
+}
+
+func unpredictableImpl(args []cty.Value, retType cty.Type) (cty.Value, error) {
+        return cty.UnknownVal(retType), nil
+}