[chore] remove vendor

1 files changed, 0 insertions, 995 deletions

diff --git a/vendor/github.com/ugorji/go/codec/cbor.go b/vendor/github.com/ugorji/go/codec/cbor.go
deleted file mode 100644
index 2229a2b26..000000000
--- a/vendor/github.com/ugorji/go/codec/cbor.go
+++ /dev/null
@@ -1,995 +0,0 @@
-//go:build notmono || codec.notmono
-
-// 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 (
-	"io"
-	"math"
-	"math/big"
-	"reflect"
-	"time"
-	"unicode/utf8"
-)
-
-// -------------------
-
-type cborEncDriver[T encWriter] struct {
-	noBuiltInTypes
-	encDriverNoState
-	encDriverNoopContainerWriter
-	encDriverContainerNoTrackerT
-
-	h   *CborHandle
-	e   *encoderBase
-	w   T
-	enc encoderI
-
-	// scratch buffer for: encode time, numbers, etc
-	//
-	// RFC3339Nano uses 35 chars: 2006-01-02T15:04:05.999999999Z07:00
-	b [40]byte
-}
-
-func (e *cborEncDriver[T]) EncodeNil() {
-	e.w.writen1(cborBdNil)
-}
-
-func (e *cborEncDriver[T]) EncodeBool(b bool) {
-	if b {
-		e.w.writen1(cborBdTrue)
-	} else {
-		e.w.writen1(cborBdFalse)
-	}
-}
-
-func (e *cborEncDriver[T]) EncodeFloat32(f float32) {
-	b := math.Float32bits(f)
-	if e.h.OptimumSize {
-		if h := floatToHalfFloatBits(b); halfFloatToFloatBits(h) == b {
-			e.w.writen1(cborBdFloat16)
-			e.w.writen2(bigen.PutUint16(h))
-			return
-		}
-	}
-	e.w.writen1(cborBdFloat32)
-	e.w.writen4(bigen.PutUint32(b))
-}
-
-func (e *cborEncDriver[T]) EncodeFloat64(f float64) {
-	if e.h.OptimumSize {
-		if f32 := float32(f); float64(f32) == f {
-			e.EncodeFloat32(f32)
-			return
-		}
-	}
-	e.w.writen1(cborBdFloat64)
-	e.w.writen8(bigen.PutUint64(math.Float64bits(f)))
-}
-
-func (e *cborEncDriver[T]) encUint(v uint64, bd byte) {
-	if v <= 0x17 {
-		e.w.writen1(byte(v) + bd)
-	} else if v <= math.MaxUint8 {
-		e.w.writen2(bd+0x18, uint8(v))
-	} else if v <= math.MaxUint16 {
-		e.w.writen1(bd + 0x19)
-		e.w.writen2(bigen.PutUint16(uint16(v)))
-	} else if v <= math.MaxUint32 {
-		e.w.writen1(bd + 0x1a)
-		e.w.writen4(bigen.PutUint32(uint32(v)))
-	} else { // if v <= math.MaxUint64 {
-		e.w.writen1(bd + 0x1b)
-		e.w.writen8(bigen.PutUint64(v))
-	}
-}
-
-func (e *cborEncDriver[T]) EncodeInt(v int64) {
-	if v < 0 {
-		e.encUint(uint64(-1-v), cborBaseNegInt)
-	} else {
-		e.encUint(uint64(v), cborBaseUint)
-	}
-}
-
-func (e *cborEncDriver[T]) EncodeUint(v uint64) {
-	e.encUint(v, cborBaseUint)
-}
-
-func (e *cborEncDriver[T]) encLen(bd byte, length int) {
-	e.encUint(uint64(length), bd)
-}
-
-func (e *cborEncDriver[T]) EncodeTime(t time.Time) {
-	if t.IsZero() {
-		e.EncodeNil()
-	} else if e.h.TimeRFC3339 {
-		e.encUint(0, cborBaseTag)
-		e.encStringBytesS(cborBaseString, stringView(t.AppendFormat(e.b[:0], time.RFC3339Nano)))
-	} else {
-		e.encUint(1, cborBaseTag)
-		t = t.UTC().Round(time.Microsecond)
-		sec, nsec := t.Unix(), uint64(t.Nanosecond())
-		if nsec == 0 {
-			e.EncodeInt(sec)
-		} else {
-			e.EncodeFloat64(float64(sec) + float64(nsec)/1e9)
-		}
-	}
-}
-
-func (e *cborEncDriver[T]) EncodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
-	e.encUint(uint64(xtag), cborBaseTag)
-	if ext == SelfExt {
-		e.enc.encodeAs(rv, basetype, false)
-	} else if v := ext.ConvertExt(rv); v == nil {
-		e.writeNilBytes()
-	} else {
-		e.enc.encodeI(v)
-	}
-}
-
-func (e *cborEncDriver[T]) EncodeRawExt(re *RawExt) {
-	e.encUint(uint64(re.Tag), cborBaseTag)
-	if re.Data != nil {
-		e.w.writeb(re.Data)
-	} else if re.Value != nil {
-		e.enc.encodeI(re.Value)
-	} else {
-		e.EncodeNil()
-	}
-}
-
-func (e *cborEncDriver[T]) WriteArrayEmpty() {
-	if e.h.IndefiniteLength {
-		e.w.writen2(cborBdIndefiniteArray, cborBdBreak)
-	} else {
-		e.w.writen1(cborBaseArray)
-		// e.encLen(cborBaseArray, 0)
-	}
-}
-
-func (e *cborEncDriver[T]) WriteMapEmpty() {
-	if e.h.IndefiniteLength {
-		e.w.writen2(cborBdIndefiniteMap, cborBdBreak)
-	} else {
-		e.w.writen1(cborBaseMap)
-		// e.encLen(cborBaseMap, 0)
-	}
-}
-
-func (e *cborEncDriver[T]) WriteArrayStart(length int) {
-	if e.h.IndefiniteLength {
-		e.w.writen1(cborBdIndefiniteArray)
-	} else {
-		e.encLen(cborBaseArray, length)
-	}
-}
-
-func (e *cborEncDriver[T]) WriteMapStart(length int) {
-	if e.h.IndefiniteLength {
-		e.w.writen1(cborBdIndefiniteMap)
-	} else {
-		e.encLen(cborBaseMap, length)
-	}
-}
-
-func (e *cborEncDriver[T]) WriteMapEnd() {
-	if e.h.IndefiniteLength {
-		e.w.writen1(cborBdBreak)
-	}
-}
-
-func (e *cborEncDriver[T]) WriteArrayEnd() {
-	if e.h.IndefiniteLength {
-		e.w.writen1(cborBdBreak)
-	}
-}
-
-func (e *cborEncDriver[T]) EncodeString(v string) {
-	bb := cborBaseString
-	if e.h.StringToRaw {
-		bb = cborBaseBytes
-	}
-	e.encStringBytesS(bb, v)
-}
-
-func (e *cborEncDriver[T]) EncodeStringNoEscape4Json(v string) { e.EncodeString(v) }
-
-func (e *cborEncDriver[T]) EncodeStringBytesRaw(v []byte) {
-	e.encStringBytesS(cborBaseBytes, stringView(v))
-}
-
-func (e *cborEncDriver[T]) encStringBytesS(bb byte, v string) {
-	if e.h.IndefiniteLength {
-		if bb == cborBaseBytes {
-			e.w.writen1(cborBdIndefiniteBytes)
-		} else {
-			e.w.writen1(cborBdIndefiniteString)
-		}
-		vlen := uint(len(v))
-		n := max(4, min(vlen/4, 1024))
-		for i := uint(0); i < vlen; {
-			i2 := i + n
-			if i2 >= vlen {
-				i2 = vlen
-			}
-			v2 := v[i:i2]
-			e.encLen(bb, len(v2))
-			e.w.writestr(v2)
-			i = i2
-		}
-		e.w.writen1(cborBdBreak)
-	} else {
-		e.encLen(bb, len(v))
-		e.w.writestr(v)
-	}
-}
-
-func (e *cborEncDriver[T]) EncodeBytes(v []byte) {
-	if v == nil {
-		e.writeNilBytes()
-		return
-	}
-	e.EncodeStringBytesRaw(v)
-}
-
-func (e *cborEncDriver[T]) writeNilOr(v byte) {
-	if !e.h.NilCollectionToZeroLength {
-		v = cborBdNil
-	}
-	e.w.writen1(v)
-}
-
-func (e *cborEncDriver[T]) writeNilArray() {
-	e.writeNilOr(cborBaseArray)
-}
-
-func (e *cborEncDriver[T]) writeNilMap() {
-	e.writeNilOr(cborBaseMap)
-}
-
-func (e *cborEncDriver[T]) writeNilBytes() {
-	e.writeNilOr(cborBaseBytes)
-}
-
-// ----------------------
-
-type cborDecDriver[T decReader] struct {
-	decDriverNoopContainerReader
-	// decDriverNoopNumberHelper
-	noBuiltInTypes
-
-	h   *CborHandle
-	d   *decoderBase
-	r   T
-	dec decoderI
-	bdAndBdread
-	// st bool // skip tags
-	// bytes bool
-}
-
-func (d *cborDecDriver[T]) readNextBd() {
-	d.bd = d.r.readn1()
-	d.bdRead = true
-}
-
-func (d *cborDecDriver[T]) advanceNil() (null bool) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	if d.bd == cborBdNil || d.bd == cborBdUndefined {
-		d.bdRead = false
-		return true // null = true
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) TryNil() bool {
-	return d.advanceNil()
-}
-
-// skipTags is called to skip any tags in the stream.
-//
-// Since any value can be tagged, then we should call skipTags
-// before any value is decoded.
-//
-// By definition, skipTags should not be called before
-// checking for break, or nil or undefined.
-func (d *cborDecDriver[T]) skipTags() {
-	for d.bd>>5 == cborMajorTag {
-		d.decUint()
-		d.bd = d.r.readn1()
-	}
-}
-
-func (d *cborDecDriver[T]) ContainerType() (vt valueType) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	if d.bd == cborBdNil {
-		d.bdRead = false // always consume nil after seeing it in container type
-		return valueTypeNil
-	}
-	major := d.bd >> 5
-	if major == cborMajorBytes {
-		return valueTypeBytes
-	} else if major == cborMajorString {
-		return valueTypeString
-	} else if major == cborMajorArray {
-		return valueTypeArray
-	} else if major == cborMajorMap {
-		return valueTypeMap
-	}
-	return valueTypeUnset
-}
-
-func (d *cborDecDriver[T]) CheckBreak() (v bool) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	if d.bd == cborBdBreak {
-		d.bdRead = false
-		v = true
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) decUint() (ui uint64) {
-	v := d.bd & 0x1f
-	if v <= 0x17 {
-		ui = uint64(v)
-	} else if v == 0x18 {
-		ui = uint64(d.r.readn1())
-	} else if v == 0x19 {
-		ui = uint64(bigen.Uint16(d.r.readn2()))
-	} else if v == 0x1a {
-		ui = uint64(bigen.Uint32(d.r.readn4()))
-	} else if v == 0x1b {
-		ui = uint64(bigen.Uint64(d.r.readn8()))
-	} else {
-		halt.errorf("invalid descriptor decoding uint: %x/%s (%x)", d.bd, cbordesc(d.bd), v)
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) decLen() int {
-	return int(d.decUint())
-}
-
-func (d *cborDecDriver[T]) decFloat() (f float64, ok bool) {
-	ok = true
-	switch d.bd {
-	case cborBdFloat16:
-		f = float64(math.Float32frombits(halfFloatToFloatBits(bigen.Uint16(d.r.readn2()))))
-	case cborBdFloat32:
-		f = float64(math.Float32frombits(bigen.Uint32(d.r.readn4())))
-	case cborBdFloat64:
-		f = math.Float64frombits(bigen.Uint64(d.r.readn8()))
-	default:
-		if d.bd>>5 == cborMajorTag {
-			// extension tag for bignum/decimal
-			switch d.bd & 0x1f { // tag
-			case 2:
-				f = d.decTagBigIntAsFloat(false)
-			case 3:
-				f = d.decTagBigIntAsFloat(true)
-			case 4:
-				f = d.decTagBigFloatAsFloat(true)
-			case 5:
-				f = d.decTagBigFloatAsFloat(false)
-			default:
-				ok = false
-			}
-		} else {
-			ok = false
-		}
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) decInteger() (ui uint64, neg, ok bool) {
-	ok = true
-	switch d.bd >> 5 {
-	case cborMajorUint:
-		ui = d.decUint()
-	case cborMajorNegInt:
-		ui = d.decUint()
-		neg = true
-	default:
-		ok = false
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) DecodeInt64() (i int64) {
-	if d.advanceNil() {
-		return
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	v1, v2, v3 := d.decInteger()
-	i = decNegintPosintFloatNumberHelper{d}.int64(v1, v2, v3, true)
-	d.bdRead = false
-	return
-}
-
-func (d *cborDecDriver[T]) DecodeUint64() (ui uint64) {
-	if d.advanceNil() {
-		return
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	ui = decNegintPosintFloatNumberHelper{d}.uint64(d.decInteger())
-	d.bdRead = false
-	return
-}
-
-func (d *cborDecDriver[T]) DecodeFloat64() (f float64) {
-	if d.advanceNil() {
-		return
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	v1, v2 := d.decFloat()
-	f = decNegintPosintFloatNumberHelper{d}.float64(v1, v2, true)
-	d.bdRead = false
-	return
-}
-
-// bool can be decoded from bool only (single byte).
-func (d *cborDecDriver[T]) DecodeBool() (b bool) {
-	if d.advanceNil() {
-		return
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	if d.bd == cborBdTrue {
-		b = true
-	} else if d.bd == cborBdFalse {
-	} else {
-		halt.errorf("not bool - %s %x/%s", msgBadDesc, d.bd, cbordesc(d.bd))
-	}
-	d.bdRead = false
-	return
-}
-
-func (d *cborDecDriver[T]) ReadMapStart() (length int) {
-	if d.advanceNil() {
-		return containerLenNil
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	d.bdRead = false
-	if d.bd == cborBdIndefiniteMap {
-		return containerLenUnknown
-	}
-	if d.bd>>5 != cborMajorMap {
-		halt.errorf("error reading map; got major type: %x, expected %x/%s", d.bd>>5, cborMajorMap, cbordesc(d.bd))
-	}
-	return d.decLen()
-}
-
-func (d *cborDecDriver[T]) ReadArrayStart() (length int) {
-	if d.advanceNil() {
-		return containerLenNil
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	d.bdRead = false
-	if d.bd == cborBdIndefiniteArray {
-		return containerLenUnknown
-	}
-	if d.bd>>5 != cborMajorArray {
-		halt.errorf("invalid array; got major type: %x, expect: %x/%s", d.bd>>5, cborMajorArray, cbordesc(d.bd))
-	}
-	return d.decLen()
-}
-
-// MARKER d.d.buf is ONLY used within DecodeBytes.
-// Safe to use freely here only.
-
-func (d *cborDecDriver[T]) DecodeBytes() (bs []byte, state dBytesAttachState) {
-	if d.advanceNil() {
-		return
-	}
-	if d.h.SkipUnexpectedTags {
-		d.skipTags()
-	}
-	fnEnsureNonNilBytes := func() {
-		// buf is nil at first. Ensure a non-nil value is returned.
-		if bs == nil {
-			bs = zeroByteSlice
-			state = dBytesDetach
-		}
-	}
-	if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
-		major := d.bd >> 5
-		val4str := d.h.ValidateUnicode && major == cborMajorString
-		bs = d.d.buf[:0]
-		d.bdRead = false
-		for !d.CheckBreak() {
-			if d.bd>>5 != major {
-				const msg = "malformed indefinite string/bytes %x (%s); " +
-					"contains chunk with major type %v, expected %v"
-				halt.errorf(msg, d.bd, cbordesc(d.bd), d.bd>>5, major)
-			}
-			n := uint(d.decLen())
-			bs = append(bs, d.r.readx(n)...)
-			d.bdRead = false
-			if val4str && !utf8.Valid(bs[len(bs)-int(n):]) {
-				const msg = "indefinite-length text string contains chunk " +
-					"that is not a valid utf-8 sequence: 0x%x"
-				halt.errorf(msg, bs[len(bs)-int(n):])
-			}
-		}
-		d.bdRead = false
-		d.d.buf = bs
-		state = dBytesAttachBuffer
-		fnEnsureNonNilBytes()
-		return
-	}
-	if d.bd == cborBdIndefiniteArray {
-		d.bdRead = false
-		bs = d.d.buf[:0]
-		for !d.CheckBreak() {
-			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
-		}
-		d.d.buf = bs
-		state = dBytesAttachBuffer
-		fnEnsureNonNilBytes()
-		return
-	}
-	var cond bool
-	if d.bd>>5 == cborMajorArray {
-		d.bdRead = false
-		slen := d.decLen()
-		bs, cond = usableByteSlice(d.d.buf, slen)
-		for i := 0; i < len(bs); i++ {
-			bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
-		}
-		for i := len(bs); i < slen; i++ {
-			bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
-		}
-		if cond {
-			d.d.buf = bs
-		}
-		state = dBytesAttachBuffer
-		fnEnsureNonNilBytes()
-		return
-	}
-	clen := d.decLen()
-	d.bdRead = false
-	bs, cond = d.r.readxb(uint(clen))
-	state = d.d.attachState(cond)
-	return
-}
-
-func (d *cborDecDriver[T]) DecodeStringAsBytes() (out []byte, state dBytesAttachState) {
-	out, state = d.DecodeBytes()
-	if d.h.ValidateUnicode && !utf8.Valid(out) {
-		halt.errorf("DecodeStringAsBytes: invalid UTF-8: %s", out)
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) DecodeTime() (t time.Time) {
-	if d.advanceNil() {
-		return
-	}
-	if d.bd>>5 != cborMajorTag {
-		halt.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
-	}
-	xtag := d.decUint()
-	d.bdRead = false
-	return d.decodeTime(xtag)
-}
-
-func (d *cborDecDriver[T]) decodeTime(xtag uint64) (t time.Time) {
-	switch xtag {
-	case 0:
-		var err error
-		t, err = time.Parse(time.RFC3339, stringView(bytesOKs(d.DecodeStringAsBytes())))
-		halt.onerror(err)
-	case 1:
-		f1, f2 := math.Modf(d.DecodeFloat64())
-		t = time.Unix(int64(f1), int64(f2*1e9))
-	default:
-		halt.errorf("invalid tag for time.Time - expecting 0 or 1, got 0x%x", xtag)
-	}
-	t = t.UTC().Round(time.Microsecond)
-	return
-}
-
-func (d *cborDecDriver[T]) preDecodeExt(checkTag bool, xtag uint64) (realxtag uint64, ok bool) {
-	if d.advanceNil() {
-		return
-	}
-	if d.bd>>5 != cborMajorTag {
-		halt.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
-	}
-	realxtag = d.decUint()
-	d.bdRead = false
-	if checkTag && xtag != realxtag {
-		halt.errorf("Wrong extension tag. Got %b. Expecting: %v", realxtag, xtag)
-	}
-	ok = true
-	return
-}
-
-func (d *cborDecDriver[T]) DecodeRawExt(re *RawExt) {
-	if realxtag, ok := d.preDecodeExt(false, 0); ok {
-		re.Tag = realxtag
-		d.dec.decode(&re.Value)
-		d.bdRead = false
-	}
-}
-
-func (d *cborDecDriver[T]) DecodeExt(rv interface{}, basetype reflect.Type, xtag uint64, ext Ext) {
-	if _, ok := d.preDecodeExt(true, xtag); ok {
-		if ext == SelfExt {
-			d.dec.decodeAs(rv, basetype, false)
-		} else {
-			d.dec.interfaceExtConvertAndDecode(rv, ext)
-		}
-		d.bdRead = false
-	}
-}
-
-func (d *cborDecDriver[T]) decTagBigIntAsFloat(neg bool) (f float64) {
-	bs, _ := d.DecodeBytes()
-	bi := new(big.Int).SetBytes(bs)
-	if neg { // neg big.Int
-		bi0 := bi
-		bi = new(big.Int).Sub(big.NewInt(-1), bi0)
-	}
-	f, _ = bi.Float64()
-	return
-}
-
-func (d *cborDecDriver[T]) decTagBigFloatAsFloat(decimal bool) (f float64) {
-	if nn := d.r.readn1(); nn != 82 {
-		halt.errorf("(%d) decoding decimal/big.Float: expected 2 numbers", nn)
-	}
-	exp := d.DecodeInt64()
-	mant := d.DecodeInt64()
-	if decimal { // m*(10**e)
-		// MARKER: if precision/other issues crop, consider using big.Float on base 10.
-		// The logic is more convoluted, which is why we leverage readFloatResult for now.
-		rf := readFloatResult{exp: int8(exp)}
-		if mant >= 0 {
-			rf.mantissa = uint64(mant)
-		} else {
-			rf.neg = true
-			rf.mantissa = uint64(-mant)
-		}
-		f, _ = parseFloat64_reader(rf)
-		// f = float64(mant) * math.Pow10(exp)
-	} else { // m*(2**e)
-		// f = float64(mant) * math.Pow(2, exp)
-		bfm := new(big.Float).SetPrec(64).SetInt64(mant)
-		bf := new(big.Float).SetPrec(64).SetMantExp(bfm, int(exp))
-		f, _ = bf.Float64()
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) DecodeNaked() {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-
-	n := d.d.naked()
-	var decodeFurther bool
-	switch d.bd >> 5 {
-	case cborMajorUint:
-		if d.h.SignedInteger {
-			n.v = valueTypeInt
-			n.i = d.DecodeInt64()
-		} else {
-			n.v = valueTypeUint
-			n.u = d.DecodeUint64()
-		}
-	case cborMajorNegInt:
-		n.v = valueTypeInt
-		n.i = d.DecodeInt64()
-	case cborMajorBytes:
-		d.d.fauxUnionReadRawBytes(d, false, d.h.RawToString) //, d.h.ZeroCopy)
-	case cborMajorString:
-		n.v = valueTypeString
-		n.s = d.d.detach2Str(d.DecodeStringAsBytes())
-	case cborMajorArray:
-		n.v = valueTypeArray
-		decodeFurther = true
-	case cborMajorMap:
-		n.v = valueTypeMap
-		decodeFurther = true
-	case cborMajorTag:
-		n.v = valueTypeExt
-		n.u = d.decUint()
-		d.bdRead = false
-		n.l = nil
-		xx := d.h.getExtForTag(n.u)
-		if xx == nil {
-			switch n.u {
-			case 0, 1:
-				n.v = valueTypeTime
-				n.t = d.decodeTime(n.u)
-			case 2:
-				n.f = d.decTagBigIntAsFloat(false)
-				n.v = valueTypeFloat
-			case 3:
-				n.f = d.decTagBigIntAsFloat(true)
-				n.v = valueTypeFloat
-			case 4:
-				n.f = d.decTagBigFloatAsFloat(true)
-				n.v = valueTypeFloat
-			case 5:
-				n.f = d.decTagBigFloatAsFloat(false)
-				n.v = valueTypeFloat
-			case 55799: // skip
-				d.DecodeNaked()
-			default:
-				if d.h.SkipUnexpectedTags {
-					d.DecodeNaked()
-				}
-				// else we will use standard mode to decode ext e.g. into a RawExt
-			}
-			return
-		}
-		// if n.u == 0 || n.u == 1 {
-		// 	d.bdRead = false
-		// 	n.v = valueTypeTime
-		// 	n.t = d.decodeTime(n.u)
-		// } else if d.h.SkipUnexpectedTags && d.h.getExtForTag(n.u) == nil {
-		// 	// d.skipTags() // no need to call this - tags already skipped
-		// 	d.bdRead = false
-		// 	d.DecodeNaked()
-		// 	return // return when done (as true recursive function)
-		// }
-	case cborMajorSimpleOrFloat:
-		switch d.bd {
-		case cborBdNil, cborBdUndefined:
-			n.v = valueTypeNil
-		case cborBdFalse:
-			n.v = valueTypeBool
-			n.b = false
-		case cborBdTrue:
-			n.v = valueTypeBool
-			n.b = true
-		case cborBdFloat16, cborBdFloat32, cborBdFloat64:
-			n.v = valueTypeFloat
-			n.f = d.DecodeFloat64()
-		default:
-			halt.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
-		}
-	default: // should never happen
-		halt.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
-	}
-	if !decodeFurther {
-		d.bdRead = false
-	}
-}
-
-func (d *cborDecDriver[T]) uintBytes() (v []byte, ui uint64) {
-	// this is only used by nextValueBytes, so it's ok to
-	// use readx and bigenstd here.
-	switch vv := d.bd & 0x1f; vv {
-	case 0x18:
-		v = d.r.readx(1)
-		ui = uint64(v[0])
-	case 0x19:
-		v = d.r.readx(2)
-		ui = uint64(bigenstd.Uint16(v))
-	case 0x1a:
-		v = d.r.readx(4)
-		ui = uint64(bigenstd.Uint32(v))
-	case 0x1b:
-		v = d.r.readx(8)
-		ui = uint64(bigenstd.Uint64(v))
-	default:
-		if vv > 0x1b {
-			halt.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
-		}
-		ui = uint64(vv)
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) nextValueBytes() (v []byte) {
-	if !d.bdRead {
-		d.readNextBd()
-	}
-	d.r.startRecording()
-	d.nextValueBytesBdReadR()
-	v = d.r.stopRecording()
-	d.bdRead = false
-	return
-}
-
-// func (d *cborDecDriver[T]) nextValueBytesR(v0 []byte) (v []byte) {
-// 	d.readNextBd()
-// 	v0 = append(v0, d.bd)
-// 	d.r.startRecording(v0)
-// 	d.nextValueBytesBdReadR()
-// 	v = d.r.stopRecording()
-// 	return
-// }
-
-func (d *cborDecDriver[T]) nextValueBytesBdReadR() {
-	// var bs []byte
-	var ui uint64
-
-	switch d.bd >> 5 {
-	case cborMajorUint, cborMajorNegInt:
-		d.uintBytes()
-	case cborMajorString, cborMajorBytes:
-		if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
-			for {
-				d.readNextBd()
-				if d.bd == cborBdBreak {
-					break
-				}
-				_, ui = d.uintBytes()
-				d.r.skip(uint(ui))
-			}
-		} else {
-			_, ui = d.uintBytes()
-			d.r.skip(uint(ui))
-		}
-	case cborMajorArray:
-		if d.bd == cborBdIndefiniteArray {
-			for {
-				d.readNextBd()
-				if d.bd == cborBdBreak {
-					break
-				}
-				d.nextValueBytesBdReadR()
-			}
-		} else {
-			_, ui = d.uintBytes()
-			for i := uint64(0); i < ui; i++ {
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-			}
-		}
-	case cborMajorMap:
-		if d.bd == cborBdIndefiniteMap {
-			for {
-				d.readNextBd()
-				if d.bd == cborBdBreak {
-					break
-				}
-				d.nextValueBytesBdReadR()
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-			}
-		} else {
-			_, ui = d.uintBytes()
-			for i := uint64(0); i < ui; i++ {
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-				d.readNextBd()
-				d.nextValueBytesBdReadR()
-			}
-		}
-	case cborMajorTag:
-		d.uintBytes()
-		d.readNextBd()
-		d.nextValueBytesBdReadR()
-	case cborMajorSimpleOrFloat:
-		switch d.bd {
-		case cborBdNil, cborBdUndefined, cborBdFalse, cborBdTrue: // pass
-		case cborBdFloat16:
-			d.r.skip(2)
-		case cborBdFloat32:
-			d.r.skip(4)
-		case cborBdFloat64:
-			d.r.skip(8)
-		default:
-			halt.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
-		}
-	default: // should never happen
-		halt.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
-	}
-	return
-}
-
-func (d *cborDecDriver[T]) reset() {
-	d.bdAndBdread.reset()
-	// d.st = d.h.SkipUnexpectedTags
-}
-
-// ----
-//
-// The following below are similar across all format files (except for the format name).
-//
-// We keep them together here, so that we can easily copy and compare.
-
-// ----
-
-func (d *cborEncDriver[T]) init(hh Handle, shared *encoderBase, enc encoderI) (fp interface{}) {
-	callMake(&d.w)
-	d.h = hh.(*CborHandle)
-	d.e = shared
-	if shared.bytes {
-		fp = cborFpEncBytes
-	} else {
-		fp = cborFpEncIO
-	}
-	// d.w.init()
-	d.init2(enc)
-	return
-}
-
-func (e *cborEncDriver[T]) writeBytesAsis(b []byte) { e.w.writeb(b) }
-
-// func (e *cborEncDriver[T]) writeStringAsisDblQuoted(v string) { e.w.writeqstr(v) }
-
-func (e *cborEncDriver[T]) writerEnd() { e.w.end() }
-
-func (e *cborEncDriver[T]) resetOutBytes(out *[]byte) {
-	e.w.resetBytes(*out, out)
-}
-
-func (e *cborEncDriver[T]) resetOutIO(out io.Writer) {
-	e.w.resetIO(out, e.h.WriterBufferSize, &e.e.blist)
-}
-
-// ----
-
-func (d *cborDecDriver[T]) init(hh Handle, shared *decoderBase, dec decoderI) (fp interface{}) {
-	callMake(&d.r)
-	d.h = hh.(*CborHandle)
-	d.d = shared
-	if shared.bytes {
-		fp = cborFpDecBytes
-	} else {
-		fp = cborFpDecIO
-	}
-	// d.r.init()
-	d.init2(dec)
-	return
-}
-
-func (d *cborDecDriver[T]) NumBytesRead() int {
-	return int(d.r.numread())
-}
-
-func (d *cborDecDriver[T]) resetInBytes(in []byte) {
-	d.r.resetBytes(in)
-}
-
-func (d *cborDecDriver[T]) resetInIO(r io.Reader) {
-	d.r.resetIO(r, d.h.ReaderBufferSize, d.h.MaxInitLen, &d.d.blist)
-}
-
-// ---- (custom stanza)
-
-func (d *cborDecDriver[T]) descBd() string {
-	return sprintf("%v (%s)", d.bd, cbordesc(d.bd))
-}
-
-func (d *cborDecDriver[T]) DecodeFloat32() (f float32) {
-	return float32(chkOvf.Float32V(d.DecodeFloat64()))
-}
-
-func (d *cborEncDriver[T]) init2(enc encoderI) {
-	d.enc = enc
-}
-
-func (d *cborDecDriver[T]) init2(dec decoderI) {
-	d.dec = dec
-	// d.d.cbor = true
-}