mirror of
https://github.com/phishingclub/phishingclub.git
synced 2026-10-05 06:56:55 +02:00
129 lines
3.2 KiB
Go
129 lines
3.2 KiB
Go
package g
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/flate"
|
|
"compress/gzip"
|
|
"compress/zlib"
|
|
"io"
|
|
)
|
|
|
|
type (
|
|
// A struct that wraps Bytes for compression.
|
|
bcompress struct{ bytes Bytes }
|
|
|
|
// A struct that wraps Bytes for decompression.
|
|
bdecompress struct{ bytes Bytes }
|
|
)
|
|
|
|
// Compress returns a bcompress struct wrapping the given Bytes.
|
|
func (bs Bytes) Compress() bcompress { return bcompress{bs} }
|
|
|
|
// Decompress returns a bdecompress struct wrapping the given Bytes.
|
|
func (bs Bytes) Decompress() bdecompress { return bdecompress{bs} }
|
|
|
|
// Zlib compresses the wrapped Bytes using the zlib compression algorithm and
|
|
// returns the compressed data as Bytes.
|
|
func (c bcompress) Zlib() Bytes {
|
|
buffer := new(bytes.Buffer)
|
|
writer := zlib.NewWriter(buffer)
|
|
|
|
_, _ = writer.Write(c.bytes)
|
|
_ = writer.Flush()
|
|
_ = writer.Close()
|
|
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
// Zlib decompresses the wrapped Bytes using the zlib compression algorithm and
|
|
// returns the decompressed data as a Result[Bytes].
|
|
func (d bdecompress) Zlib() Result[Bytes] {
|
|
reader, err := zlib.NewReader(bytes.NewReader(d.bytes))
|
|
if err != nil {
|
|
return Err[Bytes](err)
|
|
}
|
|
|
|
defer reader.Close()
|
|
|
|
buffer := new(bytes.Buffer)
|
|
if _, err := io.Copy(buffer, reader); err != nil {
|
|
return Err[Bytes](err)
|
|
}
|
|
|
|
return Ok(Bytes(buffer.Bytes()))
|
|
}
|
|
|
|
// Gzip compresses the wrapped Bytes using the gzip compression format and
|
|
// returns the compressed data as Bytes.
|
|
func (c bcompress) Gzip() Bytes {
|
|
buffer := new(bytes.Buffer)
|
|
writer := gzip.NewWriter(buffer)
|
|
|
|
_, _ = writer.Write(c.bytes)
|
|
_ = writer.Flush()
|
|
_ = writer.Close()
|
|
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
// Gzip decompresses the wrapped Bytes using the gzip compression format and
|
|
// returns the decompressed data as a Result[Bytes].
|
|
func (d bdecompress) Gzip() Result[Bytes] {
|
|
reader, err := gzip.NewReader(bytes.NewReader(d.bytes))
|
|
if err != nil {
|
|
return Err[Bytes](err)
|
|
}
|
|
|
|
defer reader.Close()
|
|
|
|
buffer := new(bytes.Buffer)
|
|
if _, err := io.Copy(buffer, reader); err != nil {
|
|
return Err[Bytes](err)
|
|
}
|
|
|
|
return Ok(Bytes(buffer.Bytes()))
|
|
}
|
|
|
|
// Flate compresses the wrapped Bytes using the flate (deflate) compression
|
|
// algorithm and returns the compressed data as Bytes.
|
|
// It accepts an optional compression level. If no level is provided, it
|
|
// defaults to 7. The level is clamped to the valid flate range [-2, 9] to
|
|
// avoid an invalid-level error that would otherwise return a nil writer and
|
|
// panic on use.
|
|
func (c bcompress) Flate(level ...int) Bytes {
|
|
buffer := new(bytes.Buffer)
|
|
|
|
l := 7
|
|
if len(level) != 0 {
|
|
l = level[0]
|
|
}
|
|
|
|
if l < flate.HuffmanOnly {
|
|
l = flate.HuffmanOnly
|
|
} else if l > flate.BestCompression {
|
|
l = flate.BestCompression
|
|
}
|
|
|
|
writer, _ := flate.NewWriter(buffer, l)
|
|
|
|
_, _ = writer.Write(c.bytes)
|
|
_ = writer.Flush()
|
|
_ = writer.Close()
|
|
|
|
return buffer.Bytes()
|
|
}
|
|
|
|
// Flate decompresses the wrapped Bytes using the flate (deflate) compression
|
|
// algorithm and returns the decompressed data as a Result[Bytes].
|
|
func (d bdecompress) Flate() Result[Bytes] {
|
|
reader := flate.NewReader(bytes.NewReader(d.bytes))
|
|
defer reader.Close()
|
|
|
|
buffer := new(bytes.Buffer)
|
|
if _, err := io.Copy(buffer, reader); err != nil {
|
|
return Err[Bytes](err)
|
|
}
|
|
|
|
return Ok(Bytes(buffer.Bytes()))
|
|
}
|