Update dependencies

vendor/github.com/rogpeppe/go-internal/fmtsort/mapelem.go

@@ -1,3 +1,6 @@
+//go:build go1.12
+// +build go1.12
+
 package fmtsort
 
 import "reflect"

vendor/github.com/rogpeppe/go-internal/fmtsort/mapelem_1.11.go

@@ -0,0 +1,24 @@
+//go:build !go1.12
+// +build !go1.12
+
+package fmtsort
+
+import "reflect"
+
+const brokenNaNs = true
+
+func mapElems(mapValue reflect.Value) ([]reflect.Value, []reflect.Value) {
+	key := mapValue.MapKeys()
+	value := make([]reflect.Value, 0, len(key))
+	for _, k := range key {
+		v := mapValue.MapIndex(k)
+		if !v.IsValid() {
+			// Note: we can't retrieve the value, probably because
+			// the key is NaN, so just do the best we can and
+			// add a zero value of the correct type in that case.
+			v = reflect.Zero(mapValue.Type().Elem())
+		}
+		value = append(value, v)
+	}
+	return key, value
+}

vendor/github.com/rogpeppe/go-internal/fmtsort/sort.go

@@ -36,18 +36,19 @@ func (o *SortedMap) Swap(i, j int) {
 //
 // The ordering rules are more general than with Go's < operator:
 //
-//   - when applicable, nil compares low
-//   - ints, floats, and strings order by <
-//   - NaN compares less than non-NaN floats
-//   - bool compares false before true
-//   - complex compares real, then imag
-//   - pointers compare by machine address
-//   - channel values compare by machine address
-//   - structs compare each field in turn
-//   - arrays compare each element in turn.
-//     Otherwise identical arrays compare by length.
-//   - interface values compare first by reflect.Type describing the concrete type
-//     and then by concrete value as described in the previous rules.
+//  - when applicable, nil compares low
+//  - ints, floats, and strings order by <
+//  - NaN compares less than non-NaN floats
+//  - bool compares false before true
+//  - complex compares real, then imag
+//  - pointers compare by machine address
+//  - channel values compare by machine address
+//  - structs compare each field in turn
+//  - arrays compare each element in turn.
+//    Otherwise identical arrays compare by length.
+//  - interface values compare first by reflect.Type describing the concrete type
+//    and then by concrete value as described in the previous rules.
+//
 func Sort(mapValue reflect.Value) *SortedMap {
 	if mapValue.Type().Kind() != reflect.Map {
 		return nil
@@ -143,14 +144,14 @@ func compare(aVal, bVal reflect.Value) int {
 			return 0
 		}
 	case reflect.Struct:
-		for i := range aVal.NumField() {
+		for i := 0; i < aVal.NumField(); i++ {
 			if c := compare(aVal.Field(i), bVal.Field(i)); c != 0 {
 				return c
 			}
 		}
 		return 0
 	case reflect.Array:
-		for i := range aVal.Len() {
+		for i := 0; i < aVal.Len(); i++ {
 			if c := compare(aVal.Index(i), bVal.Index(i)); c != 0 {
 				return c
 			}