build(deps): bump github.com/shamaton/msgpack/v2 from 2.1.1 to 2.2.0

Bumps [github.com/shamaton/msgpack/v2](https://github.com/shamaton/msgpack) from 2.1.1 to 2.2.0.
- [Release notes](https://github.com/shamaton/msgpack/releases)
- [Commits](https://github.com/shamaton/msgpack/compare/v2.1.1...v2.2.0)

---
updated-dependencies:
- dependency-name: github.com/shamaton/msgpack/v2
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/bool.go

@@ -0,0 +1,10 @@
+package encoding
+
+import "github.com/shamaton/msgpack/v2/def"
+
+func (e *encoder) writeBool(v bool) error {
+	if v {
+		return e.setByte1Int(def.True)
+	}
+	return e.setByte1Int(def.False)
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/byte.go

@@ -0,0 +1,40 @@
+package encoding
+
+import (
+	"math"
+	"reflect"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+var typeByte = reflect.TypeOf(byte(0))
+
+func (e *encoder) isByteSlice(rv reflect.Value) bool {
+	return rv.Type().Elem() == typeByte
+}
+
+func (e *encoder) writeByteSliceLength(l int) error {
+	if l <= math.MaxUint8 {
+		if err := e.setByte1Int(def.Bin8); err != nil {
+			return err
+		}
+		if err := e.setByte1Int(l); err != nil {
+			return err
+		}
+	} else if l <= math.MaxUint16 {
+		if err := e.setByte1Int(def.Bin16); err != nil {
+			return err
+		}
+		if err := e.setByte2Int(l); err != nil {
+			return err
+		}
+	} else if uint(l) <= math.MaxUint32 {
+		if err := e.setByte1Int(def.Bin32); err != nil {
+			return err
+		}
+		if err := e.setByte4Int(l); err != nil {
+			return err
+		}
+	}
+	return nil
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/complex.go

@@ -0,0 +1,39 @@
+package encoding
+
+import (
+	"math"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+func (e *encoder) writeComplex64(v complex64) error {
+	if err := e.setByte1Int(def.Fixext8); err != nil {
+		return err
+	}
+	if err := e.setByte1Int(int(def.ComplexTypeCode())); err != nil {
+		return err
+	}
+	if err := e.setByte4Uint64(uint64(math.Float32bits(real(v)))); err != nil {
+		return err
+	}
+	if err := e.setByte4Uint64(uint64(math.Float32bits(imag(v)))); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (e *encoder) writeComplex128(v complex128) error {
+	if err := e.setByte1Int(def.Fixext16); err != nil {
+		return err
+	}
+	if err := e.setByte1Int(int(def.ComplexTypeCode())); err != nil {
+		return err
+	}
+	if err := e.setByte8Uint64(math.Float64bits(real(v))); err != nil {
+		return err
+	}
+	if err := e.setByte8Uint64(math.Float64bits(imag(v))); err != nil {
+		return err
+	}
+	return nil
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/encoding.go

@@ -0,0 +1,194 @@
+package encoding
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+
+	"github.com/shamaton/msgpack/v2/internal/common"
+)
+
+type encoder struct {
+	w       io.Writer
+	asArray bool
+	buf     *common.Buffer
+	common.Common
+}
+
+// Encode writes MessagePack-encoded byte array of v to writer.
+func Encode(w io.Writer, v any, asArray bool) error {
+	e := encoder{
+		w:       w,
+		buf:     common.GetBuffer(),
+		asArray: asArray,
+	}
+
+	rv := reflect.ValueOf(v)
+	if rv.Kind() == reflect.Ptr {
+		rv = rv.Elem()
+		if rv.Kind() == reflect.Ptr {
+			rv = rv.Elem()
+		}
+	}
+
+	err := e.create(rv)
+	if err == nil {
+		err = e.buf.Flush(e.w)
+	}
+	common.PutBuffer(e.buf)
+	return err
+}
+
+func (e *encoder) create(rv reflect.Value) error {
+
+	switch rv.Kind() {
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		v := rv.Uint()
+		return e.writeUint(v)
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		v := rv.Int()
+		return e.writeInt(v)
+
+	case reflect.Float32:
+		return e.writeFloat32(rv.Float())
+
+	case reflect.Float64:
+		return e.writeFloat64(rv.Float())
+
+	case reflect.Bool:
+		return e.writeBool(rv.Bool())
+
+	case reflect.String:
+		return e.writeString(rv.String())
+
+	case reflect.Complex64:
+		return e.writeComplex64(complex64(rv.Complex()))
+
+	case reflect.Complex128:
+		return e.writeComplex128(rv.Complex())
+
+	case reflect.Slice:
+		if rv.IsNil() {
+			return e.writeNil()
+		}
+		l := rv.Len()
+		// bin format
+		if e.isByteSlice(rv) {
+			if err := e.writeByteSliceLength(l); err != nil {
+				return err
+			}
+			return e.setBytes(rv.Bytes())
+		}
+
+		// format
+		if err := e.writeSliceLength(l); err != nil {
+			return err
+		}
+
+		if find, err := e.writeFixedSlice(rv); err != nil {
+			return err
+		} else if find {
+			return nil
+		}
+
+		// func
+		elem := rv.Type().Elem()
+		var f structWriteFunc
+		if elem.Kind() == reflect.Struct {
+			f = e.getStructWriter(elem)
+		} else {
+			f = e.create
+		}
+
+		// objects
+		for i := 0; i < l; i++ {
+			if err := f(rv.Index(i)); err != nil {
+				return err
+			}
+		}
+
+	case reflect.Array:
+		l := rv.Len()
+		// bin format
+		if e.isByteSlice(rv) {
+			if err := e.writeByteSliceLength(l); err != nil {
+				return err
+			}
+			// objects
+			for i := 0; i < l; i++ {
+				if err := e.setByte1Uint64(rv.Index(i).Uint()); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+
+		// format
+		if err := e.writeSliceLength(l); err != nil {
+			return err
+		}
+
+		// func
+		elem := rv.Type().Elem()
+		var f structWriteFunc
+		if elem.Kind() == reflect.Struct {
+			f = e.getStructWriter(elem)
+		} else {
+			f = e.create
+		}
+
+		// objects
+		for i := 0; i < l; i++ {
+			if err := f(rv.Index(i)); err != nil {
+				return err
+			}
+		}
+
+	case reflect.Map:
+		if rv.IsNil() {
+			return e.writeNil()
+		}
+
+		l := rv.Len()
+		if err := e.writeMapLength(l); err != nil {
+			return err
+		}
+
+		if find, err := e.writeFixedMap(rv); err != nil {
+			return err
+		} else if find {
+			return nil
+		}
+
+		// key-value
+		keys := rv.MapKeys()
+		for _, k := range keys {
+			if err := e.create(k); err != nil {
+				return err
+			}
+			if err := e.create(rv.MapIndex(k)); err != nil {
+				return err
+			}
+		}
+
+	case reflect.Struct:
+		return e.writeStruct(rv)
+
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return e.writeNil()
+		}
+
+		return e.create(rv.Elem())
+
+	case reflect.Interface:
+		return e.create(rv.Elem())
+
+	case reflect.Invalid:
+		return e.writeNil()
+	default:
+		return fmt.Errorf("type(%v) is unsupported", rv.Kind())
+	}
+	return nil
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/ext.go

@@ -0,0 +1,48 @@
+package encoding
+
+import (
+	"reflect"
+
+	"github.com/shamaton/msgpack/v2/ext"
+	"github.com/shamaton/msgpack/v2/time"
+)
+
+var extCoderMap = map[reflect.Type]ext.StreamEncoder{time.StreamEncoder.Type(): time.StreamEncoder}
+var extCoders = []ext.StreamEncoder{time.StreamEncoder}
+
+// AddExtEncoder adds encoders for extension types.
+func AddExtEncoder(f ext.StreamEncoder) {
+	// ignore time
+	if f.Type() == time.Encoder.Type() {
+		return
+	}
+
+	_, ok := extCoderMap[f.Type()]
+	if !ok {
+		extCoderMap[f.Type()] = f
+		updateExtCoders()
+	}
+}
+
+// RemoveExtEncoder removes encoders for extension types.
+func RemoveExtEncoder(f ext.StreamEncoder) {
+	// ignore time
+	if f.Type() == time.Encoder.Type() {
+		return
+	}
+
+	_, ok := extCoderMap[f.Type()]
+	if ok {
+		delete(extCoderMap, f.Type())
+		updateExtCoders()
+	}
+}
+
+func updateExtCoders() {
+	extCoders = make([]ext.StreamEncoder, len(extCoderMap))
+	i := 0
+	for k := range extCoderMap {
+		extCoders[i] = extCoderMap[k]
+		i++
+	}
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/float.go

@@ -0,0 +1,27 @@
+package encoding
+
+import (
+	"math"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+func (e *encoder) writeFloat32(v float64) error {
+	if err := e.setByte1Int(def.Float32); err != nil {
+		return err
+	}
+	if err := e.setByte4Uint64(uint64(math.Float32bits(float32(v)))); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (e *encoder) writeFloat64(v float64) error {
+	if err := e.setByte1Int(def.Float64); err != nil {
+		return err
+	}
+	if err := e.setByte8Uint64(math.Float64bits(v)); err != nil {
+		return err
+	}
+	return nil
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/int.go

@@ -0,0 +1,52 @@
+package encoding
+
+import (
+	"math"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+func (e *encoder) isNegativeFixInt64(v int64) bool {
+	return def.NegativeFixintMin <= v && v <= def.NegativeFixintMax
+}
+
+func (e *encoder) writeInt(v int64) error {
+	if v >= 0 {
+		if err := e.writeUint(uint64(v)); err != nil {
+			return err
+		}
+	} else if e.isNegativeFixInt64(v) {
+		if err := e.setByte1Int64(v); err != nil {
+			return err
+		}
+	} else if v >= math.MinInt8 {
+		if err := e.setByte1Int(def.Int8); err != nil {
+			return err
+		}
+		if err := e.setByte1Int64(v); err != nil {
+			return err
+		}
+	} else if v >= math.MinInt16 {
+		if err := e.setByte1Int(def.Int16); err != nil {
+			return err
+		}
+		if err := e.setByte2Int64(v); err != nil {
+			return err
+		}
+	} else if v >= math.MinInt32 {
+		if err := e.setByte1Int(def.Int32); err != nil {
+			return err
+		}
+		if err := e.setByte4Int64(v); err != nil {
+			return err
+		}
+	} else {
+		if err := e.setByte1Int(def.Int64); err != nil {
+			return err
+		}
+		if err := e.setByte8Int64(v); err != nil {
+			return err
+		}
+	}
+	return nil
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/map.go

@@ -0,0 +1,433 @@
+package encoding
+
+import (
+	"math"
+	"reflect"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+func (e *encoder) writeMapLength(l int) error {
+
+	// format
+	if l <= 0x0f {
+		if err := e.setByte1Int(def.FixMap + l); err != nil {
+			return err
+		}
+	} else if l <= math.MaxUint16 {
+		if err := e.setByte1Int(def.Map16); err != nil {
+			return err
+		}
+		if err := e.setByte2Int(l); err != nil {
+			return err
+		}
+	} else if uint(l) <= math.MaxUint32 {
+		if err := e.setByte1Int(def.Map32); err != nil {
+			return err
+		}
+		if err := e.setByte4Int(l); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (e *encoder) writeFixedMap(rv reflect.Value) (bool, error) {
+	switch m := rv.Interface().(type) {
+	case map[string]int:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[string]uint:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[string]float32:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeFloat32(float64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[string]float64:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeFloat64(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[string]bool:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[string]string:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[string]int8:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[string]int16:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[string]int32:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[string]int64:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[string]uint8:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[string]uint16:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[string]uint32:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[string]uint64:
+		for k, v := range m {
+			if err := e.writeString(k); err != nil {
+				return false, err
+			}
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[int]string:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int]bool:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[uint]string:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint]bool:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[float32]string:
+		for k, v := range m {
+			if err := e.writeFloat32(float64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[float32]bool:
+		for k, v := range m {
+			if err := e.writeFloat32(float64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[float64]string:
+		for k, v := range m {
+			if err := e.writeFloat64(k); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[float64]bool:
+		for k, v := range m {
+			if err := e.writeFloat64(k); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[int8]string:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int8]bool:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int16]string:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int16]bool:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int32]string:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int32]bool:
+		for k, v := range m {
+			if err := e.writeInt(int64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int64]string:
+		for k, v := range m {
+			if err := e.writeInt(k); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[int64]bool:
+		for k, v := range m {
+			if err := e.writeInt(k); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case map[uint8]string:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint8]bool:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint16]string:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint16]bool:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint32]string:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint32]bool:
+		for k, v := range m {
+			if err := e.writeUint(uint64(k)); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint64]string:
+		for k, v := range m {
+			if err := e.writeUint(k); err != nil {
+				return false, err
+			}
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	case map[uint64]bool:
+		for k, v := range m {
+			if err := e.writeUint(k); err != nil {
+				return false, err
+			}
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	}
+	return false, nil
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/nil.go

@@ -0,0 +1,7 @@
+package encoding
+
+import "github.com/shamaton/msgpack/v2/def"
+
+func (e *encoder) writeNil() error {
+	return e.setByte1Int(def.Nil)
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/set.go

@@ -0,0 +1,93 @@
+package encoding
+
+func (e *encoder) setByte1Int64(value int64) error {
+	return e.buf.Write(e.w, byte(value))
+}
+
+func (e *encoder) setByte2Int64(value int64) error {
+	return e.buf.Write(e.w,
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte4Int64(value int64) error {
+	return e.buf.Write(e.w,
+		byte(value>>24),
+		byte(value>>16),
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte8Int64(value int64) error {
+	return e.buf.Write(e.w,
+		byte(value>>56),
+		byte(value>>48),
+		byte(value>>40),
+		byte(value>>32),
+		byte(value>>24),
+		byte(value>>16),
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte1Uint64(value uint64) error {
+	return e.buf.Write(e.w, byte(value))
+}
+
+func (e *encoder) setByte2Uint64(value uint64) error {
+	return e.buf.Write(e.w,
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte4Uint64(value uint64) error {
+	return e.buf.Write(e.w,
+		byte(value>>24),
+		byte(value>>16),
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte8Uint64(value uint64) error {
+	return e.buf.Write(e.w,
+		byte(value>>56),
+		byte(value>>48),
+		byte(value>>40),
+		byte(value>>32),
+		byte(value>>24),
+		byte(value>>16),
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte1Int(value int) error {
+	return e.buf.Write(e.w,
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte2Int(value int) error {
+	return e.buf.Write(e.w,
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setByte4Int(value int) error {
+	return e.buf.Write(e.w,
+		byte(value>>24),
+		byte(value>>16),
+		byte(value>>8),
+		byte(value),
+	)
+}
+
+func (e *encoder) setBytes(bs []byte) error {
+	return e.buf.Write(e.w, bs...)
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/slice.go

@@ -0,0 +1,151 @@
+package encoding
+
+import (
+	"math"
+	"reflect"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+func (e *encoder) writeSliceLength(l int) error {
+	// format size
+	if l <= 0x0f {
+		if err := e.setByte1Int(def.FixArray + l); err != nil {
+			return err
+		}
+	} else if l <= math.MaxUint16 {
+		if err := e.setByte1Int(def.Array16); err != nil {
+			return err
+		}
+		if err := e.setByte2Int(l); err != nil {
+			return err
+		}
+	} else if uint(l) <= math.MaxUint32 {
+		if err := e.setByte1Int(def.Array32); err != nil {
+			return err
+		}
+		if err := e.setByte4Int(l); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (e *encoder) writeFixedSlice(rv reflect.Value) (bool, error) {
+
+	switch sli := rv.Interface().(type) {
+	case []int:
+		for _, v := range sli {
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []uint:
+		for _, v := range sli {
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []string:
+		for _, v := range sli {
+			if err := e.writeString(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []float32:
+		for _, v := range sli {
+			if err := e.writeFloat32(float64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []float64:
+		for _, v := range sli {
+			if err := e.writeFloat64(float64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []bool:
+		for _, v := range sli {
+			if err := e.writeBool(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []int8:
+		for _, v := range sli {
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []int16:
+		for _, v := range sli {
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []int32:
+		for _, v := range sli {
+			if err := e.writeInt(int64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []int64:
+		for _, v := range sli {
+			if err := e.writeInt(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []uint8:
+		for _, v := range sli {
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []uint16:
+		for _, v := range sli {
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []uint32:
+		for _, v := range sli {
+			if err := e.writeUint(uint64(v)); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+
+	case []uint64:
+		for _, v := range sli {
+			if err := e.writeUint(v); err != nil {
+				return false, err
+			}
+		}
+		return true, nil
+	}
+
+	return false, nil
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/string.go

@@ -0,0 +1,41 @@
+package encoding
+
+import (
+	"math"
+	"unsafe"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+func (e *encoder) writeString(str string) error {
+	// NOTE : unsafe
+	strBytes := *(*[]byte)(unsafe.Pointer(&str))
+	l := len(strBytes)
+	if l < 32 {
+		if err := e.setByte1Int(def.FixStr + l); err != nil {
+			return err
+		}
+	} else if l <= math.MaxUint8 {
+		if err := e.setByte1Int(def.Str8); err != nil {
+			return err
+		}
+		if err := e.setByte1Int(l); err != nil {
+			return err
+		}
+	} else if l <= math.MaxUint16 {
+		if err := e.setByte1Int(def.Str16); err != nil {
+			return err
+		}
+		if err := e.setByte2Int(l); err != nil {
+			return err
+		}
+	} else {
+		if err := e.setByte1Int(def.Str32); err != nil {
+			return err
+		}
+		if err := e.setByte4Int(l); err != nil {
+			return err
+		}
+	}
+	return e.setBytes(strBytes)
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/struct.go

@@ -0,0 +1,140 @@
+package encoding
+
+import (
+	"math"
+	"reflect"
+	"sync"
+
+	"github.com/shamaton/msgpack/v2/def"
+	"github.com/shamaton/msgpack/v2/internal/common"
+)
+
+type structCache struct {
+	indexes []int
+	names   []string
+	common.Common
+}
+
+var cachemap = sync.Map{}
+
+type structWriteFunc func(rv reflect.Value) error
+
+func (e *encoder) getStructWriter(typ reflect.Type) structWriteFunc {
+
+	for i := range extCoders {
+		if extCoders[i].Type() == typ {
+			return func(rv reflect.Value) error {
+				return extCoders[i].Write(e.w, rv, e.buf)
+			}
+		}
+	}
+
+	if e.asArray {
+		return e.writeStructArray
+	}
+	return e.writeStructMap
+}
+
+func (e *encoder) writeStruct(rv reflect.Value) error {
+
+	for i := range extCoders {
+		if extCoders[i].Type() == rv.Type() {
+			return extCoders[i].Write(e.w, rv, e.buf)
+		}
+	}
+
+	if e.asArray {
+		return e.writeStructArray(rv)
+	}
+	return e.writeStructMap(rv)
+}
+
+func (e *encoder) writeStructArray(rv reflect.Value) error {
+	c := e.getStructCache(rv)
+
+	// write format
+	num := len(c.indexes)
+	if num <= 0x0f {
+		if err := e.setByte1Int(def.FixArray + num); err != nil {
+			return err
+		}
+	} else if num <= math.MaxUint16 {
+		if err := e.setByte1Int(def.Array16); err != nil {
+			return err
+		}
+		if err := e.setByte2Int(num); err != nil {
+			return err
+		}
+	} else if uint(num) <= math.MaxUint32 {
+		if err := e.setByte1Int(def.Array32); err != nil {
+			return err
+		}
+		if err := e.setByte4Int(num); err != nil {
+			return err
+		}
+	}
+
+	for i := 0; i < num; i++ {
+		if err := e.create(rv.Field(c.indexes[i])); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (e *encoder) writeStructMap(rv reflect.Value) error {
+	c := e.getStructCache(rv)
+
+	// format size
+	num := len(c.indexes)
+	if num <= 0x0f {
+		if err := e.setByte1Int(def.FixMap + num); err != nil {
+			return err
+		}
+	} else if num <= math.MaxUint16 {
+		if err := e.setByte1Int(def.Map16); err != nil {
+			return err
+		}
+		if err := e.setByte2Int(num); err != nil {
+			return err
+		}
+	} else if uint(num) <= math.MaxUint32 {
+		if err := e.setByte1Int(def.Map32); err != nil {
+			return err
+		}
+		if err := e.setByte4Int(num); err != nil {
+			return err
+		}
+	}
+
+	for i := 0; i < num; i++ {
+		if err := e.writeString(c.names[i]); err != nil {
+			return err
+		}
+		if err := e.create(rv.Field(c.indexes[i])); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (e *encoder) getStructCache(rv reflect.Value) *structCache {
+	t := rv.Type()
+	cache, find := cachemap.Load(t)
+	if find {
+		return cache.(*structCache)
+	}
+
+	var c *structCache
+	if !find {
+		c = &structCache{}
+		for i := 0; i < rv.NumField(); i++ {
+			if ok, name := e.CheckField(rv.Type().Field(i)); ok {
+				c.indexes = append(c.indexes, i)
+				c.names = append(c.names, name)
+			}
+		}
+		cachemap.Store(t, c)
+	}
+	return c
+}

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/uint.go

@@ -0,0 +1,44 @@
+package encoding
+
+import (
+	"math"
+
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+func (e *encoder) writeUint(v uint64) error {
+	if v <= math.MaxInt8 {
+		if err := e.setByte1Uint64(v); err != nil {
+			return err
+		}
+	} else if v <= math.MaxUint8 {
+		if err := e.setByte1Int(def.Uint8); err != nil {
+			return err
+		}
+		if err := e.setByte1Uint64(v); err != nil {
+			return err
+		}
+	} else if v <= math.MaxUint16 {
+		if err := e.setByte1Int(def.Uint16); err != nil {
+			return err
+		}
+		if err := e.setByte2Uint64(v); err != nil {
+			return err
+		}
+	} else if v <= math.MaxUint32 {
+		if err := e.setByte1Int(def.Uint32); err != nil {
+			return err
+		}
+		if err := e.setByte4Uint64(v); err != nil {
+			return err
+		}
+	} else {
+		if err := e.setByte1Int(def.Uint64); err != nil {
+			return err
+		}
+		if err := e.setByte8Uint64(v); err != nil {
+			return err
+		}
+	}
+	return nil
+}