[chore] remove vendor

1 files changed, 0 insertions, 944 deletions

diff --git a/vendor/github.com/ugorji/go/codec/decode.base.go b/vendor/github.com/ugorji/go/codec/decode.base.go
deleted file mode 100644
index e82f40252..000000000
--- a/vendor/github.com/ugorji/go/codec/decode.base.go
+++ /dev/null
@@ -1,944 +0,0 @@
-// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
-// Use of this source code is governed by a MIT license found in the LICENSE file.
-
-package codec
-
-import (
-	"errors"
-	"io"
-	"math"
-	"reflect"
-	"slices"
-	"sync"
-	"time"
-)
-
-func init() {
-	for _, v := range []interface{}{
-		(*string)(nil),
-		(*bool)(nil),
-		(*int)(nil),
-		(*int8)(nil),
-		(*int16)(nil),
-		(*int32)(nil),
-		(*int64)(nil),
-		(*uint)(nil),
-		(*uint8)(nil),
-		(*uint16)(nil),
-		(*uint32)(nil),
-		(*uint64)(nil),
-		(*uintptr)(nil),
-		(*float32)(nil),
-		(*float64)(nil),
-		(*complex64)(nil),
-		(*complex128)(nil),
-		(*[]byte)(nil),
-		([]byte)(nil),
-		(*time.Time)(nil),
-		(*Raw)(nil),
-		(*interface{})(nil),
-	} {
-		decBuiltinRtids = append(decBuiltinRtids, i2rtid(v))
-	}
-	slices.Sort(decBuiltinRtids)
-}
-
-const msgBadDesc = "unrecognized descriptor byte"
-
-var decBuiltinRtids []uintptr
-
-// decDriver calls (DecodeBytes and DecodeStringAsBytes) return a state
-// of the view they return, allowing consumers to handle appropriately.
-//
-// sequencing of this is intentional:
-//   - mutable if <= dBytesAttachBuffer  (buf | view | invalid)
-//   - noCopy if >= dBytesAttachViewZerocopy
-type dBytesAttachState uint8
-
-const (
-	dBytesAttachInvalid      dBytesAttachState = iota
-	dBytesAttachView                           // (bytes && !zerocopy && !buf)
-	dBytesAttachBuffer                         // (buf)
-	dBytesAttachViewZerocopy                   // (bytes && zerocopy && !buf)
-	dBytesDetach                               // (!bytes && !buf)
-)
-
-type dBytesIntoState uint8
-
-const (
-	dBytesIntoNoChange dBytesIntoState = iota
-	dBytesIntoParamOut
-	dBytesIntoParamOutSlice
-	dBytesIntoNew
-)
-
-func (x dBytesAttachState) String() string {
-	switch x {
-	case dBytesAttachInvalid:
-		return "invalid"
-	case dBytesAttachView:
-		return "view"
-	case dBytesAttachBuffer:
-		return "buffer"
-	case dBytesAttachViewZerocopy:
-		return "view-zerocopy"
-	case dBytesDetach:
-		return "detach"
-	}
-	return "unknown"
-}
-
-const (
-	decDefMaxDepth         = 1024        // maximum depth
-	decDefChanCap          = 64          // should be large, as cap cannot be expanded
-	decScratchByteArrayLen = (4 + 3) * 8 // around cacheLineSize ie ~64, depending on Decoder size
-
-	// MARKER: massage decScratchByteArrayLen to ensure xxxDecDriver structs fit within cacheLine*N
-
-	// decFailNonEmptyIntf configures whether we error
-	// when decoding naked into a non-empty interface.
-	//
-	// Typically, we cannot decode non-nil stream value into
-	// nil interface with methods (e.g. io.Reader).
-	// However, in some scenarios, this should be allowed:
-	//   - MapType
-	//   - SliceType
-	//   - Extensions
-	//
-	// Consequently, we should relax this. Put it behind a const flag for now.
-	decFailNonEmptyIntf = false
-
-	// decUseTransient says whether we should use the transient optimization.
-	//
-	// There's potential for GC corruption or memory overwrites if transient isn't
-	// used carefully, so this flag helps turn it off quickly if needed.
-	//
-	// Use it everywhere needed so we can completely remove unused code blocks.
-	decUseTransient = true
-)
-
-var (
-	errNeedMapOrArrayDecodeToStruct = errors.New("only encoded map or array can decode into struct")
-	errCannotDecodeIntoNil          = errors.New("cannot decode into nil")
-
-	errExpandSliceCannotChange = errors.New("expand slice: cannot change")
-
-	errDecoderNotInitialized = errors.New("Decoder not initialized")
-
-	errDecUnreadByteNothingToRead   = errors.New("cannot unread - nothing has been read")
-	errDecUnreadByteLastByteNotRead = errors.New("cannot unread - last byte has not been read")
-	errDecUnreadByteUnknown         = errors.New("cannot unread - reason unknown")
-	errMaxDepthExceeded             = errors.New("maximum decoding depth exceeded")
-)
-
-type decNotDecodeableReason uint8
-
-const (
-	decNotDecodeableReasonUnknown decNotDecodeableReason = iota
-	decNotDecodeableReasonBadKind
-	decNotDecodeableReasonNonAddrValue
-	decNotDecodeableReasonNilReference
-)
-
-type decDriverI interface {
-
-	// this will check if the next token is a break.
-	CheckBreak() bool
-
-	// TryNil tries to decode as nil.
-	// If a nil is in the stream, it consumes it and returns true.
-	//
-	// Note: if TryNil returns true, that must be handled.
-	TryNil() bool
-
-	// ContainerType returns one of: Bytes, String, Nil, Slice or Map.
-	//
-	// Return unSet if not known.
-	//
-	// Note: Implementations MUST fully consume sentinel container types, specifically Nil.
-	ContainerType() (vt valueType)
-
-	// DecodeNaked will decode primitives (number, bool, string, []byte) and RawExt.
-	// For maps and arrays, it will not do the decoding in-band, but will signal
-	// the decoder, so that is done later, by setting the fauxUnion.valueType field.
-	//
-	// Note: Numbers are decoded as int64, uint64, float64 only (no smaller sized number types).
-	// for extensions, DecodeNaked must read the tag and the []byte if it exists.
-	// if the []byte is not read, then kInterfaceNaked will treat it as a Handle
-	// that stores the subsequent value in-band, and complete reading the RawExt.
-	//
-	// extensions should also use readx to decode them, for efficiency.
-	// kInterface will extract the detached byte slice if it has to pass it outside its realm.
-	DecodeNaked()
-
-	DecodeInt64() (i int64)
-	DecodeUint64() (ui uint64)
-
-	DecodeFloat32() (f float32)
-	DecodeFloat64() (f float64)
-
-	DecodeBool() (b bool)
-
-	// DecodeStringAsBytes returns the bytes representing a string.
-	// It will return a view into scratch buffer or input []byte (if applicable).
-	//
-	// Note: This can also decode symbols, if supported.
-	//
-	// Users should consume it right away and not store it for later use.
-	DecodeStringAsBytes() (v []byte, state dBytesAttachState)
-
-	// DecodeBytes returns the bytes representing a binary value.
-	// It will return a view into scratch buffer or input []byte (if applicable).
-	DecodeBytes() (out []byte, state dBytesAttachState)
-	// DecodeBytes(bs []byte, isstring, zerocopy bool) (bsOut []byte)
-
-	// DecodeExt will decode into an extension.
-	// ext is never nil.
-	DecodeExt(v interface{}, basetype reflect.Type, xtag uint64, ext Ext)
-	// decodeExt(verifyTag bool, tag byte) (xtag byte, xbs []byte)
-
-	// DecodeRawExt will decode into a *RawExt
-	DecodeRawExt(re *RawExt)
-
-	DecodeTime() (t time.Time)
-
-	// ReadArrayStart will return the length of the array.
-	// If the format doesn't prefix the length, it returns containerLenUnknown.
-	// If the expected array was a nil in the stream, it returns containerLenNil.
-	ReadArrayStart() int
-
-	// ReadMapStart will return the length of the array.
-	// If the format doesn't prefix the length, it returns containerLenUnknown.
-	// If the expected array was a nil in the stream, it returns containerLenNil.
-	ReadMapStart() int
-
-	decDriverContainerTracker
-
-	reset()
-
-	// atEndOfDecode()
-
-	// nextValueBytes will return the bytes representing the next value in the stream.
-	// It generally will include the last byte read, as that is a part of the next value
-	// in the stream.
-	nextValueBytes() []byte
-
-	// descBd will describe the token descriptor that signifies what type was decoded
-	descBd() string
-
-	// isBytes() bool
-
-	resetInBytes(in []byte)
-	resetInIO(r io.Reader)
-
-	NumBytesRead() int
-
-	init(h Handle, shared *decoderBase, dec decoderI) (fp interface{})
-
-	// driverStateManager
-	decNegintPosintFloatNumber
-}
-
-type decInit2er struct{}
-
-func (decInit2er) init2(dec decoderI) {}
-
-type decDriverContainerTracker interface {
-	ReadArrayElem(firstTime bool)
-	ReadMapElemKey(firstTime bool)
-	ReadMapElemValue()
-	ReadArrayEnd()
-	ReadMapEnd()
-}
-
-type decNegintPosintFloatNumber interface {
-	decInteger() (ui uint64, neg, ok bool)
-	decFloat() (f float64, ok bool)
-}
-
-type decDriverNoopNumberHelper struct{}
-
-func (x decDriverNoopNumberHelper) decInteger() (ui uint64, neg, ok bool) {
-	panic("decInteger unsupported")
-}
-func (x decDriverNoopNumberHelper) decFloat() (f float64, ok bool) { panic("decFloat unsupported") }
-
-type decDriverNoopContainerReader struct{}
-
-func (x decDriverNoopContainerReader) ReadArrayStart() (v int)       { panic("ReadArrayStart unsupported") }
-func (x decDriverNoopContainerReader) ReadMapStart() (v int)         { panic("ReadMapStart unsupported") }
-func (x decDriverNoopContainerReader) ReadArrayEnd()                 {}
-func (x decDriverNoopContainerReader) ReadMapEnd()                   {}
-func (x decDriverNoopContainerReader) ReadArrayElem(firstTime bool)  {}
-func (x decDriverNoopContainerReader) ReadMapElemKey(firstTime bool) {}
-func (x decDriverNoopContainerReader) ReadMapElemValue()             {}
-func (x decDriverNoopContainerReader) CheckBreak() (v bool)          { return }
-
-// ----
-
-type decFnInfo struct {
-	ti     *typeInfo
-	xfFn   Ext
-	xfTag  uint64
-	addrD  bool // decoding into a pointer is preferred
-	addrDf bool // force: if addrD, then decode function MUST take a ptr
-}
-
-// DecodeOptions captures configuration options during decode.
-type DecodeOptions struct {
-	// MapType specifies type to use during schema-less decoding of a map in the stream.
-	// If nil (unset), we default to map[string]interface{} iff json handle and MapKeyAsString=true,
-	// else map[interface{}]interface{}.
-	MapType reflect.Type
-
-	// SliceType specifies type to use during schema-less decoding of an array in the stream.
-	// If nil (unset), we default to []interface{} for all formats.
-	SliceType reflect.Type
-
-	// MaxInitLen defines the maxinum initial length that we "make" a collection
-	// (string, slice, map, chan). If 0 or negative, we default to a sensible value
-	// based on the size of an element in the collection.
-	//
-	// For example, when decoding, a stream may say that it has 2^64 elements.
-	// We should not auto-matically provision a slice of that size, to prevent Out-Of-Memory crash.
-	// Instead, we provision up to MaxInitLen, fill that up, and start appending after that.
-	MaxInitLen int
-
-	// ReaderBufferSize is the size of the buffer used when reading.
-	//
-	// if > 0, we use a smart buffer internally for performance purposes.
-	ReaderBufferSize int
-
-	// MaxDepth defines the maximum depth when decoding nested
-	// maps and slices. If 0 or negative, we default to a suitably large number (currently 1024).
-	MaxDepth int16
-
-	// If ErrorIfNoField, return an error when decoding a map
-	// from a codec stream into a struct, and no matching struct field is found.
-	ErrorIfNoField bool
-
-	// If ErrorIfNoArrayExpand, return an error when decoding a slice/array that cannot be expanded.
-	// For example, the stream contains an array of 8 items, but you are decoding into a [4]T array,
-	// or you are decoding into a slice of length 4 which is non-addressable (and so cannot be set).
-	ErrorIfNoArrayExpand bool
-
-	// If SignedInteger, use the int64 during schema-less decoding of unsigned values (not uint64).
-	SignedInteger bool
-
-	// MapValueReset controls how we decode into a map value.
-	//
-	// By default, we MAY retrieve the mapping for a key, and then decode into that.
-	// However, especially with big maps, that retrieval may be expensive and unnecessary
-	// if the stream already contains all that is necessary to recreate the value.
-	//
-	// If true, we will never retrieve the previous mapping,
-	// but rather decode into a new value and set that in the map.
-	//
-	// If false, we will retrieve the previous mapping if necessary e.g.
-	// the previous mapping is a pointer, or is a struct or array with pre-set state,
-	// or is an interface.
-	MapValueReset bool
-
-	// SliceElementReset: on decoding a slice, reset the element to a zero value first.
-	//
-	// concern: if the slice already contained some garbage, we will decode into that garbage.
-	SliceElementReset bool
-
-	// InterfaceReset controls how we decode into an interface.
-	//
-	// By default, when we see a field that is an interface{...},
-	// or a map with interface{...} value, we will attempt decoding into the
-	// "contained" value.
-	//
-	// However, this prevents us from reading a string into an interface{}
-	// that formerly contained a number.
-	//
-	// If true, we will decode into a new "blank" value, and set that in the interface.
-	// If false, we will decode into whatever is contained in the interface.
-	InterfaceReset bool
-
-	// InternString controls interning of strings during decoding.
-	//
-	// Some handles, e.g. json, typically will read map keys as strings.
-	// If the set of keys are finite, it may help reduce allocation to
-	// look them up from a map (than to allocate them afresh).
-	//
-	// Note: Handles will be smart when using the intern functionality.
-	// Every string should not be interned.
-	// An excellent use-case for interning is struct field names,
-	// or map keys where key type is string.
-	InternString bool
-
-	// PreferArrayOverSlice controls whether to decode to an array or a slice.
-	//
-	// This only impacts decoding into a nil interface{}.
-	//
-	// Consequently, it has no effect on codecgen.
-	//
-	// *Note*: This only applies if using go1.5 and above,
-	// as it requires reflect.ArrayOf support which was absent before go1.5.
-	PreferArrayOverSlice bool
-
-	// DeleteOnNilMapValue controls how to decode a nil value in the stream.
-	//
-	// If true, we will delete the mapping of the key.
-	// Else, just set the mapping to the zero value of the type.
-	//
-	// Deprecated: This does NOTHING and is left behind for compiling compatibility.
-	// This change is necessitated because 'nil' in a stream now consistently
-	// means the zero value (ie reset the value to its zero state).
-	DeleteOnNilMapValue bool
-
-	// RawToString controls how raw bytes in a stream are decoded into a nil interface{}.
-	// By default, they are decoded as []byte, but can be decoded as string (if configured).
-	RawToString bool
-
-	// ZeroCopy controls whether decoded values of []byte or string type
-	// point into the input []byte parameter passed to a NewDecoderBytes/ResetBytes(...) call.
-	//
-	// To illustrate, if ZeroCopy and decoding from a []byte (not io.Writer),
-	// then a []byte or string in the output result may just be a slice of (point into)
-	// the input bytes.
-	//
-	// This optimization prevents unnecessary copying.
-	//
-	// However, it is made optional, as the caller MUST ensure that the input parameter []byte is
-	// not modified after the Decode() happens, as any changes are mirrored in the decoded result.
-	ZeroCopy bool
-
-	// PreferPointerForStructOrArray controls whether a struct or array
-	// is stored in a nil interface{}, or a pointer to it.
-	//
-	// This mostly impacts when we decode registered extensions.
-	PreferPointerForStructOrArray bool
-
-	// ValidateUnicode controls will cause decoding to fail if an expected unicode
-	// string is well-formed but include invalid codepoints.
-	//
-	// This could have a performance impact.
-	ValidateUnicode bool
-}
-
-// ----------------------------------------
-
-type decoderBase struct {
-	perType decPerType
-
-	h *BasicHandle
-
-	rtidFn, rtidFnNoExt *atomicRtidFnSlice
-
-	buf []byte
-
-	// used for interning strings
-	is internerMap
-
-	err error
-
-	// sd decoderI
-
-	blist bytesFreeList
-
-	mtr  bool // is maptype a known type?
-	str  bool // is slicetype a known type?
-	jsms bool // is json handle, and MapKeyAsString
-
-	bytes bool // uses a bytes reader
-	bufio bool // uses a ioDecReader with buffer size > 0
-
-	// ---- cpu cache line boundary?
-	// ---- writable fields during execution --- *try* to keep in sep cache line
-	maxdepth int16
-	depth    int16
-
-	// Extensions can call Decode() within a current Decode() call.
-	// We need to know when the top level Decode() call returns,
-	// so we can decide whether to Release() or not.
-	calls uint16 // what depth in mustDecode are we in now.
-
-	c containerState
-
-	// decByteState
-
-	n fauxUnion
-
-	// b is an always-available scratch buffer used by Decoder and decDrivers.
-	// By being always-available, it can be used for one-off things without
-	// having to get from freelist, use, and return back to freelist.
-	//
-	// Use it for a narrow set of things e.g.
-	//   - binc uses it for parsing numbers, represented at 8 or less bytes
-	//   - uses as potential buffer for struct field names
-	b [decScratchByteArrayLen]byte
-
-	hh Handle
-	// cache the mapTypeId and sliceTypeId for faster comparisons
-	mtid uintptr
-	stid uintptr
-}
-
-func (d *decoderBase) maxInitLen() uint {
-	return uint(max(1024, d.h.MaxInitLen))
-}
-
-func (d *decoderBase) naked() *fauxUnion {
-	return &d.n
-}
-
-func (d *decoderBase) fauxUnionReadRawBytes(dr decDriverI, asString, rawToString bool) { //, handleZeroCopy bool) {
-	// fauxUnion is only used within DecodeNaked calls; consequently, we should try to intern.
-	d.n.l, d.n.a = dr.DecodeBytes()
-	if asString || rawToString {
-		d.n.v = valueTypeString
-		d.n.s = d.detach2Str(d.n.l, d.n.a)
-	} else {
-		d.n.v = valueTypeBytes
-		d.n.l = d.detach2Bytes(d.n.l, d.n.a)
-	}
-}
-
-// Return a fixed (detached) string representation of a []byte.
-//
-// Possibly get an interned version of a string,
-// iff InternString=true and decoding a map key.
-//
-// This should mostly be used for map keys, struct field names, etc
-// where the key type is string. This is because keys of a map/struct are
-// typically reused across many objects.
-func (d *decoderBase) detach2Str(v []byte, state dBytesAttachState) (s string) {
-	// note: string([]byte) checks - and optimizes - for len 0 and len 1
-	if len(v) <= 1 {
-		s = string(v)
-	} else if state >= dBytesAttachViewZerocopy { // !scratchBuf && d.bytes && d.h.ZeroCopy
-		s = stringView(v)
-	} else if d.is == nil || d.c != containerMapKey || len(v) > internMaxStrLen {
-		s = string(v)
-	} else {
-		s = d.is.string(v)
-	}
-	return
-}
-
-func (d *decoderBase) usableStructFieldNameBytes(buf, v []byte, state dBytesAttachState) (out []byte) {
-	// In JSON, mapElemValue reads a colon and spaces.
-	// In bufio mode of ioDecReader, fillbuf could overwrite the read buffer
-	// which readXXX() calls return sub-slices from.
-	//
-	// Consequently, we detach the bytes in this special case.
-	//
-	// Note: ioDecReader (non-bufio) and bytesDecReader do not have
-	// this issue (as no fillbuf exists where bytes might be returned from).
-	if d.bufio && d.h.jsonHandle && state < dBytesAttachViewZerocopy {
-		if cap(buf) > len(v) {
-			out = buf[:len(v)]
-		} else if len(d.b) > len(v) {
-			out = d.b[:len(v)]
-		} else {
-			out = make([]byte, len(v), max(64, len(v)))
-		}
-		copy(out, v)
-		return
-	}
-	return v
-}
-
-func (d *decoderBase) detach2Bytes(in []byte, state dBytesAttachState) (out []byte) {
-	if cap(in) == 0 || state >= dBytesAttachViewZerocopy {
-		return in
-	}
-	if len(in) == 0 {
-		return zeroByteSlice
-	}
-	out = make([]byte, len(in))
-	copy(out, in)
-	return out
-}
-
-func (d *decoderBase) attachState(usingBufFromReader bool) (r dBytesAttachState) {
-	if usingBufFromReader {
-		r = dBytesAttachBuffer
-	} else if !d.bytes {
-		r = dBytesDetach
-	} else if d.h.ZeroCopy {
-		r = dBytesAttachViewZerocopy
-	} else {
-		r = dBytesAttachView
-	}
-	return
-}
-
-func (d *decoderBase) mapStart(v int) int {
-	if v != containerLenNil {
-		d.depthIncr()
-		d.c = containerMapStart
-	}
-	return v
-}
-
-func (d *decoderBase) HandleName() string {
-	return d.hh.Name()
-}
-
-func (d *decoderBase) isBytes() bool {
-	return d.bytes
-}
-
-type decoderI interface {
-	Decode(v interface{}) (err error)
-	HandleName() string
-	MustDecode(v interface{})
-	NumBytesRead() int
-	Release() // deprecated
-	Reset(r io.Reader)
-	ResetBytes(in []byte)
-	ResetString(s string)
-
-	isBytes() bool
-	wrapErr(v error, err *error)
-	swallow()
-
-	nextValueBytes() []byte // wrapper method, for use in tests
-	// getDecDriver() decDriverI
-
-	decode(v interface{})
-	decodeAs(v interface{}, t reflect.Type, ext bool)
-
-	interfaceExtConvertAndDecode(v interface{}, ext InterfaceExt)
-}
-
-var errDecNoResetBytesWithReader = errors.New("cannot reset an Decoder reading from []byte with a io.Reader")
-var errDecNoResetReaderWithBytes = errors.New("cannot reset an Decoder reading from io.Reader with a []byte")
-
-func setZero(iv interface{}) {
-	rv, isnil := isNil(iv, false)
-	if isnil {
-		return
-	}
-	if !rv.IsValid() {
-		rv = reflect.ValueOf(iv)
-	}
-	if isnilBitset.isset(byte(rv.Kind())) && rvIsNil(rv) {
-		return
-	}
-	// var canDecode bool
-	switch v := iv.(type) {
-	case *string:
-		*v = ""
-	case *bool:
-		*v = false
-	case *int:
-		*v = 0
-	case *int8:
-		*v = 0
-	case *int16:
-		*v = 0
-	case *int32:
-		*v = 0
-	case *int64:
-		*v = 0
-	case *uint:
-		*v = 0
-	case *uint8:
-		*v = 0
-	case *uint16:
-		*v = 0
-	case *uint32:
-		*v = 0
-	case *uint64:
-		*v = 0
-	case *float32:
-		*v = 0
-	case *float64:
-		*v = 0
-	case *complex64:
-		*v = 0
-	case *complex128:
-		*v = 0
-	case *[]byte:
-		*v = nil
-	case *Raw:
-		*v = nil
-	case *time.Time:
-		*v = time.Time{}
-	case reflect.Value:
-		decSetNonNilRV2Zero(v)
-	default:
-		if !fastpathDecodeSetZeroTypeSwitch(iv) {
-			decSetNonNilRV2Zero(rv)
-		}
-	}
-}
-
-// decSetNonNilRV2Zero will set the non-nil value to its zero value.
-func decSetNonNilRV2Zero(v reflect.Value) {
-	// If not decodeable (settable), we do not touch it.
-	// We considered empty'ing it if not decodeable e.g.
-	//    - if chan, drain it
-	//    - if map, clear it
-	//    - if slice or array, zero all elements up to len
-	//
-	// However, we decided instead that we either will set the
-	// whole value to the zero value, or leave AS IS.
-
-	k := v.Kind()
-	if k == reflect.Interface {
-		decSetNonNilRV2Zero4Intf(v)
-	} else if k == reflect.Ptr {
-		decSetNonNilRV2Zero4Ptr(v)
-	} else if v.CanSet() {
-		rvSetDirectZero(v)
-	}
-}
-
-func decSetNonNilRV2Zero4Ptr(v reflect.Value) {
-	ve := v.Elem()
-	if ve.CanSet() {
-		rvSetZero(ve) // we can have a pointer to an interface
-	} else if v.CanSet() {
-		rvSetZero(v)
-	}
-}
-
-func decSetNonNilRV2Zero4Intf(v reflect.Value) {
-	ve := v.Elem()
-	if ve.CanSet() {
-		rvSetDirectZero(ve) // interfaces always have element as a non-interface
-	} else if v.CanSet() {
-		rvSetZero(v)
-	}
-}
-
-func (d *decoderBase) arrayCannotExpand(sliceLen, streamLen int) {
-	if d.h.ErrorIfNoArrayExpand {
-		halt.errorf("cannot expand array len during decode from %v to %v", any(sliceLen), any(streamLen))
-	}
-}
-
-//go:noinline
-func (d *decoderBase) haltAsNotDecodeable(rv reflect.Value) {
-	if !rv.IsValid() {
-		halt.onerror(errCannotDecodeIntoNil)
-	}
-	// check if an interface can be retrieved, before grabbing an interface
-	if !rv.CanInterface() {
-		halt.errorf("cannot decode into a value without an interface: %v", rv)
-	}
-	halt.errorf("cannot decode into value of kind: %v, %#v", rv.Kind(), rv2i(rv))
-}
-
-func (d *decoderBase) depthIncr() {
-	d.depth++
-	if d.depth >= d.maxdepth {
-		halt.onerror(errMaxDepthExceeded)
-	}
-}
-
-func (d *decoderBase) depthDecr() {
-	d.depth--
-}
-
-func (d *decoderBase) arrayStart(v int) int {
-	if v != containerLenNil {
-		d.depthIncr()
-		d.c = containerArrayStart
-	}
-	return v
-}
-
-func (d *decoderBase) oneShotAddrRV(rvt reflect.Type, rvk reflect.Kind) reflect.Value {
-	// MARKER 2025: is this slow for calling oneShot?
-	if decUseTransient && d.h.getTypeInfo4RT(baseRT(rvt)).flagCanTransient {
-		return d.perType.TransientAddrK(rvt, rvk)
-	}
-	return rvZeroAddrK(rvt, rvk)
-}
-
-// decNegintPosintFloatNumberHelper is used for formats that are binary
-// and have distinct ways of storing positive integers vs negative integers
-// vs floats, which are uniquely identified by the byte descriptor.
-//
-// Currently, these formats are binc, cbor and simple.
-type decNegintPosintFloatNumberHelper struct {
-	d decDriverI
-}
-
-func (x decNegintPosintFloatNumberHelper) uint64(ui uint64, neg, ok bool) uint64 {
-	if ok && !neg {
-		return ui
-	}
-	return x.uint64TryFloat(ok)
-}
-
-func (x decNegintPosintFloatNumberHelper) uint64TryFloat(neg bool) (ui uint64) {
-	if neg { // neg = true
-		halt.errorStr("assigning negative signed value to unsigned type")
-	}
-	f, ok := x.d.decFloat()
-	if !(ok && f >= 0 && noFrac64(math.Float64bits(f))) {
-		halt.errorStr2("invalid number loading uint64, with descriptor: ", x.d.descBd())
-	}
-	return uint64(f)
-}
-
-func (x decNegintPosintFloatNumberHelper) int64(ui uint64, neg, ok, cbor bool) (i int64) {
-	if ok {
-		return decNegintPosintFloatNumberHelperInt64v(ui, neg, cbor)
-	}
-	// 	return x.int64TryFloat()
-	// }
-	// func (x decNegintPosintFloatNumberHelper) int64TryFloat() (i int64) {
-	f, ok := x.d.decFloat()
-	if !(ok && noFrac64(math.Float64bits(f))) {
-		halt.errorf("invalid number loading uint64 (%v), with descriptor: %s", f, x.d.descBd())
-	}
-	return int64(f)
-}
-
-func (x decNegintPosintFloatNumberHelper) float64(f float64, ok, cbor bool) float64 {
-	if ok {
-		return f
-	}
-	return x.float64TryInteger(cbor)
-}
-
-func (x decNegintPosintFloatNumberHelper) float64TryInteger(cbor bool) float64 {
-	ui, neg, ok := x.d.decInteger()
-	if !ok {
-		halt.errorStr2("invalid descriptor for float: ", x.d.descBd())
-	}
-	return float64(decNegintPosintFloatNumberHelperInt64v(ui, neg, cbor))
-}
-
-func decNegintPosintFloatNumberHelperInt64v(ui uint64, neg, incrIfNeg bool) (i int64) {
-	if neg && incrIfNeg {
-		ui++
-	}
-	i = chkOvf.SignedIntV(ui)
-	if neg {
-		i = -i
-	}
-	return
-}
-
-// isDecodeable checks if value can be decoded into
-//
-// decode can take any reflect.Value that is a inherently addressable i.e.
-//   - non-nil chan    (we will SEND to it)
-//   - non-nil slice   (we will set its elements)
-//   - non-nil map     (we will put into it)
-//   - non-nil pointer (we can "update" it)
-//   - func: no
-//   - interface: no
-//   - array:                   if canAddr=true
-//   - any other value pointer: if canAddr=true
-func isDecodeable(rv reflect.Value) (canDecode bool, reason decNotDecodeableReason) {
-	switch rv.Kind() {
-	case reflect.Ptr, reflect.Slice, reflect.Chan, reflect.Map:
-		canDecode = !rvIsNil(rv)
-		reason = decNotDecodeableReasonNilReference
-	case reflect.Func, reflect.Interface, reflect.Invalid, reflect.UnsafePointer:
-		reason = decNotDecodeableReasonBadKind
-	default:
-		canDecode = rv.CanAddr()
-		reason = decNotDecodeableReasonNonAddrValue
-	}
-	return
-}
-
-// decInferLen will infer a sensible length, given the following:
-//   - clen: length wanted.
-//   - maxlen: max length to be returned.
-//     if <= 0, it is unset, and we infer it based on the unit size
-//   - unit: number of bytes for each element of the collection
-func decInferLen(clen int, maxlen, unit uint) (n uint) {
-	// anecdotal testing showed increase in allocation with map length of 16.
-	// We saw same typical alloc from 0-8, then a 20% increase at 16.
-	// Thus, we set it to 8.
-
-	const (
-		minLenIfUnset = 8
-		maxMem        = 1024 * 1024 // 1 MB Memory
-	)
-
-	// handle when maxlen is not set i.e. <= 0
-
-	// clen==0:           use 0
-	// maxlen<=0, clen<0: use default
-	// maxlen> 0, clen<0: use default
-	// maxlen<=0, clen>0: infer maxlen, and cap on it
-	// maxlen> 0, clen>0: cap at maxlen
-
-	if clen == 0 || clen == containerLenNil {
-		return 0
-	}
-	if clen < 0 {
-		// if unspecified, return 64 for bytes, ... 8 for uint64, ... and everything else
-		return max(64/unit, minLenIfUnset)
-	}
-	if unit == 0 {
-		return uint(clen)
-	}
-	if maxlen == 0 {
-		maxlen = maxMem / unit
-	}
-	return min(uint(clen), maxlen)
-}
-
-type Decoder struct {
-	decoderI
-}
-
-// NewDecoder returns a Decoder for decoding a stream of bytes from an io.Reader.
-//
-// For efficiency, Users are encouraged to configure ReaderBufferSize on the handle
-// OR pass in a memory buffered reader (eg bufio.Reader, bytes.Buffer).
-func NewDecoder(r io.Reader, h Handle) *Decoder {
-	return &Decoder{h.newDecoder(r)}
-}
-
-// NewDecoderBytes returns a Decoder which efficiently decodes directly
-// from a byte slice with zero copying.
-func NewDecoderBytes(in []byte, h Handle) *Decoder {
-	return &Decoder{h.newDecoderBytes(in)}
-}
-
-// NewDecoderString returns a Decoder which efficiently decodes directly
-// from a string with zero copying.
-//
-// It is a convenience function that calls NewDecoderBytes with a
-// []byte view into the string.
-//
-// This can be an efficient zero-copy if using default mode i.e. without codec.safe tag.
-func NewDecoderString(s string, h Handle) *Decoder {
-	return NewDecoderBytes(bytesView(s), h)
-}
-
-// ----
-
-func sideDecode(h Handle, p *sync.Pool, fn func(decoderI)) {
-	var s decoderI
-	if usePoolForSideDecode {
-		s = p.Get().(decoderI)
-		defer p.Put(s)
-	} else {
-		// initialization cycle error
-		// s = NewDecoderBytes(nil, h).decoderI
-		s = p.New().(decoderI)
-	}
-	fn(s)
-}
-
-func oneOffDecode(sd decoderI, v interface{}, in []byte, basetype reflect.Type, ext bool) {
-	sd.ResetBytes(in)
-	sd.decodeAs(v, basetype, ext)
-	// d.sideDecoder(xbs)
-	// d.sideDecode(rv, basetype)
-}
-
-func bytesOKdbi(v []byte, _ dBytesIntoState) []byte {
-	return v
-}
-
-func bytesOKs(bs []byte, _ dBytesAttachState) []byte {
-	return bs
-}