From b865d62bb843621aa0e2bd1fa21269959b1aaaf0 Mon Sep 17 00:00:00 2001
From: Martin Atkins <mart@degeneration.co.uk>
Date: Fri, 2 Feb 2018 11:15:48 -0800
Subject: [PATCH] govendor fetch github.com/hashicorp/hcl2/...

This just catches us up with the latest fixes and improvements in upstream
HCL2.
---
 .../hashicorp/hcl2/hcl/diagnostic_text.go     |   85 +-
 .../hashicorp/hcl2/hcl/expr_list.go           |   37 +
 .../hashicorp/hcl2/hcl/expr_unwrap.go         |   68 +
 .../hashicorp/hcl2/hcl/hclsyntax/doc.go       |    4 +-
 .../hcl2/hcl/hclsyntax/expression.go          |   16 +-
 .../hashicorp/hcl2/hcl/hclsyntax/generate.go  |    2 +
 .../hcl2/hcl/hclsyntax/navigation.go          |    2 +-
 .../hashicorp/hcl2/hcl/hclsyntax/parser.go    |  247 +-
 .../hcl2/hcl/hclsyntax/parser_template.go     |    4 +-
 .../hashicorp/hcl2/hcl/hclsyntax/public.go    |   30 +-
 .../hcl2/hcl/hclsyntax/scan_string_lit.go     |  301 +++
 .../hcl2/hcl/hclsyntax/scan_string_lit.rl     |  105 +
 .../hcl2/hcl/hclsyntax/scan_tokens.go         | 2329 ++++++++++++++---
 .../hcl2/hcl/hclsyntax/scan_tokens.rl         |   36 +-
 .../hashicorp/hcl2/hcl/hclsyntax/structure.go |    2 +-
 .../hashicorp/hcl2/hcl/hclsyntax/token.go     |    1 +
 .../hcl2/hcl/hclsyntax/token_type_string.go   |    4 +-
 .../hashicorp/hcl2/hcl/json/navigation.go     |    2 +-
 .../hashicorp/hcl2/hcl/json/parser.go         |    2 +-
 .../hashicorp/hcl2/hcl/json/public.go         |   29 +-
 .../hashicorp/hcl2/hcl/json/spec.md           |    2 +-
 .../hashicorp/hcl2/hcl/json/structure.go      |   74 +-
 vendor/github.com/hashicorp/hcl2/hcl/ops.go   |    2 +-
 vendor/github.com/hashicorp/hcl2/hcl/pos.go   |  166 ++
 .../hashicorp/hcl2/hcl/pos_scanner.go         |  148 ++
 vendor/github.com/hashicorp/hcl2/hcl/spec.md  |    4 +-
 .../hashicorp/hcl2/hcl/traversal.go           |   28 +
 .../hashicorp/hcl2/hcl/traversal_for_expr.go  |  121 +
 .../hashicorp/hcl2/hcldec/public.go           |   25 +
 .../github.com/hashicorp/hcl2/hcldec/spec.go  |  139 +
 .../github.com/hashicorp/hcl2/hcltest/mock.go |  124 +-
 .../github.com/hashicorp/hcl2/hclwrite/ast.go |    2 +-
 .../hashicorp/hcl2/hclwrite/format.go         |    2 +-
 .../hashicorp/hcl2/hclwrite/parser.go         |   14 +-
 .../hashicorp/hcl2/hclwrite/public.go         |    2 +-
 .../hashicorp/hcl2/hclwrite/tokens.go         |    4 +-
 vendor/vendor.json                            |   48 +-
 37 files changed, 3532 insertions(+), 679 deletions(-)
 create mode 100644 vendor/github.com/hashicorp/hcl2/hcl/expr_list.go
 create mode 100644 vendor/github.com/hashicorp/hcl2/hcl/expr_unwrap.go
 create mode 100644 vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go
 create mode 100644 vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.rl
 create mode 100644 vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go
 create mode 100644 vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go

diff --git a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go
index 9776f04de4..dfa473add8 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go
@@ -2,7 +2,6 @@ package hcl
 
 import (
 	"bufio"
-	"bytes"
 	"errors"
 	"fmt"
 	"io"
@@ -43,7 +42,7 @@ func (w *diagnosticTextWriter) WriteDiagnostic(diag *Diagnostic) error {
 		return errors.New("nil diagnostic")
 	}
 
-	var colorCode, resetCode string
+	var colorCode, highlightCode, resetCode string
 	if w.color {
 		switch diag.Severity {
 		case DiagError:
@@ -52,6 +51,7 @@ func (w *diagnosticTextWriter) WriteDiagnostic(diag *Diagnostic) error {
 			colorCode = "\x1b[33m"
 		}
 		resetCode = "\x1b[0m"
+		highlightCode = "\x1b[1;4m"
 	}
 
 	var severityStr string
@@ -68,24 +68,31 @@ func (w *diagnosticTextWriter) WriteDiagnostic(diag *Diagnostic) error {
 	fmt.Fprintf(w.wr, "%s%s%s: %s\n\n", colorCode, severityStr, resetCode, diag.Summary)
 
 	if diag.Subject != nil {
+		snipRange := *diag.Subject
+		highlightRange := snipRange
+		if diag.Context != nil {
+			// Show enough of the source code to include both the subject
+			// and context ranges, which overlap in all reasonable
+			// situations.
+			snipRange = RangeOver(snipRange, *diag.Context)
+		}
+		// We can't illustrate an empty range, so we'll turn such ranges into
+		// single-character ranges, which might not be totally valid (may point
+		// off the end of a line, or off the end of the file) but are good
+		// enough for the bounds checks we do below.
+		if snipRange.Empty() {
+			snipRange.End.Byte++
+			snipRange.End.Column++
+		}
+		if highlightRange.Empty() {
+			highlightRange.End.Byte++
+			highlightRange.End.Column++
+		}
 
 		file := w.files[diag.Subject.Filename]
 		if file == nil || file.Bytes == nil {
 			fmt.Fprintf(w.wr, "  on %s line %d:\n  (source code not available)\n\n", diag.Subject.Filename, diag.Subject.Start.Line)
 		} else {
-			src := file.Bytes
-			r := bytes.NewReader(src)
-			sc := bufio.NewScanner(r)
-			sc.Split(bufio.ScanLines)
-
-			var startLine, endLine int
-			if diag.Context != nil {
-				startLine = diag.Context.Start.Line
-				endLine = diag.Context.End.Line
-			} else {
-				startLine = diag.Subject.Start.Line
-				endLine = diag.Subject.End.Line
-			}
 
 			var contextLine string
 			if diag.Subject != nil {
@@ -95,35 +102,33 @@ func (w *diagnosticTextWriter) WriteDiagnostic(diag *Diagnostic) error {
 				}
 			}
 
-			li := 1
-			var ls string
-			for sc.Scan() {
-				ls = sc.Text()
-
-				if li == startLine {
-					break
-				}
-				li++
-			}
-
 			fmt.Fprintf(w.wr, "  on %s line %d%s:\n", diag.Subject.Filename, diag.Subject.Start.Line, contextLine)
 
-			// TODO: Generate markers for the specific characters that are in the Context and Subject ranges.
-			// For now, we just print out the lines.
+			src := file.Bytes
+			sc := NewRangeScanner(src, diag.Subject.Filename, bufio.ScanLines)
 
-			fmt.Fprintf(w.wr, "%4d: %s\n", li, ls)
-
-			if endLine > li {
-				for sc.Scan() {
-					ls = sc.Text()
-					li++
-
-					fmt.Fprintf(w.wr, "%4d: %s\n", li, ls)
-
-					if li == endLine {
-						break
-					}
+			for sc.Scan() {
+				lineRange := sc.Range()
+				if !lineRange.Overlaps(snipRange) {
+					continue
 				}
+
+				beforeRange, highlightedRange, afterRange := lineRange.PartitionAround(highlightRange)
+				if highlightedRange.Empty() {
+					fmt.Fprintf(w.wr, "%4d: %s\n", lineRange.Start.Line, sc.Bytes())
+				} else {
+					before := beforeRange.SliceBytes(src)
+					highlighted := highlightedRange.SliceBytes(src)
+					after := afterRange.SliceBytes(src)
+					fmt.Fprintf(
+						w.wr, "%4d: %s%s%s%s%s\n",
+						lineRange.Start.Line,
+						before,
+						highlightCode, highlighted, resetCode,
+						after,
+					)
+				}
+
 			}
 
 			w.wr.Write([]byte{'\n'})
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/expr_list.go b/vendor/github.com/hashicorp/hcl2/hcl/expr_list.go
new file mode 100644
index 0000000000..d05cca0b9a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/expr_list.go
@@ -0,0 +1,37 @@
+package hcl
+
+// ExprList tests if the given expression is a static list construct and,
+// if so, extracts the expressions that represent the list elements.
+// If the given expression is not a static list, error diagnostics are
+// returned.
+//
+// A particular Expression implementation can support this function by
+// offering a method called ExprList that takes no arguments and returns
+// []Expression. This method should return nil if a static list cannot
+// be extracted.  Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+func ExprList(expr Expression) ([]Expression, Diagnostics) {
+	type exprList interface {
+		ExprList() []Expression
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(exprList)
+		return supported
+	})
+
+	if exL, supported := physExpr.(exprList); supported {
+		if list := exL.ExprList(); list != nil {
+			return list, nil
+		}
+	}
+	return nil, Diagnostics{
+		&Diagnostic{
+			Severity: DiagError,
+			Summary:  "Invalid expression",
+			Detail:   "A static list expression is required.",
+			Subject:  expr.StartRange().Ptr(),
+		},
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/expr_unwrap.go b/vendor/github.com/hashicorp/hcl2/hcl/expr_unwrap.go
new file mode 100644
index 0000000000..6d5d205c49
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/expr_unwrap.go
@@ -0,0 +1,68 @@
+package hcl
+
+type unwrapExpression interface {
+	UnwrapExpression() Expression
+}
+
+// UnwrapExpression removes any "wrapper" expressions from the given expression,
+// to recover the representation of the physical expression given in source
+// code.
+//
+// Sometimes wrapping expressions are used to modify expression behavior, e.g.
+// in extensions that need to make some local variables available to certain
+// sub-trees of the configuration. This can make it difficult to reliably
+// type-assert on the physical AST types used by the underlying syntax.
+//
+// Unwrapping an expression may modify its behavior by stripping away any
+// additional constraints or capabilities being applied to the Value and
+// Variables methods, so this function should generally only be used prior
+// to operations that concern themselves with the static syntax of the input
+// configuration, and not with the effective value of the expression.
+//
+// Wrapper expression types must support unwrapping by implementing a method
+// called UnwrapExpression that takes no arguments and returns the embedded
+// Expression. Implementations of this method should peel away only one level
+// of wrapping, if multiple are present. This method may return nil to
+// indicate _dynamically_ that no wrapped expression is available, for
+// expression types that might only behave as wrappers in certain cases.
+func UnwrapExpression(expr Expression) Expression {
+	for {
+		unwrap, wrapped := expr.(unwrapExpression)
+		if !wrapped {
+			return expr
+		}
+		innerExpr := unwrap.UnwrapExpression()
+		if innerExpr == nil {
+			return expr
+		}
+		expr = innerExpr
+	}
+}
+
+// UnwrapExpressionUntil is similar to UnwrapExpression except it gives the
+// caller an opportunity to test each level of unwrapping to see each a
+// particular expression is accepted.
+//
+// This could be used, for example, to unwrap until a particular other
+// interface is satisfied, regardless of wrap wrapping level it is satisfied
+// at.
+//
+// The given callback function must return false to continue wrapping, or
+// true to accept and return the proposed expression given. If the callback
+// function rejects even the final, physical expression then the result of
+// this function is nil.
+func UnwrapExpressionUntil(expr Expression, until func(Expression) bool) Expression {
+	for {
+		if until(expr) {
+			return expr
+		}
+		unwrap, wrapped := expr.(unwrapExpression)
+		if !wrapped {
+			return nil
+		}
+		expr = unwrap.UnwrapExpression()
+		if expr == nil {
+			return nil
+		}
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/doc.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/doc.go
index 8db11573fa..617bc29dc2 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/doc.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/doc.go
@@ -1,7 +1,7 @@
-// Package hclsyntax contains the parser, AST, etc for zcl's native language,
+// Package hclsyntax contains the parser, AST, etc for HCL's native language,
 // as opposed to the JSON variant.
 //
 // In normal use applications should rarely depend on this package directly,
 // instead preferring the higher-level interface of the main hcl package and
-// its companion hclparse.
+// its companion package hclparse.
 package hclsyntax
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
index e90ac2be6e..4fa1988bf6 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
@@ -9,7 +9,7 @@ import (
 	"github.com/zclconf/go-cty/cty/function"
 )
 
-// Expression is the abstract type for nodes that behave as zcl expressions.
+// Expression is the abstract type for nodes that behave as HCL expressions.
 type Expression interface {
 	Node
 
@@ -70,6 +70,11 @@ func (e *ScopeTraversalExpr) StartRange() hcl.Range {
 	return e.SrcRange
 }
 
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *ScopeTraversalExpr) AsTraversal() hcl.Traversal {
+	return e.Traversal
+}
+
 // RelativeTraversalExpr is an Expression that retrieves a value from another
 // value using a _relative_ traversal.
 type RelativeTraversalExpr struct {
@@ -539,6 +544,15 @@ func (e *TupleConsExpr) StartRange() hcl.Range {
 	return e.OpenRange
 }
 
+// Implementation for hcl.ExprList
+func (e *TupleConsExpr) ExprList() []hcl.Expression {
+	ret := make([]hcl.Expression, len(e.Exprs))
+	for i, expr := range e.Exprs {
+		ret[i] = expr
+	}
+	return ret
+}
+
 type ObjectConsExpr struct {
 	Items []ObjectConsItem
 
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/generate.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/generate.go
index ecc389f114..841656a6a1 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/generate.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/generate.go
@@ -4,4 +4,6 @@ package hclsyntax
 //go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/DerivedCoreProperties.txt -m UnicodeDerived -p ID_Start,ID_Continue -o unicode_derived.rl
 //go:generate ragel -Z scan_tokens.rl
 //go:generate gofmt -w scan_tokens.go
+//go:generate ragel -Z scan_string_lit.rl
+//go:generate gofmt -w scan_string_lit.go
 //go:generate stringer -type TokenType -output token_type_string.go
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go
index 8a04c2081a..4d41b6b662 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/navigation.go
@@ -9,7 +9,7 @@ type navigation struct {
 	root *Body
 }
 
-// Implementation of zcled.ContextString
+// Implementation of hcled.ContextString
 func (n navigation) ContextString(offset int) string {
 	// We will walk our top-level blocks until we find one that contains
 	// the given offset, and then construct a representation of the header
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
index 0f81ddfb14..28c6a7b19c 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
@@ -1,9 +1,10 @@
 package hclsyntax
 
 import (
-	"bufio"
 	"bytes"
 	"fmt"
+	"strconv"
+	"unicode/utf8"
 
 	"github.com/apparentlymart/go-textseg/textseg"
 	"github.com/hashicorp/hcl2/hcl"
@@ -627,7 +628,7 @@ Traversal:
 			if lit, isLit := keyExpr.(*LiteralValueExpr); isLit {
 				litKey, _ := lit.Value(nil)
 				rng := hcl.RangeBetween(open.Range, close.Range)
-				step := &hcl.TraverseIndex{
+				step := hcl.TraverseIndex{
 					Key:      litKey,
 					SrcRange: rng,
 				}
@@ -1476,139 +1477,149 @@ func (p *parser) decodeStringLit(tok Token) (string, hcl.Diagnostics) {
 	var diags hcl.Diagnostics
 
 	ret := make([]byte, 0, len(tok.Bytes))
-	var esc []byte
+	slices := scanStringLit(tok.Bytes, quoted)
 
-	sc := bufio.NewScanner(bytes.NewReader(tok.Bytes))
-	sc.Split(textseg.ScanGraphemeClusters)
+	// We will mutate rng constantly as we walk through our token slices below.
+	// Any diagnostics must take a copy of this rng rather than simply pointing
+	// to it, e.g. by using rng.Ptr() rather than &rng.
+	rng := tok.Range
+	rng.End = rng.Start
 
-	pos := tok.Range.Start
-	newPos := pos
-Character:
-	for sc.Scan() {
-		pos = newPos
-		ch := sc.Bytes()
-
-		// Adjust position based on our new character.
-		// \r\n is considered to be a single character in text segmentation,
-		if (len(ch) == 1 && ch[0] == '\n') || (len(ch) == 2 && ch[1] == '\n') {
-			newPos.Line++
-			newPos.Column = 0
-		} else {
-			newPos.Column++
+Slices:
+	for _, slice := range slices {
+		if len(slice) == 0 {
+			continue
 		}
-		newPos.Byte += len(ch)
 
-		if len(esc) > 0 {
-			switch esc[0] {
-			case '\\':
-				if len(ch) == 1 {
-					switch ch[0] {
+		// Advance the start of our range to where the previous token ended
+		rng.Start = rng.End
 
-					// TODO: numeric character escapes with \uXXXX
-
-					case 'n':
-						ret = append(ret, '\n')
-						esc = esc[:0]
-						continue Character
-					case 'r':
-						ret = append(ret, '\r')
-						esc = esc[:0]
-						continue Character
-					case 't':
-						ret = append(ret, '\t')
-						esc = esc[:0]
-						continue Character
-					case '"':
-						ret = append(ret, '"')
-						esc = esc[:0]
-						continue Character
-					case '\\':
-						ret = append(ret, '\\')
-						esc = esc[:0]
-						continue Character
-					}
-				}
-
-				var detail string
-				switch {
-				case len(ch) == 1 && (ch[0] == '$' || ch[0] == '!'):
-					detail = fmt.Sprintf(
-						"The characters \"\\%s\" do not form a recognized escape sequence. To escape a \"%s{\" template sequence, use \"%s%s{\".",
-						ch, ch, ch, ch,
-					)
-				default:
-					detail = fmt.Sprintf("The characters \"\\%s\" do not form a recognized escape sequence.", ch)
-				}
+		// Advance the end of our range to after our token.
+		b := slice
+		for len(b) > 0 {
+			adv, ch, _ := textseg.ScanGraphemeClusters(b, true)
+			rng.End.Byte += adv
+			switch ch[0] {
+			case '\r', '\n':
+				rng.End.Line++
+				rng.End.Column = 1
+			default:
+				rng.End.Column++
+			}
+			b = b[adv:]
+		}
 
+	TokenType:
+		switch slice[0] {
+		case '\\':
+			if !quoted {
+				// If we're not in quoted mode then just treat this token as
+				// normal. (Slices can still start with backslash even if we're
+				// not specifically looking for backslash sequences.)
+				break TokenType
+			}
+			if len(slice) < 2 {
 				diags = append(diags, &hcl.Diagnostic{
 					Severity: hcl.DiagError,
 					Summary:  "Invalid escape sequence",
-					Detail:   detail,
-					Subject: &hcl.Range{
-						Filename: tok.Range.Filename,
-						Start: hcl.Pos{
-							Line:   pos.Line,
-							Column: pos.Column - 1, // safe because we know the previous character must be a backslash
-							Byte:   pos.Byte - 1,
-						},
-						End: hcl.Pos{
-							Line:   pos.Line,
-							Column: pos.Column + 1, // safe because we know the previous character must be a backslash
-							Byte:   pos.Byte + len(ch),
-						},
-					},
+					Detail:   "Backslash must be followed by an escape sequence selector character.",
+					Subject:  rng.Ptr(),
 				})
-				ret = append(ret, ch...)
-				esc = esc[:0]
-				continue Character
+				break TokenType
+			}
 
-			case '$', '!':
-				switch len(esc) {
-				case 1:
-					if len(ch) == 1 && ch[0] == esc[0] {
-						esc = append(esc, ch[0])
-						continue Character
-					}
+			switch slice[1] {
 
-					// Any other character means this wasn't an escape sequence
-					// after all.
-					ret = append(ret, esc...)
-					ret = append(ret, ch...)
-					esc = esc[:0]
-				case 2:
-					if len(ch) == 1 && ch[0] == '{' {
-						// successful escape sequence
-						ret = append(ret, esc[0])
-					} else {
-						// not an escape sequence, so just output literal
-						ret = append(ret, esc...)
-					}
-					ret = append(ret, ch...)
-					esc = esc[:0]
-				default:
-					// should never happen
-					panic("have invalid escape sequence >2 characters")
+			case 'n':
+				ret = append(ret, '\n')
+				continue Slices
+			case 'r':
+				ret = append(ret, '\r')
+				continue Slices
+			case 't':
+				ret = append(ret, '\t')
+				continue Slices
+			case '"':
+				ret = append(ret, '"')
+				continue Slices
+			case '\\':
+				ret = append(ret, '\\')
+				continue Slices
+			case 'u', 'U':
+				if slice[1] == 'u' && len(slice) != 6 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   "The \\u escape sequence must be followed by four hexadecimal digits.",
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				} else if slice[1] == 'U' && len(slice) != 10 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   "The \\U escape sequence must be followed by eight hexadecimal digits.",
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
 				}
 
-			}
-		} else {
-			if len(ch) == 1 {
-				switch ch[0] {
-				case '\\':
-					if quoted { // ignore backslashes in unquoted mode
-						esc = append(esc, '\\')
-						continue Character
-					}
-				case '$':
-					esc = append(esc, '$')
-					continue Character
-				case '!':
-					esc = append(esc, '!')
-					continue Character
+				numHex := string(slice[2:])
+				num, err := strconv.ParseUint(numHex, 16, 32)
+				if err != nil {
+					// Should never happen because the scanner won't match
+					// a sequence of digits that isn't valid.
+					panic(err)
 				}
+
+				r := rune(num)
+				l := utf8.RuneLen(r)
+				if l == -1 {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Invalid escape sequence",
+						Detail:   fmt.Sprintf("Cannot encode character U+%04x in UTF-8.", num),
+						Subject:  rng.Ptr(),
+					})
+					break TokenType
+				}
+				for i := 0; i < l; i++ {
+					ret = append(ret, 0)
+				}
+				rb := ret[len(ret)-l:]
+				utf8.EncodeRune(rb, r)
+
+				continue Slices
+
+			default:
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid escape sequence",
+					Detail:   fmt.Sprintf("The symbol %q is not a valid escape sequence selector.", slice[1:]),
+					Subject:  rng.Ptr(),
+				})
+				ret = append(ret, slice[1:]...)
+				continue Slices
 			}
-			ret = append(ret, ch...)
+
+		case '$', '%':
+			if len(slice) != 3 {
+				// Not long enough to be our escape sequence, so it's literal.
+				break TokenType
+			}
+
+			if slice[1] == slice[0] && slice[2] == '{' {
+				ret = append(ret, slice[0])
+				ret = append(ret, '{')
+				continue Slices
+			}
+
+			break TokenType
 		}
+
+		// If we fall out here or break out of here from the switch above
+		// then this slice is just a literal.
+		ret = append(ret, slice...)
 	}
 
 	return string(ret), diags
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go
index e04c8e0f36..3711067eeb 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser_template.go
@@ -435,7 +435,7 @@ Token:
 			})
 
 		case TokenTemplateControl:
-			// if the opener is !{~ then we want to eat any trailing whitespace
+			// if the opener is %{~ then we want to eat any trailing whitespace
 			// in the preceding literal token, assuming it is indeed a literal
 			// token.
 			if canTrimPrev && len(next.Bytes) == 3 && next.Bytes[2] == '~' && len(parts) > 0 {
@@ -452,7 +452,7 @@ Token:
 					diags = append(diags, &hcl.Diagnostic{
 						Severity: hcl.DiagError,
 						Summary:  "Invalid template directive",
-						Detail:   "A template directive keyword (\"if\", \"for\", etc) is expected at the beginning of a !{ sequence.",
+						Detail:   "A template directive keyword (\"if\", \"for\", etc) is expected at the beginning of a %{ sequence.",
 						Subject:  &kw.Range,
 						Context:  hcl.RangeBetween(next.Range, kw.Range).Ptr(),
 					})
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/public.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/public.go
index 49d8ab182b..e527d63f4b 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/public.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/public.go
@@ -4,13 +4,13 @@ import (
 	"github.com/hashicorp/hcl2/hcl"
 )
 
-// ParseConfig parses the given buffer as a whole zcl config file, returning
+// ParseConfig parses the given buffer as a whole HCL config file, returning
 // a *hcl.File representing its contents. If HasErrors called on the returned
 // diagnostics returns true, the returned body is likely to be incomplete
 // and should therefore be used with care.
 //
-// The body in the returned file has dynamic type *zclsyntax.Body, so callers
-// may freely type-assert this to get access to the full zclsyntax API in
+// The body in the returned file has dynamic type *hclsyntax.Body, so callers
+// may freely type-assert this to get access to the full hclsyntax API in
 // situations where detailed access is required. However, most common use-cases
 // should be served using the hcl.Body interface to ensure compatibility with
 // other configurationg syntaxes, such as JSON.
@@ -30,7 +30,7 @@ func ParseConfig(src []byte, filename string, start hcl.Pos) (*hcl.File, hcl.Dia
 	}, diags
 }
 
-// ParseExpression parses the given buffer as a standalone zcl expression,
+// ParseExpression parses the given buffer as a standalone HCL expression,
 // returning it as an instance of Expression.
 func ParseExpression(src []byte, filename string, start hcl.Pos) (Expression, hcl.Diagnostics) {
 	tokens, diags := LexExpression(src, filename, start)
@@ -57,7 +57,7 @@ func ParseExpression(src []byte, filename string, start hcl.Pos) (Expression, hc
 	return expr, diags
 }
 
-// ParseTemplate parses the given buffer as a standalone zcl template,
+// ParseTemplate parses the given buffer as a standalone HCL template,
 // returning it as an instance of Expression.
 func ParseTemplate(src []byte, filename string, start hcl.Pos) (Expression, hcl.Diagnostics) {
 	tokens, diags := LexTemplate(src, filename, start)
@@ -89,7 +89,7 @@ func ParseTraversalAbs(src []byte, filename string, start hcl.Pos) (hcl.Traversa
 }
 
 // LexConfig performs lexical analysis on the given buffer, treating it as a
-// whole zcl config file, and returns the resulting tokens.
+// whole HCL config file, and returns the resulting tokens.
 //
 // Only minimal validation is done during lexical analysis, so the returned
 // diagnostics may include errors about lexical issues such as bad character
@@ -102,7 +102,7 @@ func LexConfig(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagnost
 }
 
 // LexExpression performs lexical analysis on the given buffer, treating it as
-// a standalone zcl expression, and returns the resulting tokens.
+// a standalone HCL expression, and returns the resulting tokens.
 //
 // Only minimal validation is done during lexical analysis, so the returned
 // diagnostics may include errors about lexical issues such as bad character
@@ -117,7 +117,7 @@ func LexExpression(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diag
 }
 
 // LexTemplate performs lexical analysis on the given buffer, treating it as a
-// standalone zcl template, and returns the resulting tokens.
+// standalone HCL template, and returns the resulting tokens.
 //
 // Only minimal validation is done during lexical analysis, so the returned
 // diagnostics may include errors about lexical issues such as bad character
@@ -128,3 +128,17 @@ func LexTemplate(src []byte, filename string, start hcl.Pos) (Tokens, hcl.Diagno
 	diags := checkInvalidTokens(tokens)
 	return tokens, diags
 }
+
+// ValidIdentifier tests if the given string could be a valid identifier in
+// a native syntax expression.
+//
+// This is useful when accepting names from the user that will be used as
+// variable or attribute names in the scope, to ensure that any name chosen
+// will be traversable using the variable or attribute traversal syntax.
+func ValidIdentifier(s string) bool {
+	// This is a kinda-expensive way to do something pretty simple, but it
+	// is easiest to do with our existing scanner-related infrastructure here
+	// and nobody should be validating identifiers in a tight loop.
+	tokens := scanTokens([]byte(s), "", hcl.Pos{}, scanIdentOnly)
+	return len(tokens) == 2 && tokens[0].Type == TokenIdent && tokens[1].Type == TokenEOF
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go
new file mode 100644
index 0000000000..de1f524caf
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.go
@@ -0,0 +1,301 @@
+// line 1 "scan_string_lit.rl"
+
+package hclsyntax
+
+// This file is generated from scan_string_lit.rl. DO NOT EDIT.
+
+// line 9 "scan_string_lit.go"
+var _hclstrtok_actions []byte = []byte{
+	0, 1, 0, 1, 1, 2, 1, 0,
+}
+
+var _hclstrtok_key_offsets []byte = []byte{
+	0, 0, 2, 4, 6, 10, 14, 18,
+	22, 27, 31, 36, 41, 46, 51, 57,
+	62, 74, 85, 96, 107, 118, 129, 140,
+	151,
+}
+
+var _hclstrtok_trans_keys []byte = []byte{
+	128, 191, 128, 191, 128, 191, 10, 13,
+	36, 37, 10, 13, 36, 37, 10, 13,
+	36, 37, 10, 13, 36, 37, 10, 13,
+	36, 37, 123, 10, 13, 36, 37, 10,
+	13, 36, 37, 92, 10, 13, 36, 37,
+	92, 10, 13, 36, 37, 92, 10, 13,
+	36, 37, 92, 10, 13, 36, 37, 92,
+	123, 10, 13, 36, 37, 92, 85, 117,
+	128, 191, 192, 223, 224, 239, 240, 247,
+	248, 255, 10, 13, 36, 37, 92, 48,
+	57, 65, 70, 97, 102, 10, 13, 36,
+	37, 92, 48, 57, 65, 70, 97, 102,
+	10, 13, 36, 37, 92, 48, 57, 65,
+	70, 97, 102, 10, 13, 36, 37, 92,
+	48, 57, 65, 70, 97, 102, 10, 13,
+	36, 37, 92, 48, 57, 65, 70, 97,
+	102, 10, 13, 36, 37, 92, 48, 57,
+	65, 70, 97, 102, 10, 13, 36, 37,
+	92, 48, 57, 65, 70, 97, 102, 10,
+	13, 36, 37, 92, 48, 57, 65, 70,
+	97, 102,
+}
+
+var _hclstrtok_single_lengths []byte = []byte{
+	0, 0, 0, 0, 4, 4, 4, 4,
+	5, 4, 5, 5, 5, 5, 6, 5,
+	2, 5, 5, 5, 5, 5, 5, 5,
+	5,
+}
+
+var _hclstrtok_range_lengths []byte = []byte{
+	0, 1, 1, 1, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	5, 3, 3, 3, 3, 3, 3, 3,
+	3,
+}
+
+var _hclstrtok_index_offsets []byte = []byte{
+	0, 0, 2, 4, 6, 11, 16, 21,
+	26, 32, 37, 43, 49, 55, 61, 68,
+	74, 82, 91, 100, 109, 118, 127, 136,
+	145,
+}
+
+var _hclstrtok_indicies []byte = []byte{
+	0, 1, 2, 1, 3, 1, 5, 6,
+	7, 8, 4, 10, 11, 12, 13, 9,
+	14, 11, 12, 13, 9, 10, 11, 15,
+	13, 9, 10, 11, 12, 13, 14, 9,
+	10, 11, 12, 15, 9, 17, 18, 19,
+	20, 21, 16, 23, 24, 25, 26, 27,
+	22, 0, 24, 25, 26, 27, 22, 23,
+	24, 28, 26, 27, 22, 23, 24, 25,
+	26, 27, 0, 22, 23, 24, 25, 28,
+	27, 22, 29, 30, 22, 2, 3, 31,
+	22, 0, 23, 24, 25, 26, 27, 32,
+	32, 32, 22, 23, 24, 25, 26, 27,
+	33, 33, 33, 22, 23, 24, 25, 26,
+	27, 34, 34, 34, 22, 23, 24, 25,
+	26, 27, 30, 30, 30, 22, 23, 24,
+	25, 26, 27, 35, 35, 35, 22, 23,
+	24, 25, 26, 27, 36, 36, 36, 22,
+	23, 24, 25, 26, 27, 37, 37, 37,
+	22, 23, 24, 25, 26, 27, 0, 0,
+	0, 22,
+}
+
+var _hclstrtok_trans_targs []byte = []byte{
+	11, 0, 1, 2, 4, 5, 6, 7,
+	9, 4, 5, 6, 7, 9, 5, 8,
+	10, 11, 12, 13, 15, 16, 10, 11,
+	12, 13, 15, 16, 14, 17, 21, 3,
+	18, 19, 20, 22, 23, 24,
+}
+
+var _hclstrtok_trans_actions []byte = []byte{
+	0, 0, 0, 0, 0, 1, 1, 1,
+	1, 3, 5, 5, 5, 5, 0, 0,
+	0, 1, 1, 1, 1, 1, 3, 5,
+	5, 5, 5, 5, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0,
+}
+
+var _hclstrtok_eof_actions []byte = []byte{
+	0, 0, 0, 0, 0, 3, 3, 3,
+	3, 3, 0, 3, 3, 3, 3, 3,
+	3, 3, 3, 3, 3, 3, 3, 3,
+	3,
+}
+
+const hclstrtok_start int = 4
+const hclstrtok_first_final int = 4
+const hclstrtok_error int = 0
+
+const hclstrtok_en_quoted int = 10
+const hclstrtok_en_unquoted int = 4
+
+// line 10 "scan_string_lit.rl"
+
+func scanStringLit(data []byte, quoted bool) [][]byte {
+	var ret [][]byte
+
+	// line 61 "scan_string_lit.rl"
+
+	// Ragel state
+	p := 0          // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+	ts := 0
+	te := 0
+	eof := pe
+
+	var cs int // current state
+	switch {
+	case quoted:
+		cs = hclstrtok_en_quoted
+	default:
+		cs = hclstrtok_en_unquoted
+	}
+
+	// Make Go compiler happy
+	_ = ts
+	_ = eof
+
+	/*token := func () {
+	    ret = append(ret, data[ts:te])
+	}*/
+
+	// line 154 "scan_string_lit.go"
+	{
+	}
+
+	// line 158 "scan_string_lit.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(_hclstrtok_key_offsets[cs])
+		_trans = int(_hclstrtok_index_offsets[cs])
+
+		_klen = int(_hclstrtok_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] < _hclstrtok_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _hclstrtok_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_hclstrtok_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] < _hclstrtok_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _hclstrtok_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_hclstrtok_indicies[_trans])
+		cs = int(_hclstrtok_trans_targs[_trans])
+
+		if _hclstrtok_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_hclstrtok_trans_actions[_trans])
+		_nacts = uint(_hclstrtok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _hclstrtok_actions[_acts-1] {
+			case 0:
+				// line 40 "scan_string_lit.rl"
+
+				// If te is behind p then we've skipped over some literal
+				// characters which we must now return.
+				if te < p {
+					ret = append(ret, data[te:p])
+				}
+				ts = p
+
+			case 1:
+				// line 48 "scan_string_lit.rl"
+
+				te = p
+				ret = append(ret, data[ts:te])
+
+				// line 255 "scan_string_lit.go"
+			}
+		}
+
+	_again:
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			__acts := _hclstrtok_eof_actions[cs]
+			__nacts := uint(_hclstrtok_actions[__acts])
+			__acts++
+			for ; __nacts > 0; __nacts-- {
+				__acts++
+				switch _hclstrtok_actions[__acts-1] {
+				case 1:
+					// line 48 "scan_string_lit.rl"
+
+					te = p
+					ret = append(ret, data[ts:te])
+
+					// line 281 "scan_string_lit.go"
+				}
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+	// line 89 "scan_string_lit.rl"
+
+	if te < p {
+		// Collect any leftover literal characters at the end of the input
+		ret = append(ret, data[te:p])
+	}
+
+	// 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
+	// tolerate it and let the caller deal with it.
+	if cs < hclstrtok_first_final {
+		ret = append(ret, data[p:len(data)])
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.rl b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.rl
new file mode 100644
index 0000000000..f8ac117516
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_string_lit.rl
@@ -0,0 +1,105 @@
+
+package hclsyntax
+
+// This file is generated from scan_string_lit.rl. DO NOT EDIT.
+%%{
+  # (except you are actually in scan_string_lit.rl here, so edit away!)
+
+  machine hclstrtok;
+  write data;
+}%%
+
+func scanStringLit(data []byte, quoted bool) [][]byte {
+    var ret [][]byte
+
+    %%{
+        include UnicodeDerived "unicode_derived.rl";
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+        BadUTF8 = any - AnyUTF8;
+
+        Hex = ('0'..'9' | 'a'..'f' | 'A'..'F');
+
+        # Our goal with this patterns is to capture user intent as best as
+        # possible, even if the input is invalid. The caller will then verify
+        # whether each token is valid and generate suitable error messages
+        # if not.
+        UnicodeEscapeShort = "\\u" . Hex{0,4};
+        UnicodeEscapeLong = "\\U" . Hex{0,8};
+        UnicodeEscape = (UnicodeEscapeShort | UnicodeEscapeLong);
+        SimpleEscape = "\\" . (AnyUTF8 - ('U'|'u'))?;
+        TemplateEscape = ("$" . ("$" . ("{"?))?) | ("%" . ("%" . ("{"?))?);
+        Newline = ("\r\n" | "\r" | "\n");
+
+        action Begin {
+            // If te is behind p then we've skipped over some literal
+            // characters which we must now return.
+            if te < p {
+                ret = append(ret, data[te:p])
+            }
+            ts = p;
+        }
+        action End {
+            te = p;
+            ret = append(ret, data[ts:te]);
+        }
+
+        QuotedToken = (UnicodeEscape | SimpleEscape | TemplateEscape | Newline) >Begin %End;
+        UnquotedToken = (TemplateEscape | Newline) >Begin %End;
+        QuotedLiteral = (any - ("\\" | "$" | "%" | "\r" | "\n"));
+        UnquotedLiteral = (any - ("$" | "%" | "\r" | "\n"));
+
+        quoted := (QuotedToken | QuotedLiteral)**;
+        unquoted := (UnquotedToken | UnquotedLiteral)**;
+
+    }%%
+
+    // Ragel state
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    eof := pe
+
+    var cs int // current state
+    switch {
+    case quoted:
+        cs = hclstrtok_en_quoted
+    default:
+        cs = hclstrtok_en_unquoted
+    }
+
+    // Make Go compiler happy
+    _ = ts
+    _ = eof
+
+    /*token := func () {
+        ret = append(ret, data[ts:te])
+    }*/
+
+    %%{
+        write init nocs;
+        write exec;
+    }%%
+
+    if te < p {
+        // Collect any leftover literal characters at the end of the input
+        ret = append(ret, data[te:p])
+    }
+
+    // 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
+    // tolerate it and let the caller deal with it.
+    if cs < hclstrtok_first_final {
+        ret = append(ret, data[p:len(data)])
+    }
+
+    return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go
index a8ab57c3e5..7d557c08d1 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go
@@ -1,4 +1,5 @@
 // line 1 "scan_tokens.rl"
+
 package hclsyntax
 
 import (
@@ -9,8 +10,8 @@ import (
 
 // This file is generated from scan_tokens.rl. DO NOT EDIT.
 
-// line 14 "scan_tokens.go"
-var _zcltok_actions []byte = []byte{
+// line 15 "scan_tokens.go"
+var _hcltok_actions []byte = []byte{
 	0, 1, 0, 1, 2, 1, 3, 1, 4,
 	1, 5, 1, 6, 1, 7, 1, 8,
 	1, 9, 1, 10, 1, 11, 1, 12,
@@ -19,22 +20,24 @@ var _zcltok_actions []byte = []byte{
 	1, 23, 1, 24, 1, 25, 1, 26,
 	1, 27, 1, 30, 1, 31, 1, 32,
 	1, 33, 1, 34, 1, 35, 1, 36,
-	1, 37, 1, 38, 1, 39, 1, 45,
-	1, 46, 1, 47, 1, 48, 1, 49,
-	1, 50, 1, 51, 1, 52, 1, 53,
-	1, 54, 1, 55, 1, 56, 1, 57,
-	1, 58, 1, 59, 1, 60, 1, 61,
-	1, 62, 1, 63, 1, 64, 1, 65,
-	1, 66, 1, 67, 1, 68, 1, 69,
-	1, 70, 1, 71, 1, 72, 1, 73,
-	1, 74, 1, 75, 2, 0, 1, 2,
-	3, 16, 2, 3, 17, 2, 3, 28,
-	2, 3, 29, 2, 3, 40, 2, 3,
-	41, 2, 3, 42, 2, 3, 43, 2,
-	3, 44,
+	1, 37, 1, 38, 1, 39, 1, 42,
+	1, 43, 1, 44, 1, 45, 1, 46,
+	1, 47, 1, 48, 1, 54, 1, 55,
+	1, 56, 1, 57, 1, 58, 1, 59,
+	1, 60, 1, 61, 1, 62, 1, 63,
+	1, 64, 1, 65, 1, 66, 1, 67,
+	1, 68, 1, 69, 1, 70, 1, 71,
+	1, 72, 1, 73, 1, 74, 1, 75,
+	1, 76, 1, 77, 1, 78, 1, 79,
+	1, 80, 1, 81, 1, 82, 1, 83,
+	2, 0, 1, 2, 3, 16, 2, 3,
+	17, 2, 3, 28, 2, 3, 29, 2,
+	3, 40, 2, 3, 41, 2, 3, 49,
+	2, 3, 50, 2, 3, 51, 2, 3,
+	52, 2, 3, 53,
 }
 
-var _zcltok_key_offsets []int16 = []int16{
+var _hcltok_key_offsets []int16 = []int16{
 	0, 0, 1, 2, 3, 5, 10, 14,
 	16, 57, 97, 143, 144, 148, 154, 154,
 	156, 158, 167, 173, 180, 181, 184, 185,
@@ -153,20 +156,89 @@ var _zcltok_key_offsets []int16 = []int16{
 	5909, 5913, 5917, 5922, 5926, 5928, 5935, 5939,
 	5947, 5951, 5952, 5954, 5956, 5958, 5960, 5962,
 	5963, 5964, 5966, 5968, 5970, 5971, 5972, 5973,
-	5974, 5976, 5978, 5980, 5981, 5982, 6057, 6058,
-	6059, 6060, 6061, 6062, 6063, 6064, 6066, 6067,
-	6072, 6074, 6076, 6077, 6121, 6122, 6123, 6125,
-	6130, 6134, 6134, 6136, 6138, 6149, 6159, 6167,
-	6168, 6170, 6171, 6175, 6179, 6189, 6193, 6200,
-	6211, 6218, 6222, 6228, 6239, 6271, 6320, 6335,
-	6350, 6355, 6357, 6362, 6394, 6402, 6404, 6426,
-	6448, 6450, 6466, 6482, 6497, 6506, 6520, 6534,
-	6550, 6551, 6552, 6553, 6554, 6556, 6558, 6560,
-	6574, 6588, 6589, 6590, 6592, 6594, 6596, 6610,
-	6624, 6625, 6626, 6628, 6630,
+	5974, 5976, 5978, 5980, 5981, 5982, 5986, 5992,
+	5992, 5994, 5996, 6005, 6011, 6018, 6019, 6022,
+	6023, 6027, 6032, 6041, 6045, 6049, 6057, 6059,
+	6061, 6063, 6066, 6098, 6100, 6102, 6106, 6110,
+	6113, 6124, 6137, 6156, 6169, 6185, 6197, 6213,
+	6228, 6249, 6259, 6271, 6282, 6296, 6311, 6321,
+	6333, 6342, 6354, 6356, 6360, 6381, 6390, 6400,
+	6406, 6412, 6413, 6462, 6464, 6468, 6470, 6476,
+	6483, 6491, 6498, 6501, 6507, 6511, 6515, 6517,
+	6521, 6525, 6529, 6535, 6543, 6551, 6557, 6559,
+	6563, 6565, 6571, 6575, 6579, 6583, 6587, 6592,
+	6599, 6605, 6607, 6609, 6613, 6615, 6621, 6625,
+	6629, 6639, 6644, 6658, 6673, 6675, 6683, 6685,
+	6690, 6704, 6709, 6711, 6715, 6716, 6720, 6726,
+	6732, 6742, 6752, 6763, 6771, 6774, 6777, 6781,
+	6785, 6787, 6790, 6790, 6793, 6795, 6825, 6827,
+	6829, 6833, 6838, 6842, 6847, 6849, 6851, 6853,
+	6862, 6866, 6870, 6876, 6878, 6886, 6894, 6906,
+	6909, 6915, 6919, 6921, 6925, 6945, 6947, 6949,
+	6960, 6966, 6968, 6970, 6972, 6976, 6982, 6988,
+	6990, 6995, 6999, 7001, 7009, 7027, 7067, 7077,
+	7081, 7083, 7085, 7086, 7090, 7094, 7098, 7102,
+	7106, 7111, 7115, 7119, 7123, 7125, 7127, 7131,
+	7141, 7145, 7147, 7151, 7155, 7159, 7172, 7174,
+	7176, 7180, 7182, 7186, 7188, 7190, 7220, 7224,
+	7228, 7232, 7235, 7242, 7247, 7258, 7262, 7278,
+	7292, 7296, 7301, 7305, 7309, 7315, 7317, 7323,
+	7325, 7329, 7331, 7337, 7342, 7347, 7357, 7359,
+	7361, 7365, 7369, 7371, 7384, 7386, 7390, 7394,
+	7402, 7404, 7408, 7410, 7411, 7414, 7419, 7421,
+	7423, 7427, 7429, 7433, 7439, 7459, 7465, 7471,
+	7473, 7474, 7484, 7485, 7493, 7500, 7502, 7505,
+	7507, 7509, 7511, 7516, 7520, 7524, 7529, 7539,
+	7549, 7553, 7557, 7571, 7597, 7607, 7609, 7611,
+	7614, 7616, 7619, 7621, 7625, 7627, 7628, 7632,
+	7634, 7636, 7643, 7647, 7654, 7661, 7670, 7686,
+	7698, 7716, 7727, 7739, 7747, 7765, 7773, 7803,
+	7806, 7816, 7826, 7838, 7849, 7858, 7871, 7883,
+	7887, 7893, 7920, 7929, 7932, 7937, 7943, 7948,
+	7969, 7973, 7979, 7979, 7986, 7995, 8003, 8006,
+	8010, 8016, 8022, 8025, 8029, 8036, 8042, 8051,
+	8060, 8064, 8068, 8072, 8076, 8083, 8087, 8091,
+	8101, 8107, 8111, 8117, 8121, 8124, 8130, 8136,
+	8148, 8152, 8156, 8166, 8170, 8181, 8183, 8185,
+	8189, 8201, 8206, 8230, 8234, 8240, 8262, 8271,
+	8275, 8278, 8279, 8287, 8295, 8301, 8311, 8318,
+	8336, 8339, 8342, 8350, 8356, 8360, 8364, 8368,
+	8374, 8382, 8387, 8393, 8397, 8405, 8412, 8416,
+	8423, 8429, 8437, 8445, 8451, 8457, 8468, 8472,
+	8484, 8493, 8510, 8527, 8530, 8534, 8536, 8542,
+	8544, 8548, 8563, 8567, 8571, 8575, 8579, 8583,
+	8585, 8591, 8596, 8600, 8606, 8613, 8616, 8634,
+	8636, 8681, 8687, 8693, 8697, 8701, 8707, 8711,
+	8717, 8723, 8730, 8732, 8738, 8744, 8748, 8752,
+	8760, 8773, 8779, 8786, 8794, 8800, 8809, 8815,
+	8819, 8824, 8828, 8836, 8840, 8844, 8874, 8880,
+	8886, 8892, 8898, 8905, 8911, 8918, 8923, 8933,
+	8937, 8944, 8950, 8954, 8961, 8965, 8971, 8974,
+	8978, 8982, 8986, 8990, 8995, 9000, 9004, 9015,
+	9019, 9023, 9029, 9037, 9041, 9058, 9062, 9068,
+	9078, 9084, 9090, 9093, 9098, 9107, 9111, 9115,
+	9121, 9125, 9131, 9139, 9157, 9158, 9168, 9169,
+	9178, 9186, 9188, 9191, 9193, 9195, 9197, 9202,
+	9215, 9219, 9234, 9263, 9274, 9276, 9280, 9284,
+	9289, 9293, 9295, 9302, 9306, 9314, 9318, 9393,
+	9395, 9396, 9397, 9398, 9399, 9400, 9402, 9403,
+	9408, 9410, 9412, 9413, 9457, 9458, 9459, 9461,
+	9466, 9470, 9470, 9472, 9474, 9485, 9495, 9503,
+	9504, 9506, 9507, 9511, 9515, 9525, 9529, 9536,
+	9547, 9554, 9558, 9564, 9575, 9607, 9656, 9671,
+	9686, 9691, 9693, 9698, 9730, 9738, 9740, 9762,
+	9784, 9786, 9802, 9818, 9833, 9842, 9856, 9870,
+	9886, 9887, 9888, 9889, 9890, 9892, 9894, 9896,
+	9910, 9924, 9925, 9926, 9928, 9930, 9932, 9946,
+	9960, 9961, 9962, 9964, 9966, 9968, 10016, 10060,
+	10062, 10067, 10071, 10071, 10073, 10075, 10086, 10096,
+	10104, 10105, 10107, 10108, 10112, 10116, 10126, 10130,
+	10137, 10148, 10155, 10159, 10165, 10176, 10208, 10257,
+	10272, 10287, 10292, 10294, 10299, 10331, 10339, 10341,
+	10363, 10385,
 }
 
-var _zcltok_trans_keys []byte = []byte{
+var _hcltok_trans_keys []byte = []byte{
 	10, 46, 42, 42, 47, 46, 69, 101,
 	48, 57, 43, 45, 48, 57, 48, 57,
 	45, 194, 195, 198, 199, 203, 205, 206,
@@ -186,7 +258,7 @@ var _zcltok_trans_keys []byte = []byte{
 	234, 237, 239, 240, 243, 48, 57, 65,
 	90, 97, 122, 196, 218, 229, 236, 10,
 	170, 181, 183, 186, 128, 150, 152, 182,
-	184, 255, 192, 255, 0, 127, 173, 130,
+	184, 255, 192, 255, 128, 255, 173, 130,
 	133, 146, 159, 165, 171, 175, 255, 181,
 	190, 184, 185, 192, 255, 140, 134, 138,
 	142, 161, 163, 255, 182, 130, 136, 137,
@@ -914,7 +986,424 @@ var _zcltok_trans_keys []byte = []byte{
 	128, 191, 128, 191, 128, 191, 128, 191,
 	128, 191, 10, 123, 128, 191, 128, 191,
 	128, 191, 123, 123, 10, 123, 128, 191,
-	128, 191, 128, 191, 123, 123, 9, 10,
+	128, 191, 128, 191, 123, 123, 170, 181,
+	183, 186, 128, 150, 152, 182, 184, 255,
+	192, 255, 128, 255, 173, 130, 133, 146,
+	159, 165, 171, 175, 255, 181, 190, 184,
+	185, 192, 255, 140, 134, 138, 142, 161,
+	163, 255, 182, 130, 136, 137, 176, 151,
+	152, 154, 160, 190, 136, 144, 192, 255,
+	135, 129, 130, 132, 133, 144, 170, 176,
+	178, 144, 154, 160, 191, 128, 169, 174,
+	255, 148, 169, 157, 158, 189, 190, 192,
+	255, 144, 255, 139, 140, 178, 255, 186,
+	128, 181, 160, 161, 162, 163, 164, 165,
+	166, 167, 168, 169, 170, 171, 172, 173,
+	174, 175, 176, 177, 178, 179, 180, 181,
+	182, 183, 184, 185, 186, 187, 188, 189,
+	190, 191, 128, 173, 128, 155, 160, 180,
+	182, 189, 148, 161, 163, 255, 176, 164,
+	165, 132, 169, 177, 141, 142, 145, 146,
+	179, 181, 186, 187, 158, 133, 134, 137,
+	138, 143, 150, 152, 155, 164, 165, 178,
+	255, 188, 129, 131, 133, 138, 143, 144,
+	147, 168, 170, 176, 178, 179, 181, 182,
+	184, 185, 190, 255, 157, 131, 134, 137,
+	138, 142, 144, 146, 152, 159, 165, 182,
+	255, 129, 131, 133, 141, 143, 145, 147,
+	168, 170, 176, 178, 179, 181, 185, 188,
+	255, 134, 138, 142, 143, 145, 159, 164,
+	165, 176, 184, 186, 255, 129, 131, 133,
+	140, 143, 144, 147, 168, 170, 176, 178,
+	179, 181, 185, 188, 191, 177, 128, 132,
+	135, 136, 139, 141, 150, 151, 156, 157,
+	159, 163, 166, 175, 156, 130, 131, 133,
+	138, 142, 144, 146, 149, 153, 154, 158,
+	159, 163, 164, 168, 170, 174, 185, 190,
+	191, 144, 151, 128, 130, 134, 136, 138,
+	141, 166, 175, 128, 131, 133, 140, 142,
+	144, 146, 168, 170, 185, 189, 255, 133,
+	137, 151, 142, 148, 155, 159, 164, 165,
+	176, 255, 128, 131, 133, 140, 142, 144,
+	146, 168, 170, 179, 181, 185, 188, 191,
+	158, 128, 132, 134, 136, 138, 141, 149,
+	150, 160, 163, 166, 175, 177, 178, 129,
+	131, 133, 140, 142, 144, 146, 186, 189,
+	255, 133, 137, 143, 147, 152, 158, 164,
+	165, 176, 185, 192, 255, 189, 130, 131,
+	133, 150, 154, 177, 179, 187, 138, 150,
+	128, 134, 143, 148, 152, 159, 166, 175,
+	178, 179, 129, 186, 128, 142, 144, 153,
+	132, 138, 141, 165, 167, 129, 130, 135,
+	136, 148, 151, 153, 159, 161, 163, 170,
+	171, 173, 185, 187, 189, 134, 128, 132,
+	136, 141, 144, 153, 156, 159, 128, 181,
+	183, 185, 152, 153, 160, 169, 190, 191,
+	128, 135, 137, 172, 177, 191, 128, 132,
+	134, 151, 153, 188, 134, 128, 129, 130,
+	131, 137, 138, 139, 140, 141, 142, 143,
+	144, 153, 154, 155, 156, 157, 158, 159,
+	160, 161, 162, 163, 164, 165, 166, 167,
+	168, 169, 170, 173, 175, 176, 177, 178,
+	179, 181, 182, 183, 188, 189, 190, 191,
+	132, 152, 172, 184, 185, 187, 128, 191,
+	128, 137, 144, 255, 158, 159, 134, 187,
+	136, 140, 142, 143, 137, 151, 153, 142,
+	143, 158, 159, 137, 177, 142, 143, 182,
+	183, 191, 255, 128, 130, 133, 136, 150,
+	152, 255, 145, 150, 151, 155, 156, 160,
+	168, 178, 255, 128, 143, 160, 255, 182,
+	183, 190, 255, 129, 255, 173, 174, 192,
+	255, 129, 154, 160, 255, 171, 173, 185,
+	255, 128, 140, 142, 148, 160, 180, 128,
+	147, 160, 172, 174, 176, 178, 179, 148,
+	150, 152, 155, 158, 159, 170, 255, 139,
+	141, 144, 153, 160, 255, 184, 255, 128,
+	170, 176, 255, 182, 255, 128, 158, 160,
+	171, 176, 187, 134, 173, 176, 180, 128,
+	171, 176, 255, 138, 143, 155, 255, 128,
+	155, 160, 255, 159, 189, 190, 192, 255,
+	167, 128, 137, 144, 153, 176, 189, 140,
+	143, 154, 170, 180, 255, 180, 255, 128,
+	183, 128, 137, 141, 189, 128, 136, 144,
+	146, 148, 182, 184, 185, 128, 181, 187,
+	191, 150, 151, 158, 159, 152, 154, 156,
+	158, 134, 135, 142, 143, 190, 255, 190,
+	128, 180, 182, 188, 130, 132, 134, 140,
+	144, 147, 150, 155, 160, 172, 178, 180,
+	182, 188, 128, 129, 130, 131, 132, 133,
+	134, 176, 177, 178, 179, 180, 181, 182,
+	183, 191, 255, 129, 147, 149, 176, 178,
+	190, 192, 255, 144, 156, 161, 144, 156,
+	165, 176, 130, 135, 149, 164, 166, 168,
+	138, 147, 152, 157, 170, 185, 188, 191,
+	142, 133, 137, 160, 255, 137, 255, 128,
+	174, 176, 255, 159, 165, 170, 180, 255,
+	167, 173, 128, 165, 176, 255, 168, 174,
+	176, 190, 192, 255, 128, 150, 160, 166,
+	168, 174, 176, 182, 184, 190, 128, 134,
+	136, 142, 144, 150, 152, 158, 160, 191,
+	128, 129, 130, 131, 132, 133, 134, 135,
+	144, 145, 255, 133, 135, 161, 175, 177,
+	181, 184, 188, 160, 151, 152, 187, 192,
+	255, 133, 173, 177, 255, 143, 159, 187,
+	255, 176, 191, 182, 183, 184, 191, 192,
+	255, 150, 255, 128, 146, 147, 148, 152,
+	153, 154, 155, 156, 158, 159, 160, 161,
+	162, 163, 164, 165, 166, 167, 168, 169,
+	170, 171, 172, 173, 174, 175, 176, 129,
+	255, 141, 255, 144, 189, 141, 143, 172,
+	255, 191, 128, 175, 180, 189, 151, 159,
+	162, 255, 175, 137, 138, 184, 255, 183,
+	255, 168, 255, 128, 179, 188, 134, 143,
+	154, 159, 184, 186, 190, 255, 128, 173,
+	176, 255, 148, 159, 189, 255, 129, 142,
+	154, 159, 191, 255, 128, 182, 128, 141,
+	144, 153, 160, 182, 186, 255, 128, 130,
+	155, 157, 160, 175, 178, 182, 129, 134,
+	137, 142, 145, 150, 160, 166, 168, 174,
+	176, 255, 155, 166, 175, 128, 170, 172,
+	173, 176, 185, 158, 159, 160, 255, 164,
+	175, 135, 138, 188, 255, 164, 169, 171,
+	172, 173, 174, 175, 180, 181, 182, 183,
+	184, 185, 187, 188, 189, 190, 191, 165,
+	186, 174, 175, 154, 255, 190, 128, 134,
+	147, 151, 157, 168, 170, 182, 184, 188,
+	128, 129, 131, 132, 134, 255, 147, 255,
+	190, 255, 144, 145, 136, 175, 188, 255,
+	128, 143, 160, 175, 179, 180, 141, 143,
+	176, 180, 182, 255, 189, 255, 191, 144,
+	153, 161, 186, 129, 154, 166, 255, 191,
+	255, 130, 135, 138, 143, 146, 151, 154,
+	156, 144, 145, 146, 147, 148, 150, 151,
+	152, 155, 157, 158, 160, 170, 171, 172,
+	175, 161, 169, 128, 129, 130, 131, 133,
+	135, 138, 139, 140, 141, 142, 143, 144,
+	145, 146, 147, 148, 149, 152, 156, 157,
+	160, 161, 162, 163, 164, 166, 168, 169,
+	170, 171, 172, 173, 174, 176, 177, 153,
+	155, 178, 179, 128, 139, 141, 166, 168,
+	186, 188, 189, 191, 255, 142, 143, 158,
+	255, 187, 255, 128, 180, 189, 128, 156,
+	160, 255, 145, 159, 161, 255, 128, 159,
+	176, 255, 139, 143, 187, 255, 128, 157,
+	160, 255, 144, 132, 135, 150, 255, 158,
+	159, 170, 175, 148, 151, 188, 255, 128,
+	167, 176, 255, 164, 255, 183, 255, 128,
+	149, 160, 167, 136, 188, 128, 133, 138,
+	181, 183, 184, 191, 255, 150, 159, 183,
+	255, 128, 158, 160, 178, 180, 181, 128,
+	149, 160, 185, 128, 183, 190, 191, 191,
+	128, 131, 133, 134, 140, 147, 149, 151,
+	153, 179, 184, 186, 160, 188, 128, 156,
+	128, 135, 137, 166, 128, 181, 128, 149,
+	160, 178, 128, 145, 128, 178, 129, 130,
+	131, 132, 133, 135, 136, 138, 139, 140,
+	141, 144, 145, 146, 147, 150, 151, 152,
+	153, 154, 155, 156, 162, 163, 171, 176,
+	177, 178, 128, 134, 135, 165, 176, 190,
+	144, 168, 176, 185, 128, 180, 182, 191,
+	182, 144, 179, 155, 133, 137, 141, 143,
+	157, 255, 190, 128, 145, 147, 183, 136,
+	128, 134, 138, 141, 143, 157, 159, 168,
+	176, 255, 171, 175, 186, 255, 128, 131,
+	133, 140, 143, 144, 147, 168, 170, 176,
+	178, 179, 181, 185, 188, 191, 144, 151,
+	128, 132, 135, 136, 139, 141, 157, 163,
+	166, 172, 176, 180, 128, 138, 144, 153,
+	134, 136, 143, 154, 255, 128, 181, 184,
+	255, 129, 151, 158, 255, 129, 131, 133,
+	143, 154, 255, 128, 137, 128, 153, 157,
+	171, 176, 185, 160, 255, 170, 190, 192,
+	255, 128, 184, 128, 136, 138, 182, 184,
+	191, 128, 144, 153, 178, 255, 168, 144,
+	145, 183, 255, 128, 142, 145, 149, 129,
+	141, 144, 146, 147, 148, 175, 255, 132,
+	255, 128, 144, 129, 143, 144, 153, 145,
+	152, 135, 255, 160, 168, 169, 171, 172,
+	173, 174, 188, 189, 190, 191, 161, 167,
+	185, 255, 128, 158, 160, 169, 144, 173,
+	176, 180, 128, 131, 144, 153, 163, 183,
+	189, 255, 144, 255, 133, 143, 191, 255,
+	143, 159, 160, 128, 129, 255, 159, 160,
+	171, 172, 255, 173, 255, 179, 255, 128,
+	176, 177, 178, 128, 129, 171, 175, 189,
+	255, 128, 136, 144, 153, 157, 158, 133,
+	134, 137, 144, 145, 146, 147, 148, 149,
+	154, 155, 156, 157, 158, 159, 168, 169,
+	170, 150, 153, 165, 169, 173, 178, 187,
+	255, 131, 132, 140, 169, 174, 255, 130,
+	132, 149, 157, 173, 186, 188, 160, 161,
+	163, 164, 167, 168, 132, 134, 149, 157,
+	186, 139, 140, 191, 255, 134, 128, 132,
+	138, 144, 146, 255, 166, 167, 129, 155,
+	187, 149, 181, 143, 175, 137, 169, 131,
+	140, 141, 192, 255, 128, 182, 187, 255,
+	173, 180, 182, 255, 132, 155, 159, 161,
+	175, 128, 160, 163, 164, 165, 184, 185,
+	186, 161, 162, 128, 134, 136, 152, 155,
+	161, 163, 164, 166, 170, 133, 143, 151,
+	255, 139, 143, 154, 255, 164, 167, 185,
+	187, 128, 131, 133, 159, 161, 162, 169,
+	178, 180, 183, 130, 135, 137, 139, 148,
+	151, 153, 155, 157, 159, 164, 190, 141,
+	143, 145, 146, 161, 162, 167, 170, 172,
+	178, 180, 183, 185, 188, 128, 137, 139,
+	155, 161, 163, 165, 169, 171, 187, 155,
+	156, 151, 255, 156, 157, 160, 181, 255,
+	186, 187, 255, 162, 255, 160, 168, 161,
+	167, 158, 255, 160, 132, 135, 133, 134,
+	176, 255, 128, 191, 154, 164, 168, 128,
+	149, 150, 191, 128, 152, 153, 191, 181,
+	128, 159, 160, 189, 190, 191, 189, 128,
+	131, 132, 185, 186, 191, 144, 128, 151,
+	152, 161, 162, 176, 177, 255, 169, 177,
+	129, 132, 141, 142, 145, 146, 179, 181,
+	186, 188, 190, 191, 192, 255, 142, 158,
+	128, 155, 156, 161, 162, 175, 176, 177,
+	178, 191, 169, 177, 180, 183, 128, 132,
+	133, 138, 139, 142, 143, 144, 145, 146,
+	147, 185, 186, 191, 157, 128, 152, 153,
+	158, 159, 177, 178, 180, 181, 191, 142,
+	146, 169, 177, 180, 189, 128, 132, 133,
+	185, 186, 191, 144, 185, 128, 159, 160,
+	161, 162, 191, 169, 177, 180, 189, 128,
+	132, 133, 140, 141, 142, 143, 144, 145,
+	146, 147, 185, 186, 191, 158, 177, 128,
+	155, 156, 161, 162, 191, 131, 145, 155,
+	157, 128, 132, 133, 138, 139, 141, 142,
+	149, 150, 152, 153, 159, 160, 162, 163,
+	164, 165, 167, 168, 170, 171, 173, 174,
+	185, 186, 191, 144, 128, 191, 141, 145,
+	169, 189, 128, 132, 133, 185, 186, 191,
+	128, 151, 152, 154, 155, 159, 160, 161,
+	162, 191, 128, 141, 145, 169, 180, 189,
+	129, 132, 133, 185, 186, 191, 158, 128,
+	159, 160, 161, 162, 176, 177, 178, 179,
+	191, 141, 145, 189, 128, 132, 133, 186,
+	187, 191, 142, 128, 147, 148, 150, 151,
+	158, 159, 161, 162, 185, 186, 191, 178,
+	188, 128, 132, 133, 150, 151, 153, 154,
+	189, 190, 191, 128, 134, 135, 191, 128,
+	177, 129, 179, 180, 191, 128, 131, 137,
+	141, 152, 160, 164, 166, 172, 177, 189,
+	129, 132, 133, 134, 135, 138, 139, 147,
+	148, 167, 168, 169, 170, 179, 180, 191,
+	133, 128, 134, 135, 155, 156, 159, 160,
+	191, 128, 129, 191, 136, 128, 172, 173,
+	191, 128, 135, 136, 140, 141, 191, 191,
+	128, 170, 171, 190, 161, 128, 143, 144,
+	149, 150, 153, 154, 157, 158, 164, 165,
+	166, 167, 173, 174, 176, 177, 180, 181,
+	255, 130, 141, 143, 159, 134, 187, 136,
+	140, 142, 143, 137, 151, 153, 142, 143,
+	158, 159, 137, 177, 191, 142, 143, 182,
+	183, 192, 255, 129, 151, 128, 133, 134,
+	135, 136, 255, 145, 150, 151, 155, 191,
+	192, 255, 128, 143, 144, 159, 160, 255,
+	182, 183, 190, 191, 192, 255, 128, 129,
+	255, 173, 174, 192, 255, 128, 129, 154,
+	155, 159, 160, 255, 171, 173, 185, 191,
+	192, 255, 141, 128, 145, 146, 159, 160,
+	177, 178, 191, 173, 128, 145, 146, 159,
+	160, 176, 177, 191, 128, 179, 180, 191,
+	151, 156, 128, 191, 128, 159, 160, 255,
+	184, 191, 192, 255, 169, 128, 170, 171,
+	175, 176, 255, 182, 191, 192, 255, 128,
+	158, 159, 191, 128, 143, 144, 173, 174,
+	175, 176, 180, 181, 191, 128, 171, 172,
+	175, 176, 255, 138, 191, 192, 255, 128,
+	150, 151, 159, 160, 255, 149, 191, 192,
+	255, 167, 128, 191, 128, 132, 133, 179,
+	180, 191, 128, 132, 133, 139, 140, 191,
+	128, 130, 131, 160, 161, 173, 174, 175,
+	176, 185, 186, 255, 166, 191, 192, 255,
+	128, 163, 164, 191, 128, 140, 141, 143,
+	144, 153, 154, 189, 190, 191, 128, 136,
+	137, 191, 173, 128, 168, 169, 177, 178,
+	180, 181, 182, 183, 191, 0, 127, 192,
+	255, 150, 151, 158, 159, 152, 154, 156,
+	158, 134, 135, 142, 143, 190, 191, 192,
+	255, 181, 189, 191, 128, 190, 133, 181,
+	128, 129, 130, 140, 141, 143, 144, 147,
+	148, 149, 150, 155, 156, 159, 160, 172,
+	173, 177, 178, 188, 189, 191, 177, 191,
+	128, 190, 128, 143, 144, 156, 157, 191,
+	130, 135, 148, 164, 166, 168, 128, 137,
+	138, 149, 150, 151, 152, 157, 158, 169,
+	170, 185, 186, 187, 188, 191, 142, 128,
+	132, 133, 137, 138, 159, 160, 255, 137,
+	191, 192, 255, 175, 128, 255, 159, 165,
+	170, 175, 177, 180, 191, 192, 255, 166,
+	173, 128, 167, 168, 175, 176, 255, 168,
+	174, 176, 191, 192, 255, 167, 175, 183,
+	191, 128, 150, 151, 159, 160, 190, 135,
+	143, 151, 128, 158, 159, 191, 128, 132,
+	133, 135, 136, 160, 161, 169, 170, 176,
+	177, 181, 182, 183, 184, 188, 189, 191,
+	160, 151, 154, 187, 192, 255, 128, 132,
+	133, 173, 174, 176, 177, 255, 143, 159,
+	187, 191, 192, 255, 128, 175, 176, 191,
+	150, 191, 192, 255, 141, 191, 192, 255,
+	128, 143, 144, 189, 190, 191, 141, 143,
+	160, 169, 172, 191, 192, 255, 191, 128,
+	174, 175, 190, 128, 157, 158, 159, 160,
+	255, 176, 191, 192, 255, 128, 150, 151,
+	159, 160, 161, 162, 255, 175, 137, 138,
+	184, 191, 192, 255, 128, 182, 183, 255,
+	130, 134, 139, 163, 191, 192, 255, 128,
+	129, 130, 179, 180, 191, 187, 189, 128,
+	177, 178, 183, 184, 191, 128, 137, 138,
+	165, 166, 175, 176, 255, 135, 159, 189,
+	191, 192, 255, 128, 131, 132, 178, 179,
+	191, 143, 165, 191, 128, 159, 160, 175,
+	176, 185, 186, 190, 128, 168, 169, 191,
+	131, 186, 128, 139, 140, 159, 160, 182,
+	183, 189, 190, 255, 176, 178, 180, 183,
+	184, 190, 191, 192, 255, 129, 128, 130,
+	131, 154, 155, 157, 158, 159, 160, 170,
+	171, 177, 178, 180, 181, 191, 128, 167,
+	175, 129, 134, 135, 136, 137, 142, 143,
+	144, 145, 150, 151, 159, 160, 255, 155,
+	166, 175, 128, 162, 163, 191, 164, 175,
+	135, 138, 188, 191, 192, 255, 174, 175,
+	154, 191, 192, 255, 157, 169, 183, 189,
+	191, 128, 134, 135, 146, 147, 151, 152,
+	158, 159, 190, 130, 133, 128, 255, 178,
+	191, 192, 255, 128, 146, 147, 255, 190,
+	191, 192, 255, 128, 143, 144, 255, 144,
+	145, 136, 175, 188, 191, 192, 255, 181,
+	128, 175, 176, 255, 189, 191, 192, 255,
+	128, 160, 161, 186, 187, 191, 128, 129,
+	154, 155, 165, 166, 255, 191, 192, 255,
+	128, 129, 130, 135, 136, 137, 138, 143,
+	144, 145, 146, 151, 152, 153, 154, 156,
+	157, 191, 128, 191, 128, 129, 130, 131,
+	133, 138, 139, 140, 141, 142, 143, 144,
+	145, 146, 147, 148, 149, 152, 156, 157,
+	160, 161, 162, 163, 164, 166, 168, 169,
+	170, 171, 172, 173, 174, 176, 177, 132,
+	151, 153, 155, 158, 175, 178, 179, 180,
+	191, 140, 167, 187, 190, 128, 255, 142,
+	143, 158, 191, 192, 255, 187, 191, 192,
+	255, 128, 180, 181, 191, 128, 156, 157,
+	159, 160, 255, 145, 191, 192, 255, 128,
+	159, 160, 175, 176, 255, 139, 143, 182,
+	191, 192, 255, 144, 132, 135, 150, 191,
+	192, 255, 158, 175, 148, 151, 188, 191,
+	192, 255, 128, 167, 168, 175, 176, 255,
+	164, 191, 192, 255, 183, 191, 192, 255,
+	128, 149, 150, 159, 160, 167, 168, 191,
+	136, 182, 188, 128, 133, 134, 137, 138,
+	184, 185, 190, 191, 255, 150, 159, 183,
+	191, 192, 255, 179, 128, 159, 160, 181,
+	182, 191, 128, 149, 150, 159, 160, 185,
+	186, 191, 128, 183, 184, 189, 190, 191,
+	128, 148, 152, 129, 143, 144, 179, 180,
+	191, 128, 159, 160, 188, 189, 191, 128,
+	156, 157, 191, 136, 128, 164, 165, 191,
+	128, 181, 182, 191, 128, 149, 150, 159,
+	160, 178, 179, 191, 128, 145, 146, 191,
+	128, 178, 179, 191, 128, 130, 131, 132,
+	133, 134, 135, 136, 138, 139, 140, 141,
+	144, 145, 146, 147, 150, 151, 152, 153,
+	154, 156, 162, 163, 171, 176, 177, 178,
+	129, 191, 128, 130, 131, 183, 184, 191,
+	128, 130, 131, 175, 176, 191, 128, 143,
+	144, 168, 169, 191, 128, 130, 131, 166,
+	167, 191, 182, 128, 143, 144, 178, 179,
+	191, 128, 130, 131, 178, 179, 191, 128,
+	154, 156, 129, 132, 133, 191, 146, 128,
+	171, 172, 191, 135, 137, 142, 158, 128,
+	168, 169, 175, 176, 255, 159, 191, 192,
+	255, 144, 128, 156, 157, 161, 162, 191,
+	128, 134, 135, 138, 139, 191, 128, 175,
+	176, 191, 134, 128, 131, 132, 135, 136,
+	191, 128, 174, 175, 191, 128, 151, 152,
+	155, 156, 191, 132, 128, 191, 128, 170,
+	171, 191, 128, 153, 154, 191, 160, 190,
+	192, 255, 128, 184, 185, 191, 137, 128,
+	174, 175, 191, 128, 129, 177, 178, 255,
+	144, 191, 192, 255, 128, 142, 143, 144,
+	145, 146, 149, 129, 148, 150, 191, 175,
+	191, 192, 255, 132, 191, 192, 255, 128,
+	144, 129, 143, 145, 191, 144, 153, 128,
+	143, 145, 152, 154, 191, 135, 191, 192,
+	255, 160, 168, 169, 171, 172, 173, 174,
+	188, 189, 190, 191, 128, 159, 161, 167,
+	170, 187, 185, 191, 192, 255, 128, 143,
+	144, 173, 174, 191, 128, 131, 132, 162,
+	163, 183, 184, 188, 189, 255, 133, 143,
+	145, 191, 192, 255, 128, 146, 147, 159,
+	160, 191, 160, 128, 191, 128, 129, 191,
+	192, 255, 159, 160, 171, 128, 170, 172,
+	191, 192, 255, 173, 191, 192, 255, 179,
+	191, 192, 255, 128, 176, 177, 178, 129,
+	191, 128, 129, 130, 191, 171, 175, 189,
+	191, 192, 255, 128, 136, 137, 143, 144,
+	153, 154, 191, 144, 145, 146, 147, 148,
+	149, 154, 155, 156, 157, 158, 159, 128,
+	143, 150, 153, 160, 191, 149, 157, 173,
+	186, 188, 160, 161, 163, 164, 167, 168,
+	132, 134, 149, 157, 186, 191, 139, 140,
+	192, 255, 133, 145, 128, 134, 135, 137,
+	138, 255, 166, 167, 129, 155, 187, 149,
+	181, 143, 175, 137, 169, 131, 140, 191,
+	192, 255, 160, 163, 164, 165, 184, 185,
+	186, 128, 159, 161, 162, 166, 191, 133,
+	191, 192, 255, 132, 160, 163, 167, 179,
+	184, 186, 128, 164, 165, 168, 169, 187,
+	188, 191, 130, 135, 137, 139, 144, 147,
+	151, 153, 155, 157, 159, 163, 171, 179,
+	184, 189, 191, 128, 140, 141, 148, 149,
+	160, 161, 164, 165, 166, 167, 190, 138,
+	164, 170, 128, 155, 156, 160, 161, 187,
+	188, 191, 128, 191, 155, 156, 128, 191,
+	151, 191, 192, 255, 156, 157, 160, 128,
+	191, 181, 191, 192, 255, 158, 159, 186,
+	128, 185, 187, 191, 192, 255, 162, 191,
+	192, 255, 160, 168, 128, 159, 161, 167,
+	169, 191, 158, 191, 192, 255, 9, 10,
 	13, 32, 33, 34, 35, 38, 46, 47,
 	60, 61, 62, 64, 92, 95, 123, 124,
 	125, 126, 127, 194, 195, 198, 199, 203,
@@ -924,7 +1413,7 @@ var _zcltok_trans_keys []byte = []byte{
 	238, 239, 240, 0, 39, 40, 45, 48,
 	57, 58, 63, 65, 90, 91, 96, 97,
 	122, 192, 193, 196, 218, 229, 236, 241,
-	247, 9, 10, 32, 61, 10, 38, 46,
+	247, 9, 32, 10, 61, 10, 38, 46,
 	42, 47, 42, 46, 69, 101, 48, 57,
 	60, 61, 61, 62, 61, 45, 95, 194,
 	195, 198, 199, 203, 204, 205, 206, 207,
@@ -996,9 +1485,62 @@ var _zcltok_trans_keys []byte = []byte{
 	248, 255, 10, 13, 36, 37, 128, 191,
 	192, 223, 224, 239, 240, 247, 248, 255,
 	126, 126, 128, 191, 128, 191, 128, 191,
+	194, 195, 198, 199, 203, 204, 205, 206,
+	207, 210, 212, 213, 214, 215, 216, 217,
+	219, 220, 221, 222, 223, 224, 225, 226,
+	227, 228, 233, 234, 237, 238, 239, 240,
+	65, 90, 97, 122, 128, 191, 192, 193,
+	196, 218, 229, 236, 241, 247, 248, 255,
+	45, 95, 194, 195, 198, 199, 203, 204,
+	205, 206, 207, 210, 212, 213, 214, 215,
+	216, 217, 219, 220, 221, 222, 223, 224,
+	225, 226, 227, 228, 233, 234, 237, 239,
+	240, 243, 48, 57, 65, 90, 97, 122,
+	196, 218, 229, 236, 128, 191, 170, 181,
+	186, 128, 191, 151, 183, 128, 255, 192,
+	255, 0, 127, 173, 130, 133, 146, 159,
+	165, 171, 175, 191, 192, 255, 181, 190,
+	128, 175, 176, 183, 184, 185, 186, 191,
+	134, 139, 141, 162, 128, 135, 136, 255,
+	182, 130, 137, 176, 151, 152, 154, 160,
+	136, 191, 192, 255, 128, 143, 144, 170,
+	171, 175, 176, 178, 179, 191, 128, 159,
+	160, 191, 176, 128, 138, 139, 173, 174,
+	255, 148, 150, 164, 167, 173, 176, 185,
+	189, 190, 192, 255, 144, 128, 145, 146,
+	175, 176, 191, 128, 140, 141, 255, 166,
+	176, 178, 191, 192, 255, 186, 128, 137,
+	138, 170, 171, 179, 180, 181, 182, 191,
+	160, 161, 162, 164, 165, 166, 167, 168,
+	169, 170, 171, 172, 173, 174, 175, 176,
+	177, 178, 179, 180, 181, 182, 183, 184,
+	185, 186, 187, 188, 189, 190, 128, 191,
+	128, 129, 130, 131, 137, 138, 139, 140,
+	141, 142, 143, 144, 153, 154, 155, 156,
+	157, 158, 159, 160, 161, 162, 163, 164,
+	165, 166, 167, 168, 169, 170, 171, 172,
+	173, 174, 175, 176, 177, 178, 179, 180,
+	182, 183, 184, 188, 189, 190, 191, 132,
+	187, 129, 130, 132, 133, 134, 176, 177,
+	178, 179, 180, 181, 182, 183, 128, 191,
+	128, 129, 130, 131, 132, 133, 134, 135,
+	144, 136, 143, 145, 191, 192, 255, 182,
+	183, 184, 128, 191, 128, 191, 191, 128,
+	190, 192, 255, 128, 146, 147, 148, 152,
+	153, 154, 155, 156, 158, 159, 160, 161,
+	162, 163, 164, 165, 166, 167, 168, 169,
+	170, 171, 172, 173, 174, 175, 176, 129,
+	191, 192, 255, 158, 159, 128, 157, 160,
+	191, 192, 255, 128, 191, 164, 169, 171,
+	172, 173, 174, 175, 180, 181, 182, 183,
+	184, 185, 187, 188, 189, 190, 191, 128,
+	163, 165, 186, 144, 145, 146, 147, 148,
+	150, 151, 152, 155, 157, 158, 160, 170,
+	171, 172, 175, 128, 159, 161, 169, 173,
+	191, 128, 191,
 }
 
-var _zcltok_single_lengths []byte = []byte{
+var _hcltok_single_lengths []byte = []byte{
 	0, 1, 1, 1, 2, 3, 2, 0,
 	31, 30, 36, 1, 4, 0, 0, 0,
 	0, 1, 2, 1, 1, 1, 1, 0,
@@ -1117,7 +1659,71 @@ var _zcltok_single_lengths []byte = []byte{
 	2, 0, 3, 0, 0, 1, 0, 2,
 	0, 1, 0, 0, 0, 0, 0, 1,
 	1, 0, 0, 0, 1, 1, 1, 1,
-	0, 0, 0, 1, 1, 53, 1, 1,
+	0, 0, 0, 1, 1, 4, 0, 0,
+	0, 0, 1, 2, 1, 1, 1, 1,
+	0, 1, 1, 0, 0, 2, 0, 0,
+	0, 1, 32, 0, 0, 0, 0, 1,
+	3, 1, 1, 1, 0, 2, 0, 1,
+	1, 2, 0, 3, 0, 1, 0, 2,
+	1, 2, 0, 0, 5, 1, 4, 0,
+	0, 1, 43, 0, 0, 0, 2, 3,
+	2, 1, 1, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 1,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	4, 1, 0, 15, 0, 0, 0, 1,
+	6, 1, 0, 0, 1, 0, 2, 0,
+	0, 0, 9, 0, 1, 1, 0, 0,
+	0, 3, 0, 1, 0, 28, 0, 0,
+	0, 1, 0, 1, 0, 0, 0, 1,
+	0, 0, 0, 0, 0, 0, 0, 1,
+	0, 2, 0, 0, 18, 0, 0, 1,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	1, 0, 0, 0, 16, 36, 0, 0,
+	0, 0, 1, 0, 0, 0, 0, 0,
+	1, 0, 0, 0, 0, 0, 0, 2,
+	0, 0, 0, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 28, 0, 0,
+	0, 1, 1, 1, 1, 0, 0, 2,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 4, 0, 0,
+	2, 2, 0, 11, 0, 0, 0, 0,
+	0, 0, 0, 1, 1, 3, 0, 0,
+	4, 0, 0, 0, 18, 0, 0, 0,
+	1, 4, 1, 4, 1, 0, 3, 2,
+	2, 2, 1, 0, 0, 1, 8, 0,
+	0, 0, 4, 12, 0, 2, 0, 3,
+	0, 1, 0, 2, 0, 1, 2, 0,
+	0, 3, 0, 1, 1, 1, 2, 2,
+	4, 1, 6, 2, 4, 2, 4, 1,
+	4, 0, 6, 1, 3, 1, 2, 0,
+	2, 11, 1, 1, 1, 0, 1, 1,
+	0, 2, 0, 3, 3, 2, 1, 0,
+	0, 0, 1, 0, 1, 0, 1, 1,
+	0, 2, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 1, 0, 0, 0,
+	0, 0, 0, 0, 1, 0, 0, 0,
+	4, 3, 2, 2, 0, 6, 1, 0,
+	1, 1, 0, 2, 0, 4, 3, 0,
+	1, 1, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 0, 1, 0, 3,
+	0, 2, 0, 0, 0, 3, 0, 2,
+	1, 1, 3, 1, 0, 0, 0, 0,
+	0, 5, 2, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 1, 1, 0, 0,
+	35, 4, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	3, 0, 1, 0, 0, 3, 0, 0,
+	1, 0, 0, 0, 0, 28, 0, 0,
+	0, 0, 1, 0, 3, 1, 4, 0,
+	1, 0, 0, 1, 0, 0, 1, 0,
+	0, 0, 0, 1, 1, 0, 7, 0,
+	0, 2, 2, 0, 11, 0, 0, 0,
+	0, 0, 1, 1, 3, 0, 0, 4,
+	0, 0, 0, 12, 1, 4, 1, 5,
+	2, 0, 3, 2, 2, 2, 1, 7,
+	0, 7, 17, 3, 0, 2, 0, 3,
+	0, 0, 1, 0, 2, 0, 53, 2,
 	1, 1, 1, 1, 1, 2, 1, 3,
 	2, 2, 1, 34, 1, 1, 0, 3,
 	2, 0, 0, 0, 1, 2, 4, 1,
@@ -1127,10 +1733,15 @@ var _zcltok_single_lengths []byte = []byte{
 	0, 6, 4, 3, 1, 4, 4, 4,
 	1, 1, 1, 1, 0, 0, 0, 4,
 	2, 1, 1, 0, 0, 0, 4, 2,
-	1, 1, 0, 0, 0,
+	1, 1, 0, 0, 0, 32, 34, 0,
+	3, 2, 0, 0, 0, 1, 2, 4,
+	1, 0, 1, 0, 0, 0, 0, 1,
+	1, 1, 0, 0, 1, 30, 47, 13,
+	9, 3, 0, 1, 28, 2, 0, 18,
+	16, 0,
 }
 
-var _zcltok_range_lengths []byte = []byte{
+var _hcltok_range_lengths []byte = []byte{
 	0, 0, 0, 0, 0, 1, 1, 1,
 	5, 5, 5, 0, 0, 3, 0, 1,
 	1, 4, 2, 3, 0, 1, 0, 2,
@@ -1249,7 +1860,71 @@ var _zcltok_range_lengths []byte = []byte{
 	1, 2, 1, 2, 1, 3, 2, 3,
 	2, 0, 1, 1, 1, 1, 1, 0,
 	0, 1, 1, 1, 0, 0, 0, 0,
-	1, 1, 1, 0, 0, 11, 0, 0,
+	1, 1, 1, 0, 0, 0, 3, 0,
+	1, 1, 4, 2, 3, 0, 1, 0,
+	2, 2, 4, 2, 2, 3, 1, 1,
+	1, 1, 0, 1, 1, 2, 2, 1,
+	4, 6, 9, 6, 8, 5, 8, 7,
+	10, 4, 6, 4, 7, 7, 5, 5,
+	4, 5, 1, 2, 8, 4, 3, 3,
+	3, 0, 3, 1, 2, 1, 2, 2,
+	3, 3, 1, 3, 2, 2, 1, 2,
+	2, 2, 3, 4, 4, 3, 1, 2,
+	1, 3, 2, 2, 2, 2, 2, 3,
+	3, 1, 1, 2, 1, 3, 2, 2,
+	3, 2, 7, 0, 1, 4, 1, 2,
+	4, 2, 1, 2, 0, 2, 2, 3,
+	5, 5, 1, 4, 1, 1, 2, 2,
+	1, 0, 0, 1, 1, 1, 1, 1,
+	2, 2, 2, 2, 1, 1, 1, 4,
+	2, 2, 3, 1, 4, 4, 6, 1,
+	3, 1, 1, 2, 1, 1, 1, 5,
+	3, 1, 1, 1, 2, 3, 3, 1,
+	2, 2, 1, 4, 1, 2, 5, 2,
+	1, 1, 0, 2, 2, 2, 2, 2,
+	2, 2, 2, 2, 1, 1, 2, 4,
+	2, 1, 2, 2, 2, 6, 1, 1,
+	2, 1, 2, 1, 1, 1, 2, 2,
+	2, 1, 3, 2, 5, 2, 8, 6,
+	2, 2, 2, 2, 3, 1, 3, 1,
+	2, 1, 3, 2, 2, 3, 1, 1,
+	1, 1, 1, 1, 1, 2, 2, 4,
+	1, 2, 1, 0, 1, 1, 1, 1,
+	0, 1, 2, 3, 1, 3, 3, 1,
+	0, 3, 0, 2, 3, 1, 0, 0,
+	0, 0, 2, 2, 2, 2, 1, 5,
+	2, 2, 5, 7, 5, 0, 1, 0,
+	1, 1, 1, 1, 1, 0, 1, 1,
+	1, 2, 2, 3, 3, 4, 7, 5,
+	7, 5, 3, 3, 7, 3, 13, 1,
+	3, 5, 3, 5, 3, 6, 5, 2,
+	2, 8, 4, 1, 2, 3, 2, 10,
+	2, 2, 0, 2, 3, 3, 1, 2,
+	3, 3, 1, 2, 3, 3, 4, 4,
+	2, 1, 2, 2, 3, 2, 2, 5,
+	3, 2, 3, 2, 1, 3, 3, 6,
+	2, 2, 5, 2, 5, 1, 1, 2,
+	4, 1, 11, 1, 3, 8, 4, 2,
+	1, 0, 4, 3, 3, 3, 2, 9,
+	1, 1, 4, 3, 2, 2, 2, 3,
+	4, 2, 3, 2, 4, 3, 2, 2,
+	3, 3, 4, 3, 3, 4, 2, 5,
+	4, 8, 7, 1, 2, 1, 3, 1,
+	2, 5, 1, 2, 2, 2, 2, 1,
+	3, 2, 2, 3, 3, 1, 9, 1,
+	5, 1, 3, 2, 2, 3, 2, 3,
+	3, 3, 1, 3, 3, 2, 2, 4,
+	5, 3, 3, 4, 3, 3, 3, 2,
+	2, 2, 4, 2, 2, 1, 3, 3,
+	3, 3, 3, 3, 2, 2, 3, 2,
+	3, 3, 2, 3, 2, 3, 1, 2,
+	2, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 3, 2, 3, 2, 3, 5,
+	3, 3, 1, 2, 3, 2, 2, 1,
+	2, 3, 4, 3, 0, 3, 0, 2,
+	3, 1, 0, 0, 0, 0, 2, 3,
+	2, 4, 6, 4, 1, 1, 2, 1,
+	2, 1, 3, 2, 3, 2, 11, 0,
 	0, 0, 0, 0, 0, 0, 0, 1,
 	0, 0, 0, 5, 0, 0, 1, 1,
 	1, 0, 1, 1, 5, 4, 2, 0,
@@ -1259,10 +1934,15 @@ var _zcltok_range_lengths []byte = []byte{
 	1, 5, 6, 6, 4, 5, 5, 6,
 	0, 0, 0, 0, 1, 1, 1, 5,
 	6, 0, 0, 1, 1, 1, 5, 6,
-	0, 0, 1, 1, 1,
+	0, 0, 1, 1, 1, 8, 5, 1,
+	1, 1, 0, 1, 1, 5, 4, 2,
+	0, 1, 0, 2, 2, 5, 2, 3,
+	5, 3, 2, 3, 5, 1, 1, 1,
+	3, 1, 1, 2, 2, 3, 1, 2,
+	3, 1,
 }
 
-var _zcltok_index_offsets []int16 = []int16{
+var _hcltok_index_offsets []int16 = []int16{
 	0, 0, 2, 4, 6, 9, 14, 18,
 	20, 57, 93, 135, 137, 142, 146, 147,
 	149, 151, 157, 162, 167, 169, 172, 174,
@@ -1381,20 +2061,89 @@ var _zcltok_index_offsets []int16 = []int16{
 	4692, 4696, 4699, 4704, 4707, 4709, 4714, 4717,
 	4723, 4726, 4728, 4730, 4732, 4734, 4736, 4738,
 	4740, 4742, 4744, 4746, 4748, 4750, 4752, 4754,
-	4756, 4758, 4760, 4762, 4764, 4766, 4831, 4833,
-	4835, 4837, 4839, 4841, 4843, 4845, 4848, 4850,
-	4855, 4858, 4861, 4863, 4903, 4905, 4907, 4909,
-	4914, 4918, 4919, 4921, 4923, 4930, 4937, 4944,
-	4946, 4948, 4950, 4953, 4956, 4962, 4965, 4970,
-	4977, 4982, 4985, 4989, 4996, 5028, 5077, 5092,
-	5105, 5110, 5112, 5116, 5147, 5153, 5155, 5176,
-	5196, 5198, 5210, 5221, 5231, 5237, 5247, 5257,
-	5268, 5270, 5272, 5274, 5276, 5278, 5280, 5282,
-	5292, 5301, 5303, 5305, 5307, 5309, 5311, 5321,
-	5330, 5332, 5334, 5336, 5338,
+	4756, 4758, 4760, 4762, 4764, 4766, 4771, 4775,
+	4776, 4778, 4780, 4786, 4791, 4796, 4798, 4801,
+	4803, 4806, 4810, 4816, 4819, 4822, 4828, 4830,
+	4832, 4834, 4837, 4870, 4872, 4874, 4877, 4880,
+	4883, 4891, 4899, 4910, 4918, 4927, 4935, 4944,
+	4953, 4965, 4972, 4979, 4987, 4995, 5004, 5010,
+	5018, 5024, 5032, 5034, 5037, 5051, 5057, 5065,
+	5069, 5073, 5075, 5122, 5124, 5127, 5129, 5134,
+	5140, 5146, 5151, 5154, 5158, 5161, 5164, 5166,
+	5169, 5172, 5175, 5179, 5184, 5189, 5193, 5195,
+	5198, 5200, 5204, 5207, 5210, 5213, 5216, 5220,
+	5225, 5229, 5231, 5233, 5236, 5238, 5242, 5245,
+	5248, 5256, 5260, 5268, 5284, 5286, 5291, 5293,
+	5297, 5308, 5312, 5314, 5317, 5319, 5322, 5327,
+	5331, 5337, 5343, 5354, 5359, 5362, 5365, 5368,
+	5371, 5373, 5377, 5378, 5381, 5383, 5413, 5415,
+	5417, 5420, 5424, 5427, 5431, 5433, 5435, 5437,
+	5443, 5446, 5449, 5453, 5455, 5460, 5465, 5472,
+	5475, 5479, 5483, 5485, 5488, 5508, 5510, 5512,
+	5519, 5523, 5525, 5527, 5529, 5532, 5536, 5540,
+	5542, 5546, 5549, 5551, 5556, 5574, 5613, 5619,
+	5622, 5624, 5626, 5628, 5631, 5634, 5637, 5640,
+	5643, 5647, 5650, 5653, 5656, 5658, 5660, 5663,
+	5670, 5673, 5675, 5678, 5681, 5684, 5692, 5694,
+	5696, 5699, 5701, 5704, 5706, 5708, 5738, 5741,
+	5744, 5747, 5750, 5755, 5759, 5766, 5769, 5778,
+	5787, 5790, 5794, 5797, 5800, 5804, 5806, 5810,
+	5812, 5815, 5817, 5821, 5825, 5829, 5837, 5839,
+	5841, 5845, 5849, 5851, 5864, 5866, 5869, 5872,
+	5877, 5879, 5882, 5884, 5886, 5889, 5894, 5896,
+	5898, 5903, 5905, 5908, 5912, 5932, 5936, 5940,
+	5942, 5944, 5952, 5954, 5961, 5966, 5968, 5972,
+	5975, 5978, 5981, 5985, 5988, 5991, 5995, 6005,
+	6011, 6014, 6017, 6027, 6047, 6053, 6056, 6058,
+	6062, 6064, 6067, 6069, 6073, 6075, 6077, 6081,
+	6083, 6085, 6091, 6094, 6099, 6104, 6110, 6120,
+	6128, 6140, 6147, 6157, 6163, 6175, 6181, 6199,
+	6202, 6210, 6216, 6226, 6233, 6240, 6248, 6256,
+	6259, 6264, 6284, 6290, 6293, 6297, 6301, 6305,
+	6317, 6320, 6325, 6326, 6332, 6339, 6345, 6348,
+	6351, 6355, 6359, 6362, 6365, 6370, 6374, 6380,
+	6386, 6389, 6393, 6396, 6399, 6404, 6407, 6410,
+	6416, 6420, 6423, 6427, 6430, 6433, 6437, 6441,
+	6448, 6451, 6454, 6460, 6463, 6470, 6472, 6474,
+	6477, 6486, 6491, 6505, 6509, 6513, 6528, 6534,
+	6537, 6540, 6542, 6547, 6553, 6557, 6565, 6571,
+	6581, 6584, 6587, 6592, 6596, 6599, 6602, 6605,
+	6609, 6614, 6618, 6622, 6625, 6630, 6635, 6638,
+	6644, 6648, 6654, 6659, 6663, 6667, 6675, 6678,
+	6686, 6692, 6702, 6713, 6716, 6719, 6721, 6725,
+	6727, 6730, 6741, 6745, 6748, 6751, 6754, 6757,
+	6759, 6763, 6767, 6770, 6774, 6779, 6782, 6792,
+	6794, 6835, 6841, 6845, 6848, 6851, 6855, 6858,
+	6862, 6866, 6871, 6873, 6877, 6881, 6884, 6887,
+	6892, 6901, 6905, 6910, 6915, 6919, 6926, 6930,
+	6933, 6937, 6940, 6945, 6948, 6951, 6981, 6985,
+	6989, 6993, 6997, 7002, 7006, 7012, 7016, 7024,
+	7027, 7032, 7036, 7039, 7044, 7047, 7051, 7054,
+	7057, 7060, 7063, 7066, 7070, 7074, 7077, 7087,
+	7090, 7093, 7098, 7104, 7107, 7122, 7125, 7129,
+	7135, 7139, 7143, 7146, 7150, 7157, 7160, 7163,
+	7169, 7172, 7176, 7181, 7197, 7199, 7207, 7209,
+	7217, 7223, 7225, 7229, 7232, 7235, 7238, 7242,
+	7253, 7256, 7268, 7292, 7300, 7302, 7306, 7309,
+	7314, 7317, 7319, 7324, 7327, 7333, 7336, 7401,
+	7404, 7406, 7408, 7410, 7412, 7414, 7417, 7419,
+	7424, 7427, 7430, 7432, 7472, 7474, 7476, 7478,
+	7483, 7487, 7488, 7490, 7492, 7499, 7506, 7513,
+	7515, 7517, 7519, 7522, 7525, 7531, 7534, 7539,
+	7546, 7551, 7554, 7558, 7565, 7597, 7646, 7661,
+	7674, 7679, 7681, 7685, 7716, 7722, 7724, 7745,
+	7765, 7767, 7779, 7790, 7800, 7806, 7816, 7826,
+	7837, 7839, 7841, 7843, 7845, 7847, 7849, 7851,
+	7861, 7870, 7872, 7874, 7876, 7878, 7880, 7890,
+	7899, 7901, 7903, 7905, 7907, 7909, 7950, 7990,
+	7992, 7997, 8001, 8002, 8004, 8006, 8013, 8020,
+	8027, 8029, 8031, 8033, 8036, 8039, 8045, 8048,
+	8053, 8060, 8065, 8068, 8072, 8079, 8111, 8160,
+	8175, 8188, 8193, 8195, 8199, 8230, 8236, 8238,
+	8259, 8279,
 }
 
-var _zcltok_indicies []int16 = []int16{
+var _hcltok_indicies []int16 = []int16{
 	2, 1, 4, 3, 6, 5, 6, 7,
 	5, 9, 11, 11, 10, 8, 12, 12,
 	10, 8, 10, 8, 13, 15, 16, 18,
@@ -1413,7 +2162,7 @@ var _zcltok_indicies []int16 = []int16{
 	64, 65, 40, 42, 66, 44, 67, 68,
 	69, 14, 14, 14, 17, 41, 3, 47,
 	3, 14, 14, 14, 14, 3, 14, 14,
-	14, 3, 14, 3, 14, 3, 14, 3,
+	14, 3, 14, 3, 14, 14, 3, 3,
 	3, 3, 3, 3, 14, 3, 3, 3,
 	3, 14, 14, 14, 14, 14, 3, 3,
 	14, 3, 3, 14, 3, 14, 3, 3,
@@ -1990,88 +2739,456 @@ var _zcltok_indicies []int16 = []int16{
 	773, 772, 775, 774, 776, 777, 777, 774,
 	778, 774, 779, 776, 780, 777, 781, 777,
 	783, 782, 784, 785, 785, 782, 786, 782,
-	787, 784, 788, 785, 789, 785, 790, 791,
-	792, 793, 794, 795, 796, 797, 799, 800,
-	801, 802, 803, 672, 672, 672, 804, 805,
-	806, 807, 672, 810, 811, 813, 814, 815,
-	809, 816, 817, 818, 819, 820, 821, 822,
-	823, 824, 825, 826, 827, 828, 829, 830,
-	831, 832, 833, 834, 835, 837, 838, 839,
-	840, 841, 842, 672, 798, 10, 798, 422,
-	798, 422, 809, 812, 836, 843, 808, 790,
-	844, 791, 845, 793, 846, 848, 847, 2,
-	1, 849, 847, 850, 847, 5, 1, 847,
-	6, 5, 9, 11, 11, 10, 852, 853,
-	854, 847, 855, 856, 847, 857, 847, 422,
-	422, 859, 860, 491, 472, 861, 472, 862,
-	863, 864, 865, 866, 867, 868, 869, 870,
-	871, 872, 546, 873, 522, 874, 875, 876,
-	877, 878, 879, 880, 881, 882, 883, 884,
-	885, 422, 422, 422, 427, 567, 858, 886,
-	847, 887, 847, 672, 888, 422, 422, 422,
-	672, 888, 672, 672, 422, 888, 422, 888,
-	422, 888, 422, 672, 672, 672, 672, 672,
-	888, 422, 672, 672, 672, 422, 672, 422,
-	888, 422, 672, 672, 672, 672, 422, 888,
-	672, 422, 672, 422, 672, 422, 672, 672,
-	422, 672, 888, 422, 672, 422, 672, 422,
-	672, 888, 672, 422, 888, 672, 422, 672,
-	422, 888, 672, 672, 672, 672, 672, 888,
-	422, 422, 672, 422, 672, 888, 672, 422,
-	888, 672, 672, 888, 422, 422, 672, 422,
-	672, 422, 672, 888, 889, 890, 891, 892,
-	893, 894, 895, 896, 897, 898, 899, 717,
-	900, 901, 902, 903, 904, 905, 906, 907,
-	908, 909, 910, 911, 910, 912, 913, 914,
-	915, 916, 673, 888, 917, 918, 919, 920,
-	921, 922, 923, 924, 925, 926, 927, 928,
-	929, 930, 931, 932, 933, 934, 935, 727,
-	936, 937, 938, 694, 939, 940, 941, 942,
-	943, 944, 673, 945, 946, 947, 948, 949,
-	950, 951, 952, 676, 953, 673, 676, 954,
-	955, 956, 957, 685, 888, 958, 959, 960,
-	961, 705, 962, 963, 685, 964, 965, 966,
-	967, 968, 673, 888, 969, 928, 970, 971,
-	972, 685, 973, 974, 676, 673, 685, 427,
-	888, 938, 673, 676, 685, 427, 685, 427,
-	975, 685, 888, 427, 676, 976, 977, 676,
-	978, 979, 683, 980, 981, 982, 983, 984,
-	934, 985, 986, 987, 988, 989, 990, 991,
-	992, 993, 994, 995, 996, 953, 997, 676,
-	685, 427, 888, 998, 999, 685, 673, 888,
-	427, 673, 888, 676, 1000, 733, 1001, 1002,
-	1003, 1004, 1005, 1006, 1007, 1008, 673, 1009,
-	1010, 1011, 1012, 1013, 1014, 673, 685, 888,
-	1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023,
-	1024, 1025, 1026, 1022, 1028, 1029, 1030, 1031,
-	1015, 1027, 1015, 888, 1015, 888, 1032, 1032,
-	1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040,
-	1037, 769, 1041, 1041, 1041, 1036, 1042, 1041,
-	770, 771, 1043, 1041, 769, 1041, 1041, 1036,
-	1044, 1041, 770, 771, 1043, 1041, 769, 1036,
-	1044, 1045, 1046, 1047, 769, 1041, 1041, 1041,
-	1036, 1042, 770, 771, 1043, 1041, 769, 1041,
-	1041, 1041, 1036, 1042, 770, 771, 1043, 1041,
-	769, 1041, 1041, 1041, 1036, 1042, 771, 770,
-	771, 1043, 1041, 769, 1049, 769, 1051, 1050,
-	1052, 769, 1054, 1053, 769, 1055, 773, 1055,
-	1056, 1055, 775, 1057, 1058, 1059, 1060, 1061,
-	1062, 1063, 1060, 777, 775, 1057, 1065, 1064,
-	778, 779, 1066, 1064, 777, 1068, 1067, 1070,
-	1069, 777, 1071, 778, 1071, 779, 1071, 783,
-	1072, 1073, 1074, 1075, 1076, 1077, 1078, 1075,
-	785, 783, 1072, 1080, 1079, 786, 787, 1081,
-	1079, 785, 1083, 1082, 1085, 1084, 785, 1086,
-	786, 1086, 787, 1086,
+	787, 784, 788, 785, 789, 785, 791, 791,
+	791, 791, 790, 791, 791, 791, 790, 791,
+	790, 791, 791, 790, 790, 790, 790, 790,
+	790, 791, 790, 790, 790, 790, 791, 791,
+	791, 791, 791, 790, 790, 791, 790, 790,
+	791, 790, 791, 790, 790, 791, 790, 790,
+	790, 791, 791, 791, 791, 791, 791, 790,
+	791, 791, 790, 791, 791, 790, 790, 790,
+	790, 790, 790, 791, 791, 790, 790, 791,
+	790, 791, 791, 791, 790, 793, 794, 795,
+	796, 797, 798, 799, 800, 801, 802, 803,
+	804, 805, 806, 807, 808, 809, 810, 811,
+	812, 813, 814, 815, 816, 817, 818, 819,
+	820, 821, 822, 823, 824, 790, 791, 790,
+	791, 790, 791, 791, 790, 791, 791, 790,
+	790, 790, 791, 790, 790, 790, 790, 790,
+	790, 790, 791, 790, 790, 790, 790, 790,
+	790, 790, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 790, 790, 790,
+	790, 790, 790, 790, 790, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 790, 790,
+	790, 790, 790, 790, 790, 790, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 790,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	790, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 790, 791, 791, 791,
+	791, 791, 791, 790, 791, 791, 791, 791,
+	791, 791, 790, 790, 790, 790, 790, 790,
+	790, 790, 791, 791, 791, 791, 791, 791,
+	791, 791, 790, 791, 791, 791, 791, 791,
+	791, 791, 791, 790, 791, 791, 791, 791,
+	791, 790, 790, 790, 790, 790, 790, 790,
+	790, 791, 791, 791, 791, 791, 791, 790,
+	791, 791, 791, 791, 791, 791, 791, 790,
+	791, 790, 791, 791, 790, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 790, 791, 791, 791, 791, 791,
+	790, 791, 791, 791, 791, 791, 791, 791,
+	790, 791, 791, 791, 790, 791, 791, 791,
+	790, 791, 790, 825, 826, 827, 828, 829,
+	830, 831, 832, 833, 834, 835, 836, 837,
+	838, 839, 840, 841, 842, 843, 844, 845,
+	846, 847, 848, 849, 850, 851, 852, 853,
+	854, 855, 856, 857, 858, 859, 860, 797,
+	861, 862, 863, 864, 865, 866, 797, 842,
+	797, 790, 791, 790, 791, 791, 790, 790,
+	791, 790, 790, 790, 790, 791, 790, 790,
+	790, 790, 790, 791, 790, 790, 790, 790,
+	790, 791, 791, 791, 791, 791, 790, 790,
+	790, 791, 790, 790, 790, 791, 791, 791,
+	790, 790, 790, 791, 791, 790, 790, 790,
+	791, 791, 791, 790, 790, 790, 791, 791,
+	791, 791, 790, 791, 791, 791, 791, 790,
+	790, 790, 790, 790, 791, 791, 791, 791,
+	790, 790, 791, 791, 791, 790, 790, 791,
+	791, 791, 791, 790, 791, 791, 790, 791,
+	791, 790, 790, 790, 791, 791, 791, 790,
+	790, 790, 790, 791, 791, 791, 791, 791,
+	790, 790, 790, 790, 791, 790, 791, 791,
+	790, 791, 791, 790, 791, 790, 791, 791,
+	791, 790, 791, 791, 790, 790, 790, 791,
+	790, 790, 790, 790, 790, 790, 790, 791,
+	791, 791, 791, 790, 791, 791, 791, 791,
+	791, 791, 791, 790, 867, 868, 869, 870,
+	871, 872, 873, 874, 875, 797, 876, 877,
+	878, 879, 880, 790, 791, 790, 790, 790,
+	790, 790, 791, 791, 790, 791, 791, 791,
+	790, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 790, 791, 791, 791, 790,
+	790, 791, 791, 791, 790, 790, 791, 790,
+	790, 791, 791, 791, 791, 791, 790, 790,
+	790, 790, 791, 791, 791, 791, 791, 791,
+	790, 791, 791, 791, 791, 791, 790, 881,
+	836, 882, 883, 884, 797, 885, 886, 842,
+	797, 790, 791, 791, 791, 791, 790, 790,
+	790, 791, 790, 790, 791, 791, 791, 790,
+	790, 790, 791, 791, 790, 847, 790, 842,
+	797, 797, 887, 790, 797, 790, 791, 842,
+	888, 889, 842, 890, 891, 842, 892, 893,
+	894, 895, 896, 897, 842, 898, 899, 900,
+	842, 901, 902, 903, 861, 904, 905, 906,
+	861, 907, 842, 797, 790, 790, 791, 791,
+	790, 790, 790, 791, 791, 791, 791, 790,
+	791, 791, 790, 790, 790, 790, 791, 791,
+	790, 790, 791, 791, 790, 790, 790, 790,
+	790, 790, 791, 791, 791, 790, 790, 790,
+	791, 790, 790, 790, 791, 791, 790, 791,
+	791, 791, 791, 790, 791, 791, 791, 791,
+	790, 791, 791, 791, 791, 791, 791, 790,
+	790, 790, 791, 791, 791, 791, 790, 908,
+	909, 790, 797, 790, 791, 790, 790, 791,
+	842, 910, 911, 912, 913, 892, 914, 915,
+	916, 917, 918, 919, 920, 921, 922, 923,
+	924, 925, 797, 790, 790, 791, 790, 791,
+	791, 791, 791, 791, 791, 791, 790, 791,
+	791, 791, 790, 791, 790, 790, 791, 790,
+	791, 790, 790, 791, 791, 791, 791, 790,
+	791, 791, 791, 790, 790, 791, 791, 791,
+	791, 790, 791, 791, 790, 790, 791, 791,
+	791, 791, 791, 790, 926, 927, 928, 929,
+	930, 931, 932, 933, 934, 935, 936, 932,
+	938, 939, 940, 941, 937, 790, 942, 943,
+	842, 944, 945, 946, 947, 948, 949, 950,
+	951, 952, 842, 797, 953, 954, 955, 956,
+	842, 957, 958, 959, 960, 961, 962, 963,
+	964, 965, 966, 967, 968, 969, 970, 971,
+	842, 873, 797, 972, 790, 791, 791, 791,
+	791, 791, 790, 790, 790, 791, 790, 791,
+	791, 790, 791, 790, 791, 791, 790, 790,
+	790, 791, 791, 791, 790, 790, 790, 791,
+	791, 791, 790, 790, 790, 790, 791, 790,
+	790, 791, 790, 790, 791, 791, 791, 790,
+	790, 791, 790, 791, 791, 791, 790, 791,
+	791, 791, 791, 791, 791, 790, 790, 790,
+	791, 791, 790, 791, 791, 790, 791, 791,
+	790, 791, 791, 790, 791, 791, 791, 791,
+	791, 791, 791, 790, 791, 790, 791, 790,
+	791, 791, 790, 791, 790, 791, 791, 790,
+	791, 790, 791, 790, 973, 944, 974, 975,
+	976, 977, 978, 979, 980, 981, 982, 825,
+	983, 842, 984, 985, 986, 842, 987, 857,
+	988, 989, 990, 991, 992, 993, 994, 995,
+	842, 790, 790, 790, 791, 791, 791, 790,
+	791, 791, 790, 791, 791, 790, 790, 790,
+	790, 790, 791, 791, 791, 791, 790, 791,
+	791, 791, 791, 791, 791, 790, 790, 790,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 790, 791, 791, 791, 791, 791, 791,
+	791, 791, 790, 791, 791, 790, 790, 790,
+	790, 791, 791, 791, 790, 790, 790, 791,
+	790, 790, 790, 791, 791, 790, 791, 791,
+	791, 790, 791, 790, 790, 790, 791, 791,
+	790, 791, 791, 791, 790, 791, 791, 791,
+	790, 790, 790, 790, 791, 842, 911, 996,
+	997, 797, 842, 797, 790, 790, 791, 790,
+	791, 842, 996, 797, 790, 842, 998, 797,
+	790, 790, 791, 842, 999, 1000, 1001, 902,
+	1002, 1003, 842, 1004, 1005, 1006, 797, 790,
+	790, 791, 791, 791, 790, 791, 791, 790,
+	791, 791, 791, 791, 790, 790, 791, 790,
+	790, 791, 791, 790, 791, 790, 842, 797,
+	790, 1007, 842, 1008, 790, 797, 790, 791,
+	790, 791, 1009, 842, 1010, 1011, 790, 791,
+	790, 790, 790, 791, 791, 791, 791, 790,
+	1012, 1013, 1014, 842, 1015, 1016, 1017, 1018,
+	1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026,
+	1027, 1028, 797, 790, 791, 791, 791, 790,
+	790, 790, 790, 791, 791, 790, 790, 791,
+	790, 790, 790, 790, 790, 790, 790, 791,
+	790, 791, 790, 790, 790, 790, 790, 790,
+	791, 791, 791, 791, 791, 790, 790, 791,
+	790, 790, 790, 791, 790, 790, 791, 790,
+	790, 791, 790, 790, 791, 790, 790, 790,
+	791, 791, 791, 790, 790, 790, 791, 791,
+	791, 791, 790, 1029, 842, 1030, 842, 1031,
+	1032, 1033, 1034, 797, 790, 791, 791, 791,
+	791, 791, 790, 790, 790, 791, 790, 790,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 790, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 790, 791,
+	791, 791, 791, 791, 790, 1035, 842, 797,
+	790, 791, 1036, 842, 827, 797, 790, 791,
+	1037, 790, 797, 790, 791, 842, 1038, 797,
+	790, 790, 791, 1039, 790, 842, 1040, 797,
+	790, 790, 791, 1042, 1041, 791, 791, 791,
+	791, 1042, 1041, 791, 1042, 1041, 1042, 1042,
+	791, 1042, 1041, 791, 1042, 791, 1042, 1041,
+	791, 1042, 791, 1042, 791, 1041, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1041, 791,
+	791, 1042, 1042, 791, 1042, 791, 1042, 1041,
+	1042, 1042, 1042, 1042, 1042, 791, 1042, 791,
+	1042, 791, 1042, 1041, 1042, 1042, 791, 1042,
+	791, 1042, 1041, 1042, 1042, 1042, 1042, 1042,
+	791, 1042, 791, 1042, 1041, 791, 791, 1042,
+	791, 1042, 1041, 1042, 1042, 1042, 791, 1042,
+	791, 1042, 791, 1042, 791, 1042, 1041, 1042,
+	791, 1042, 791, 1042, 1041, 791, 1042, 1042,
+	1042, 1042, 791, 1042, 791, 1042, 791, 1042,
+	791, 1042, 791, 1042, 791, 1042, 1041, 791,
+	1042, 1041, 1042, 1042, 1042, 791, 1042, 791,
+	1042, 1041, 1042, 791, 1042, 791, 1042, 1041,
+	791, 1042, 1042, 1042, 1042, 791, 1042, 791,
+	1042, 1041, 791, 1042, 791, 1042, 791, 1042,
+	1041, 1042, 1042, 791, 1042, 791, 1042, 1041,
+	791, 1042, 791, 1042, 791, 1042, 791, 1041,
+	1042, 1042, 1042, 791, 1042, 791, 1042, 1041,
+	791, 1042, 1041, 1042, 1042, 791, 1042, 1041,
+	1042, 1042, 1042, 791, 1042, 1042, 1042, 1042,
+	1042, 1042, 791, 791, 1042, 791, 1042, 791,
+	1042, 791, 1042, 1041, 1042, 791, 1042, 791,
+	1042, 1041, 791, 1042, 1041, 1042, 791, 1042,
+	1041, 1042, 791, 1042, 1041, 791, 791, 1042,
+	1041, 791, 1042, 791, 1042, 791, 1042, 791,
+	1042, 791, 1042, 791, 1041, 1042, 1042, 791,
+	1042, 1042, 1042, 1042, 791, 791, 1042, 1042,
+	1042, 1042, 1042, 791, 1042, 1042, 1042, 1042,
+	1042, 1041, 791, 1042, 1042, 791, 1042, 791,
+	1041, 1042, 1042, 791, 1042, 1041, 791, 791,
+	1042, 791, 1041, 1042, 1042, 1041, 791, 1042,
+	791, 1041, 1042, 1041, 791, 1042, 791, 1042,
+	791, 1041, 1042, 1042, 1041, 791, 1042, 791,
+	1042, 791, 1042, 1041, 1042, 791, 1042, 791,
+	1042, 1041, 791, 1042, 1041, 791, 791, 1042,
+	1041, 1042, 791, 1041, 1042, 1041, 791, 1042,
+	791, 1042, 791, 1041, 1042, 1041, 791, 791,
+	1042, 1041, 1042, 791, 1042, 791, 1042, 1041,
+	791, 1042, 791, 1041, 1042, 1041, 791, 791,
+	1042, 791, 1041, 1042, 1041, 791, 791, 1042,
+	1041, 1042, 791, 1042, 1041, 1042, 791, 1042,
+	1041, 1042, 791, 1042, 791, 1042, 791, 1041,
+	1042, 1041, 791, 791, 1042, 1041, 1042, 791,
+	1042, 791, 1042, 1041, 791, 1042, 1041, 1042,
+	1042, 791, 1042, 791, 1042, 1041, 1041, 791,
+	1041, 791, 1042, 1042, 791, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1041, 791, 1042, 1042,
+	1042, 791, 1041, 1042, 1042, 1042, 791, 1042,
+	791, 1042, 791, 1042, 791, 1042, 791, 1042,
+	1041, 791, 791, 1042, 1041, 1042, 791, 1042,
+	1041, 791, 791, 1042, 791, 791, 791, 1042,
+	791, 1042, 791, 1042, 791, 1042, 791, 1041,
+	791, 1042, 791, 1042, 791, 1041, 1042, 1041,
+	791, 1042, 791, 1041, 1042, 791, 1042, 1042,
+	1042, 1041, 791, 1042, 791, 791, 1042, 791,
+	1041, 1042, 1042, 1041, 791, 1042, 1042, 1042,
+	1042, 791, 1042, 791, 1041, 1042, 1042, 1042,
+	791, 1042, 1041, 1042, 791, 1042, 791, 1042,
+	791, 1042, 791, 1042, 1041, 1042, 1042, 791,
+	1042, 1041, 791, 1042, 791, 1042, 791, 1041,
+	1042, 1042, 1041, 791, 1042, 791, 1041, 1042,
+	1041, 791, 1042, 1041, 791, 1042, 791, 1042,
+	1041, 1042, 1042, 1042, 1041, 791, 791, 791,
+	1042, 1041, 791, 1042, 791, 1041, 1042, 1041,
+	791, 1042, 791, 1042, 791, 1041, 1042, 1042,
+	1042, 1041, 791, 1042, 791, 1041, 1042, 1042,
+	1042, 1042, 1041, 791, 1042, 791, 1042, 1041,
+	791, 791, 1042, 791, 1042, 1041, 1042, 791,
+	1042, 791, 1041, 1042, 1042, 1041, 791, 1042,
+	791, 1042, 1041, 791, 1042, 1042, 1042, 791,
+	1042, 791, 1041, 791, 1042, 1041, 1042, 791,
+	791, 1042, 791, 1042, 791, 1041, 1042, 1042,
+	1042, 1042, 1041, 791, 1042, 791, 1042, 791,
+	1042, 791, 1042, 791, 1042, 1041, 1042, 1042,
+	1042, 791, 1042, 791, 1042, 791, 1042, 791,
+	1041, 1042, 1042, 791, 791, 1042, 1041, 1042,
+	791, 1042, 1042, 1041, 791, 1042, 791, 1042,
+	1041, 791, 791, 1042, 1042, 1042, 1042, 791,
+	1042, 791, 1042, 791, 1041, 1042, 1042, 791,
+	1041, 1042, 1041, 791, 1042, 791, 1041, 1042,
+	1041, 791, 1042, 791, 1041, 1042, 791, 1042,
+	1042, 1041, 791, 1042, 1042, 791, 1041, 1042,
+	1041, 791, 1042, 791, 1042, 1041, 1042, 791,
+	1042, 791, 1041, 1042, 1041, 791, 1042, 791,
+	1042, 791, 1042, 791, 1042, 791, 1042, 1041,
+	1043, 1041, 1044, 1045, 1046, 1047, 1048, 1049,
+	1050, 1051, 1052, 1053, 1054, 1046, 1055, 1056,
+	1057, 1058, 1059, 1046, 1060, 1061, 1062, 1063,
+	1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071,
+	1072, 1073, 1074, 1046, 1075, 1043, 1055, 1043,
+	1076, 1043, 1041, 1042, 1042, 1042, 1042, 791,
+	1041, 1042, 1042, 1041, 791, 1042, 1041, 791,
+	791, 1042, 1041, 791, 1042, 791, 1041, 1042,
+	1041, 791, 791, 1042, 791, 1041, 1042, 1042,
+	1041, 791, 1042, 1042, 1042, 1041, 791, 1042,
+	791, 1042, 1042, 1041, 791, 791, 1042, 791,
+	1041, 1042, 1041, 791, 1042, 1041, 791, 791,
+	1042, 791, 1042, 1041, 791, 1042, 791, 791,
+	1042, 791, 1042, 791, 1041, 1042, 1042, 1041,
+	791, 1042, 1042, 791, 1042, 1041, 791, 1042,
+	791, 1042, 1041, 791, 1042, 791, 1041, 791,
+	1042, 1042, 1042, 791, 1042, 1041, 1042, 791,
+	1042, 1041, 791, 1042, 1041, 1042, 791, 1042,
+	1041, 791, 1042, 1041, 791, 1042, 791, 1042,
+	1041, 791, 1042, 1041, 791, 1042, 1041, 1077,
+	1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085,
+	1086, 1087, 1088, 1048, 1089, 1090, 1091, 1092,
+	1093, 1090, 1094, 1095, 1096, 1097, 1098, 1099,
+	1100, 1101, 1102, 1043, 1041, 1042, 791, 1042,
+	1041, 1042, 791, 1042, 1041, 1042, 791, 1042,
+	1041, 1042, 791, 1042, 1041, 791, 1042, 791,
+	1042, 1041, 1042, 791, 1042, 1041, 1042, 791,
+	791, 791, 1042, 1041, 1042, 791, 1042, 1041,
+	1042, 1042, 1042, 1042, 791, 1042, 791, 1041,
+	1042, 1041, 791, 791, 1042, 791, 1042, 1041,
+	1042, 791, 1042, 1041, 791, 1042, 1041, 1042,
+	1042, 791, 1042, 1041, 791, 1042, 1041, 1042,
+	791, 1042, 1041, 791, 1042, 1041, 791, 1042,
+	1041, 791, 1042, 1041, 1042, 1041, 791, 791,
+	1042, 1041, 1042, 791, 1042, 1041, 791, 1042,
+	791, 1041, 1042, 1041, 791, 1046, 1103, 1043,
+	1046, 1104, 1046, 1105, 1055, 1043, 1041, 1042,
+	1041, 791, 1042, 1041, 791, 1046, 1104, 1055,
+	1043, 1041, 1046, 1106, 1043, 1055, 1043, 1041,
+	1042, 1041, 791, 1046, 1107, 1064, 1108, 1090,
+	1109, 1102, 1046, 1110, 1111, 1112, 1043, 1055,
+	1043, 1041, 1042, 1041, 791, 1042, 791, 1042,
+	1041, 791, 1042, 791, 1042, 791, 1041, 1042,
+	1042, 1041, 791, 1042, 791, 1042, 1041, 791,
+	1042, 1041, 1046, 1055, 797, 1041, 1113, 1046,
+	1114, 1055, 1043, 1041, 797, 1042, 1041, 791,
+	1042, 1041, 791, 1115, 1046, 1116, 1117, 1043,
+	1041, 791, 1042, 1041, 1042, 1042, 1041, 791,
+	791, 1042, 791, 1042, 1041, 1046, 1118, 1119,
+	1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127,
+	1128, 1043, 1055, 1043, 1041, 1042, 791, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 791, 1042,
+	791, 1042, 1042, 1042, 1042, 1042, 1042, 1041,
+	791, 1042, 1042, 791, 1042, 791, 1041, 1042,
+	791, 1042, 1042, 1042, 791, 1042, 1042, 791,
+	1042, 1042, 791, 1042, 1042, 791, 1042, 1042,
+	1041, 791, 1046, 1129, 1046, 1105, 1130, 1131,
+	1132, 1043, 1055, 1043, 1041, 1042, 1041, 791,
+	1042, 1042, 1042, 791, 1042, 1042, 1042, 791,
+	1042, 791, 1042, 1041, 791, 791, 791, 791,
+	1042, 1042, 791, 791, 791, 791, 791, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 791, 1042,
+	791, 1042, 791, 1041, 1042, 1042, 1042, 791,
+	1042, 791, 1042, 1041, 1055, 797, 1133, 1046,
+	1055, 797, 1042, 1041, 791, 1134, 1046, 1135,
+	1055, 797, 1042, 1041, 791, 1042, 791, 1136,
+	1055, 1043, 1041, 797, 1042, 1041, 791, 1046,
+	1137, 1043, 1055, 1043, 1041, 1042, 1041, 791,
+	1138, 1139, 1140, 1138, 1141, 1142, 1143, 1144,
+	1146, 1147, 1148, 1149, 1150, 672, 672, 672,
+	1151, 1152, 1153, 1154, 672, 1157, 1158, 1160,
+	1161, 1162, 1156, 1163, 1164, 1165, 1166, 1167,
+	1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175,
+	1176, 1177, 1178, 1179, 1180, 1181, 1182, 1184,
+	1185, 1186, 1187, 1188, 1189, 672, 1145, 10,
+	1145, 422, 1145, 422, 1156, 1159, 1183, 1190,
+	1155, 1138, 1138, 1191, 1139, 1192, 1194, 1193,
+	2, 1, 1195, 1193, 1196, 1193, 5, 1,
+	1193, 6, 5, 9, 11, 11, 10, 1198,
+	1199, 1200, 1193, 1201, 1202, 1193, 1203, 1193,
+	422, 422, 1205, 1206, 491, 472, 1207, 472,
+	1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215,
+	1216, 1217, 1218, 546, 1219, 522, 1220, 1221,
+	1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229,
+	1230, 1231, 422, 422, 422, 427, 567, 1204,
+	1232, 1193, 1233, 1193, 672, 1234, 422, 422,
+	422, 672, 1234, 672, 672, 422, 1234, 422,
+	1234, 422, 1234, 422, 672, 672, 672, 672,
+	672, 1234, 422, 672, 672, 672, 422, 672,
+	422, 1234, 422, 672, 672, 672, 672, 422,
+	1234, 672, 422, 672, 422, 672, 422, 672,
+	672, 422, 672, 1234, 422, 672, 422, 672,
+	422, 672, 1234, 672, 422, 1234, 672, 422,
+	672, 422, 1234, 672, 672, 672, 672, 672,
+	1234, 422, 422, 672, 422, 672, 1234, 672,
+	422, 1234, 672, 672, 1234, 422, 422, 672,
+	422, 672, 422, 672, 1234, 1235, 1236, 1237,
+	1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245,
+	717, 1246, 1247, 1248, 1249, 1250, 1251, 1252,
+	1253, 1254, 1255, 1256, 1257, 1256, 1258, 1259,
+	1260, 1261, 1262, 673, 1234, 1263, 1264, 1265,
+	1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
+	1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281,
+	727, 1282, 1283, 1284, 694, 1285, 1286, 1287,
+	1288, 1289, 1290, 673, 1291, 1292, 1293, 1294,
+	1295, 1296, 1297, 1298, 676, 1299, 673, 676,
+	1300, 1301, 1302, 1303, 685, 1234, 1304, 1305,
+	1306, 1307, 705, 1308, 1309, 685, 1310, 1311,
+	1312, 1313, 1314, 673, 1234, 1315, 1274, 1316,
+	1317, 1318, 685, 1319, 1320, 676, 673, 685,
+	427, 1234, 1284, 673, 676, 685, 427, 685,
+	427, 1321, 685, 1234, 427, 676, 1322, 1323,
+	676, 1324, 1325, 683, 1326, 1327, 1328, 1329,
+	1330, 1280, 1331, 1332, 1333, 1334, 1335, 1336,
+	1337, 1338, 1339, 1340, 1341, 1342, 1299, 1343,
+	676, 685, 427, 1234, 1344, 1345, 685, 673,
+	1234, 427, 673, 1234, 676, 1346, 733, 1347,
+	1348, 1349, 1350, 1351, 1352, 1353, 1354, 673,
+	1355, 1356, 1357, 1358, 1359, 1360, 673, 685,
+	1234, 1362, 1363, 1364, 1365, 1366, 1367, 1368,
+	1369, 1370, 1371, 1372, 1368, 1374, 1375, 1376,
+	1377, 1361, 1373, 1361, 1234, 1361, 1234, 1378,
+	1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385,
+	1386, 1383, 769, 1387, 1387, 1387, 1382, 1388,
+	1387, 770, 771, 1389, 1387, 769, 1387, 1387,
+	1382, 1390, 1387, 770, 771, 1389, 1387, 769,
+	1382, 1390, 1391, 1392, 1393, 769, 1387, 1387,
+	1387, 1382, 1388, 770, 771, 1389, 1387, 769,
+	1387, 1387, 1387, 1382, 1388, 770, 771, 1389,
+	1387, 769, 1387, 1387, 1387, 1382, 1388, 771,
+	770, 771, 1389, 1387, 769, 1395, 769, 1397,
+	1396, 1398, 769, 1400, 1399, 769, 1401, 773,
+	1401, 1402, 1401, 775, 1403, 1404, 1405, 1406,
+	1407, 1408, 1409, 1406, 777, 775, 1403, 1411,
+	1410, 778, 779, 1412, 1410, 777, 1414, 1413,
+	1416, 1415, 777, 1417, 778, 1417, 779, 1417,
+	783, 1418, 1419, 1420, 1421, 1422, 1423, 1424,
+	1421, 785, 783, 1418, 1426, 1425, 786, 787,
+	1427, 1425, 785, 1429, 1428, 1431, 1430, 785,
+	1432, 786, 1432, 787, 1432, 1435, 1436, 1438,
+	1439, 1440, 1434, 1441, 1442, 1443, 1444, 1445,
+	1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453,
+	1454, 1455, 1456, 1457, 1458, 1459, 1460, 1462,
+	1463, 1464, 1465, 1466, 1467, 791, 791, 1433,
+	1434, 1437, 1461, 1468, 1433, 1042, 791, 791,
+	1470, 1471, 861, 842, 1472, 842, 1473, 1474,
+	1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482,
+	1483, 916, 1484, 892, 1485, 1486, 1487, 1488,
+	1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496,
+	791, 791, 791, 797, 937, 1469, 1042, 1497,
+	791, 791, 791, 1042, 1497, 1042, 1042, 791,
+	1497, 791, 1497, 791, 1497, 791, 1042, 1042,
+	1042, 1042, 1042, 1497, 791, 1042, 1042, 1042,
+	791, 1042, 791, 1497, 791, 1042, 1042, 1042,
+	1042, 791, 1497, 1042, 791, 1042, 791, 1042,
+	791, 1042, 1042, 791, 1042, 1497, 791, 1042,
+	791, 1042, 791, 1042, 1497, 1042, 791, 1497,
+	1042, 791, 1042, 791, 1497, 1042, 1042, 1042,
+	1042, 1042, 1497, 791, 791, 1042, 791, 1042,
+	1497, 1042, 791, 1497, 1042, 1042, 1497, 791,
+	791, 1042, 791, 1042, 791, 1042, 1497, 1498,
+	1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506,
+	1507, 1508, 1087, 1509, 1510, 1511, 1512, 1513,
+	1514, 1515, 1516, 1517, 1518, 1519, 1520, 1519,
+	1521, 1522, 1523, 1524, 1525, 1043, 1497, 1526,
+	1527, 1528, 1529, 1530, 1531, 1532, 1533, 1534,
+	1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542,
+	1543, 1544, 1097, 1545, 1546, 1547, 1064, 1548,
+	1549, 1550, 1551, 1552, 1553, 1043, 1554, 1555,
+	1556, 1557, 1558, 1559, 1560, 1561, 1046, 1562,
+	1043, 1046, 1563, 1564, 1565, 1566, 1055, 1497,
+	1567, 1568, 1569, 1570, 1075, 1571, 1572, 1055,
+	1573, 1574, 1575, 1576, 1577, 1043, 1497, 1578,
+	1537, 1579, 1580, 1581, 1055, 1582, 1583, 1046,
+	1043, 1055, 797, 1497, 1547, 1043, 1046, 1055,
+	797, 1055, 797, 1584, 1055, 1497, 797, 1046,
+	1585, 1586, 1046, 1587, 1588, 1053, 1589, 1590,
+	1591, 1592, 1593, 1543, 1594, 1595, 1596, 1597,
+	1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605,
+	1562, 1606, 1046, 1055, 797, 1497, 1607, 1608,
+	1055, 1043, 1497, 797, 1043, 1497, 1046, 1609,
+	1103, 1610, 1611, 1612, 1613, 1614, 1615, 1616,
+	1617, 1043, 1618, 1619, 1620, 1621, 1622, 1623,
+	1043, 1055, 1497, 1625, 1626, 1627, 1628, 1629,
+	1630, 1631, 1632, 1633, 1634, 1635, 1631, 1637,
+	1638, 1639, 1640, 1624, 1636, 1624, 1497, 1624,
+	1497,
 }
 
-var _zcltok_trans_targs []int16 = []int16{
-	949, 1, 949, 949, 949, 3, 4, 958,
-	949, 5, 959, 6, 7, 9, 10, 287,
+var _hcltok_trans_targs []int16 = []int16{
+	1462, 1, 1462, 1462, 1462, 3, 4, 1470,
+	1462, 5, 1471, 6, 7, 9, 10, 287,
 	13, 14, 15, 16, 17, 288, 289, 20,
 	290, 22, 23, 291, 292, 293, 294, 295,
 	296, 297, 298, 299, 300, 329, 349, 354,
-	128, 129, 130, 357, 152, 372, 376, 949,
+	128, 129, 130, 357, 152, 372, 376, 1462,
 	11, 12, 18, 19, 21, 24, 25, 26,
 	27, 28, 29, 30, 31, 32, 33, 65,
 	106, 121, 132, 155, 171, 284, 34, 35,
@@ -2118,7 +3235,7 @@ var _zcltok_trans_targs []int16 = []int16{
 	382, 384, 385, 386, 387, 388, 389, 390,
 	391, 392, 393, 394, 395, 396, 397, 398,
 	399, 400, 401, 402, 403, 404, 406, 407,
-	408, 409, 411, 413, 415, 949, 963, 438,
+	408, 409, 411, 413, 415, 1462, 1475, 438,
 	439, 440, 441, 418, 442, 443, 444, 445,
 	446, 447, 448, 449, 450, 451, 452, 453,
 	454, 455, 456, 457, 458, 459, 460, 461,
@@ -2149,8 +3266,8 @@ var _zcltok_trans_targs []int16 = []int16{
 	653, 654, 656, 657, 658, 659, 660, 661,
 	662, 663, 664, 665, 666, 667, 668, 669,
 	670, 671, 672, 674, 675, 676, 677, 678,
-	679, 681, 683, 685, 687, 689, 690, 949,
-	949, 691, 828, 829, 760, 830, 831, 832,
+	679, 681, 683, 685, 687, 689, 690, 1462,
+	1462, 691, 828, 829, 760, 830, 831, 832,
 	833, 834, 835, 789, 836, 725, 837, 838,
 	839, 840, 841, 842, 843, 844, 745, 845,
 	846, 847, 848, 849, 850, 851, 852, 853,
@@ -2162,55 +3279,125 @@ var _zcltok_trans_targs []int16 = []int16{
 	897, 899, 900, 901, 903, 904, 905, 906,
 	907, 908, 909, 910, 911, 912, 913, 915,
 	916, 917, 918, 921, 923, 924, 926, 928,
-	1001, 1002, 930, 931, 1001, 933, 1015, 1015,
-	1015, 1016, 937, 938, 1017, 1018, 1022, 1022,
-	1022, 1023, 944, 945, 1024, 1025, 950, 949,
-	951, 952, 953, 949, 954, 955, 949, 956,
-	957, 960, 961, 962, 949, 964, 949, 965,
-	949, 966, 967, 968, 969, 970, 971, 972,
-	973, 974, 975, 976, 977, 978, 979, 980,
-	981, 982, 983, 984, 985, 986, 987, 988,
-	989, 990, 991, 992, 993, 994, 995, 996,
-	997, 998, 999, 1000, 949, 949, 949, 949,
-	949, 949, 2, 949, 949, 8, 949, 949,
-	949, 949, 949, 416, 417, 421, 422, 423,
-	424, 425, 426, 427, 428, 429, 430, 431,
-	432, 434, 436, 437, 469, 510, 525, 532,
-	534, 536, 556, 559, 575, 688, 949, 949,
-	949, 692, 693, 694, 695, 696, 697, 698,
-	699, 700, 701, 702, 704, 705, 706, 707,
-	708, 709, 710, 711, 712, 713, 714, 715,
-	716, 717, 718, 719, 720, 721, 722, 723,
-	724, 726, 727, 728, 729, 730, 731, 732,
-	733, 734, 735, 736, 737, 738, 739, 740,
-	742, 743, 744, 746, 747, 748, 749, 750,
-	751, 752, 753, 754, 755, 756, 757, 758,
-	759, 761, 762, 763, 764, 765, 766, 767,
-	768, 769, 771, 772, 773, 774, 775, 776,
-	777, 778, 779, 780, 781, 782, 783, 784,
-	785, 786, 787, 788, 790, 791, 792, 793,
-	794, 795, 796, 797, 798, 799, 800, 801,
-	802, 803, 804, 805, 806, 807, 808, 809,
-	810, 812, 813, 814, 815, 816, 817, 818,
-	819, 820, 821, 822, 823, 824, 825, 826,
-	827, 856, 881, 884, 885, 887, 894, 895,
-	898, 902, 914, 919, 920, 922, 925, 927,
-	1001, 1001, 1008, 1010, 1003, 1001, 1012, 1013,
-	1014, 1001, 929, 932, 1004, 1005, 1006, 1007,
-	1001, 1009, 1001, 1001, 1011, 1001, 1001, 1001,
-	934, 935, 940, 941, 1015, 1019, 1020, 1021,
-	1015, 936, 939, 1015, 1015, 1015, 1015, 1015,
-	942, 947, 948, 1022, 1026, 1027, 1028, 1022,
-	943, 946, 1022, 1022, 1022, 1022, 1022,
+	1513, 1514, 930, 931, 1513, 933, 1527, 1527,
+	1527, 1528, 937, 938, 1529, 1530, 1534, 1534,
+	1534, 1535, 944, 945, 1536, 1537, 1541, 1542,
+	1541, 971, 972, 973, 974, 951, 975, 976,
+	977, 978, 979, 980, 981, 982, 983, 984,
+	985, 986, 987, 988, 989, 990, 991, 992,
+	993, 994, 995, 996, 997, 998, 999, 1000,
+	1001, 1003, 1004, 1005, 1006, 1007, 1008, 1009,
+	1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
+	1018, 1019, 953, 1020, 1021, 1022, 1023, 1024,
+	1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032,
+	1033, 1034, 1035, 1036, 1037, 952, 1038, 1039,
+	1040, 1041, 1042, 1044, 1045, 1046, 1047, 1048,
+	1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056,
+	1057, 1059, 1060, 1061, 1062, 1063, 1064, 1068,
+	1070, 1071, 1072, 1073, 968, 1074, 1075, 1076,
+	1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084,
+	1085, 1086, 1087, 1088, 1090, 1091, 1093, 1094,
+	1095, 1096, 1097, 1098, 966, 1099, 1100, 1101,
+	1102, 1103, 1104, 1105, 1106, 1107, 1109, 1141,
+	1165, 1168, 1169, 1171, 1180, 1181, 1184, 1188,
+	1206, 1066, 1213, 1215, 1217, 1219, 1110, 1111,
+	1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119,
+	1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127,
+	1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135,
+	1136, 1137, 1138, 1139, 1140, 1142, 1143, 1144,
+	1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152,
+	1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160,
+	1161, 1162, 1163, 1164, 1166, 1167, 1170, 1172,
+	1173, 1174, 1175, 1176, 1177, 1178, 1179, 1182,
+	1183, 1185, 1186, 1187, 1189, 1190, 1191, 1192,
+	1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200,
+	1201, 1202, 1203, 1204, 1205, 1207, 1208, 1209,
+	1210, 1211, 1212, 1214, 1216, 1218, 1220, 1222,
+	1223, 1541, 1541, 1224, 1361, 1362, 1293, 1363,
+	1364, 1365, 1366, 1367, 1368, 1322, 1369, 1258,
+	1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377,
+	1278, 1378, 1379, 1380, 1381, 1382, 1383, 1384,
+	1385, 1386, 1387, 1303, 1388, 1390, 1391, 1392,
+	1393, 1394, 1395, 1396, 1397, 1398, 1399, 1236,
+	1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407,
+	1408, 1274, 1409, 1410, 1411, 1412, 1413, 1344,
+	1415, 1416, 1419, 1421, 1422, 1423, 1424, 1425,
+	1426, 1429, 1430, 1432, 1433, 1434, 1436, 1437,
+	1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445,
+	1446, 1448, 1449, 1450, 1451, 1454, 1456, 1457,
+	1459, 1461, 1463, 1462, 1464, 1465, 1462, 1466,
+	1467, 1462, 1468, 1469, 1472, 1473, 1474, 1462,
+	1476, 1462, 1477, 1462, 1478, 1479, 1480, 1481,
+	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489,
+	1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
+	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505,
+	1506, 1507, 1508, 1509, 1510, 1511, 1512, 1462,
+	1462, 1462, 1462, 1462, 2, 1462, 1462, 8,
+	1462, 1462, 1462, 1462, 1462, 416, 417, 421,
+	422, 423, 424, 425, 426, 427, 428, 429,
+	430, 431, 432, 434, 436, 437, 469, 510,
+	525, 532, 534, 536, 556, 559, 575, 688,
+	1462, 1462, 1462, 692, 693, 694, 695, 696,
+	697, 698, 699, 700, 701, 702, 704, 705,
+	706, 707, 708, 709, 710, 711, 712, 713,
+	714, 715, 716, 717, 718, 719, 720, 721,
+	722, 723, 724, 726, 727, 728, 729, 730,
+	731, 732, 733, 734, 735, 736, 737, 738,
+	739, 740, 742, 743, 744, 746, 747, 748,
+	749, 750, 751, 752, 753, 754, 755, 756,
+	757, 758, 759, 761, 762, 763, 764, 765,
+	766, 767, 768, 769, 771, 772, 773, 774,
+	775, 776, 777, 778, 779, 780, 781, 782,
+	783, 784, 785, 786, 787, 788, 790, 791,
+	792, 793, 794, 795, 796, 797, 798, 799,
+	800, 801, 802, 803, 804, 805, 806, 807,
+	808, 809, 810, 812, 813, 814, 815, 816,
+	817, 818, 819, 820, 821, 822, 823, 824,
+	825, 826, 827, 856, 881, 884, 885, 887,
+	894, 895, 898, 902, 914, 919, 920, 922,
+	925, 927, 1513, 1513, 1520, 1522, 1515, 1513,
+	1524, 1525, 1526, 1513, 929, 932, 1516, 1517,
+	1518, 1519, 1513, 1521, 1513, 1513, 1523, 1513,
+	1513, 1513, 934, 935, 940, 941, 1527, 1531,
+	1532, 1533, 1527, 936, 939, 1527, 1527, 1527,
+	1527, 1527, 942, 947, 948, 1534, 1538, 1539,
+	1540, 1534, 943, 946, 1534, 1534, 1534, 1534,
+	1534, 1541, 1543, 1544, 1545, 1546, 1547, 1548,
+	1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556,
+	1557, 1558, 1559, 1560, 1561, 1562, 1563, 1564,
+	1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572,
+	1573, 1574, 1575, 1576, 1577, 1541, 949, 950,
+	954, 955, 956, 957, 958, 959, 960, 961,
+	962, 963, 964, 965, 967, 969, 970, 1002,
+	1043, 1058, 1065, 1067, 1069, 1089, 1092, 1108,
+	1221, 1541, 1225, 1226, 1227, 1228, 1229, 1230,
+	1231, 1232, 1233, 1234, 1235, 1237, 1238, 1239,
+	1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247,
+	1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255,
+	1256, 1257, 1259, 1260, 1261, 1262, 1263, 1264,
+	1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272,
+	1273, 1275, 1276, 1277, 1279, 1280, 1281, 1282,
+	1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290,
+	1291, 1292, 1294, 1295, 1296, 1297, 1298, 1299,
+	1300, 1301, 1302, 1304, 1305, 1306, 1307, 1308,
+	1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316,
+	1317, 1318, 1319, 1320, 1321, 1323, 1324, 1325,
+	1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333,
+	1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341,
+	1342, 1343, 1345, 1346, 1347, 1348, 1349, 1350,
+	1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358,
+	1359, 1360, 1389, 1414, 1417, 1418, 1420, 1427,
+	1428, 1431, 1435, 1447, 1452, 1453, 1455, 1458,
+	1460,
 }
 
-var _zcltok_trans_actions []byte = []byte{
-	131, 0, 71, 127, 87, 0, 0, 151,
-	123, 0, 5, 0, 0, 0, 0, 0,
+var _hcltok_trans_actions []byte = []byte{
+	143, 0, 85, 139, 101, 0, 0, 169,
+	135, 0, 5, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 101,
+	0, 0, 0, 0, 0, 0, 0, 115,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
@@ -2257,7 +3444,7 @@ var _zcltok_trans_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 125, 148, 0,
+	0, 0, 0, 0, 0, 137, 166, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
@@ -2288,34 +3475,7 @@ var _zcltok_trans_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 129,
-	105, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	27, 5, 0, 0, 29, 0, 49, 35,
-	47, 136, 0, 0, 0, 0, 69, 55,
-	67, 142, 0, 0, 0, 0, 0, 73,
-	0, 0, 0, 99, 160, 0, 91, 5,
-	154, 5, 0, 0, 93, 0, 95, 0,
-	103, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 5,
-	5, 5, 157, 157, 157, 157, 157, 157,
-	5, 5, 157, 5, 117, 121, 107, 115,
-	77, 83, 0, 113, 109, 0, 81, 75,
-	89, 79, 111, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 85, 97,
+	0, 0, 0, 0, 0, 0, 0, 141,
 	119, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
@@ -2328,22 +3488,119 @@ var _zcltok_trans_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
+	27, 5, 0, 0, 29, 0, 49, 35,
+	47, 148, 0, 0, 0, 0, 69, 55,
+	67, 154, 0, 0, 0, 0, 79, 160,
+	83, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
-	13, 11, 0, 0, 5, 15, 0, 5,
-	5, 21, 0, 0, 0, 5, 5, 5,
-	23, 0, 17, 7, 0, 19, 9, 25,
-	0, 0, 0, 0, 37, 0, 139, 139,
-	43, 0, 0, 39, 31, 41, 33, 45,
-	0, 0, 0, 57, 0, 145, 145, 63,
-	0, 0, 59, 51, 61, 53, 65,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 81, 73, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 87, 0, 0, 113, 178,
+	0, 105, 5, 172, 5, 0, 0, 107,
+	0, 109, 0, 117, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 5, 5, 5, 175, 175, 175,
+	175, 175, 175, 5, 5, 175, 5, 121,
+	133, 129, 91, 97, 0, 127, 123, 0,
+	95, 89, 103, 93, 125, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	99, 111, 131, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 13, 11, 0, 0, 5, 15,
+	0, 5, 5, 21, 0, 0, 0, 5,
+	5, 5, 23, 0, 17, 7, 0, 19,
+	9, 25, 0, 0, 0, 0, 37, 0,
+	151, 151, 43, 0, 0, 39, 31, 41,
+	33, 45, 0, 0, 0, 57, 0, 157,
+	157, 63, 0, 0, 59, 51, 61, 53,
+	65, 71, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	5, 5, 5, 163, 163, 163, 163, 163,
+	163, 5, 5, 163, 5, 75, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 77, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0,
 }
 
-var _zcltok_to_state_actions []byte = []byte{
+var _hcltok_to_state_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
@@ -2462,7 +3719,71 @@ var _zcltok_to_state_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 1, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
@@ -2470,12 +3791,17 @@ var _zcltok_to_state_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 1, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 133,
-	0, 0, 0, 0, 0, 0, 133, 0,
-	0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 145,
+	0, 0, 0, 0, 0, 0, 145, 0,
+	0, 0, 0, 0, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0,
 }
 
-var _zcltok_from_state_actions []byte = []byte{
+var _hcltok_from_state_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
@@ -2594,7 +3920,71 @@ var _zcltok_from_state_actions []byte = []byte{
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 3, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 3, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0,
@@ -2604,10 +3994,15 @@ var _zcltok_from_state_actions []byte = []byte{
 	0, 3, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 3,
 	0, 0, 0, 0, 0, 0, 3, 0,
-	0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 3, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0,
 }
 
-var _zcltok_eof_trans []int16 = []int16{
+var _hcltok_eof_trans []int16 = []int16{
 	0, 1, 4, 1, 1, 9, 9, 9,
 	4, 4, 4, 4, 4, 4, 4, 4,
 	4, 4, 4, 4, 4, 4, 4, 4,
@@ -2726,29 +4121,99 @@ var _zcltok_eof_trans []int16 = []int16{
 	672, 672, 672, 672, 672, 672, 672, 672,
 	672, 769, 769, 769, 769, 773, 773, 775,
 	777, 775, 775, 777, 0, 0, 783, 785,
-	783, 783, 785, 0, 0, 0, 845, 846,
-	847, 848, 846, 848, 848, 848, 852, 853,
-	848, 848, 848, 859, 848, 848, 889, 889,
-	889, 889, 889, 889, 889, 889, 889, 889,
-	889, 889, 889, 889, 889, 889, 889, 889,
-	889, 889, 889, 889, 889, 889, 889, 889,
-	889, 889, 889, 889, 889, 889, 889, 889,
-	889, 0, 1042, 1042, 1042, 1042, 1042, 1042,
-	1049, 1051, 1049, 1054, 1056, 1056, 1056, 0,
-	1065, 1068, 1070, 1072, 1072, 1072, 0, 1080,
-	1083, 1085, 1087, 1087, 1087,
+	783, 783, 785, 0, 0, 791, 791, 793,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	791, 791, 791, 791, 791, 791, 791, 791,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042,
+	1042, 1042, 1042, 1042, 1042, 1042, 0, 1192,
+	1193, 1194, 1193, 1194, 1194, 1194, 1198, 1199,
+	1194, 1194, 1194, 1205, 1194, 1194, 1235, 1235,
+	1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235,
+	1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235,
+	1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235,
+	1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235,
+	1235, 0, 1388, 1388, 1388, 1388, 1388, 1388,
+	1395, 1397, 1395, 1400, 1402, 1402, 1402, 0,
+	1411, 1414, 1416, 1418, 1418, 1418, 0, 1426,
+	1429, 1431, 1433, 1433, 1433, 0, 1470, 1498,
+	1498, 1498, 1498, 1498, 1498, 1498, 1498, 1498,
+	1498, 1498, 1498, 1498, 1498, 1498, 1498, 1498,
+	1498, 1498, 1498, 1498, 1498, 1498, 1498, 1498,
+	1498, 1498, 1498, 1498, 1498, 1498, 1498, 1498,
+	1498, 1498,
 }
 
-const zcltok_start int = 949
-const zcltok_first_final int = 949
-const zcltok_error int = 0
+const hcltok_start int = 1462
+const hcltok_first_final int = 1462
+const hcltok_error int = 0
 
-const zcltok_en_stringTemplate int = 1001
-const zcltok_en_heredocTemplate int = 1015
-const zcltok_en_bareTemplate int = 1022
-const zcltok_en_main int = 949
+const hcltok_en_stringTemplate int = 1513
+const hcltok_en_heredocTemplate int = 1527
+const hcltok_en_bareTemplate int = 1534
+const hcltok_en_identOnly int = 1541
+const hcltok_en_main int = 1462
 
-// line 15 "scan_tokens.rl"
+// line 16 "scan_tokens.rl"
 
 func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token {
 	f := &tokenAccum{
@@ -2757,7 +4222,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 		Pos:      start,
 	}
 
-	// line 272 "scan_tokens.rl"
+	// line 276 "scan_tokens.rl"
 
 	// Ragel state
 	p := 0          // "Pointer" into data
@@ -2772,9 +4237,11 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 	var cs int // current state
 	switch mode {
 	case scanNormal:
-		cs = zcltok_en_main
+		cs = hcltok_en_main
 	case scanTemplate:
-		cs = zcltok_en_bareTemplate
+		cs = hcltok_en_bareTemplate
+	case scanIdentOnly:
+		cs = hcltok_en_identOnly
 	default:
 		panic("invalid scanMode")
 	}
@@ -2783,7 +4250,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 	var retBraces []int              // stack of brace levels that cause us to use fret
 	var heredocs []heredocInProgress // stack of heredocs we're currently processing
 
-	// line 305 "scan_tokens.rl"
+	// line 311 "scan_tokens.rl"
 
 	// Make Go compiler happy
 	_ = ts
@@ -2803,7 +4270,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 		f.emitToken(TokenType(b[0]), ts, te)
 	}
 
-	// line 2816 "scan_tokens.go"
+	// line 4282 "scan_tokens.go"
 	{
 		top = 0
 		ts = 0
@@ -2811,7 +4278,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 		act = 0
 	}
 
-	// line 2824 "scan_tokens.go"
+	// line 4290 "scan_tokens.go"
 	{
 		var _klen int
 		var _trans int
@@ -2825,25 +4292,25 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 			goto _out
 		}
 	_resume:
-		_acts = int(_zcltok_from_state_actions[cs])
-		_nacts = uint(_zcltok_actions[_acts])
+		_acts = int(_hcltok_from_state_actions[cs])
+		_nacts = uint(_hcltok_actions[_acts])
 		_acts++
 		for ; _nacts > 0; _nacts-- {
 			_acts++
-			switch _zcltok_actions[_acts-1] {
+			switch _hcltok_actions[_acts-1] {
 			case 2:
 				// line 1 "NONE"
 
 				ts = p
 
-				// line 2848 "scan_tokens.go"
+				// line 4314 "scan_tokens.go"
 			}
 		}
 
-		_keys = int(_zcltok_key_offsets[cs])
-		_trans = int(_zcltok_index_offsets[cs])
+		_keys = int(_hcltok_key_offsets[cs])
+		_trans = int(_hcltok_index_offsets[cs])
 
-		_klen = int(_zcltok_single_lengths[cs])
+		_klen = int(_hcltok_single_lengths[cs])
 		if _klen > 0 {
 			_lower := int(_keys)
 			var _mid int
@@ -2855,9 +4322,9 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 
 				_mid = _lower + ((_upper - _lower) >> 1)
 				switch {
-				case data[p] < _zcltok_trans_keys[_mid]:
+				case data[p] < _hcltok_trans_keys[_mid]:
 					_upper = _mid - 1
-				case data[p] > _zcltok_trans_keys[_mid]:
+				case data[p] > _hcltok_trans_keys[_mid]:
 					_lower = _mid + 1
 				default:
 					_trans += int(_mid - int(_keys))
@@ -2868,7 +4335,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 			_trans += _klen
 		}
 
-		_klen = int(_zcltok_range_lengths[cs])
+		_klen = int(_hcltok_range_lengths[cs])
 		if _klen > 0 {
 			_lower := int(_keys)
 			var _mid int
@@ -2880,9 +4347,9 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 
 				_mid = _lower + (((_upper - _lower) >> 1) & ^1)
 				switch {
-				case data[p] < _zcltok_trans_keys[_mid]:
+				case data[p] < _hcltok_trans_keys[_mid]:
 					_upper = _mid - 2
-				case data[p] > _zcltok_trans_keys[_mid+1]:
+				case data[p] > _hcltok_trans_keys[_mid+1]:
 					_lower = _mid + 2
 				default:
 					_trans += int((_mid - int(_keys)) >> 1)
@@ -2893,27 +4360,27 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 		}
 
 	_match:
-		_trans = int(_zcltok_indicies[_trans])
+		_trans = int(_hcltok_indicies[_trans])
 	_eof_trans:
-		cs = int(_zcltok_trans_targs[_trans])
+		cs = int(_hcltok_trans_targs[_trans])
 
-		if _zcltok_trans_actions[_trans] == 0 {
+		if _hcltok_trans_actions[_trans] == 0 {
 			goto _again
 		}
 
-		_acts = int(_zcltok_trans_actions[_trans])
-		_nacts = uint(_zcltok_actions[_acts])
+		_acts = int(_hcltok_trans_actions[_trans])
+		_nacts = uint(_hcltok_actions[_acts])
 		_acts++
 		for ; _nacts > 0; _nacts-- {
 			_acts++
-			switch _zcltok_actions[_acts-1] {
+			switch _hcltok_actions[_acts-1] {
 			case 3:
 				// line 1 "NONE"
 
 				te = p + 1
 
 			case 4:
-				// line 138 "scan_tokens.rl"
+				// line 137 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -2927,12 +4394,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 5:
-				// line 148 "scan_tokens.rl"
+				// line 147 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -2946,12 +4413,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 6:
-				// line 80 "scan_tokens.rl"
+				// line 79 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -2965,21 +4432,21 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 
 				}
 			case 7:
-				// line 222 "scan_tokens.rl"
+				// line 221 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenInvalid)
 				}
 			case 8:
-				// line 223 "scan_tokens.rl"
+				// line 222 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenBadUTF8)
 				}
 			case 9:
-				// line 138 "scan_tokens.rl"
+				// line 137 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -2994,12 +4461,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 10:
-				// line 148 "scan_tokens.rl"
+				// line 147 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3014,12 +4481,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 11:
-				// line 221 "scan_tokens.rl"
+				// line 220 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3027,7 +4494,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenQuotedLit)
 				}
 			case 12:
-				// line 222 "scan_tokens.rl"
+				// line 221 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3035,7 +4502,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenInvalid)
 				}
 			case 13:
-				// line 223 "scan_tokens.rl"
+				// line 222 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3043,29 +4510,29 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenBadUTF8)
 				}
 			case 14:
-				// line 221 "scan_tokens.rl"
+				// line 220 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
 					token(TokenQuotedLit)
 				}
 			case 15:
-				// line 223 "scan_tokens.rl"
+				// line 222 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
 					token(TokenBadUTF8)
 				}
 			case 16:
-				// line 126 "scan_tokens.rl"
+				// line 125 "scan_tokens.rl"
 
 				act = 10
 			case 17:
-				// line 231 "scan_tokens.rl"
+				// line 230 "scan_tokens.rl"
 
 				act = 11
 			case 18:
-				// line 138 "scan_tokens.rl"
+				// line 137 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3079,12 +4546,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 19:
-				// line 148 "scan_tokens.rl"
+				// line 147 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3098,12 +4565,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 20:
-				// line 107 "scan_tokens.rl"
+				// line 106 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3131,14 +4598,14 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenStringLit)
 				}
 			case 21:
-				// line 231 "scan_tokens.rl"
+				// line 230 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenBadUTF8)
 				}
 			case 22:
-				// line 138 "scan_tokens.rl"
+				// line 137 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3153,12 +4620,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 23:
-				// line 148 "scan_tokens.rl"
+				// line 147 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3173,12 +4640,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 24:
-				// line 126 "scan_tokens.rl"
+				// line 125 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3190,7 +4657,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenStringLit)
 				}
 			case 25:
-				// line 231 "scan_tokens.rl"
+				// line 230 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3198,7 +4665,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenBadUTF8)
 				}
 			case 26:
-				// line 126 "scan_tokens.rl"
+				// line 125 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
@@ -3235,15 +4702,15 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 				}
 
 			case 28:
-				// line 134 "scan_tokens.rl"
+				// line 133 "scan_tokens.rl"
 
 				act = 14
 			case 29:
-				// line 238 "scan_tokens.rl"
+				// line 237 "scan_tokens.rl"
 
 				act = 15
 			case 30:
-				// line 138 "scan_tokens.rl"
+				// line 137 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3257,12 +4724,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 31:
-				// line 148 "scan_tokens.rl"
+				// line 147 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3276,26 +4743,26 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 32:
-				// line 134 "scan_tokens.rl"
+				// line 133 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenStringLit)
 				}
 			case 33:
-				// line 238 "scan_tokens.rl"
+				// line 237 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenBadUTF8)
 				}
 			case 34:
-				// line 138 "scan_tokens.rl"
+				// line 137 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3310,12 +4777,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 35:
-				// line 148 "scan_tokens.rl"
+				// line 147 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3330,12 +4797,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 949
+						cs = 1462
 						goto _again
 					}
 				}
 			case 36:
-				// line 134 "scan_tokens.rl"
+				// line 133 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3343,7 +4810,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenStringLit)
 				}
 			case 37:
-				// line 238 "scan_tokens.rl"
+				// line 237 "scan_tokens.rl"
 
 				te = p
 				p--
@@ -3351,7 +4818,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 					token(TokenBadUTF8)
 				}
 			case 38:
-				// line 134 "scan_tokens.rl"
+				// line 133 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
@@ -3380,112 +4847,180 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 				}
 
 			case 40:
-				// line 244 "scan_tokens.rl"
+				// line 241 "scan_tokens.rl"
 
-				act = 18
+				act = 16
 			case 41:
-				// line 246 "scan_tokens.rl"
+				// line 242 "scan_tokens.rl"
 
-				act = 19
+				act = 17
 			case 42:
-				// line 257 "scan_tokens.rl"
+				// line 242 "scan_tokens.rl"
 
-				act = 29
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
 			case 43:
-				// line 268 "scan_tokens.rl"
+				// line 243 "scan_tokens.rl"
 
-				act = 36
+				te = p + 1
+				{
+					token(TokenInvalid)
+				}
 			case 44:
-				// line 269 "scan_tokens.rl"
+				// line 241 "scan_tokens.rl"
 
-				act = 37
+				te = p
+				p--
+				{
+					token(TokenIdent)
+				}
 			case 45:
-				// line 246 "scan_tokens.rl"
+				// line 242 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 46:
+				// line 241 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenIdent)
+				}
+			case 47:
+				// line 242 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 48:
+				// line 1 "NONE"
+
+				switch act {
+				case 16:
+					{
+						p = (te) - 1
+						token(TokenIdent)
+					}
+				case 17:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				}
+
+			case 49:
+				// line 249 "scan_tokens.rl"
+
+				act = 21
+			case 50:
+				// line 251 "scan_tokens.rl"
+
+				act = 22
+			case 51:
+				// line 262 "scan_tokens.rl"
+
+				act = 32
+			case 52:
+				// line 272 "scan_tokens.rl"
+
+				act = 38
+			case 53:
+				// line 273 "scan_tokens.rl"
+
+				act = 39
+			case 54:
+				// line 251 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenComment)
 				}
-			case 46:
-				// line 247 "scan_tokens.rl"
+			case 55:
+				// line 252 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenNewline)
 				}
-			case 47:
-				// line 249 "scan_tokens.rl"
+			case 56:
+				// line 254 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenEqualOp)
 				}
-			case 48:
-				// line 250 "scan_tokens.rl"
+			case 57:
+				// line 255 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenNotEqual)
 				}
-			case 49:
-				// line 251 "scan_tokens.rl"
+			case 58:
+				// line 256 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenGreaterThanEq)
 				}
-			case 50:
-				// line 252 "scan_tokens.rl"
+			case 59:
+				// line 257 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenLessThanEq)
 				}
-			case 51:
-				// line 253 "scan_tokens.rl"
+			case 60:
+				// line 258 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenAnd)
 				}
-			case 52:
-				// line 254 "scan_tokens.rl"
+			case 61:
+				// line 259 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenOr)
 				}
-			case 53:
-				// line 255 "scan_tokens.rl"
+			case 62:
+				// line 260 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenEllipsis)
 				}
-			case 54:
-				// line 256 "scan_tokens.rl"
+			case 63:
+				// line 261 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenFatArrow)
 				}
-			case 55:
-				// line 257 "scan_tokens.rl"
+			case 64:
+				// line 262 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					selfToken()
 				}
-			case 56:
-				// line 158 "scan_tokens.rl"
+			case 65:
+				// line 157 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenOBrace)
 					braces++
 				}
-			case 57:
-				// line 163 "scan_tokens.rl"
+			case 66:
+				// line 162 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3505,8 +5040,8 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						braces--
 					}
 				}
-			case 58:
-				// line 175 "scan_tokens.rl"
+			case 67:
+				// line 174 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3535,8 +5070,8 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						braces--
 					}
 				}
-			case 59:
-				// line 75 "scan_tokens.rl"
+			case 68:
+				// line 74 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3545,12 +5080,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 1001
+						cs = 1513
 						goto _again
 					}
 				}
-			case 60:
-				// line 85 "scan_tokens.rl"
+			case 69:
+				// line 84 "scan_tokens.rl"
 
 				te = p + 1
 				{
@@ -3576,156 +5111,148 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 						stack = append(stack, 0)
 						stack[top] = cs
 						top++
-						cs = 1015
+						cs = 1527
 						goto _again
 					}
 				}
-			case 61:
-				// line 268 "scan_tokens.rl"
+			case 70:
+				// line 272 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenBadUTF8)
 				}
-			case 62:
-				// line 269 "scan_tokens.rl"
+			case 71:
+				// line 273 "scan_tokens.rl"
 
 				te = p + 1
 				{
 					token(TokenInvalid)
 				}
-			case 63:
-				// line 242 "scan_tokens.rl"
+			case 72:
+				// line 247 "scan_tokens.rl"
 
 				te = p
 				p--
 
-			case 64:
-				// line 243 "scan_tokens.rl"
+			case 73:
+				// line 248 "scan_tokens.rl"
 
 				te = p
 				p--
 				{
 					token(TokenNumberLit)
 				}
-			case 65:
-				// line 244 "scan_tokens.rl"
+			case 74:
+				// line 249 "scan_tokens.rl"
 
 				te = p
 				p--
 				{
 					token(TokenIdent)
 				}
-			case 66:
-				// line 246 "scan_tokens.rl"
+			case 75:
+				// line 251 "scan_tokens.rl"
 
 				te = p
 				p--
 				{
 					token(TokenComment)
 				}
-			case 67:
-				// line 257 "scan_tokens.rl"
+			case 76:
+				// line 262 "scan_tokens.rl"
 
 				te = p
 				p--
 				{
 					selfToken()
 				}
-			case 68:
-				// line 267 "scan_tokens.rl"
-
-				te = p
-				p--
-				{
-					token(TokenTabs)
-				}
-			case 69:
-				// line 268 "scan_tokens.rl"
+			case 77:
+				// line 272 "scan_tokens.rl"
 
 				te = p
 				p--
 				{
 					token(TokenBadUTF8)
 				}
-			case 70:
-				// line 269 "scan_tokens.rl"
+			case 78:
+				// line 273 "scan_tokens.rl"
 
 				te = p
 				p--
 				{
 					token(TokenInvalid)
 				}
-			case 71:
-				// line 243 "scan_tokens.rl"
+			case 79:
+				// line 248 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
 					token(TokenNumberLit)
 				}
-			case 72:
-				// line 244 "scan_tokens.rl"
+			case 80:
+				// line 249 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
 					token(TokenIdent)
 				}
-			case 73:
-				// line 257 "scan_tokens.rl"
+			case 81:
+				// line 262 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
 					selfToken()
 				}
-			case 74:
-				// line 268 "scan_tokens.rl"
+			case 82:
+				// line 272 "scan_tokens.rl"
 
 				p = (te) - 1
 				{
 					token(TokenBadUTF8)
 				}
-			case 75:
+			case 83:
 				// line 1 "NONE"
 
 				switch act {
-				case 18:
+				case 21:
 					{
 						p = (te) - 1
 						token(TokenIdent)
 					}
-				case 19:
+				case 22:
 					{
 						p = (te) - 1
 						token(TokenComment)
 					}
-				case 29:
+				case 32:
 					{
 						p = (te) - 1
 						selfToken()
 					}
-				case 36:
+				case 38:
 					{
 						p = (te) - 1
 						token(TokenBadUTF8)
 					}
-				case 37:
+				case 39:
 					{
 						p = (te) - 1
 						token(TokenInvalid)
 					}
 				}
 
-				// line 3592 "scan_tokens.go"
+				// line 5104 "scan_tokens.go"
 			}
 		}
 
 	_again:
-		_acts = int(_zcltok_to_state_actions[cs])
-		_nacts = uint(_zcltok_actions[_acts])
+		_acts = int(_hcltok_to_state_actions[cs])
+		_nacts = uint(_hcltok_actions[_acts])
 		_acts++
 		for ; _nacts > 0; _nacts-- {
 			_acts++
-			switch _zcltok_actions[_acts-1] {
+			switch _hcltok_actions[_acts-1] {
 			case 0:
 				// line 1 "NONE"
 
@@ -3736,7 +5263,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 
 				act = 0
 
-				// line 3612 "scan_tokens.go"
+				// line 5124 "scan_tokens.go"
 			}
 		}
 
@@ -3751,8 +5278,8 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 		{
 		}
 		if p == eof {
-			if _zcltok_eof_trans[cs] > 0 {
-				_trans = int(_zcltok_eof_trans[cs] - 1)
+			if _hcltok_eof_trans[cs] > 0 {
+				_trans = int(_hcltok_eof_trans[cs] - 1)
 				goto _eof_trans
 			}
 		}
@@ -3762,12 +5289,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
 		}
 	}
 
-	// line 328 "scan_tokens.rl"
+	// line 334 "scan_tokens.rl"
 
 	// If we fall out here without being in a final state then we've
 	// encountered something that the scanner can't match, which we'll
 	// deal with as an invalid.
-	if cs < zcltok_first_final {
+	if cs < hcltok_first_final {
 		f.emitToken(TokenInvalid, p, len(data))
 	}
 
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl
index 4a395c1336..dc3f56b9b4 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl
@@ -1,16 +1,17 @@
-package zclsyntax
+
+package hclsyntax
 
 import (
     "bytes"
 
-    "github.com/zclconf/go-zcl/zcl"
+    "github.com/hashicorp/hcl2/hcl"
 )
 
 // This file is generated from scan_tokens.rl. DO NOT EDIT.
 %%{
   # (except you are actually in scan_tokens.rl here, so edit away!)
 
-  machine zcltok;
+  machine hcltok;
   write data;
 }%%
 
@@ -62,15 +63,13 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
             ("/*" any* "*/")
         );
 
-        # Tabs are not valid, but we accept them in the scanner and mark them
-        # as tokens so that we can produce diagnostics advising the user to
-        # use spaces instead.
-        Tabs = 0x09+;
-
-        # Note: zclwrite assumes that only ASCII spaces appear between tokens,
+        # Note: hclwrite assumes that only ASCII spaces appear between tokens,
         # and uses this assumption to recreate the spaces between tokens by
-        # looking at byte offset differences.
-        Spaces = ' '+;
+        # looking at byte offset differences. This means it will produce
+        # incorrect results in the presence of tabs, but that's acceptable
+        # because the canonical style (which hclwrite itself can impose
+        # automatically is to never use tabs).
+        Spaces = (' ' | 0x09)+;
 
         action beginStringTemplate {
             token(TokenOQuote);
@@ -238,6 +237,12 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
             BrokenUTF8            => { token(TokenBadUTF8); };
         *|;
 
+        identOnly := |*
+            Ident            => { token(TokenIdent) };
+            BrokenUTF8       => { token(TokenBadUTF8) };
+            AnyUTF8          => { token(TokenInvalid) };
+        *|;
+
         main := |*
             Spaces           => {};
             NumberLit        => { token(TokenNumberLit) };
@@ -264,7 +269,6 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
             BeginStringTmpl  => beginStringTemplate;
             BeginHeredocTmpl => beginHeredocTemplate;
 
-            Tabs             => { token(TokenTabs) };
             BrokenUTF8       => { token(TokenBadUTF8) };
             AnyUTF8          => { token(TokenInvalid) };
         *|;
@@ -284,9 +288,11 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
     var cs int // current state
     switch mode {
     case scanNormal:
-        cs = zcltok_en_main
+        cs = hcltok_en_main
     case scanTemplate:
-        cs = zcltok_en_bareTemplate
+        cs = hcltok_en_bareTemplate
+    case scanIdentOnly:
+        cs = hcltok_en_identOnly
     default:
         panic("invalid scanMode")
     }
@@ -330,7 +336,7 @@ func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []To
     // If we fall out here without being in a final state then we've
     // encountered something that the scanner can't match, which we'll
     // deal with as an invalid.
-    if cs < zcltok_first_final {
+    if cs < hcltok_first_final {
         f.emitToken(TokenInvalid, p, len(data))
     }
 
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go
index eb686d5de7..d69f65b62e 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/structure.go
@@ -25,7 +25,7 @@ func (b *Block) AsHCLBlock() *hcl.Block {
 	}
 }
 
-// Body is the implementation of hcl.Body for the zcl native syntax.
+// Body is the implementation of hcl.Body for the HCL native syntax.
 type Body struct {
 	Attributes Attributes
 	Blocks     Blocks
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go
index 00d6d720a2..53e847d136 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go
@@ -110,6 +110,7 @@ type scanMode int
 const (
 	scanNormal scanMode = iota
 	scanTemplate
+	scanIdentOnly
 )
 
 type tokenAccum struct {
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go
index dfe69b21a9..93de7ee9dd 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token_type_string.go
@@ -2,7 +2,7 @@
 
 package hclsyntax
 
-import "fmt"
+import "strconv"
 
 const _TokenType_name = "TokenNilTokenNewlineTokenBangTokenPercentTokenBitwiseAndTokenOParenTokenCParenTokenStarTokenPlusTokenCommaTokenMinusTokenDotTokenSlashTokenColonTokenSemicolonTokenLessThanTokenEqualTokenGreaterThanTokenQuestionTokenCommentTokenOHeredocTokenIdentTokenNumberLitTokenQuotedLitTokenStringLitTokenOBrackTokenCBrackTokenBitwiseXorTokenBacktickTokenCHeredocTokenOBraceTokenBitwiseOrTokenCBraceTokenBitwiseNotTokenOQuoteTokenCQuoteTokenTemplateControlTokenEllipsisTokenFatArrowTokenTemplateSeqEndTokenAndTokenOrTokenTemplateInterpTokenEqualOpTokenNotEqualTokenLessThanEqTokenGreaterThanEqTokenEOFTokenTabsTokenStarStarTokenInvalidTokenBadUTF8"
 
@@ -65,5 +65,5 @@ func (i TokenType) String() string {
 	if str, ok := _TokenType_map[i]; ok {
 		return str
 	}
-	return fmt.Sprintf("TokenType(%d)", i)
+	return "TokenType(" + strconv.FormatInt(int64(i), 10) + ")"
 }
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go b/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go
index d28e6037ea..307eebb2cd 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go
@@ -8,7 +8,7 @@ type navigation struct {
 	root *objectVal
 }
 
-// Implementation of zcled.ContextString
+// Implementation of hcled.ContextString
 func (n navigation) ContextString(offset int) string {
 	steps := navigationStepsRev(n.root, offset)
 	if steps == nil {
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
index 41d05fb4c7..f36625e0f8 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
@@ -168,7 +168,7 @@ Token:
 			}
 
 			if colon.Type == tokenEquals {
-				// Possible confusion with native zcl syntax.
+				// Possible confusion with native HCL syntax.
 				return nil, diags.Append(&hcl.Diagnostic{
 					Severity: hcl.DiagError,
 					Summary:  "Missing attribute value colon",
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/public.go b/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
index 8d4b052621..04ee9147cd 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
@@ -9,10 +9,10 @@ import (
 )
 
 // Parse attempts to parse the given buffer as JSON and, if successful, returns
-// a hcl.File for the zcl configuration represented by it.
+// a hcl.File for the HCL configuration represented by it.
 //
 // This is not a generic JSON parser. Instead, it deals only with the profile
-// of JSON used to express zcl configuration.
+// of JSON used to express HCL configuration.
 //
 // The returned file is valid only if the returned diagnostics returns false
 // from its HasErrors method. If HasErrors returns true, the file represents
@@ -88,28 +88,3 @@ func ParseFile(filename string) (*hcl.File, hcl.Diagnostics) {
 
 	return Parse(src, filename)
 }
-
-// ParseWithHIL is like Parse except the returned file will use the HIL
-// template syntax for expressions in strings, rather than the native zcl
-// template syntax.
-//
-// This is intended for providing backward compatibility for applications that
-// used to use HCL/HIL and thus had a JSON-based format with HIL
-// interpolations.
-func ParseWithHIL(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
-	file, diags := Parse(src, filename)
-	if file != nil && file.Body != nil {
-		file.Body.(*body).useHIL = true
-	}
-	return file, diags
-}
-
-// ParseFileWithHIL is like ParseWithHIL but it reads data from a file before
-// parsing it.
-func ParseFileWithHIL(filename string) (*hcl.File, hcl.Diagnostics) {
-	file, diags := ParseFile(filename)
-	if file != nil && file.Body != nil {
-		file.Body.(*body).useHIL = true
-	}
-	return file, diags
-}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md
index d6e8bf696f..9b08a4f264 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md
@@ -3,7 +3,7 @@
 This is the specification for the JSON serialization for hcl. HCL is a system
 for defining configuration languages for applications. The HCL information
 model is designed to support multiple concrete syntaxes for configuration,
-and this JSON-based format complements [the native syntax](../zclsyntax/spec.md)
+and this JSON-based format complements [the native syntax](../hclsyntax/spec.md)
 by being easy to machine-generate, whereas the native syntax is oriented
 towards human authoring and maintenence.
 
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
index d13607eed0..fc9f580db2 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
@@ -3,8 +3,8 @@ package json
 import (
 	"fmt"
 
-	"github.com/hashicorp/hcl2/hcl/hclsyntax"
 	"github.com/hashicorp/hcl2/hcl"
+	"github.com/hashicorp/hcl2/hcl/hclsyntax"
 	"github.com/zclconf/go-cty/cty"
 )
 
@@ -17,12 +17,6 @@ type body struct {
 	// be treated as non-existing. This is used when Body.PartialContent is
 	// called, to produce the "remaining content" Body.
 	hiddenAttrs map[string]struct{}
-
-	// If set, string values are turned into expressions using HIL's template
-	// language, rather than the native zcl language. This is intended to
-	// allow applications moving from HCL to zcl to continue to parse the
-	// JSON variant of their config that HCL handled previously.
-	useHIL bool
 }
 
 // expression is the implementation of "Expression" used for files processed
@@ -133,7 +127,6 @@ func (b *body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Bod
 	unusedBody := &body{
 		obj:         b.obj,
 		hiddenAttrs: usedNames,
-		useHIL:      b.useHIL,
 	}
 
 	return content, unusedBody, diags
@@ -219,8 +212,7 @@ func (b *body) unpackBlock(v node, typeName string, typeRange *hcl.Range, labels
 			Type:   typeName,
 			Labels: labels,
 			Body: &body{
-				obj:    tv,
-				useHIL: b.useHIL,
+				obj: tv,
 			},
 
 			DefRange:    tv.OpenRange,
@@ -245,8 +237,7 @@ func (b *body) unpackBlock(v node, typeName string, typeRange *hcl.Range, labels
 				Type:   typeName,
 				Labels: labels,
 				Body: &body{
-					obj:    ov,
-					useHIL: b.useHIL,
+					obj: ov,
 				},
 
 				DefRange:    tv.OpenRange,
@@ -269,7 +260,7 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
 	switch v := e.src.(type) {
 	case *stringVal:
 		if ctx != nil {
-			// Parse string contents as a zcl native language expression.
+			// Parse string contents as a HCL native language expression.
 			// We only do this if we have a context, so passing a nil context
 			// is how the caller specifies that interpolations are not allowed
 			// and that the string should just be returned verbatim.
@@ -279,7 +270,7 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
 				v.SrcRange.Filename,
 
 				// This won't produce _exactly_ the right result, since
-				// the zclsyntax parser can't "see" any escapes we removed
+				// the hclsyntax parser can't "see" any escapes we removed
 				// while parsing JSON, but it's better than nothing.
 				hcl.Pos{
 					Line: v.SrcRange.Start.Line,
@@ -297,8 +288,6 @@ func (e *expression) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
 			return val, diags
 		}
 
-		// FIXME: Once the native zcl template language parser is implemented,
-		// parse string values as templates and evaluate them.
 		return cty.StringVal(v.Value), nil
 	case *numberVal:
 		return cty.NumberVal(v.Value), nil
@@ -330,8 +319,26 @@ func (e *expression) Variables() []hcl.Traversal {
 
 	switch v := e.src.(type) {
 	case *stringVal:
-		// FIXME: Once the native zcl template language parser is implemented,
-		// parse with that and look for variables in there too,
+		templateSrc := v.Value
+		expr, diags := hclsyntax.ParseTemplate(
+			[]byte(templateSrc),
+			v.SrcRange.Filename,
+
+			// This won't produce _exactly_ the right result, since
+			// the hclsyntax parser can't "see" any escapes we removed
+			// while parsing JSON, but it's better than nothing.
+			hcl.Pos{
+				Line: v.SrcRange.Start.Line,
+
+				// skip over the opening quote mark
+				Byte:   v.SrcRange.Start.Byte + 1,
+				Column: v.SrcRange.Start.Column + 1,
+			},
+		)
+		if diags.HasErrors() {
+			return vars
+		}
+		return expr.Variables()
 
 	case *arrayVal:
 		for _, jsonVal := range v.Values {
@@ -353,3 +360,34 @@ func (e *expression) Range() hcl.Range {
 func (e *expression) StartRange() hcl.Range {
 	return e.src.StartRange()
 }
+
+// Implementation for hcl.AbsTraversalForExpr.
+func (e *expression) AsTraversal() hcl.Traversal {
+	// In JSON-based syntax a traversal is given as a string containing
+	// traversal syntax as defined by hclsyntax.ParseTraversalAbs.
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		traversal, diags := hclsyntax.ParseTraversalAbs([]byte(v.Value), v.SrcRange.Filename, v.SrcRange.Start)
+		if diags.HasErrors() {
+			return nil
+		}
+		return traversal
+	default:
+		return nil
+	}
+}
+
+// Implementation for hcl.ExprList.
+func (e *expression) ExprList() []hcl.Expression {
+	switch v := e.src.(type) {
+	case *arrayVal:
+		ret := make([]hcl.Expression, len(v.Values))
+		for i, node := range v.Values {
+			ret[i] = &expression{src: node}
+		}
+		return ret
+	default:
+		return nil
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/ops.go b/vendor/github.com/hashicorp/hcl2/hcl/ops.go
index 80312b010d..f4e30b09cb 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/ops.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/ops.go
@@ -8,7 +8,7 @@ import (
 )
 
 // Index is a helper function that performs the same operation as the index
-// operator in the zcl expression language. That is, the result is the
+// operator in the HCL expression language. That is, the result is the
 // same as it would be for collection[key] in a configuration expression.
 //
 // This is exported so that applications can perform indexing in a manner
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/pos.go b/vendor/github.com/hashicorp/hcl2/hcl/pos.go
index 3ccdfacb87..1a4b329dcf 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/pos.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/pos.go
@@ -60,6 +60,40 @@ func RangeBetween(start, end Range) Range {
 	}
 }
 
+// RangeOver returns a new range that covers both of the given ranges and
+// possibly additional content between them if the two ranges do not overlap.
+//
+// If either range is empty then it is ignored. The result is empty if both
+// given ranges are empty.
+//
+// The result is meaningless if the two ranges to not belong to the same
+// source file.
+func RangeOver(a, b Range) Range {
+	if a.Empty() {
+		return b
+	}
+	if b.Empty() {
+		return a
+	}
+
+	var start, end Pos
+	if a.Start.Byte < b.Start.Byte {
+		start = a.Start
+	} else {
+		start = b.Start
+	}
+	if a.End.Byte > b.End.Byte {
+		end = a.End
+	} else {
+		end = b.End
+	}
+	return Range{
+		Filename: a.Filename,
+		Start:    start,
+		End:      end,
+	}
+}
+
 // ContainsOffset returns true if and only if the given byte offset is within
 // the receiving Range.
 func (r Range) ContainsOffset(offset int) bool {
@@ -94,3 +128,135 @@ func (r Range) String() string {
 		)
 	}
 }
+
+func (r Range) Empty() bool {
+	return r.Start.Byte == r.End.Byte
+}
+
+// CanSliceBytes returns true if SliceBytes could return an accurate
+// sub-slice of the given slice.
+//
+// This effectively tests whether the start and end offsets of the range
+// are within the bounds of the slice, and thus whether SliceBytes can be
+// trusted to produce an accurate start and end position within that slice.
+func (r Range) CanSliceBytes(b []byte) bool {
+	switch {
+	case r.Start.Byte < 0 || r.Start.Byte > len(b):
+		return false
+	case r.End.Byte < 0 || r.End.Byte > len(b):
+		return false
+	case r.End.Byte < r.Start.Byte:
+		return false
+	default:
+		return true
+	}
+}
+
+// SliceBytes returns a sub-slice of the given slice that is covered by the
+// receiving range, assuming that the given slice is the source code of the
+// file indicated by r.Filename.
+//
+// If the receiver refers to any byte offsets that are outside of the slice
+// then the result is constrained to the overlapping portion only, to avoid
+// a panic. Use CanSliceBytes to determine if the result is guaranteed to
+// be an accurate span of the requested range.
+func (r Range) SliceBytes(b []byte) []byte {
+	start := r.Start.Byte
+	end := r.End.Byte
+	if start < 0 {
+		start = 0
+	} else if start > len(b) {
+		start = len(b)
+	}
+	if end < 0 {
+		end = 0
+	} else if end > len(b) {
+		end = len(b)
+	}
+	if end < start {
+		end = start
+	}
+	return b[start:end]
+}
+
+// Overlaps returns true if the receiver and the other given range share any
+// characters in common.
+func (r Range) Overlaps(other Range) bool {
+	switch {
+	case r.Filename != other.Filename:
+		// If the ranges are in different files then they can't possibly overlap
+		return false
+	case r.Empty() || other.Empty():
+		// Empty ranges can never overlap
+		return false
+	case r.ContainsOffset(other.Start.Byte) || r.ContainsOffset(other.End.Byte):
+		return true
+	case other.ContainsOffset(r.Start.Byte) || other.ContainsOffset(r.End.Byte):
+		return true
+	default:
+		return false
+	}
+}
+
+// Overlap finds a range that is either identical to or a sub-range of both
+// the receiver and the other given range. It returns an empty range
+// within the receiver if there is no overlap between the two ranges.
+//
+// A non-empty result is either identical to or a subset of the receiver.
+func (r Range) Overlap(other Range) Range {
+	if !r.Overlaps(other) {
+		// Start == End indicates an empty range
+		return Range{
+			Filename: r.Filename,
+			Start:    r.Start,
+			End:      r.Start,
+		}
+	}
+
+	var start, end Pos
+	if r.Start.Byte > other.Start.Byte {
+		start = r.Start
+	} else {
+		start = other.Start
+	}
+	if r.End.Byte < other.End.Byte {
+		end = r.End
+	} else {
+		end = other.End
+	}
+
+	return Range{
+		Filename: r.Filename,
+		Start:    start,
+		End:      end,
+	}
+}
+
+// PartitionAround finds the portion of the given range that overlaps with
+// the reciever and returns three ranges: the portion of the reciever that
+// precedes the overlap, the overlap itself, and then the portion of the
+// reciever that comes after the overlap.
+//
+// If the two ranges do not overlap then all three returned ranges are empty.
+//
+// If the given range aligns with or extends beyond either extent of the
+// reciever then the corresponding outer range will be empty.
+func (r Range) PartitionAround(other Range) (before, overlap, after Range) {
+	overlap = r.Overlap(other)
+	if overlap.Empty() {
+		return overlap, overlap, overlap
+	}
+
+	before = Range{
+		Filename: r.Filename,
+		Start:    r.Start,
+		End:      overlap.Start,
+	}
+	after = Range{
+		Filename: r.Filename,
+		Start:    overlap.End,
+		End:      r.End,
+	}
+
+	return before, overlap, after
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go b/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go
new file mode 100644
index 0000000000..7c8f2dfa58
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/pos_scanner.go
@@ -0,0 +1,148 @@
+package hcl
+
+import (
+	"bufio"
+	"bytes"
+
+	"github.com/apparentlymart/go-textseg/textseg"
+)
+
+// RangeScanner is a helper that will scan over a buffer using a bufio.SplitFunc
+// and visit a source range for each token matched.
+//
+// For example, this can be used with bufio.ScanLines to find the source range
+// for each line in the file, skipping over the actual newline characters, which
+// may be useful when printing source code snippets as part of diagnostic
+// messages.
+//
+// The line and column information in the returned ranges is produced by
+// counting newline characters and grapheme clusters respectively, which
+// mimics the behavior we expect from a parser when producing ranges.
+type RangeScanner struct {
+	filename string
+	b        []byte
+	cb       bufio.SplitFunc
+
+	pos Pos    // position of next byte to process in b
+	cur Range  // latest range
+	tok []byte // slice of b that is covered by cur
+	err error  // error from last scan, if any
+}
+
+// Create a new RangeScanner for the given buffer, producing ranges for the
+// given filename.
+//
+// Since ranges have grapheme-cluster granularity rather than byte granularity,
+// the scanner will produce incorrect results if the given SplitFunc creates
+// tokens between grapheme cluster boundaries. In particular, it is incorrect
+// to use RangeScanner with bufio.ScanRunes because it will produce tokens
+// around individual UTF-8 sequences, which will split any multi-sequence
+// grapheme clusters.
+func NewRangeScanner(b []byte, filename string, cb bufio.SplitFunc) *RangeScanner {
+	return &RangeScanner{
+		filename: filename,
+		b:        b,
+		cb:       cb,
+		pos: Pos{
+			Byte:   0,
+			Line:   1,
+			Column: 1,
+		},
+	}
+}
+
+func (sc *RangeScanner) Scan() bool {
+	if sc.pos.Byte >= len(sc.b) || sc.err != nil {
+		// All done
+		return false
+	}
+
+	// Since we're operating on an in-memory buffer, we always pass the whole
+	// remainder of the buffer to our SplitFunc and set isEOF to let it know
+	// that it has the whole thing.
+	advance, token, err := sc.cb(sc.b[sc.pos.Byte:], true)
+
+	// Since we are setting isEOF to true this should never happen, but
+	// if it does we will just abort and assume the SplitFunc is misbehaving.
+	if advance == 0 && token == nil && err == nil {
+		return false
+	}
+
+	if err != nil {
+		sc.err = err
+		sc.cur = Range{
+			Filename: sc.filename,
+			Start:    sc.pos,
+			End:      sc.pos,
+		}
+		sc.tok = nil
+		return false
+	}
+
+	sc.tok = token
+	start := sc.pos
+	end := sc.pos
+	new := sc.pos
+
+	// adv is similar to token but it also includes any subsequent characters
+	// we're being asked to skip over by the SplitFunc.
+	// adv is a slice covering any additional bytes we are skipping over, based
+	// on what the SplitFunc told us to do with advance.
+	adv := sc.b[sc.pos.Byte : sc.pos.Byte+advance]
+
+	// We now need to scan over our token to count the grapheme clusters
+	// so we can correctly advance Column, and count the newlines so we
+	// can correctly advance Line.
+	advR := bytes.NewReader(adv)
+	gsc := bufio.NewScanner(advR)
+	advanced := 0
+	gsc.Split(textseg.ScanGraphemeClusters)
+	for gsc.Scan() {
+		gr := gsc.Bytes()
+		new.Byte += len(gr)
+		new.Column++
+
+		// We rely here on the fact that \r\n is considered a grapheme cluster
+		// and so we don't need to worry about miscounting additional lines
+		// on files with Windows-style line endings.
+		if len(gr) != 0 && (gr[0] == '\r' || gr[0] == '\n') {
+			new.Column = 1
+			new.Line++
+		}
+
+		if advanced < len(token) {
+			// If we've not yet found the end of our token then we'll
+			// also push our "end" marker along.
+			// (if advance > len(token) then we'll stop moving "end" early
+			// so that the caller only sees the range covered by token.)
+			end = new
+		}
+		advanced += len(gr)
+	}
+
+	sc.cur = Range{
+		Filename: sc.filename,
+		Start:    start,
+		End:      end,
+	}
+	sc.pos = new
+	return true
+}
+
+// Range returns a range that covers the latest token obtained after a call
+// to Scan returns true.
+func (sc *RangeScanner) Range() Range {
+	return sc.cur
+}
+
+// Bytes returns the slice of the input buffer that is covered by the range
+// that would be returned by Range.
+func (sc *RangeScanner) Bytes() []byte {
+	return sc.tok
+}
+
+// Err can be called after Scan returns false to determine if the latest read
+// resulted in an error, and obtain that error if so.
+func (sc *RangeScanner) Err() error {
+	return sc.err
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/spec.md b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
index db4e9ef979..e50bd73a21 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/spec.md
+++ b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
@@ -7,7 +7,7 @@ concrete syntaxes for configuration, each with a mapping to the model defined
 in this specification.
 
 The two primary syntaxes intended for use in conjunction with this model are
-[the HCL native syntax](./zclsyntax/spec.md) and [the JSON syntax](./json/spec.md).
+[the HCL native syntax](./hclsyntax/spec.md) and [the JSON syntax](./json/spec.md).
 In principle other syntaxes are possible as long as either their language model
 is sufficiently rich to express the concepts described in this specification
 or the language targets a well-defined subset of the specification.
@@ -159,7 +159,7 @@ a computation in terms of literal values, variables, and functions.
 Each syntax defines its own representation of expressions. For syntaxes based
 in languages that do not have any non-literal expression syntax, it is
 recommended to embed the template language from
-[the native syntax](./zclsyntax/spec.md) e.g. as a post-processing step on
+[the native syntax](./hclsyntax/spec.md) e.g. as a post-processing step on
 string literals.
 
 ### Expression Evaluation
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
index 867ed425f5..24f4c91b7f 100644
--- a/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
@@ -156,6 +156,17 @@ func (t Traversal) RootName() string {
 	return t[0].(TraverseRoot).Name
 }
 
+// SourceRange returns the source range for the traversal.
+func (t Traversal) SourceRange() Range {
+	if len(t) == 0 {
+		// Nothing useful to return here, but we'll return something
+		// that's correctly-typed at least.
+		return Range{}
+	}
+
+	return RangeBetween(t[0].SourceRange(), t[len(t)-1].SourceRange())
+}
+
 // TraversalSplit represents a pair of traversals, the first of which is
 // an absolute traversal and the second of which is relative to the first.
 //
@@ -206,6 +217,7 @@ func (t TraversalSplit) RootName() string {
 // A Traverser is a step within a Traversal.
 type Traverser interface {
 	TraversalStep(cty.Value) (cty.Value, Diagnostics)
+	SourceRange() Range
 	isTraverserSigil() isTraverser
 }
 
@@ -231,6 +243,10 @@ func (tn TraverseRoot) TraversalStep(cty.Value) (cty.Value, Diagnostics) {
 	panic("Cannot traverse an absolute traversal")
 }
 
+func (tn TraverseRoot) SourceRange() Range {
+	return tn.SrcRange
+}
+
 // TraverseAttr looks up an attribute in its initial value.
 type TraverseAttr struct {
 	isTraverser
@@ -301,6 +317,10 @@ func (tn TraverseAttr) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
 	}
 }
 
+func (tn TraverseAttr) SourceRange() Range {
+	return tn.SrcRange
+}
+
 // TraverseIndex applies the index operation to its initial value.
 type TraverseIndex struct {
 	isTraverser
@@ -312,6 +332,10 @@ func (tn TraverseIndex) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
 	return Index(val, tn.Key, &tn.SrcRange)
 }
 
+func (tn TraverseIndex) SourceRange() Range {
+	return tn.SrcRange
+}
+
 // TraverseSplat applies the splat operation to its initial value.
 type TraverseSplat struct {
 	isTraverser
@@ -322,3 +346,7 @@ type TraverseSplat struct {
 func (tn TraverseSplat) TraversalStep(val cty.Value) (cty.Value, Diagnostics) {
 	panic("TraverseSplat not yet implemented")
 }
+
+func (tn TraverseSplat) SourceRange() Range {
+	return tn.SrcRange
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
new file mode 100644
index 0000000000..5f529467b1
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal_for_expr.go
@@ -0,0 +1,121 @@
+package hcl
+
+// AbsTraversalForExpr attempts to interpret the given expression as
+// an absolute traversal, or returns error diagnostic(s) if that is
+// not possible for the given expression.
+//
+// A particular Expression implementation can support this function by
+// offering a method called AsTraversal that takes no arguments and
+// returns either a valid absolute traversal or nil to indicate that
+// no traversal is possible. Alternatively, an implementation can support
+// UnwrapExpression to delegate handling of this function to a wrapped
+// Expression object.
+//
+// In most cases the calling application is interested in the value
+// that results from an expression, but in rarer cases the application
+// needs to see the the name of the variable and subsequent
+// attributes/indexes itself, for example to allow users to give references
+// to the variables themselves rather than to their values. An implementer
+// of this function should at least support attribute and index steps.
+func AbsTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
+	type asTraversal interface {
+		AsTraversal() Traversal
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(asTraversal)
+		return supported
+	})
+
+	if asT, supported := physExpr.(asTraversal); supported {
+		if traversal := asT.AsTraversal(); traversal != nil {
+			return traversal, nil
+		}
+	}
+	return nil, Diagnostics{
+		&Diagnostic{
+			Severity: DiagError,
+			Summary:  "Invalid expression",
+			Detail:   "A static variable reference is required.",
+			Subject:  expr.Range().Ptr(),
+		},
+	}
+}
+
+// RelTraversalForExpr is similar to AbsTraversalForExpr but it returns
+// a relative traversal instead. Due to the nature of HCL expressions, the
+// first element of the returned traversal is always a TraverseAttr, and
+// then it will be followed by zero or more other expressions.
+//
+// Any expression accepted by AbsTraversalForExpr is also accepted by
+// RelTraversalForExpr.
+func RelTraversalForExpr(expr Expression) (Traversal, Diagnostics) {
+	traversal, diags := AbsTraversalForExpr(expr)
+	if len(traversal) > 0 {
+		root := traversal[0].(TraverseRoot)
+		traversal[0] = TraverseAttr{
+			Name:     root.Name,
+			SrcRange: root.SrcRange,
+		}
+	}
+	return traversal, diags
+}
+
+// ExprAsKeyword attempts to interpret the given expression as a static keyword,
+// returning the keyword string if possible, and the empty string if not.
+//
+// A static keyword, for the sake of this function, is a single identifier.
+// For example, the following attribute has an expression that would produce
+// the keyword "foo":
+//
+//     example = foo
+//
+// This function is a variant of AbsTraversalForExpr, which uses the same
+// interface on the given expression. This helper constrains the result
+// further by requiring only a single root identifier.
+//
+// This function is intended to be used with the following idiom, to recognize
+// situations where one of a fixed set of keywords is required and arbitrary
+// expressions are not allowed:
+//
+//     switch hcl.ExprAsKeyword(expr) {
+//     case "allow":
+//         // (take suitable action for keyword "allow")
+//     case "deny":
+//         // (take suitable action for keyword "deny")
+//     default:
+//         diags = append(diags, &hcl.Diagnostic{
+//             // ... "invalid keyword" diagnostic message ...
+//         })
+//     }
+//
+// The above approach will generate the same message for both the use of an
+// unrecognized keyword and for not using a keyword at all, which is usually
+// reasonable if the message specifies that the given value must be a keyword
+// from that fixed list.
+//
+// Note that in the native syntax the keywords "true", "false", and "null" are
+// recognized as literal values during parsing and so these reserved words
+// cannot not be accepted as keywords by this function.
+//
+// Since interpreting an expression as a keyword bypasses usual expression
+// evaluation, it should be used sparingly for situations where e.g. one of
+// a fixed set of keywords is used in a structural way in a special attribute
+// to affect the further processing of a block.
+func ExprAsKeyword(expr Expression) string {
+	type asTraversal interface {
+		AsTraversal() Traversal
+	}
+
+	physExpr := UnwrapExpressionUntil(expr, func(expr Expression) bool {
+		_, supported := expr.(asTraversal)
+		return supported
+	})
+
+	if asT, supported := physExpr.(asTraversal); supported {
+		if traversal := asT.AsTraversal(); len(traversal) == 1 {
+			return traversal.RootName()
+		}
+	}
+	return ""
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/public.go b/vendor/github.com/hashicorp/hcl2/hcldec/public.go
index 3e58f7b3c2..5d1f10a3db 100644
--- a/vendor/github.com/hashicorp/hcl2/hcldec/public.go
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/public.go
@@ -51,3 +51,28 @@ func ImpliedType(spec Spec) cty.Type {
 func SourceRange(body hcl.Body, spec Spec) hcl.Range {
 	return sourceRange(body, nil, spec)
 }
+
+// ChildBlockTypes returns a map of all of the child block types declared
+// by the given spec, with block type names as keys and the associated
+// nested body specs as values.
+func ChildBlockTypes(spec Spec) map[string]Spec {
+	ret := map[string]Spec{}
+
+	// visitSameBodyChildren walks through the spec structure, calling
+	// the given callback for each descendent spec encountered. We are
+	// interested in the specs that reference attributes and blocks.
+	var visit visitFunc
+	visit = func(s Spec) {
+		if bs, ok := s.(blockSpec); ok {
+			for _, blockS := range bs.blockHeaderSchemata() {
+				ret[blockS.Type] = bs.nestedSpec()
+			}
+		}
+
+		s.visitSameBodyChildren(visit)
+	}
+
+	visit(spec)
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/spec.go b/vendor/github.com/hashicorp/hcl2/hcldec/spec.go
index f0e6842be0..25cafcd97b 100644
--- a/vendor/github.com/hashicorp/hcl2/hcldec/spec.go
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/spec.go
@@ -7,6 +7,7 @@ import (
 	"github.com/hashicorp/hcl2/hcl"
 	"github.com/zclconf/go-cty/cty"
 	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
 )
 
 // A Spec is a description of how to decode a hcl.Body to a cty.Value.
@@ -52,6 +53,7 @@ type attrSpec interface {
 // blockSpec is implemented by specs that require blocks from the body.
 type blockSpec interface {
 	blockHeaderSchemata() []hcl.BlockHeaderSchema
+	nestedSpec() Spec
 }
 
 // specNeedingVariables is implemented by specs that can use variables
@@ -298,6 +300,11 @@ func (s *BlockSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
 	}
 }
 
+// blockSpec implementation
+func (s *BlockSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
 // specNeedingVariables implementation
 func (s *BlockSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
 	var childBlock *hcl.Block
@@ -409,6 +416,11 @@ func (s *BlockListSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
 	}
 }
 
+// blockSpec implementation
+func (s *BlockListSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
 // specNeedingVariables implementation
 func (s *BlockListSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
 	var ret []hcl.Traversal
@@ -519,6 +531,11 @@ func (s *BlockSetSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
 	}
 }
 
+// blockSpec implementation
+func (s *BlockSetSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
 // specNeedingVariables implementation
 func (s *BlockSetSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
 	var ret []hcl.Traversal
@@ -631,6 +648,11 @@ func (s *BlockMapSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
 	}
 }
 
+// blockSpec implementation
+func (s *BlockMapSpec) nestedSpec() Spec {
+	return s.Nested
+}
+
 // specNeedingVariables implementation
 func (s *BlockMapSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
 	var ret []hcl.Traversal
@@ -857,3 +879,120 @@ func (s *DefaultSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockL
 	// reasonable source range to return anyway.
 	return s.Primary.sourceRange(content, blockLabels)
 }
+
+// TransformExprSpec is a spec that wraps another and then evaluates a given
+// hcl.Expression on the result.
+//
+// The implied type of this spec is determined by evaluating the expression
+// with an unknown value of the nested spec's implied type, which may cause
+// the result to be imprecise. This spec should not be used in situations where
+// precise result type information is needed.
+type TransformExprSpec struct {
+	Wrapped      Spec
+	Expr         hcl.Expression
+	TransformCtx *hcl.EvalContext
+	VarName      string
+}
+
+func (s *TransformExprSpec) visitSameBodyChildren(cb visitFunc) {
+	cb(s.Wrapped)
+}
+
+func (s *TransformExprSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	wrappedVal, diags := s.Wrapped.decode(content, blockLabels, ctx)
+	if diags.HasErrors() {
+		// We won't try to run our function in this case, because it'll probably
+		// generate confusing additional errors that will distract from the
+		// root cause.
+		return cty.UnknownVal(s.impliedType()), diags
+	}
+
+	chiCtx := s.TransformCtx.NewChild()
+	chiCtx.Variables = map[string]cty.Value{
+		s.VarName: wrappedVal,
+	}
+	resultVal, resultDiags := s.Expr.Value(chiCtx)
+	diags = append(diags, resultDiags...)
+	return resultVal, diags
+}
+
+func (s *TransformExprSpec) impliedType() cty.Type {
+	wrappedTy := s.Wrapped.impliedType()
+	chiCtx := s.TransformCtx.NewChild()
+	chiCtx.Variables = map[string]cty.Value{
+		s.VarName: cty.UnknownVal(wrappedTy),
+	}
+	resultVal, _ := s.Expr.Value(chiCtx)
+	return resultVal.Type()
+}
+
+func (s *TransformExprSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We'll just pass through our wrapped range here, even though that's
+	// not super-accurate, because there's nothing better to return.
+	return s.Wrapped.sourceRange(content, blockLabels)
+}
+
+// TransformFuncSpec is a spec that wraps another and then evaluates a given
+// cty function with the result. The given function must expect exactly one
+// argument, where the result of the wrapped spec will be passed.
+//
+// The implied type of this spec is determined by type-checking the function
+// with an unknown value of the nested spec's implied type, which may cause
+// the result to be imprecise. This spec should not be used in situations where
+// precise result type information is needed.
+//
+// If the given function produces an error when run, this spec will produce
+// a non-user-actionable diagnostic message. It's the caller's responsibility
+// to ensure that the given function cannot fail for any non-error result
+// of the wrapped spec.
+type TransformFuncSpec struct {
+	Wrapped Spec
+	Func    function.Function
+}
+
+func (s *TransformFuncSpec) visitSameBodyChildren(cb visitFunc) {
+	cb(s.Wrapped)
+}
+
+func (s *TransformFuncSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	wrappedVal, diags := s.Wrapped.decode(content, blockLabels, ctx)
+	if diags.HasErrors() {
+		// We won't try to run our function in this case, because it'll probably
+		// generate confusing additional errors that will distract from the
+		// root cause.
+		return cty.UnknownVal(s.impliedType()), diags
+	}
+
+	resultVal, err := s.Func.Call([]cty.Value{wrappedVal})
+	if err != nil {
+		// This is not a good example of a diagnostic because it is reporting
+		// a programming error in the calling application, rather than something
+		// an end-user could act on.
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Transform function failed",
+			Detail:   fmt.Sprintf("Decoder transform returned an error: %s", err),
+			Subject:  s.sourceRange(content, blockLabels).Ptr(),
+		})
+		return cty.UnknownVal(s.impliedType()), diags
+	}
+
+	return resultVal, diags
+}
+
+func (s *TransformFuncSpec) impliedType() cty.Type {
+	wrappedTy := s.Wrapped.impliedType()
+	resultTy, err := s.Func.ReturnType([]cty.Type{wrappedTy})
+	if err != nil {
+		// Should never happen with a correctly-configured spec
+		return cty.DynamicPseudoType
+	}
+
+	return resultTy
+}
+
+func (s *TransformFuncSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We'll just pass through our wrapped range here, even though that's
+	// not super-accurate, because there's nothing better to return.
+	return s.Wrapped.sourceRange(content, blockLabels)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcltest/mock.go b/vendor/github.com/hashicorp/hcl2/hcltest/mock.go
index a886bed8ea..510fc2497f 100644
--- a/vendor/github.com/hashicorp/hcl2/hcltest/mock.go
+++ b/vendor/github.com/hashicorp/hcl2/hcltest/mock.go
@@ -3,13 +3,15 @@ package hcltest
 import (
 	"fmt"
 
+	"github.com/hashicorp/hcl2/hcl/hclsyntax"
+
 	"github.com/hashicorp/hcl2/hcl"
 	"github.com/zclconf/go-cty/cty"
 )
 
 // MockBody returns a hcl.Body implementation that works in terms of a
 // caller-constructed hcl.BodyContent, thus avoiding the need to parse
-// a "real" zcl config file to use as input to a test.
+// a "real" HCL config file to use as input to a test.
 func MockBody(content *hcl.BodyContent) hcl.Body {
 	return mockBody{content}
 }
@@ -149,6 +151,21 @@ func (e mockExprLiteral) StartRange() hcl.Range {
 	return e.Range()
 }
 
+// Implementation for hcl.ExprList
+func (e mockExprLiteral) ExprList() []hcl.Expression {
+	v := e.V
+	ty := v.Type()
+	if v.IsKnown() && !v.IsNull() && (ty.IsListType() || ty.IsTupleType()) {
+		ret := make([]hcl.Expression, 0, v.LengthInt())
+		for it := v.ElementIterator(); it.Next(); {
+			_, v := it.Element()
+			ret = append(ret, MockExprLiteral(v))
+		}
+		return ret
+	}
+	return nil
+}
+
 // MockExprVariable returns a hcl.Expression that evaluates to the value of
 // the variable with the given name.
 func MockExprVariable(name string) hcl.Expression {
@@ -197,6 +214,111 @@ func (e mockExprVariable) StartRange() hcl.Range {
 	return e.Range()
 }
 
+// Implementation for hcl.AbsTraversalForExpr and hcl.RelTraversalForExpr.
+func (e mockExprVariable) AsTraversal() hcl.Traversal {
+	return hcl.Traversal{
+		hcl.TraverseRoot{
+			Name:     string(e),
+			SrcRange: e.Range(),
+		},
+	}
+}
+
+// MockExprTraversal returns a hcl.Expression that evaluates the given
+// absolute traversal.
+func MockExprTraversal(traversal hcl.Traversal) hcl.Expression {
+	return mockExprTraversal{
+		Traversal: traversal,
+	}
+}
+
+// MockExprTraversalSrc is like MockExprTraversal except it takes a
+// traversal string as defined by the native syntax and parses it first.
+//
+// This method is primarily for testing with hard-coded traversal strings, so
+// it will panic if the given string is not syntactically correct.
+func MockExprTraversalSrc(src string) hcl.Expression {
+	traversal, diags := hclsyntax.ParseTraversalAbs([]byte(src), "MockExprTraversal", hcl.Pos{})
+	if diags.HasErrors() {
+		panic("invalid traversal string")
+	}
+	return MockExprTraversal(traversal)
+}
+
+type mockExprTraversal struct {
+	Traversal hcl.Traversal
+}
+
+func (e mockExprTraversal) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return e.Traversal.TraverseAbs(ctx)
+}
+
+func (e mockExprTraversal) Variables() []hcl.Traversal {
+	return []hcl.Traversal{e.Traversal}
+}
+
+func (e mockExprTraversal) Range() hcl.Range {
+	return e.Traversal.SourceRange()
+}
+
+func (e mockExprTraversal) StartRange() hcl.Range {
+	return e.Range()
+}
+
+// Implementation for hcl.AbsTraversalForExpr and hcl.RelTraversalForExpr.
+func (e mockExprTraversal) AsTraversal() hcl.Traversal {
+	return e.Traversal
+}
+
+func MockExprList(exprs []hcl.Expression) hcl.Expression {
+	return mockExprList{
+		Exprs: exprs,
+	}
+}
+
+type mockExprList struct {
+	Exprs []hcl.Expression
+}
+
+func (e mockExprList) Value(ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	if len(e.Exprs) == 0 {
+		return cty.ListValEmpty(cty.DynamicPseudoType), nil
+	}
+	vals := make([]cty.Value, 0, len(e.Exprs))
+	var diags hcl.Diagnostics
+
+	for _, expr := range e.Exprs {
+		val, valDiags := expr.Value(ctx)
+		diags = append(diags, valDiags...)
+		vals = append(vals, val)
+	}
+
+	return cty.ListVal(vals), diags
+}
+
+func (e mockExprList) Variables() []hcl.Traversal {
+	var traversals []hcl.Traversal
+	for _, expr := range e.Exprs {
+		traversals = append(traversals, expr.Variables()...)
+	}
+	return traversals
+}
+
+func (e mockExprList) Range() hcl.Range {
+	return hcl.Range{
+		Filename: "MockExprList",
+	}
+}
+
+func (e mockExprList) StartRange() hcl.Range {
+	return e.Range()
+}
+
+// Implementation for hcl.ExprList
+func (e mockExprList) ExprList() []hcl.Expression {
+	return e.Exprs
+}
+
 // MockAttrs constructs and returns a hcl.Attributes map with attributes
 // derived from the given expression map.
 //
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go b/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go
index 35c746bd6d..19d00703c0 100644
--- a/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/ast.go
@@ -82,7 +82,7 @@ func (n *Body) AppendUnstructuredTokens(seq *TokenSeq) {
 // given name, or returns nil if there is currently no matching attribute.
 //
 // A valid AST has only one definition of each attribute, but that constraint
-// is not enforced in the zclwrite AST, so a tree that has been mutated by
+// is not enforced in the hclwrite AST, so a tree that has been mutated by
 // other calls may contain additional matching attributes that cannot be seen
 // by this method.
 func (n *Body) FindAttribute(name string) *Attribute {
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
index 1ccc78f5f5..64f161dab7 100644
--- a/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/format.go
@@ -49,7 +49,7 @@ func formatIndent(lines []formatLine) {
 
 	// We'll start our indent stack at a reasonable capacity to minimize the
 	// chance of us needing to grow it; 10 here means 10 levels of indent,
-	// which should be more than enough for reasonable zcl uses.
+	// which should be more than enough for reasonable HCL uses.
 	indents := make([]int, 0, 10)
 
 	for i := range lines {
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go b/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go
index 72802d311c..4a4851adc9 100644
--- a/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/parser.go
@@ -3,18 +3,18 @@ package hclwrite
 import (
 	"sort"
 
-	"github.com/hashicorp/hcl2/hcl/hclsyntax"
 	"github.com/hashicorp/hcl2/hcl"
+	"github.com/hashicorp/hcl2/hcl/hclsyntax"
 )
 
 // Our "parser" here is actually not doing any parsing of its own. Instead,
-// it leans on the native parser in zclsyntax, and then uses the source ranges
+// it leans on the native parser in hclsyntax, and then uses the source ranges
 // from the AST to partition the raw token sequence to match the raw tokens
 // up to AST nodes.
 //
 // This strategy feels somewhat counter-intuitive, since most of the work the
 // parser does is thrown away here, but this strategy is chosen because the
-// normal parsing work done by zclsyntax is considered to be the "main case",
+// normal parsing work done by hclsyntax is considered to be the "main case",
 // while modifying and re-printing source is more of an edge case, used only
 // in ancillary tools, and so it's good to keep all the main parsing logic
 // with the main case but keep all of the extra complexity of token wrangling
@@ -30,7 +30,7 @@ func parse(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics)
 		return nil, diags
 	}
 
-	// To do our work here, we use the "native" tokens (those from zclsyntax)
+	// To do our work here, we use the "native" tokens (those from hclsyntax)
 	// to match against source ranges in the AST, but ultimately produce
 	// slices from our sequence of "writer" tokens, which contain only
 	// *relative* position information that is more appropriate for
@@ -333,7 +333,7 @@ func parseExpression(nativeExpr hclsyntax.Expression, from inputTokens) *Express
 	}
 }
 
-// writerTokens takes a sequence of tokens as produced by the main zclsyntax
+// writerTokens takes a sequence of tokens as produced by the main hclsyntax
 // package and transforms it into an equivalent sequence of tokens using
 // this package's own token model.
 //
@@ -389,7 +389,7 @@ func writerTokens(nativeTokens hclsyntax.Tokens) Tokens {
 // true then it will make a best effort that may produce strange results at
 // the boundaries.
 //
-// Native zclsyntax tokens are used here, because they contain the necessary
+// Native hclsyntax tokens are used here, because they contain the necessary
 // absolute position information. However, since writerTokens produces a
 // correlatable sequence of writer tokens, the resulting indices can be
 // used also to index into its result, allowing the partitioning of writer
@@ -488,7 +488,7 @@ func partitionLineEndTokens(toks hclsyntax.Tokens) (afterComment, afterNewline i
 	return len(toks), len(toks)
 }
 
-// lexConfig uses the zclsyntax scanner to get a token stream and then
+// lexConfig uses the hclsyntax scanner to get a token stream and then
 // rewrites it into this package's token model.
 //
 // Any errors produced during scanning are ignored, so the results of this
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/public.go b/vendor/github.com/hashicorp/hcl2/hclwrite/public.go
index ee2d920446..d9b0dd5aa9 100644
--- a/vendor/github.com/hashicorp/hcl2/hclwrite/public.go
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/public.go
@@ -6,7 +6,7 @@ import (
 	"github.com/hashicorp/hcl2/hcl"
 )
 
-// ParseConfig interprets the given source bytes into a *zclwrite.File. The
+// ParseConfig interprets the given source bytes into a *hclwrite.File. The
 // resulting AST can be used to perform surgical edits on the source code
 // before turning it back into bytes again.
 func ParseConfig(src []byte, filename string, start hcl.Pos) (*File, hcl.Diagnostics) {
diff --git a/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go b/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go
index 18689ea47a..8fb87f2529 100644
--- a/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go
+++ b/vendor/github.com/hashicorp/hcl2/hclwrite/tokens.go
@@ -9,7 +9,7 @@ import (
 )
 
 // TokenGen is an abstract type that can append tokens to a list. It is the
-// low-level foundation underlying the zclwrite AST; the AST provides a
+// low-level foundation underlying the hclwrite AST; the AST provides a
 // convenient abstraction over raw token sequences to facilitate common tasks,
 // but it's also possible to directly manipulate the tree of token generators
 // to make changes that the AST API doesn't directly allow.
@@ -22,7 +22,7 @@ type TokenGen interface {
 type TokenCallback func(*Token)
 
 // Token is a single sequence of bytes annotated with a type. It is similar
-// in purpose to zclsyntax.Token, but discards the source position information
+// in purpose to hclsyntax.Token, but discards the source position information
 // since that is not useful in code generation.
 type Token struct {
 	Type  hclsyntax.TokenType
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 0a9fdf2639..3465886dd1 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -1697,56 +1697,56 @@
 		{
 			"checksumSHA1": "6kxMiZSmgazD/CZgmnEeEMJSAOM=",
 			"path": "github.com/hashicorp/hcl2/gohcl",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
-			"checksumSHA1": "TsNlThzf92FMwcnM4Fc0mArHroU=",
+			"checksumSHA1": "l2zkxDVi2EUwFdvsVcIfyuOr4zo=",
 			"path": "github.com/hashicorp/hcl2/hcl",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
-			"checksumSHA1": "+Dv8V2cfl7Vy6rUklhXj5Cli8aU=",
+			"checksumSHA1": "iLOUzHOej23ORpmbXAndg5Ft5H0=",
 			"path": "github.com/hashicorp/hcl2/hcl/hclsyntax",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
-			"checksumSHA1": "GAArMzjaoFNPa7HFnhjZmaeBZII=",
+			"checksumSHA1": "O8jJfHiwuQFmAo0ivcBhni4pWyg=",
 			"path": "github.com/hashicorp/hcl2/hcl/json",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
-			"checksumSHA1": "u6YPoPz3GflgHb1dN1YN8nCWAXY=",
+			"checksumSHA1": "672O/GQ9z+OFsG3eHLKq1yg3ZGM=",
 			"path": "github.com/hashicorp/hcl2/hcldec",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
 			"checksumSHA1": "sySYF9Ew71VS/LfrG+s/0jK+1VQ=",
 			"path": "github.com/hashicorp/hcl2/hcled",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
 			"checksumSHA1": "IzmftuG99BqNhbFGhxZaGwtiMtM=",
 			"path": "github.com/hashicorp/hcl2/hclparse",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
-			"checksumSHA1": "4supppf3CMdAEUEDrXP8niXvAR0=",
+			"checksumSHA1": "v5qx2XghQ+EtvFLa4a0Efjiwt9I=",
 			"path": "github.com/hashicorp/hcl2/hcltest",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
-			"checksumSHA1": "p+dun/Fx4beswXTtoEjVnwDJE+Y=",
+			"checksumSHA1": "9UCSLRG+TEAsNKOZJUaJj/7d6r8=",
 			"path": "github.com/hashicorp/hcl2/hclwrite",
-			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
-			"revisionTime": "2017-10-03T23:27:34Z"
+			"revision": "5ca9713bf06addcefc0a4e16f779e43a2c88570c",
+			"revisionTime": "2018-02-05T02:55:09Z"
 		},
 		{
 			"checksumSHA1": "M09yxoBoCEtG7EcHR8aEWLzMMJc=",