[chore]: Bump github.com/gin-contrib/gzip from 1.0.1 to 1.1.0 (#3639)

Bumps [github.com/gin-contrib/gzip](https://github.com/gin-contrib/gzip) from 1.0.1 to 1.1.0.
- [Release notes](https://github.com/gin-contrib/gzip/releases)
- [Changelog](https://github.com/gin-contrib/gzip/blob/master/.goreleaser.yaml)
- [Commits](https://github.com/gin-contrib/gzip/compare/v1.0.1...v1.1.0)

---
updated-dependencies:
- dependency-name: github.com/gin-contrib/gzip
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

1 files changed, 127 insertions, 109 deletions

diff --git a/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go
index 6657220ab..85c90fc07 100644
--- a/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go
+++ b/vendor/github.com/bytedance/sonic/internal/rt/fastvalue.go
@@ -17,209 +17,209 @@
 package rt
 
 import (
-    `reflect`
-    `unsafe`
+	"reflect"
+	"unsafe"
 )
 
 var (
-    reflectRtypeItab = findReflectRtypeItab()
+	reflectRtypeItab = findReflectRtypeItab()
 )
 
 // GoType.KindFlags const
 const (
-    F_direct    = 1 << 5
-    F_kind_mask = (1 << 5) - 1
+	F_direct    = 1 << 5
+	F_kind_mask = (1 << 5) - 1
 )
 
 // GoType.Flags const
 const (
-    tflagUncommon      uint8 = 1 << 0
-    tflagExtraStar     uint8 = 1 << 1
-    tflagNamed         uint8 = 1 << 2
-    tflagRegularMemory uint8 = 1 << 3
+	tflagUncommon      uint8 = 1 << 0
+	tflagExtraStar     uint8 = 1 << 1
+	tflagNamed         uint8 = 1 << 2
+	tflagRegularMemory uint8 = 1 << 3
 )
 
 type GoType struct {
-    Size       uintptr
-    PtrData    uintptr
-    Hash       uint32
-    Flags      uint8
-    Align      uint8
-    FieldAlign uint8
-    KindFlags  uint8
-    Traits     unsafe.Pointer
-    GCData     *byte
-    Str        int32
-    PtrToSelf  int32
+	Size       uintptr
+	PtrData    uintptr
+	Hash       uint32
+	Flags      uint8
+	Align      uint8
+	FieldAlign uint8
+	KindFlags  uint8
+	Traits     unsafe.Pointer
+	GCData     *byte
+	Str        int32
+	PtrToSelf  int32
 }
 
 func (self *GoType) IsNamed() bool {
-    return (self.Flags & tflagNamed) != 0
+	return (self.Flags & tflagNamed) != 0
 }
 
 func (self *GoType) Kind() reflect.Kind {
-    return reflect.Kind(self.KindFlags & F_kind_mask)
+	return reflect.Kind(self.KindFlags & F_kind_mask)
 }
 
 func (self *GoType) Pack() (t reflect.Type) {
-    (*GoIface)(unsafe.Pointer(&t)).Itab = reflectRtypeItab
-    (*GoIface)(unsafe.Pointer(&t)).Value = unsafe.Pointer(self)
-    return
+	(*GoIface)(unsafe.Pointer(&t)).Itab = reflectRtypeItab
+	(*GoIface)(unsafe.Pointer(&t)).Value = unsafe.Pointer(self)
+	return
 }
 
 func (self *GoType) String() string {
-    return self.Pack().String()
+	return self.Pack().String()
 }
 
 func (self *GoType) Indirect() bool {
-    return self.KindFlags & F_direct == 0
+	return self.KindFlags&F_direct == 0
 }
 
 type GoMap struct {
-    Count      int
-    Flags      uint8
-    B          uint8
-    Overflow   uint16
-    Hash0      uint32
-    Buckets    unsafe.Pointer
-    OldBuckets unsafe.Pointer
-    Evacuate   uintptr
-    Extra      unsafe.Pointer
+	Count      int
+	Flags      uint8
+	B          uint8
+	Overflow   uint16
+	Hash0      uint32
+	Buckets    unsafe.Pointer
+	OldBuckets unsafe.Pointer
+	Evacuate   uintptr
+	Extra      unsafe.Pointer
 }
 
 type GoMapIterator struct {
-    K           unsafe.Pointer
-    V           unsafe.Pointer
-    T           *GoMapType
-    H           *GoMap
-    Buckets     unsafe.Pointer
-    Bptr        *unsafe.Pointer
-    Overflow    *[]unsafe.Pointer
-    OldOverflow *[]unsafe.Pointer
-    StartBucket uintptr
-    Offset      uint8
-    Wrapped     bool
-    B           uint8
-    I           uint8
-    Bucket      uintptr
-    CheckBucket uintptr
+	K           unsafe.Pointer
+	V           unsafe.Pointer
+	T           *GoMapType
+	H           *GoMap
+	Buckets     unsafe.Pointer
+	Bptr        *unsafe.Pointer
+	Overflow    *[]unsafe.Pointer
+	OldOverflow *[]unsafe.Pointer
+	StartBucket uintptr
+	Offset      uint8
+	Wrapped     bool
+	B           uint8
+	I           uint8
+	Bucket      uintptr
+	CheckBucket uintptr
 }
 
 type GoItab struct {
-    it unsafe.Pointer
-    Vt *GoType
-    hv uint32
-    _  [4]byte
-    fn [1]uintptr
+	it unsafe.Pointer
+	Vt *GoType
+	hv uint32
+	_  [4]byte
+	fn [1]uintptr
 }
 
 type GoIface struct {
-    Itab  *GoItab
-    Value unsafe.Pointer
+	Itab  *GoItab
+	Value unsafe.Pointer
 }
 
 type GoEface struct {
-    Type  *GoType
-    Value unsafe.Pointer
+	Type  *GoType
+	Value unsafe.Pointer
 }
 
 func (self GoEface) Pack() (v interface{}) {
-    *(*GoEface)(unsafe.Pointer(&v)) = self
-    return
+	*(*GoEface)(unsafe.Pointer(&v)) = self
+	return
 }
 
 type GoPtrType struct {
-    GoType
-    Elem *GoType
+	GoType
+	Elem *GoType
 }
 
 type GoMapType struct {
-    GoType
-    Key        *GoType
-    Elem       *GoType
-    Bucket     *GoType
-    Hasher     func(unsafe.Pointer, uintptr) uintptr
-    KeySize    uint8
-    ElemSize   uint8
-    BucketSize uint16
-    Flags      uint32
+	GoType
+	Key        *GoType
+	Elem       *GoType
+	Bucket     *GoType
+	Hasher     func(unsafe.Pointer, uintptr) uintptr
+	KeySize    uint8
+	ElemSize   uint8
+	BucketSize uint16
+	Flags      uint32
 }
 
 func (self *GoMapType) IndirectElem() bool {
-    return self.Flags & 2 != 0
+	return self.Flags&2 != 0
 }
 
 type GoStructType struct {
-    GoType
-    Pkg    *byte
-    Fields []GoStructField
+	GoType
+	Pkg    *byte
+	Fields []GoStructField
 }
 
 type GoStructField struct {
-    Name     *byte
-    Type     *GoType
-    OffEmbed uintptr
+	Name     *byte
+	Type     *GoType
+	OffEmbed uintptr
 }
 
 type GoInterfaceType struct {
-    GoType
-    PkgPath *byte
-    Methods []GoInterfaceMethod
+	GoType
+	PkgPath *byte
+	Methods []GoInterfaceMethod
 }
 
 type GoInterfaceMethod struct {
-    Name int32
-    Type int32
+	Name int32
+	Type int32
 }
 
 type GoSlice struct {
-    Ptr unsafe.Pointer
-    Len int
-    Cap int
+	Ptr unsafe.Pointer
+	Len int
+	Cap int
 }
 
 type GoString struct {
-    Ptr unsafe.Pointer
-    Len int
+	Ptr unsafe.Pointer
+	Len int
 }
 
 func PtrElem(t *GoType) *GoType {
-    return (*GoPtrType)(unsafe.Pointer(t)).Elem
+	return (*GoPtrType)(unsafe.Pointer(t)).Elem
 }
 
 func MapType(t *GoType) *GoMapType {
-    return (*GoMapType)(unsafe.Pointer(t))
+	return (*GoMapType)(unsafe.Pointer(t))
 }
 
 func IfaceType(t *GoType) *GoInterfaceType {
-    return (*GoInterfaceType)(unsafe.Pointer(t))
+	return (*GoInterfaceType)(unsafe.Pointer(t))
 }
 
 func UnpackType(t reflect.Type) *GoType {
-    return (*GoType)((*GoIface)(unsafe.Pointer(&t)).Value)
+	return (*GoType)((*GoIface)(unsafe.Pointer(&t)).Value)
 }
 
 func UnpackEface(v interface{}) GoEface {
-    return *(*GoEface)(unsafe.Pointer(&v))
+	return *(*GoEface)(unsafe.Pointer(&v))
 }
 
 func UnpackIface(v interface{}) GoIface {
-    return *(*GoIface)(unsafe.Pointer(&v))
+	return *(*GoIface)(unsafe.Pointer(&v))
 }
 
 func findReflectRtypeItab() *GoItab {
-    v := reflect.TypeOf(struct{}{})
-    return (*GoIface)(unsafe.Pointer(&v)).Itab
+	v := reflect.TypeOf(struct{}{})
+	return (*GoIface)(unsafe.Pointer(&v)).Itab
 }
 
 func AssertI2I2(t *GoType, i GoIface) (r GoIface) {
-    inter := IfaceType(t)
+	inter := IfaceType(t)
 	tab := i.Itab
 	if tab == nil {
 		return
 	}
 	if (*GoInterfaceType)(tab.it) != inter {
-		tab = Getitab(inter, tab.Vt, true)
+		tab = GetItab(inter, tab.Vt, true)
 		if tab == nil {
 			return
 		}
@@ -229,15 +229,33 @@ func AssertI2I2(t *GoType, i GoIface) (r GoIface) {
 	return
 }
 
+func (t *GoType) IsInt64() bool {
+	return t.Kind() == reflect.Int64 || (t.Kind() == reflect.Int && t.Size == 8)
+}
+
+func (t *GoType) IsInt32() bool {
+	return t.Kind() == reflect.Int32 || (t.Kind() == reflect.Int && t.Size == 4)
+}
+
+//go:nosplit
+func (t *GoType) IsUint64() bool {
+	isUint := t.Kind() == reflect.Uint || t.Kind() == reflect.Uintptr
+	return t.Kind() == reflect.Uint64 || (isUint && t.Size == 8)
+}
+
+//go:nosplit
+func (t *GoType) IsUint32() bool {
+	isUint := t.Kind() == reflect.Uint || t.Kind() == reflect.Uintptr
+	return t.Kind() == reflect.Uint32 || (isUint && t.Size == 4)
+}
+
+//go:nosplit
+func PtrAdd(ptr unsafe.Pointer, offset uintptr) unsafe.Pointer {
+	return unsafe.Pointer(uintptr(ptr) + offset)
+}
+
 //go:noescape
-//go:linkname Getitab runtime.getitab
-func Getitab(inter *GoInterfaceType, typ *GoType, canfail bool) *GoItab
+//go:linkname GetItab runtime.getitab
+func GetItab(inter *GoInterfaceType, typ *GoType, canfail bool) *GoItab
 
 
-func GetFuncPC(fn interface{}) uintptr {
-    ft := UnpackEface(fn)
-    if ft.Type.Kind() != reflect.Func {
-        panic("not a function")
-    }
-    return *(*uintptr)(ft.Value)
-}
\ No newline at end of file