--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vendor/github.com/pelletier/go-toml/v2/internal/ast/ast.go	Tue Aug 23 22:39:43 2022 +0200
@@ -0,0 +1,144 @@
+package ast
+
+import (
+	"fmt"
+	"unsafe"
+
+	"github.com/pelletier/go-toml/v2/internal/danger"
+)
+
+// Iterator starts uninitialized, you need to call Next() first.
+//
+// For example:
+//
+//	it := n.Children()
+//	for it.Next() {
+//			it.Node()
+//	}
+type Iterator struct {
+	started bool
+	node    *Node
+}
+
+// Next moves the iterator forward and returns true if points to a
+// node, false otherwise.
+func (c *Iterator) Next() bool {
+	if !c.started {
+		c.started = true
+	} else if c.node.Valid() {
+		c.node = c.node.Next()
+	}
+	return c.node.Valid()
+}
+
+// IsLast returns true if the current node of the iterator is the last
+// one.  Subsequent call to Next() will return false.
+func (c *Iterator) IsLast() bool {
+	return c.node.next == 0
+}
+
+// Node returns a copy of the node pointed at by the iterator.
+func (c *Iterator) Node() *Node {
+	return c.node
+}
+
+// Root contains a full AST.
+//
+// It is immutable once constructed with Builder.
+type Root struct {
+	nodes []Node
+}
+
+// Iterator over the top level nodes.
+func (r *Root) Iterator() Iterator {
+	it := Iterator{}
+	if len(r.nodes) > 0 {
+		it.node = &r.nodes[0]
+	}
+	return it
+}
+
+func (r *Root) at(idx Reference) *Node {
+	return &r.nodes[idx]
+}
+
+// Arrays have one child per element in the array.  InlineTables have
+// one child per key-value pair in the table.  KeyValues have at least
+// two children. The first one is the value. The rest make a
+// potentially dotted key.  Table and Array table have one child per
+// element of the key they represent (same as KeyValue, but without
+// the last node being the value).
+type Node struct {
+	Kind Kind
+	Raw  Range  // Raw bytes from the input.
+	Data []byte // Node value (either allocated or referencing the input).
+
+	// References to other nodes, as offsets in the backing array
+	// from this node. References can go backward, so those can be
+	// negative.
+	next  int // 0 if last element
+	child int // 0 if no child
+}
+
+type Range struct {
+	Offset uint32
+	Length uint32
+}
+
+// Next returns a copy of the next node, or an invalid Node if there
+// is no next node.
+func (n *Node) Next() *Node {
+	if n.next == 0 {
+		return nil
+	}
+	ptr := unsafe.Pointer(n)
+	size := unsafe.Sizeof(Node{})
+	return (*Node)(danger.Stride(ptr, size, n.next))
+}
+
+// Child returns a copy of the first child node of this node. Other
+// children can be accessed calling Next on the first child.  Returns
+// an invalid Node if there is none.
+func (n *Node) Child() *Node {
+	if n.child == 0 {
+		return nil
+	}
+	ptr := unsafe.Pointer(n)
+	size := unsafe.Sizeof(Node{})
+	return (*Node)(danger.Stride(ptr, size, n.child))
+}
+
+// Valid returns true if the node's kind is set (not to Invalid).
+func (n *Node) Valid() bool {
+	return n != nil
+}
+
+// Key returns the child nodes making the Key on a supported
+// node. Panics otherwise.  They are guaranteed to be all be of the
+// Kind Key. A simple key would return just one element.
+func (n *Node) Key() Iterator {
+	switch n.Kind {
+	case KeyValue:
+		value := n.Child()
+		if !value.Valid() {
+			panic(fmt.Errorf("KeyValue should have at least two children"))
+		}
+		return Iterator{node: value.Next()}
+	case Table, ArrayTable:
+		return Iterator{node: n.Child()}
+	default:
+		panic(fmt.Errorf("Key() is not supported on a %s", n.Kind))
+	}
+}
+
+// Value returns a pointer to the value node of a KeyValue.
+// Guaranteed to be non-nil.  Panics if not called on a KeyValue node,
+// or if the Children are malformed.
+func (n *Node) Value() *Node {
+	return n.Child()
+}
+
+// Children returns an iterator over a node's children.
+func (n *Node) Children() Iterator {
+	return Iterator{node: n.Child()}
+}