Downgrade required Go version

1 files changed, 31 insertions, 31 deletions

diff --git a/oae2.go b/oae2.go
index 7b94825..438ff96 100644
--- a/oae2.go
+++ b/oae2.go
@@ -75,25 +75,25 @@ type Writer struct {
 	initialized bool
 	err         error
 
-	w         io.Writer
-	blockSize int
-	encrypter segmentEncrypter
-	buf       []byte
+	w           io.Writer
+	segmentSize int
+	encrypter   segmentEncrypter
+	buf         []byte
 }
 
 // NewWriter returns a Writer that encrypts data using key and writes the
-// encrypted data to w in chunks of approximately blockSize bytes. NewWriter
-// panics if blockSize <= 0.
+// encrypted data to w in chunks of approximately segmentSize bytes. NewWriter
+// panics if segmentSize <= 0.
 //
 // Make sure to call [Writer.Close] to flush the final segment.
-func NewWriter(w io.Writer, key []byte, blockSize int) *Writer {
-	if blockSize <= 0 {
-		panic("oae2.NewWriter: blockSize must be strictly greater than 0")
+func NewWriter(w io.Writer, key []byte, segmentSize int) *Writer {
+	if segmentSize <= 0 {
+		panic("oae2.NewWriter: segmentSize must be strictly greater than 0")
 	}
 	return &Writer{
-		w:         w,
-		blockSize: blockSize,
-		encrypter: segmentEncrypter{key: key},
+		w:           w,
+		segmentSize: segmentSize,
+		encrypter:   segmentEncrypter{key: key},
 	}
 }
 
@@ -107,7 +107,7 @@ func (w *Writer) initialize() error {
 	if _, w.err = w.w.Write(salt); w.err != nil {
 		return w.err
 	}
-	w.buf = make([]byte, 0, w.blockSize+aeadOverhead)
+	w.buf = make([]byte, 0, w.segmentSize+aeadOverhead)
 	return nil
 }
 
@@ -133,12 +133,12 @@ func (w *Writer) Write(buf []byte) (int, error) {
 	}
 	nn := 0
 	for len(buf) > 0 {
-		if len(w.buf) == w.blockSize {
+		if len(w.buf) == w.segmentSize {
 			if err := w.writeBuf(false); err != nil {
 				return nn, err
 			}
 		}
-		n := copy(w.buf[len(w.buf):w.blockSize], buf)
+		n := copy(w.buf[len(w.buf):w.segmentSize], buf)
 		w.buf = w.buf[:len(w.buf)+n]
 		buf = buf[n:]
 		nn += n
@@ -153,12 +153,12 @@ func (w *Writer) ReadFrom(r io.Reader) (int64, error) {
 	}
 	var nn int64
 	for {
-		n, err := r.Read(w.buf[len(w.buf) : w.blockSize+1])
+		n, err := r.Read(w.buf[len(w.buf) : w.segmentSize+1])
 		w.buf = w.buf[:len(w.buf)+n]
 		nn += int64(n)
-		if len(w.buf) == w.blockSize+1 {
-			nextByte := w.buf[w.blockSize]
-			w.buf = w.buf[:w.blockSize]
+		if len(w.buf) == w.segmentSize+1 {
+			nextByte := w.buf[w.segmentSize]
+			w.buf = w.buf[:w.segmentSize]
 			if err := w.writeBuf(false); err != nil {
 				return nn, err
 			}
@@ -218,7 +218,7 @@ type Reader struct {
 	err         error
 
 	r             bufReader
-	blockSize     int
+	segmentSize   int
 	decrypter     segmentEncrypter
 	buf           []byte
 	nRead         int
@@ -226,15 +226,15 @@ type Reader struct {
 }
 
 // NewReader returns a Reader that wraps r and decrypts the data using key in
-// chunks of size blockSize. NewReader panics if blockSize <= 0.
-func NewReader(r io.Reader, key []byte, blockSize int) *Reader {
-	if blockSize <= 0 {
-		panic("oae2.NewReader: blockSize must be strictly greater than 0")
+// chunks of size segmentSize. NewReader panics if segmentSize <= 0.
+func NewReader(r io.Reader, key []byte, segmentSize int) *Reader {
+	if segmentSize <= 0 {
+		panic("oae2.NewReader: segmentSize must be strictly greater than 0")
 	}
 	return &Reader{
-		r:         bufReader{r: r},
-		blockSize: blockSize,
-		decrypter: segmentEncrypter{key: key},
+		r:           bufReader{r: r},
+		segmentSize: segmentSize,
+		decrypter:   segmentEncrypter{key: key},
 	}
 }
 
@@ -250,7 +250,7 @@ func (r *Reader) initialize() error {
 	if r.err = r.decrypter.init(salt); r.err != nil {
 		return r.err
 	}
-	r.buf = make([]byte, 0, r.blockSize+aeadOverhead+1)
+	r.buf = make([]byte, 0, r.segmentSize+aeadOverhead+1)
 	return nil
 }
 
@@ -262,7 +262,7 @@ func (r *Reader) init() error {
 }
 
 func (r *Reader) fillBuf() error {
-	n, err := io.ReadFull(&r.r, r.buf[:r.blockSize+aeadOverhead+1])
+	n, err := io.ReadFull(&r.r, r.buf[:r.segmentSize+aeadOverhead+1])
 	if err != nil && err != io.ErrUnexpectedEOF {
 		if err == io.EOF && !r.readLastChunk {
 			return io.ErrUnexpectedEOF
@@ -271,9 +271,9 @@ func (r *Reader) fillBuf() error {
 		return err
 	}
 	r.buf = r.buf[:n]
-	if n == r.blockSize+aeadOverhead+1 {
+	if n == r.segmentSize+aeadOverhead+1 {
 		r.r.unreadByte()
-		r.buf = r.buf[:r.blockSize+aeadOverhead]
+		r.buf = r.buf[:r.segmentSize+aeadOverhead]
 	}
 	if err == io.ErrUnexpectedEOF {
 		r.readLastChunk = true