update vendor

vendor/github.com/pierrec/lz4/LICENSE

@@ -1,28 +0,0 @@
-Copyright (c) 2015, Pierre Curto
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-* Neither the name of xxHash nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-

vendor/github.com/pierrec/lz4/README.md

@@ -1,92 +0,0 @@
-# lz4 : LZ4 compression in pure Go
-
-[![Go Reference](https://pkg.go.dev/badge/github.com/pierrec/lz4/v4.svg)](https://pkg.go.dev/github.com/pierrec/lz4/v4)
-[![CI](https://github.com/pierrec/lz4/workflows/ci/badge.svg)](https://github.com/pierrec/lz4/actions)
-[![Go Report Card](https://goreportcard.com/badge/github.com/pierrec/lz4)](https://goreportcard.com/report/github.com/pierrec/lz4)
-[![GitHub tag (latest SemVer)](https://img.shields.io/github/tag/pierrec/lz4.svg?style=social)](https://github.com/pierrec/lz4/tags)
-
-## Overview
-
-This package provides a streaming interface to [LZ4 data streams](http://fastcompression.blogspot.fr/2013/04/lz4-streaming-format-final.html) as well as low level compress and uncompress functions for LZ4 data blocks.
-The implementation is based on the reference C [one](https://github.com/lz4/lz4).
-
-## Install
-
-Assuming you have the go toolchain installed:
-
-```
-go get github.com/pierrec/lz4/v4
-```
-
-There is a command line interface tool to compress and decompress LZ4 files.
-
-```
-go install github.com/pierrec/lz4/v4/cmd/lz4c
-```
-
-Usage
-
-```
-Usage of lz4c:
-  -version
-        print the program version
-
-Subcommands:
-Compress the given files or from stdin to stdout.
-compress [arguments] [<file name> ...]
-  -bc
-        enable block checksum
-  -l int
-        compression level (0=fastest)
-  -sc
-        disable stream checksum
-  -size string
-        block max size [64K,256K,1M,4M] (default "4M")
-
-Uncompress the given files or from stdin to stdout.
-uncompress [arguments] [<file name> ...]
-
-```
-
-
-## Example
-
-```
-// Compress and uncompress an input string.
-s := "hello world"
-r := strings.NewReader(s)
-
-// The pipe will uncompress the data from the writer.
-pr, pw := io.Pipe()
-zw := lz4.NewWriter(pw)
-zr := lz4.NewReader(pr)
-
-go func() {
-	// Compress the input string.
-	_, _ = io.Copy(zw, r)
-	_ = zw.Close() // Make sure the writer is closed
-	_ = pw.Close() // Terminate the pipe
-}()
-
-_, _ = io.Copy(os.Stdout, zr)
-
-// Output:
-// hello world
-```
-
-## Contributing
-
-Contributions are very welcome for bug fixing, performance improvements...!
-
-- Open an issue with a proper description
-- Send a pull request with appropriate test case(s)
-
-## Contributors
-
-Thanks to all [contributors](https://github.com/pierrec/lz4/graphs/contributors)  so far!
-
-Special thanks to [@Zariel](https://github.com/Zariel) for his asm implementation of the decoder.
-
-Special thanks to [@greatroar](https://github.com/greatroar) for his work on the asm implementations of the decoder for amd64 and arm64.
-
-Special thanks to [@klauspost](https://github.com/klauspost) for his work on optimizing the code.

vendor/github.com/pierrec/lz4/go.mod

@@ -1,3 +0,0 @@
-module github.com/pierrec/lz4/v4
-
-go 1.14

vendor/github.com/pierrec/lz4/lz4.go

@@ -1,157 +0,0 @@
-// Package lz4 implements reading and writing lz4 compressed data.
-//
-// The package supports both the LZ4 stream format,
-// as specified in http://fastcompression.blogspot.fr/2013/04/lz4-streaming-format-final.html,
-// and the LZ4 block format, defined at
-// http://fastcompression.blogspot.fr/2011/05/lz4-explained.html.
-//
-// See https://github.com/lz4/lz4 for the reference C implementation.
-package lz4
-
-import (
-	"github.com/pierrec/lz4/v4/internal/lz4block"
-	"github.com/pierrec/lz4/v4/internal/lz4errors"
-)
-
-func _() {
-	// Safety checks for duplicated elements.
-	var x [1]struct{}
-	_ = x[lz4block.CompressionLevel(Fast)-lz4block.Fast]
-	_ = x[Block64Kb-BlockSize(lz4block.Block64Kb)]
-	_ = x[Block256Kb-BlockSize(lz4block.Block256Kb)]
-	_ = x[Block1Mb-BlockSize(lz4block.Block1Mb)]
-	_ = x[Block4Mb-BlockSize(lz4block.Block4Mb)]
-}
-
-// CompressBlockBound returns the maximum size of a given buffer of size n, when not compressible.
-func CompressBlockBound(n int) int {
-	return lz4block.CompressBlockBound(n)
-}
-
-// UncompressBlock uncompresses the source buffer into the destination one,
-// and returns the uncompressed size.
-//
-// The destination buffer must be sized appropriately.
-//
-// An error is returned if the source data is invalid or the destination buffer is too small.
-func UncompressBlock(src, dst []byte) (int, error) {
-	return lz4block.UncompressBlock(src, dst, nil)
-}
-
-// UncompressBlockWithDict uncompresses the source buffer into the destination one using a
-// dictionary, and returns the uncompressed size.
-//
-// The destination buffer must be sized appropriately.
-//
-// An error is returned if the source data is invalid or the destination buffer is too small.
-func UncompressBlockWithDict(src, dst, dict []byte) (int, error) {
-	return lz4block.UncompressBlock(src, dst, dict)
-}
-
-// A Compressor compresses data into the LZ4 block format.
-// It uses a fast compression algorithm.
-//
-// A Compressor is not safe for concurrent use by multiple goroutines.
-//
-// Use a Writer to compress into the LZ4 stream format.
-type Compressor struct{ c lz4block.Compressor }
-
-// CompressBlock compresses the source buffer src into the destination dst.
-//
-// If compression is successful, the first return value is the size of the
-// compressed data, which is always >0.
-//
-// If dst has length at least CompressBlockBound(len(src)), compression always
-// succeeds. Otherwise, the first return value is zero. The error return is
-// non-nil if the compressed data does not fit in dst, but it might fit in a
-// larger buffer that is still smaller than CompressBlockBound(len(src)). The
-// return value (0, nil) means the data is likely incompressible and a buffer
-// of length CompressBlockBound(len(src)) should be passed in.
-func (c *Compressor) CompressBlock(src, dst []byte) (int, error) {
-	return c.c.CompressBlock(src, dst)
-}
-
-// CompressBlock compresses the source buffer into the destination one.
-// This is the fast version of LZ4 compression and also the default one.
-//
-// The argument hashTable is scratch space for a hash table used by the
-// compressor. If provided, it should have length at least 1<<16. If it is
-// shorter (or nil), CompressBlock allocates its own hash table.
-//
-// The size of the compressed data is returned.
-//
-// If the destination buffer size is lower than CompressBlockBound and
-// the compressed size is 0 and no error, then the data is incompressible.
-//
-// An error is returned if the destination buffer is too small.
-
-// CompressBlock is equivalent to Compressor.CompressBlock.
-// The final argument is ignored and should be set to nil.
-//
-// This function is deprecated. Use a Compressor instead.
-func CompressBlock(src, dst []byte, _ []int) (int, error) {
-	return lz4block.CompressBlock(src, dst)
-}
-
-// A CompressorHC compresses data into the LZ4 block format.
-// Its compression ratio is potentially better than that of a Compressor,
-// but it is also slower and requires more memory.
-//
-// A Compressor is not safe for concurrent use by multiple goroutines.
-//
-// Use a Writer to compress into the LZ4 stream format.
-type CompressorHC struct {
-	// Level is the maximum search depth for compression.
-	// Values <= 0 mean no maximum.
-	Level CompressionLevel
-	c     lz4block.CompressorHC
-}
-
-// CompressBlock compresses the source buffer src into the destination dst.
-//
-// If compression is successful, the first return value is the size of the
-// compressed data, which is always >0.
-//
-// If dst has length at least CompressBlockBound(len(src)), compression always
-// succeeds. Otherwise, the first return value is zero. The error return is
-// non-nil if the compressed data does not fit in dst, but it might fit in a
-// larger buffer that is still smaller than CompressBlockBound(len(src)). The
-// return value (0, nil) means the data is likely incompressible and a buffer
-// of length CompressBlockBound(len(src)) should be passed in.
-func (c *CompressorHC) CompressBlock(src, dst []byte) (int, error) {
-	return c.c.CompressBlock(src, dst, lz4block.CompressionLevel(c.Level))
-}
-
-// CompressBlockHC is equivalent to CompressorHC.CompressBlock.
-// The final two arguments are ignored and should be set to nil.
-//
-// This function is deprecated. Use a CompressorHC instead.
-func CompressBlockHC(src, dst []byte, depth CompressionLevel, _, _ []int) (int, error) {
-	return lz4block.CompressBlockHC(src, dst, lz4block.CompressionLevel(depth))
-}
-
-const (
-	// ErrInvalidSourceShortBuffer is returned by UncompressBlock or CompressBLock when a compressed
-	// block is corrupted or the destination buffer is not large enough for the uncompressed data.
-	ErrInvalidSourceShortBuffer = lz4errors.ErrInvalidSourceShortBuffer
-	// ErrInvalidFrame is returned when reading an invalid LZ4 archive.
-	ErrInvalidFrame = lz4errors.ErrInvalidFrame
-	// ErrInternalUnhandledState is an internal error.
-	ErrInternalUnhandledState = lz4errors.ErrInternalUnhandledState
-	// ErrInvalidHeaderChecksum is returned when reading a frame.
-	ErrInvalidHeaderChecksum = lz4errors.ErrInvalidHeaderChecksum
-	// ErrInvalidBlockChecksum is returned when reading a frame.
-	ErrInvalidBlockChecksum = lz4errors.ErrInvalidBlockChecksum
-	// ErrInvalidFrameChecksum is returned when reading a frame.
-	ErrInvalidFrameChecksum = lz4errors.ErrInvalidFrameChecksum
-	// ErrOptionInvalidCompressionLevel is returned when the supplied compression level is invalid.
-	ErrOptionInvalidCompressionLevel = lz4errors.ErrOptionInvalidCompressionLevel
-	// ErrOptionClosedOrError is returned when an option is applied to a closed or in error object.
-	ErrOptionClosedOrError = lz4errors.ErrOptionClosedOrError
-	// ErrOptionInvalidBlockSize is returned when
-	ErrOptionInvalidBlockSize = lz4errors.ErrOptionInvalidBlockSize
-	// ErrOptionNotApplicable is returned when trying to apply an option to an object not supporting it.
-	ErrOptionNotApplicable = lz4errors.ErrOptionNotApplicable
-	// ErrWriterNotClosed is returned when attempting to reset an unclosed writer.
-	ErrWriterNotClosed = lz4errors.ErrWriterNotClosed
-)

vendor/github.com/pierrec/lz4/options.go

@@ -1,214 +0,0 @@
-package lz4
-
-import (
-	"fmt"
-	"reflect"
-	"runtime"
-
-	"github.com/pierrec/lz4/v4/internal/lz4block"
-	"github.com/pierrec/lz4/v4/internal/lz4errors"
-)
-
-//go:generate go run golang.org/x/tools/cmd/stringer -type=BlockSize,CompressionLevel -output options_gen.go
-
-type (
-	applier interface {
-		Apply(...Option) error
-		private()
-	}
-	// Option defines the parameters to setup an LZ4 Writer or Reader.
-	Option func(applier) error
-)
-
-// String returns a string representation of the option with its parameter(s).
-func (o Option) String() string {
-	return o(nil).Error()
-}
-
-// Default options.
-var (
-	DefaultBlockSizeOption = BlockSizeOption(Block4Mb)
-	DefaultChecksumOption  = ChecksumOption(true)
-	DefaultConcurrency     = ConcurrencyOption(1)
-	defaultOnBlockDone     = OnBlockDoneOption(nil)
-)
-
-const (
-	Block64Kb BlockSize = 1 << (16 + iota*2)
-	Block256Kb
-	Block1Mb
-	Block4Mb
-)
-
-// BlockSizeIndex defines the size of the blocks to be compressed.
-type BlockSize uint32
-
-// BlockSizeOption defines the maximum size of compressed blocks (default=Block4Mb).
-func BlockSizeOption(size BlockSize) Option {
-	return func(a applier) error {
-		switch w := a.(type) {
-		case nil:
-			s := fmt.Sprintf("BlockSizeOption(%s)", size)
-			return lz4errors.Error(s)
-		case *Writer:
-			size := uint32(size)
-			if !lz4block.IsValid(size) {
-				return fmt.Errorf("%w: %d", lz4errors.ErrOptionInvalidBlockSize, size)
-			}
-			w.frame.Descriptor.Flags.BlockSizeIndexSet(lz4block.Index(size))
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}
-
-// BlockChecksumOption enables or disables block checksum (default=false).
-func BlockChecksumOption(flag bool) Option {
-	return func(a applier) error {
-		switch w := a.(type) {
-		case nil:
-			s := fmt.Sprintf("BlockChecksumOption(%v)", flag)
-			return lz4errors.Error(s)
-		case *Writer:
-			w.frame.Descriptor.Flags.BlockChecksumSet(flag)
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}
-
-// ChecksumOption enables/disables all blocks or content checksum (default=true).
-func ChecksumOption(flag bool) Option {
-	return func(a applier) error {
-		switch w := a.(type) {
-		case nil:
-			s := fmt.Sprintf("ChecksumOption(%v)", flag)
-			return lz4errors.Error(s)
-		case *Writer:
-			w.frame.Descriptor.Flags.ContentChecksumSet(flag)
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}
-
-// SizeOption sets the size of the original uncompressed data (default=0). It is useful to know the size of the
-// whole uncompressed data stream.
-func SizeOption(size uint64) Option {
-	return func(a applier) error {
-		switch w := a.(type) {
-		case nil:
-			s := fmt.Sprintf("SizeOption(%d)", size)
-			return lz4errors.Error(s)
-		case *Writer:
-			w.frame.Descriptor.Flags.SizeSet(size > 0)
-			w.frame.Descriptor.ContentSize = size
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}
-
-// ConcurrencyOption sets the number of go routines used for compression.
-// If n <= 0, then the output of runtime.GOMAXPROCS(0) is used.
-func ConcurrencyOption(n int) Option {
-	if n <= 0 {
-		n = runtime.GOMAXPROCS(0)
-	}
-	return func(a applier) error {
-		switch rw := a.(type) {
-		case nil:
-			s := fmt.Sprintf("ConcurrencyOption(%d)", n)
-			return lz4errors.Error(s)
-		case *Writer:
-			rw.num = n
-			return nil
-		case *Reader:
-			rw.num = n
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}
-
-// CompressionLevel defines the level of compression to use. The higher the better, but slower, compression.
-type CompressionLevel uint32
-
-const (
-	Fast   CompressionLevel = 0
-	Level1 CompressionLevel = 1 << (8 + iota)
-	Level2
-	Level3
-	Level4
-	Level5
-	Level6
-	Level7
-	Level8
-	Level9
-)
-
-// CompressionLevelOption defines the compression level (default=Fast).
-func CompressionLevelOption(level CompressionLevel) Option {
-	return func(a applier) error {
-		switch w := a.(type) {
-		case nil:
-			s := fmt.Sprintf("CompressionLevelOption(%s)", level)
-			return lz4errors.Error(s)
-		case *Writer:
-			switch level {
-			case Fast, Level1, Level2, Level3, Level4, Level5, Level6, Level7, Level8, Level9:
-			default:
-				return fmt.Errorf("%w: %d", lz4errors.ErrOptionInvalidCompressionLevel, level)
-			}
-			w.level = lz4block.CompressionLevel(level)
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}
-
-func onBlockDone(int) {}
-
-// OnBlockDoneOption is triggered when a block has been processed. For a Writer, it is when is has been compressed,
-// for a Reader, it is when it has been uncompressed.
-func OnBlockDoneOption(handler func(size int)) Option {
-	if handler == nil {
-		handler = onBlockDone
-	}
-	return func(a applier) error {
-		switch rw := a.(type) {
-		case nil:
-			s := fmt.Sprintf("OnBlockDoneOption(%s)", reflect.TypeOf(handler).String())
-			return lz4errors.Error(s)
-		case *Writer:
-			rw.handler = handler
-			return nil
-		case *Reader:
-			rw.handler = handler
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}
-
-// LegacyOption provides support for writing LZ4 frames in the legacy format.
-//
-// See https://github.com/lz4/lz4/blob/dev/doc/lz4_Frame_format.md#legacy-frame.
-//
-// NB. compressed Linux kernel images use a tweaked LZ4 legacy format where
-// the compressed stream is followed by the original (uncompressed) size of
-// the kernel (https://events.static.linuxfound.org/sites/events/files/lcjpcojp13_klee.pdf).
-// This is also supported as a special case.
-func LegacyOption(legacy bool) Option {
-	return func(a applier) error {
-		switch rw := a.(type) {
-		case nil:
-			s := fmt.Sprintf("LegacyOption(%v)", legacy)
-			return lz4errors.Error(s)
-		case *Writer:
-			rw.legacy = legacy
-			return nil
-		}
-		return lz4errors.ErrOptionNotApplicable
-	}
-}

vendor/github.com/pierrec/lz4/options_gen.go

@@ -1,92 +0,0 @@
-// Code generated by "stringer -type=BlockSize,CompressionLevel -output options_gen.go"; DO NOT EDIT.
-
-package lz4
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[Block64Kb-65536]
-	_ = x[Block256Kb-262144]
-	_ = x[Block1Mb-1048576]
-	_ = x[Block4Mb-4194304]
-}
-
-const (
-	_BlockSize_name_0 = "Block64Kb"
-	_BlockSize_name_1 = "Block256Kb"
-	_BlockSize_name_2 = "Block1Mb"
-	_BlockSize_name_3 = "Block4Mb"
-)
-
-func (i BlockSize) String() string {
-	switch {
-	case i == 65536:
-		return _BlockSize_name_0
-	case i == 262144:
-		return _BlockSize_name_1
-	case i == 1048576:
-		return _BlockSize_name_2
-	case i == 4194304:
-		return _BlockSize_name_3
-	default:
-		return "BlockSize(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[Fast-0]
-	_ = x[Level1-512]
-	_ = x[Level2-1024]
-	_ = x[Level3-2048]
-	_ = x[Level4-4096]
-	_ = x[Level5-8192]
-	_ = x[Level6-16384]
-	_ = x[Level7-32768]
-	_ = x[Level8-65536]
-	_ = x[Level9-131072]
-}
-
-const (
-	_CompressionLevel_name_0 = "Fast"
-	_CompressionLevel_name_1 = "Level1"
-	_CompressionLevel_name_2 = "Level2"
-	_CompressionLevel_name_3 = "Level3"
-	_CompressionLevel_name_4 = "Level4"
-	_CompressionLevel_name_5 = "Level5"
-	_CompressionLevel_name_6 = "Level6"
-	_CompressionLevel_name_7 = "Level7"
-	_CompressionLevel_name_8 = "Level8"
-	_CompressionLevel_name_9 = "Level9"
-)
-
-func (i CompressionLevel) String() string {
-	switch {
-	case i == 0:
-		return _CompressionLevel_name_0
-	case i == 512:
-		return _CompressionLevel_name_1
-	case i == 1024:
-		return _CompressionLevel_name_2
-	case i == 2048:
-		return _CompressionLevel_name_3
-	case i == 4096:
-		return _CompressionLevel_name_4
-	case i == 8192:
-		return _CompressionLevel_name_5
-	case i == 16384:
-		return _CompressionLevel_name_6
-	case i == 32768:
-		return _CompressionLevel_name_7
-	case i == 65536:
-		return _CompressionLevel_name_8
-	case i == 131072:
-		return _CompressionLevel_name_9
-	default:
-		return "CompressionLevel(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}

vendor/github.com/pierrec/lz4/reader.go

@@ -1,263 +0,0 @@
-package lz4
-
-import (
-	"io"
-
-	"github.com/pierrec/lz4/v4/internal/lz4block"
-	"github.com/pierrec/lz4/v4/internal/lz4errors"
-	"github.com/pierrec/lz4/v4/internal/lz4stream"
-)
-
-var readerStates = []aState{
-	noState:     newState,
-	errorState:  newState,
-	newState:    readState,
-	readState:   closedState,
-	closedState: newState,
-}
-
-// NewReader returns a new LZ4 frame decoder.
-func NewReader(r io.Reader) *Reader {
-	return newReader(r, false)
-}
-
-func newReader(r io.Reader, legacy bool) *Reader {
-	zr := &Reader{frame: lz4stream.NewFrame()}
-	zr.state.init(readerStates)
-	_ = zr.Apply(DefaultConcurrency, defaultOnBlockDone)
-	zr.Reset(r)
-	return zr
-}
-
-// Reader allows reading an LZ4 stream.
-type Reader struct {
-	state   _State
-	src     io.Reader        // source reader
-	num     int              // concurrency level
-	frame   *lz4stream.Frame // frame being read
-	data    []byte           // block buffer allocated in non concurrent mode
-	reads   chan []byte      // pending data
-	idx     int              // size of pending data
-	handler func(int)
-	cum     uint32
-	dict    []byte
-}
-
-func (*Reader) private() {}
-
-func (r *Reader) Apply(options ...Option) (err error) {
-	defer r.state.check(&err)
-	switch r.state.state {
-	case newState:
-	case errorState:
-		return r.state.err
-	default:
-		return lz4errors.ErrOptionClosedOrError
-	}
-	for _, o := range options {
-		if err = o(r); err != nil {
-			return
-		}
-	}
-	return
-}
-
-// Size returns the size of the underlying uncompressed data, if set in the stream.
-func (r *Reader) Size() int {
-	switch r.state.state {
-	case readState, closedState:
-		if r.frame.Descriptor.Flags.Size() {
-			return int(r.frame.Descriptor.ContentSize)
-		}
-	}
-	return 0
-}
-
-func (r *Reader) isNotConcurrent() bool {
-	return r.num == 1
-}
-
-func (r *Reader) init() error {
-	err := r.frame.ParseHeaders(r.src)
-	if err != nil {
-		return err
-	}
-	if !r.frame.Descriptor.Flags.BlockIndependence() {
-		// We can't decompress dependent blocks concurrently.
-		// Instead of throwing an error to the user, silently drop concurrency
-		r.num = 1
-	}
-	data, err := r.frame.InitR(r.src, r.num)
-	if err != nil {
-		return err
-	}
-	r.reads = data
-	r.idx = 0
-	size := r.frame.Descriptor.Flags.BlockSizeIndex()
-	r.data = size.Get()
-	r.cum = 0
-	return nil
-}
-
-func (r *Reader) Read(buf []byte) (n int, err error) {
-	defer r.state.check(&err)
-	switch r.state.state {
-	case readState:
-	case closedState, errorState:
-		return 0, r.state.err
-	case newState:
-		// First initialization.
-		if err = r.init(); r.state.next(err) {
-			return
-		}
-	default:
-		return 0, r.state.fail()
-	}
-	for len(buf) > 0 {
-		var bn int
-		if r.idx == 0 {
-			if r.isNotConcurrent() {
-				bn, err = r.read(buf)
-			} else {
-				lz4block.Put(r.data)
-				r.data = <-r.reads
-				if len(r.data) == 0 {
-					// No uncompressed data: something went wrong or we are done.
-					err = r.frame.Blocks.ErrorR()
-				}
-			}
-			switch err {
-			case nil:
-			case io.EOF:
-				if er := r.frame.CloseR(r.src); er != nil {
-					err = er
-				}
-				lz4block.Put(r.data)
-				r.data = nil
-				return
-			default:
-				return
-			}
-		}
-		if bn == 0 {
-			// Fill buf with buffered data.
-			bn = copy(buf, r.data[r.idx:])
-			r.idx += bn
-			if r.idx == len(r.data) {
-				// All data read, get ready for the next Read.
-				r.idx = 0
-			}
-		}
-		buf = buf[bn:]
-		n += bn
-		r.handler(bn)
-	}
-	return
-}
-
-// read uncompresses the next block as follow:
-// - if buf has enough room, the block is uncompressed into it directly
-//   and the lenght of used space is returned
-// - else, the uncompress data is stored in r.data and 0 is returned
-func (r *Reader) read(buf []byte) (int, error) {
-	block := r.frame.Blocks.Block
-	_, err := block.Read(r.frame, r.src, r.cum)
-	if err != nil {
-		return 0, err
-	}
-	var direct bool
-	dst := r.data[:cap(r.data)]
-	if len(buf) >= len(dst) {
-		// Uncompress directly into buf.
-		direct = true
-		dst = buf
-	}
-	dst, err = block.Uncompress(r.frame, dst, r.dict, true)
-	if err != nil {
-		return 0, err
-	}
-	if !r.frame.Descriptor.Flags.BlockIndependence() {
-		if len(r.dict)+len(dst) > 128*1024 {
-			preserveSize := 64*1024 - len(dst)
-			if preserveSize < 0 {
-				preserveSize = 0
-			}
-			r.dict = r.dict[len(r.dict)-preserveSize:]
-		}
-		r.dict = append(r.dict, dst...)
-	}
-	r.cum += uint32(len(dst))
-	if direct {
-		return len(dst), nil
-	}
-	r.data = dst
-	return 0, nil
-}
-
-// Reset clears the state of the Reader r such that it is equivalent to its
-// initial state from NewReader, but instead writing to writer.
-// No access to reader is performed.
-//
-// w.Close must be called before Reset.
-func (r *Reader) Reset(reader io.Reader) {
-	if r.data != nil {
-		lz4block.Put(r.data)
-		r.data = nil
-	}
-	r.frame.Reset(r.num)
-	r.state.reset()
-	r.src = reader
-	r.reads = nil
-}
-
-// WriteTo efficiently uncompresses the data from the Reader underlying source to w.
-func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
-	switch r.state.state {
-	case closedState, errorState:
-		return 0, r.state.err
-	case newState:
-		if err = r.init(); r.state.next(err) {
-			return
-		}
-	default:
-		return 0, r.state.fail()
-	}
-	defer r.state.nextd(&err)
-
-	var data []byte
-	if r.isNotConcurrent() {
-		size := r.frame.Descriptor.Flags.BlockSizeIndex()
-		data = size.Get()
-		defer lz4block.Put(data)
-	}
-	for {
-		var bn int
-		var dst []byte
-		if r.isNotConcurrent() {
-			bn, err = r.read(data)
-			dst = data[:bn]
-		} else {
-			lz4block.Put(dst)
-			dst = <-r.reads
-			bn = len(dst)
-			if bn == 0 {
-				// No uncompressed data: something went wrong or we are done.
-				err = r.frame.Blocks.ErrorR()
-			}
-		}
-		switch err {
-		case nil:
-		case io.EOF:
-			err = r.frame.CloseR(r.src)
-			return
-		default:
-			return
-		}
-		r.handler(bn)
-		bn, err = w.Write(dst)
-		n += int64(bn)
-		if err != nil {
-			return
-		}
-	}
-}

vendor/github.com/pierrec/lz4/state.go

@@ -1,75 +0,0 @@
-package lz4
-
-import (
-	"errors"
-	"fmt"
-	"io"
-
-	"github.com/pierrec/lz4/v4/internal/lz4errors"
-)
-
-//go:generate go run golang.org/x/tools/cmd/stringer -type=aState -output state_gen.go
-
-const (
-	noState     aState = iota // uninitialized reader
-	errorState                // unrecoverable error encountered
-	newState                  // instantiated object
-	readState                 // reading data
-	writeState                // writing data
-	closedState               // all done
-)
-
-type (
-	aState uint8
-	_State struct {
-		states []aState
-		state  aState
-		err    error
-	}
-)
-
-func (s *_State) init(states []aState) {
-	s.states = states
-	s.state = states[0]
-}
-
-func (s *_State) reset() {
-	s.state = s.states[0]
-	s.err = nil
-}
-
-// next sets the state to the next one unless it is passed a non nil error.
-// It returns whether or not it is in error.
-func (s *_State) next(err error) bool {
-	if err != nil {
-		s.err = fmt.Errorf("%s: %w", s.state, err)
-		s.state = errorState
-		return true
-	}
-	s.state = s.states[s.state]
-	return false
-}
-
-// nextd is like next but for defers.
-func (s *_State) nextd(errp *error) bool {
-	return errp != nil && s.next(*errp)
-}
-
-// check sets s in error if not already in error and if the error is not nil or io.EOF,
-func (s *_State) check(errp *error) {
-	if s.state == errorState || errp == nil {
-		return
-	}
-	if err := *errp; err != nil {
-		s.err = fmt.Errorf("%w[%s]", err, s.state)
-		if !errors.Is(err, io.EOF) {
-			s.state = errorState
-		}
-	}
-}
-
-func (s *_State) fail() error {
-	s.state = errorState
-	s.err = fmt.Errorf("%w[%s]", lz4errors.ErrInternalUnhandledState, s.state)
-	return s.err
-}

vendor/github.com/pierrec/lz4/state_gen.go

@@ -1,28 +0,0 @@
-// Code generated by "stringer -type=aState -output state_gen.go"; DO NOT EDIT.
-
-package lz4
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[noState-0]
-	_ = x[errorState-1]
-	_ = x[newState-2]
-	_ = x[readState-3]
-	_ = x[writeState-4]
-	_ = x[closedState-5]
-}
-
-const _aState_name = "noStateerrorStatenewStatereadStatewriteStateclosedState"
-
-var _aState_index = [...]uint8{0, 7, 17, 25, 34, 44, 55}
-
-func (i aState) String() string {
-	if i >= aState(len(_aState_index)-1) {
-		return "aState(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _aState_name[_aState_index[i]:_aState_index[i+1]]
-}

vendor/github.com/pierrec/lz4/writer.go

@@ -1,233 +0,0 @@
-package lz4
-
-import (
-	"io"
-
-	"github.com/pierrec/lz4/v4/internal/lz4block"
-	"github.com/pierrec/lz4/v4/internal/lz4errors"
-	"github.com/pierrec/lz4/v4/internal/lz4stream"
-)
-
-var writerStates = []aState{
-	noState:     newState,
-	newState:    writeState,
-	writeState:  closedState,
-	closedState: newState,
-	errorState:  newState,
-}
-
-// NewWriter returns a new LZ4 frame encoder.
-func NewWriter(w io.Writer) *Writer {
-	zw := &Writer{frame: lz4stream.NewFrame()}
-	zw.state.init(writerStates)
-	_ = zw.Apply(DefaultBlockSizeOption, DefaultChecksumOption, DefaultConcurrency, defaultOnBlockDone)
-	zw.Reset(w)
-	return zw
-}
-
-// Writer allows writing an LZ4 stream.
-type Writer struct {
-	state   _State
-	src     io.Writer                 // destination writer
-	level   lz4block.CompressionLevel // how hard to try
-	num     int                       // concurrency level
-	frame   *lz4stream.Frame          // frame being built
-	data    []byte                    // pending data
-	idx     int                       // size of pending data
-	handler func(int)
-	legacy  bool
-}
-
-func (*Writer) private() {}
-
-func (w *Writer) Apply(options ...Option) (err error) {
-	defer w.state.check(&err)
-	switch w.state.state {
-	case newState:
-	case errorState:
-		return w.state.err
-	default:
-		return lz4errors.ErrOptionClosedOrError
-	}
-	for _, o := range options {
-		if err = o(w); err != nil {
-			return
-		}
-	}
-	w.Reset(w.src)
-	return
-}
-
-func (w *Writer) isNotConcurrent() bool {
-	return w.num == 1
-}
-
-// init sets up the Writer when in newState. It does not change the Writer state.
-func (w *Writer) init() error {
-	w.frame.InitW(w.src, w.num, w.legacy)
-	if true || !w.isNotConcurrent() {
-		size := w.frame.Descriptor.Flags.BlockSizeIndex()
-		w.data = size.Get()
-	}
-	w.idx = 0
-	return w.frame.Descriptor.Write(w.frame, w.src)
-}
-
-func (w *Writer) Write(buf []byte) (n int, err error) {
-	defer w.state.check(&err)
-	switch w.state.state {
-	case writeState:
-	case closedState, errorState:
-		return 0, w.state.err
-	case newState:
-		if err = w.init(); w.state.next(err) {
-			return
-		}
-	default:
-		return 0, w.state.fail()
-	}
-
-	zn := len(w.data)
-	for len(buf) > 0 {
-		if w.isNotConcurrent() && w.idx == 0 && len(buf) >= zn {
-			// Avoid a copy as there is enough data for a block.
-			if err = w.write(buf[:zn], false); err != nil {
-				return
-			}
-			n += zn
-			buf = buf[zn:]
-			continue
-		}
-		// Accumulate the data to be compressed.
-		m := copy(w.data[w.idx:], buf)
-		n += m
-		w.idx += m
-		buf = buf[m:]
-
-		if w.idx < len(w.data) {
-			// Buffer not filled.
-			return
-		}
-
-		// Buffer full.
-		if err = w.write(w.data, true); err != nil {
-			return
-		}
-		if !w.isNotConcurrent() {
-			size := w.frame.Descriptor.Flags.BlockSizeIndex()
-			w.data = size.Get()
-		}
-		w.idx = 0
-	}
-	return
-}
-
-func (w *Writer) write(data []byte, safe bool) error {
-	if w.isNotConcurrent() {
-		block := w.frame.Blocks.Block
-		err := block.Compress(w.frame, data, w.level).Write(w.frame, w.src)
-		w.handler(len(block.Data))
-		return err
-	}
-	c := make(chan *lz4stream.FrameDataBlock)
-	w.frame.Blocks.Blocks <- c
-	go func(c chan *lz4stream.FrameDataBlock, data []byte, safe bool) {
-		b := lz4stream.NewFrameDataBlock(w.frame)
-		c <- b.Compress(w.frame, data, w.level)
-		<-c
-		w.handler(len(b.Data))
-		b.Close(w.frame)
-		if safe {
-			// safe to put it back as the last usage of it was FrameDataBlock.Write() called before c is closed
-			lz4block.Put(data)
-		}
-	}(c, data, safe)
-
-	return nil
-}
-
-// Close closes the Writer, flushing any unwritten data to the underlying io.Writer,
-// but does not close the underlying io.Writer.
-func (w *Writer) Close() (err error) {
-	switch w.state.state {
-	case writeState:
-	case errorState:
-		return w.state.err
-	default:
-		return nil
-	}
-	defer w.state.nextd(&err)
-	if w.idx > 0 {
-		// Flush pending data, disable w.data freeing as it is done later on.
-		if err = w.write(w.data[:w.idx], false); err != nil {
-			return err
-		}
-		w.idx = 0
-	}
-	err = w.frame.CloseW(w.src, w.num)
-	// It is now safe to free the buffer.
-	if w.data != nil {
-		lz4block.Put(w.data)
-		w.data = nil
-	}
-	return
-}
-
-// Reset clears the state of the Writer w such that it is equivalent to its
-// initial state from NewWriter, but instead writing to writer.
-// Reset keeps the previous options unless overwritten by the supplied ones.
-// No access to writer is performed.
-//
-// w.Close must be called before Reset or pending data may be dropped.
-func (w *Writer) Reset(writer io.Writer) {
-	w.frame.Reset(w.num)
-	w.state.reset()
-	w.src = writer
-}
-
-// ReadFrom efficiently reads from r and compressed into the Writer destination.
-func (w *Writer) ReadFrom(r io.Reader) (n int64, err error) {
-	switch w.state.state {
-	case closedState, errorState:
-		return 0, w.state.err
-	case newState:
-		if err = w.init(); w.state.next(err) {
-			return
-		}
-	default:
-		return 0, w.state.fail()
-	}
-	defer w.state.check(&err)
-
-	size := w.frame.Descriptor.Flags.BlockSizeIndex()
-	var done bool
-	var rn int
-	data := size.Get()
-	if w.isNotConcurrent() {
-		// Keep the same buffer for the whole process.
-		defer lz4block.Put(data)
-	}
-	for !done {
-		rn, err = io.ReadFull(r, data)
-		switch err {
-		case nil:
-		case io.EOF, io.ErrUnexpectedEOF: // read may be partial
-			done = true
-		default:
-			return
-		}
-		n += int64(rn)
-		err = w.write(data[:rn], true)
-		if err != nil {
-			return
-		}
-		w.handler(rn)
-		if !done && !w.isNotConcurrent() {
-			// The buffer will be returned automatically by go routines (safe=true)
-			// so get a new one fo the next round.
-			data = size.Get()
-		}
-	}
-	err = w.Close()
-	return
-}