func (s *Session) CloseWithError(code uint16, err error) error {
	return s.s.CloseWithError(quic.ErrorCode(code), err)
}
CloseWithError closes the connection with an error.
The error must not be nil.
package wrapper
import (
	"crypto"
	"crypto/tls"
	"crypto/x509"
	"net"
	quic "github.com/lucas-clemente/quic-go"
)
type Config struct {
	Certificate *x509.Certificate
	PrivateKey  crypto.PrivateKey
	SkipVerify  bool
}
func getDefaultQuicConfig() *quic.Config {
	return &quic.Config{
		MaxIncomingStreams:                    1000,
		MaxIncomingUniStreams:                 -1,               
		MaxReceiveStreamFlowControlWindow:     3 * (1 << 20),    
		MaxReceiveConnectionFlowControlWindow: 4.5 * (1 << 20),  
		AcceptCookie: func(clientAddr net.Addr, cookie *quic.Cookie) bool {
			return true
		},
		KeepAlive: true,
	}
}
func Client(conn net.Conn, config *Config) (*Session, error) {
	tlscfg := getTLSConfig(config)
	s, err := quic.Dial(newFakePacketConn(conn), &fakeAddr{}, "localhost:1234", tlscfg, getDefaultQuicConfig())
	if err != nil {
		return nil, err
	}
	return &Session{s: s}, nil
}
func Dial(addr string, config *Config) (*Session, error) {
	tlscfg := getTLSConfig(config)
	s, err := quic.DialAddr(addr, tlscfg, getDefaultQuicConfig())
	if err != nil {
		return nil, err
	}
	return &Session{s: s}, nil
}
func Server(conn net.Conn, config *Config) (*Listener, error) {
	tlscfg := getTLSConfig(config)
	l, err := quic.Listen(newFakePacketConn(conn), tlscfg, getDefaultQuicConfig())
	if err != nil {
		return nil, err
	}
	return &Listener{l: l}, nil
}
func Listen(addr string, config *Config) (*Listener, error) {
	tlscfg := getTLSConfig(config)
	l, err := quic.ListenAddr(addr, tlscfg, getDefaultQuicConfig())
	if err != nil {
		return nil, err
	}
	return &Listener{l: l}, nil
}
func getTLSConfig(config *Config) *tls.Config {
	return &tls.Config{
		InsecureSkipVerify: config.SkipVerify,
		ClientAuth:         tls.RequireAnyClientCert,
		Certificates: []tls.Certificate{{
			Certificate: [][]byte{config.Certificate.Raw},
			PrivateKey:  config.PrivateKey,
		}},
	}
}
type Session struct {
	s quic.Session
}
func (s *Session) OpenStream() (*Stream, error) {
	str, err := s.s.OpenStream()
	if err != nil {
		return nil, err
	}
	return &Stream{s: str}, nil
}
func (s *Session) AcceptStream() (*Stream, error) {
	str, err := s.s.AcceptStream()
	if err != nil {
		return nil, err
	}
	return &Stream{s: str}, nil
}
func (s *Session) GetRemoteCertificates() []*x509.Certificate {
	return s.s.ConnectionState().PeerCertificates
}
func (s *Session) Close() error {
	return s.s.Close()
}