refactor: move packages to internal/

13 files changed, 3035 insertions, 0 deletions

diff --git a/internal/gitdiff/apply.go b/internal/gitdiff/apply.go
new file mode 100644
index 0000000..44bbcca
--- /dev/null
+++ b/internal/gitdiff/apply.go
@@ -0,0 +1,147 @@
+package gitdiff
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"sort"
+)
+
+// Conflict indicates an apply failed due to a conflict between the patch and
+// the source content.
+//
+// Users can test if an error was caused by a conflict by using errors.Is with
+// an empty Conflict:
+//
+//	    if errors.Is(err, &Conflict{}) {
+//		       // handle conflict
+//	    }
+type Conflict struct {
+	msg string
+}
+
+func (c *Conflict) Error() string {
+	return "conflict: " + c.msg
+}
+
+// Is implements error matching for Conflict. Passing an empty instance of
+// Conflict always returns true.
+func (c *Conflict) Is(other error) bool {
+	if other, ok := other.(*Conflict); ok {
+		return other.msg == "" || other.msg == c.msg
+	}
+	return false
+}
+
+// ApplyError wraps an error that occurs during patch application with
+// additional location information, if it is available.
+type ApplyError struct {
+	// Line is the one-indexed line number in the source data
+	Line int64
+	// Fragment is the one-indexed fragment number in the file
+	Fragment int
+	// FragmentLine is the one-indexed line number in the fragment
+	FragmentLine int
+
+	err error
+}
+
+// Unwrap returns the wrapped error.
+func (e *ApplyError) Unwrap() error {
+	return e.err
+}
+
+func (e *ApplyError) Error() string {
+	return fmt.Sprintf("%v", e.err)
+}
+
+type lineNum int
+type fragNum int
+type fragLineNum int
+
+// applyError creates a new *ApplyError wrapping err or augments the information
+// in err with args if it is already an *ApplyError. Returns nil if err is nil.
+func applyError(err error, args ...interface{}) error {
+	if err == nil {
+		return nil
+	}
+
+	e, ok := err.(*ApplyError)
+	if !ok {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+		e = &ApplyError{err: err}
+	}
+	for _, arg := range args {
+		switch v := arg.(type) {
+		case lineNum:
+			e.Line = int64(v) + 1
+		case fragNum:
+			e.Fragment = int(v) + 1
+		case fragLineNum:
+			e.FragmentLine = int(v) + 1
+		}
+	}
+	return e
+}
+
+var (
+	errApplyInProgress = errors.New("gitdiff: incompatible apply in progress")
+	errApplierClosed   = errors.New("gitdiff: applier is closed")
+)
+
+// Apply applies the changes in f to src, writing the result to dst. It can
+// apply both text and binary changes.
+//
+// If an error occurs while applying, Apply returns an *ApplyError that
+// annotates the error with additional information. If the error is because of
+// a conflict with the source, the wrapped error will be a *Conflict.
+func Apply(dst io.Writer, src io.ReaderAt, f *File) error {
+	if f.IsBinary {
+		if len(f.TextFragments) > 0 {
+			return applyError(errors.New("binary file contains text fragments"))
+		}
+		if f.BinaryFragment == nil {
+			return applyError(errors.New("binary file does not contain a binary fragment"))
+		}
+	} else {
+		if f.BinaryFragment != nil {
+			return applyError(errors.New("text file contains a binary fragment"))
+		}
+	}
+
+	switch {
+	case f.BinaryFragment != nil:
+		applier := NewBinaryApplier(dst, src)
+		if err := applier.ApplyFragment(f.BinaryFragment); err != nil {
+			return err
+		}
+		return applier.Close()
+
+	case len(f.TextFragments) > 0:
+		frags := make([]*TextFragment, len(f.TextFragments))
+		copy(frags, f.TextFragments)
+
+		sort.Slice(frags, func(i, j int) bool {
+			return frags[i].OldPosition < frags[j].OldPosition
+		})
+
+		// TODO(bkeyes): consider merging overlapping fragments
+		// right now, the application fails if fragments overlap, but it should be
+		// possible to precompute the result of applying them in order
+
+		applier := NewTextApplier(dst, src)
+		for i, frag := range frags {
+			if err := applier.ApplyFragment(frag); err != nil {
+				return applyError(err, fragNum(i))
+			}
+		}
+		return applier.Close()
+
+	default:
+		// nothing to apply, just copy all the data
+		_, err := copyFrom(dst, src, 0)
+		return err
+	}
+}
diff --git a/internal/gitdiff/apply_binary.go b/internal/gitdiff/apply_binary.go
new file mode 100644
index 0000000..b34772d
--- /dev/null
+++ b/internal/gitdiff/apply_binary.go
@@ -0,0 +1,206 @@
+package gitdiff
+
+import (
+	"errors"
+	"fmt"
+	"io"
+)
+
+// BinaryApplier applies binary changes described in a fragment to source data.
+// The applier must be closed after use.
+type BinaryApplier struct {
+	dst io.Writer
+	src io.ReaderAt
+
+	closed bool
+	dirty  bool
+}
+
+// NewBinaryApplier creates an BinaryApplier that reads data from src and
+// writes modified data to dst.
+func NewBinaryApplier(dst io.Writer, src io.ReaderAt) *BinaryApplier {
+	a := BinaryApplier{
+		dst: dst,
+		src: src,
+	}
+	return &a
+}
+
+// ApplyFragment applies the changes in the fragment f and writes the result to
+// dst. ApplyFragment can be called at most once.
+//
+// If an error occurs while applying, ApplyFragment returns an *ApplyError that
+// annotates the error with additional information. If the error is because of
+// a conflict between a fragment and the source, the wrapped error will be a
+// *Conflict.
+func (a *BinaryApplier) ApplyFragment(f *BinaryFragment) error {
+	if f == nil {
+		return applyError(errors.New("nil fragment"))
+	}
+	if a.closed {
+		return applyError(errApplierClosed)
+	}
+	if a.dirty {
+		return applyError(errApplyInProgress)
+	}
+
+	// mark an apply as in progress, even if it fails before making changes
+	a.dirty = true
+
+	switch f.Method {
+	case BinaryPatchLiteral:
+		if _, err := a.dst.Write(f.Data); err != nil {
+			return applyError(err)
+		}
+	case BinaryPatchDelta:
+		if err := applyBinaryDeltaFragment(a.dst, a.src, f.Data); err != nil {
+			return applyError(err)
+		}
+	default:
+		return applyError(fmt.Errorf("unsupported binary patch method: %v", f.Method))
+	}
+	return nil
+}
+
+// Close writes any data following the last applied fragment and prevents
+// future calls to ApplyFragment.
+func (a *BinaryApplier) Close() (err error) {
+	if a.closed {
+		return nil
+	}
+
+	a.closed = true
+	if !a.dirty {
+		_, err = copyFrom(a.dst, a.src, 0)
+	} else {
+		// do nothing, applying a binary fragment copies all data
+	}
+	return err
+}
+
+func applyBinaryDeltaFragment(dst io.Writer, src io.ReaderAt, frag []byte) error {
+	srcSize, delta := readBinaryDeltaSize(frag)
+	if err := checkBinarySrcSize(src, srcSize); err != nil {
+		return err
+	}
+
+	dstSize, delta := readBinaryDeltaSize(delta)
+
+	for len(delta) > 0 {
+		op := delta[0]
+		if op == 0 {
+			return errors.New("invalid delta opcode 0")
+		}
+
+		var n int64
+		var err error
+		switch op & 0x80 {
+		case 0x80:
+			n, delta, err = applyBinaryDeltaCopy(dst, op, delta[1:], src)
+		case 0x00:
+			n, delta, err = applyBinaryDeltaAdd(dst, op, delta[1:])
+		}
+		if err != nil {
+			return err
+		}
+		dstSize -= n
+	}
+
+	if dstSize != 0 {
+		return errors.New("corrupt binary delta: insufficient or extra data")
+	}
+	return nil
+}
+
+// readBinaryDeltaSize reads a variable length size from a delta-encoded binary
+// fragment, returing the size and the unused data. Data is encoded as:
+//
+//	[[1xxxxxxx]...] [0xxxxxxx]
+//
+// in little-endian order, with 7 bits of the value per byte.
+func readBinaryDeltaSize(d []byte) (size int64, rest []byte) {
+	shift := uint(0)
+	for i, b := range d {
+		size |= int64(b&0x7F) << shift
+		shift += 7
+		if b <= 0x7F {
+			return size, d[i+1:]
+		}
+	}
+	return size, nil
+}
+
+// applyBinaryDeltaAdd applies an add opcode in a delta-encoded binary
+// fragment, returning the amount of data written and the usused part of the
+// fragment. An add operation takes the form:
+//
+//	[0xxxxxx][[data1]...]
+//
+// where the lower seven bits of the opcode is the number of data bytes
+// following the opcode. See also pack-format.txt in the Git source.
+func applyBinaryDeltaAdd(w io.Writer, op byte, delta []byte) (n int64, rest []byte, err error) {
+	size := int(op)
+	if len(delta) < size {
+		return 0, delta, errors.New("corrupt binary delta: incomplete add")
+	}
+	_, err = w.Write(delta[:size])
+	return int64(size), delta[size:], err
+}
+
+// applyBinaryDeltaCopy applies a copy opcode in a delta-encoded binary
+// fragment, returing the amount of data written and the unused part of the
+// fragment. A copy operation takes the form:
+//
+//	[1xxxxxxx][offset1][offset2][offset3][offset4][size1][size2][size3]
+//
+// where the lower seven bits of the opcode determine which non-zero offset and
+// size bytes are present in little-endian order: if bit 0 is set, offset1 is
+// present, etc. If no offset or size bytes are present, offset is 0 and size
+// is 0x10000. See also pack-format.txt in the Git source.
+func applyBinaryDeltaCopy(w io.Writer, op byte, delta []byte, src io.ReaderAt) (n int64, rest []byte, err error) {
+	const defaultSize = 0x10000
+
+	unpack := func(start, bits uint) (v int64) {
+		for i := uint(0); i < bits; i++ {
+			mask := byte(1 << (i + start))
+			if op&mask > 0 {
+				if len(delta) == 0 {
+					err = errors.New("corrupt binary delta: incomplete copy")
+					return
+				}
+				v |= int64(delta[0]) << (8 * i)
+				delta = delta[1:]
+			}
+		}
+		return
+	}
+
+	offset := unpack(0, 4)
+	size := unpack(4, 3)
+	if err != nil {
+		return 0, delta, err
+	}
+	if size == 0 {
+		size = defaultSize
+	}
+
+	// TODO(bkeyes): consider pooling these buffers
+	b := make([]byte, size)
+	if _, err := src.ReadAt(b, offset); err != nil {
+		return 0, delta, err
+	}
+
+	_, err = w.Write(b)
+	return size, delta, err
+}
+
+func checkBinarySrcSize(r io.ReaderAt, size int64) error {
+	ok, err := isLen(r, size)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return &Conflict{"fragment src size does not match actual src size"}
+	}
+	return nil
+}
diff --git a/internal/gitdiff/apply_text.go b/internal/gitdiff/apply_text.go
new file mode 100644
index 0000000..8d0accb
--- /dev/null
+++ b/internal/gitdiff/apply_text.go
@@ -0,0 +1,158 @@
+package gitdiff
+
+import (
+	"errors"
+	"io"
+)
+
+// TextApplier applies changes described in text fragments to source data. If
+// changes are described in multiple fragments, those fragments must be applied
+// in order. The applier must be closed after use.
+//
+// By default, TextApplier operates in "strict" mode, where fragment content
+// and positions must exactly match those of the source.
+type TextApplier struct {
+	dst      io.Writer
+	src      io.ReaderAt
+	lineSrc  LineReaderAt
+	nextLine int64
+
+	closed bool
+	dirty  bool
+}
+
+// NewTextApplier creates a TextApplier that reads data from src and writes
+// modified data to dst. If src implements LineReaderAt, it is used directly.
+func NewTextApplier(dst io.Writer, src io.ReaderAt) *TextApplier {
+	a := TextApplier{
+		dst: dst,
+		src: src,
+	}
+
+	if lineSrc, ok := src.(LineReaderAt); ok {
+		a.lineSrc = lineSrc
+	} else {
+		a.lineSrc = &lineReaderAt{r: src}
+	}
+
+	return &a
+}
+
+// ApplyFragment applies the changes in the fragment f, writing unwritten data
+// before the start of the fragment and any changes from the fragment. If
+// multiple text fragments apply to the same content, ApplyFragment must be
+// called in order of increasing start position. As a result, each fragment can
+// be applied at most once.
+//
+// If an error occurs while applying, ApplyFragment returns an *ApplyError that
+// annotates the error with additional information. If the error is because of
+// a conflict between the fragment and the source, the wrapped error will be a
+// *Conflict.
+func (a *TextApplier) ApplyFragment(f *TextFragment) error {
+	if a.closed {
+		return applyError(errApplierClosed)
+	}
+
+	// mark an apply as in progress, even if it fails before making changes
+	a.dirty = true
+
+	// application code assumes fragment fields are consistent
+	if err := f.Validate(); err != nil {
+		return applyError(err)
+	}
+
+	// lines are 0-indexed, positions are 1-indexed (but new files have position = 0)
+	fragStart := f.OldPosition - 1
+	if fragStart < 0 {
+		fragStart = 0
+	}
+	fragEnd := fragStart + f.OldLines
+
+	start := a.nextLine
+	if fragStart < start {
+		return applyError(&Conflict{"fragment overlaps with an applied fragment"})
+	}
+
+	if f.OldPosition == 0 {
+		ok, err := isLen(a.src, 0)
+		if err != nil {
+			return applyError(err)
+		}
+		if !ok {
+			return applyError(&Conflict{"cannot create new file from non-empty src"})
+		}
+	}
+
+	preimage := make([][]byte, fragEnd-start)
+	n, err := a.lineSrc.ReadLinesAt(preimage, start)
+	if err != nil {
+		// an EOF indicates that source file is shorter than the patch expects,
+		// which should be reported as a conflict rather than a generic error
+		if errors.Is(err, io.EOF) {
+			err = &Conflict{"src has fewer lines than required by fragment"}
+		}
+		return applyError(err, lineNum(start+int64(n)))
+	}
+
+	// copy leading data before the fragment starts
+	for i, line := range preimage[:fragStart-start] {
+		if _, err := a.dst.Write(line); err != nil {
+			a.nextLine = start + int64(i)
+			return applyError(err, lineNum(a.nextLine))
+		}
+	}
+	preimage = preimage[fragStart-start:]
+
+	// apply the changes in the fragment
+	used := int64(0)
+	for i, line := range f.Lines {
+		if err := applyTextLine(a.dst, line, preimage, used); err != nil {
+			a.nextLine = fragStart + used
+			return applyError(err, lineNum(a.nextLine), fragLineNum(i))
+		}
+		if line.Old() {
+			used++
+		}
+	}
+	a.nextLine = fragStart + used
+
+	// new position of +0,0 mean a full delete, so check for leftovers
+	if f.NewPosition == 0 && f.NewLines == 0 {
+		var b [1][]byte
+		n, err := a.lineSrc.ReadLinesAt(b[:], a.nextLine)
+		if err != nil && err != io.EOF {
+			return applyError(err, lineNum(a.nextLine))
+		}
+		if n > 0 {
+			return applyError(&Conflict{"src still has content after full delete"}, lineNum(a.nextLine))
+		}
+	}
+
+	return nil
+}
+
+func applyTextLine(dst io.Writer, line Line, preimage [][]byte, i int64) (err error) {
+	if line.Old() && string(preimage[i]) != line.Line {
+		return &Conflict{"fragment line does not match src line"}
+	}
+	if line.New() {
+		_, err = io.WriteString(dst, line.Line)
+	}
+	return err
+}
+
+// Close writes any data following the last applied fragment and prevents
+// future calls to ApplyFragment.
+func (a *TextApplier) Close() (err error) {
+	if a.closed {
+		return nil
+	}
+
+	a.closed = true
+	if !a.dirty {
+		_, err = copyFrom(a.dst, a.src, 0)
+	} else {
+		_, err = copyLinesFrom(a.dst, a.lineSrc, a.nextLine)
+	}
+	return err
+}
diff --git a/internal/gitdiff/base85.go b/internal/gitdiff/base85.go
new file mode 100644
index 0000000..86db117
--- /dev/null
+++ b/internal/gitdiff/base85.go
@@ -0,0 +1,91 @@
+package gitdiff
+
+import (
+	"fmt"
+)
+
+var (
+	b85Table map[byte]byte
+	b85Alpha = []byte(
+		"0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "!#$%&()*+-;<=>?@^_`{|}~",
+	)
+)
+
+func init() {
+	b85Table = make(map[byte]byte)
+	for i, c := range b85Alpha {
+		b85Table[c] = byte(i)
+	}
+}
+
+// base85Decode decodes Base85-encoded data from src into dst. It uses the
+// alphabet defined by base85.c in the Git source tree. src must contain at
+// least len(dst) bytes of encoded data.
+func base85Decode(dst, src []byte) error {
+	var v uint32
+	var n, ndst int
+	for i, b := range src {
+		if b, ok := b85Table[b]; ok {
+			v = 85*v + uint32(b)
+			n++
+		} else {
+			return fmt.Errorf("invalid base85 byte at index %d: 0x%X", i, src[i])
+		}
+		if n == 5 {
+			rem := len(dst) - ndst
+			for j := 0; j < 4 && j < rem; j++ {
+				dst[ndst] = byte(v >> 24)
+				ndst++
+				v <<= 8
+			}
+			v = 0
+			n = 0
+		}
+	}
+	if n > 0 {
+		return fmt.Errorf("base85 data terminated by underpadded sequence")
+	}
+	if ndst < len(dst) {
+		return fmt.Errorf("base85 data underrun: %d < %d", ndst, len(dst))
+	}
+	return nil
+}
+
+// base85Encode encodes src in Base85, writing the result to dst. It uses the
+// alphabet defined by base85.c in the Git source tree.
+func base85Encode(dst, src []byte) {
+	var di, si int
+
+	encode := func(v uint32) {
+		dst[di+0] = b85Alpha[(v/(85*85*85*85))%85]
+		dst[di+1] = b85Alpha[(v/(85*85*85))%85]
+		dst[di+2] = b85Alpha[(v/(85*85))%85]
+		dst[di+3] = b85Alpha[(v/85)%85]
+		dst[di+4] = b85Alpha[v%85]
+	}
+
+	n := (len(src) / 4) * 4
+	for si < n {
+		encode(uint32(src[si+0])<<24 | uint32(src[si+1])<<16 | uint32(src[si+2])<<8 | uint32(src[si+3]))
+		si += 4
+		di += 5
+	}
+
+	var v uint32
+	switch len(src) - si {
+	case 3:
+		v |= uint32(src[si+2]) << 8
+		fallthrough
+	case 2:
+		v |= uint32(src[si+1]) << 16
+		fallthrough
+	case 1:
+		v |= uint32(src[si+0]) << 24
+		encode(v)
+	}
+}
+
+// base85Len returns the length of n bytes of Base85 encoded data.
+func base85Len(n int) int {
+	return (n + 3) / 4 * 5
+}
diff --git a/internal/gitdiff/binary.go b/internal/gitdiff/binary.go
new file mode 100644
index 0000000..282e323
--- /dev/null
+++ b/internal/gitdiff/binary.go
@@ -0,0 +1,186 @@
+package gitdiff
+
+import (
+	"bytes"
+	"compress/zlib"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"strconv"
+	"strings"
+)
+
+func (p *parser) ParseBinaryFragments(f *File) (n int, err error) {
+	isBinary, hasData, err := p.ParseBinaryMarker()
+	if err != nil || !isBinary {
+		return 0, err
+	}
+
+	f.IsBinary = true
+	if !hasData {
+		return 0, nil
+	}
+
+	forward, err := p.ParseBinaryFragmentHeader()
+	if err != nil {
+		return 0, err
+	}
+	if forward == nil {
+		return 0, p.Errorf(0, "missing data for binary patch")
+	}
+	if err := p.ParseBinaryChunk(forward); err != nil {
+		return 0, err
+	}
+	f.BinaryFragment = forward
+
+	// valid for reverse to not exist, but it must be valid if present
+	reverse, err := p.ParseBinaryFragmentHeader()
+	if err != nil {
+		return 1, err
+	}
+	if reverse == nil {
+		return 1, nil
+	}
+	if err := p.ParseBinaryChunk(reverse); err != nil {
+		return 1, err
+	}
+	f.ReverseBinaryFragment = reverse
+
+	return 1, nil
+}
+
+func (p *parser) ParseBinaryMarker() (isBinary bool, hasData bool, err error) {
+	line := p.Line(0)
+	switch {
+	case line == "GIT binary patch\n":
+		hasData = true
+	case isBinaryNoDataMarker(line):
+	default:
+		return false, false, nil
+	}
+
+	if err = p.Next(); err != nil && err != io.EOF {
+		return false, false, err
+	}
+	return true, hasData, nil
+}
+
+func isBinaryNoDataMarker(line string) bool {
+	if strings.HasSuffix(line, " differ\n") {
+		return strings.HasPrefix(line, "Binary files ") || strings.HasPrefix(line, "Files ")
+	}
+	return false
+}
+
+func (p *parser) ParseBinaryFragmentHeader() (*BinaryFragment, error) {
+	parts := strings.SplitN(strings.TrimSuffix(p.Line(0), "\n"), " ", 2)
+	if len(parts) < 2 {
+		return nil, nil
+	}
+
+	frag := &BinaryFragment{}
+	switch parts[0] {
+	case "delta":
+		frag.Method = BinaryPatchDelta
+	case "literal":
+		frag.Method = BinaryPatchLiteral
+	default:
+		return nil, nil
+	}
+
+	var err error
+	if frag.Size, err = strconv.ParseInt(parts[1], 10, 64); err != nil {
+		nerr := err.(*strconv.NumError)
+		return nil, p.Errorf(0, "binary patch: invalid size: %v", nerr.Err)
+	}
+
+	if err := p.Next(); err != nil && err != io.EOF {
+		return nil, err
+	}
+	return frag, nil
+}
+
+func (p *parser) ParseBinaryChunk(frag *BinaryFragment) error {
+	// Binary fragments are encoded as a series of base85 encoded lines. Each
+	// line starts with a character in [A-Za-z] giving the number of bytes on
+	// the line, where A = 1 and z = 52, and ends with a newline character.
+	//
+	// The base85 encoding means each line is a multiple of 5 characters + 2
+	// additional characters for the length byte and the newline. The fragment
+	// ends with a blank line.
+	const (
+		shortestValidLine = "A00000\n"
+		maxBytesPerLine   = 52
+	)
+
+	var data bytes.Buffer
+	buf := make([]byte, maxBytesPerLine)
+	for {
+		line := p.Line(0)
+		if line == "\n" {
+			break
+		}
+		if len(line) < len(shortestValidLine) || (len(line)-2)%5 != 0 {
+			return p.Errorf(0, "binary patch: corrupt data line")
+		}
+
+		byteCount, seq := int(line[0]), line[1:len(line)-1]
+		switch {
+		case 'A' <= byteCount && byteCount <= 'Z':
+			byteCount = byteCount - 'A' + 1
+		case 'a' <= byteCount && byteCount <= 'z':
+			byteCount = byteCount - 'a' + 27
+		default:
+			return p.Errorf(0, "binary patch: invalid length byte")
+		}
+
+		// base85 encodes every 4 bytes into 5 characters, with up to 3 bytes of end padding
+		maxByteCount := len(seq) / 5 * 4
+		if byteCount > maxByteCount || byteCount < maxByteCount-3 {
+			return p.Errorf(0, "binary patch: incorrect byte count")
+		}
+
+		if err := base85Decode(buf[:byteCount], []byte(seq)); err != nil {
+			return p.Errorf(0, "binary patch: %v", err)
+		}
+		data.Write(buf[:byteCount])
+
+		if err := p.Next(); err != nil {
+			if err == io.EOF {
+				return p.Errorf(0, "binary patch: unexpected EOF")
+			}
+			return err
+		}
+	}
+
+	if err := inflateBinaryChunk(frag, &data); err != nil {
+		return p.Errorf(0, "binary patch: %v", err)
+	}
+
+	// consume the empty line that ended the fragment
+	if err := p.Next(); err != nil && err != io.EOF {
+		return err
+	}
+	return nil
+}
+
+func inflateBinaryChunk(frag *BinaryFragment, r io.Reader) error {
+	zr, err := zlib.NewReader(r)
+	if err != nil {
+		return err
+	}
+
+	data, err := ioutil.ReadAll(zr)
+	if err != nil {
+		return err
+	}
+	if err := zr.Close(); err != nil {
+		return err
+	}
+
+	if int64(len(data)) != frag.Size {
+		return fmt.Errorf("%d byte fragment inflated to %d", frag.Size, len(data))
+	}
+	frag.Data = data
+	return nil
+}
diff --git a/internal/gitdiff/file_header.go b/internal/gitdiff/file_header.go
new file mode 100644
index 0000000..7ae4bc9
--- /dev/null
+++ b/internal/gitdiff/file_header.go
@@ -0,0 +1,546 @@
+package gitdiff
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	devNull = "/dev/null"
+)
+
+// ParseNextFileHeader finds and parses the next file header in the stream. If
+// a header is found, it returns a file and all input before the header. It
+// returns nil if no headers are found before the end of the input.
+func (p *parser) ParseNextFileHeader() (*File, string, error) {
+	var preamble strings.Builder
+	var file *File
+	for {
+		// check for disconnected fragment headers (corrupt patch)
+		frag, err := p.ParseTextFragmentHeader()
+		if err != nil {
+			// not a valid header, nothing to worry about
+			goto NextLine
+		}
+		if frag != nil {
+			return nil, "", p.Errorf(-1, "patch fragment without file header: %s", frag.Header())
+		}
+
+		// check for a git-generated patch
+		file, err = p.ParseGitFileHeader()
+		if err != nil {
+			return nil, "", err
+		}
+		if file != nil {
+			return file, preamble.String(), nil
+		}
+
+		// check for a "traditional" patch
+		file, err = p.ParseTraditionalFileHeader()
+		if err != nil {
+			return nil, "", err
+		}
+		if file != nil {
+			return file, preamble.String(), nil
+		}
+
+	NextLine:
+		preamble.WriteString(p.Line(0))
+		if err := p.Next(); err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, "", err
+		}
+	}
+	return nil, preamble.String(), nil
+}
+
+func (p *parser) ParseGitFileHeader() (*File, error) {
+	const prefix = "diff --git "
+
+	if !strings.HasPrefix(p.Line(0), prefix) {
+		return nil, nil
+	}
+	header := p.Line(0)[len(prefix):]
+
+	defaultName, err := parseGitHeaderName(header)
+	if err != nil {
+		return nil, p.Errorf(0, "git file header: %v", err)
+	}
+
+	f := &File{}
+	for {
+		end, err := parseGitHeaderData(f, p.Line(1), defaultName)
+		if err != nil {
+			return nil, p.Errorf(1, "git file header: %v", err)
+		}
+
+		if err := p.Next(); err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, err
+		}
+
+		if end {
+			break
+		}
+	}
+
+	if f.OldName == "" && f.NewName == "" {
+		if defaultName == "" {
+			return nil, p.Errorf(0, "git file header: missing filename information")
+		}
+		f.OldName = defaultName
+		f.NewName = defaultName
+	}
+
+	if (f.NewName == "" && !f.IsDelete) || (f.OldName == "" && !f.IsNew) {
+		return nil, p.Errorf(0, "git file header: missing filename information")
+	}
+
+	return f, nil
+}
+
+func (p *parser) ParseTraditionalFileHeader() (*File, error) {
+	const shortestValidFragHeader = "@@ -1 +1 @@\n"
+	const (
+		oldPrefix = "--- "
+		newPrefix = "+++ "
+	)
+
+	oldLine, newLine := p.Line(0), p.Line(1)
+
+	if !strings.HasPrefix(oldLine, oldPrefix) || !strings.HasPrefix(newLine, newPrefix) {
+		return nil, nil
+	}
+	// heuristic: only a file header if followed by a (probable) fragment header
+	if len(p.Line(2)) < len(shortestValidFragHeader) || !strings.HasPrefix(p.Line(2), "@@ -") {
+		return nil, nil
+	}
+
+	// advance past the first two lines so parser is after the header
+	// no EOF check needed because we know there are >=3 valid lines
+	if err := p.Next(); err != nil {
+		return nil, err
+	}
+	if err := p.Next(); err != nil {
+		return nil, err
+	}
+
+	oldName, _, err := parseName(oldLine[len(oldPrefix):], '\t', 0)
+	if err != nil {
+		return nil, p.Errorf(0, "file header: %v", err)
+	}
+
+	newName, _, err := parseName(newLine[len(newPrefix):], '\t', 0)
+	if err != nil {
+		return nil, p.Errorf(1, "file header: %v", err)
+	}
+
+	f := &File{}
+	switch {
+	case oldName == devNull || hasEpochTimestamp(oldLine):
+		f.IsNew = true
+		f.NewName = newName
+	case newName == devNull || hasEpochTimestamp(newLine):
+		f.IsDelete = true
+		f.OldName = oldName
+	default:
+		// if old name is a prefix of new name, use that instead
+		// this avoids picking variants like "file.bak" or "file~"
+		if strings.HasPrefix(newName, oldName) {
+			f.OldName = oldName
+			f.NewName = oldName
+		} else {
+			f.OldName = newName
+			f.NewName = newName
+		}
+	}
+
+	return f, nil
+}
+
+// parseGitHeaderName extracts a default file name from the Git file header
+// line. This is required for mode-only changes and creation/deletion of empty
+// files. Other types of patch include the file name(s) in the header data.
+// If the names in the header do not match because the patch is a rename,
+// return an empty default name.
+func parseGitHeaderName(header string) (string, error) {
+	header = strings.TrimSuffix(header, "\n")
+	if len(header) == 0 {
+		return "", nil
+	}
+
+	var err error
+	var first, second string
+
+	// there are 4 cases to account for:
+	//
+	//   1) unquoted unquoted
+	//   2) unquoted "quoted"
+	//   3) "quoted" unquoted
+	//   4) "quoted" "quoted"
+	//
+	quote := strings.IndexByte(header, '"')
+	switch {
+	case quote < 0:
+		// case 1
+		first = header
+
+	case quote > 0:
+		// case 2
+		first = header[:quote-1]
+		if !isSpace(header[quote-1]) {
+			return "", fmt.Errorf("missing separator")
+		}
+
+		second, _, err = parseQuotedName(header[quote:])
+		if err != nil {
+			return "", err
+		}
+
+	case quote == 0:
+		// case 3 or case 4
+		var n int
+		first, n, err = parseQuotedName(header)
+		if err != nil {
+			return "", err
+		}
+
+		// git accepts multiple spaces after a quoted name, but not after an
+		// unquoted name, since the name might end with one or more spaces
+		for n < len(header) && isSpace(header[n]) {
+			n++
+		}
+		if n == len(header) {
+			return "", nil
+		}
+
+		if header[n] == '"' {
+			second, _, err = parseQuotedName(header[n:])
+			if err != nil {
+				return "", err
+			}
+		} else {
+			second = header[n:]
+		}
+	}
+
+	first = trimTreePrefix(first, 1)
+	if second != "" {
+		if first == trimTreePrefix(second, 1) {
+			return first, nil
+		}
+		return "", nil
+	}
+
+	// at this point, both names are unquoted (case 1)
+	// since names may contain spaces, we can't use a known separator
+	// instead, look for a split that produces two equal names
+
+	for i := 0; i < len(first)-1; i++ {
+		if !isSpace(first[i]) {
+			continue
+		}
+		second = trimTreePrefix(first[i+1:], 1)
+		if name := first[:i]; name == second {
+			return name, nil
+		}
+	}
+	return "", nil
+}
+
+// parseGitHeaderData parses a single line of metadata from a Git file header.
+// It returns true when header parsing is complete; in that case, line was the
+// first line of non-header content.
+func parseGitHeaderData(f *File, line, defaultName string) (end bool, err error) {
+	if len(line) > 0 && line[len(line)-1] == '\n' {
+		line = line[:len(line)-1]
+	}
+
+	for _, hdr := range []struct {
+		prefix string
+		end    bool
+		parse  func(*File, string, string) error
+	}{
+		{"@@ -", true, nil},
+		{"--- ", false, parseGitHeaderOldName},
+		{"+++ ", false, parseGitHeaderNewName},
+		{"old mode ", false, parseGitHeaderOldMode},
+		{"new mode ", false, parseGitHeaderNewMode},
+		{"deleted file mode ", false, parseGitHeaderDeletedMode},
+		{"new file mode ", false, parseGitHeaderCreatedMode},
+		{"copy from ", false, parseGitHeaderCopyFrom},
+		{"copy to ", false, parseGitHeaderCopyTo},
+		{"rename old ", false, parseGitHeaderRenameFrom},
+		{"rename new ", false, parseGitHeaderRenameTo},
+		{"rename from ", false, parseGitHeaderRenameFrom},
+		{"rename to ", false, parseGitHeaderRenameTo},
+		{"similarity index ", false, parseGitHeaderScore},
+		{"dissimilarity index ", false, parseGitHeaderScore},
+		{"index ", false, parseGitHeaderIndex},
+	} {
+		if strings.HasPrefix(line, hdr.prefix) {
+			if hdr.parse != nil {
+				err = hdr.parse(f, line[len(hdr.prefix):], defaultName)
+			}
+			return hdr.end, err
+		}
+	}
+
+	// unknown line indicates the end of the header
+	// this usually happens if the diff is empty
+	return true, nil
+}
+
+func parseGitHeaderOldName(f *File, line, defaultName string) error {
+	name, _, err := parseName(line, '\t', 1)
+	if err != nil {
+		return err
+	}
+	if f.OldName == "" && !f.IsNew {
+		f.OldName = name
+		return nil
+	}
+	return verifyGitHeaderName(name, f.OldName, f.IsNew, "old")
+}
+
+func parseGitHeaderNewName(f *File, line, defaultName string) error {
+	name, _, err := parseName(line, '\t', 1)
+	if err != nil {
+		return err
+	}
+	if f.NewName == "" && !f.IsDelete {
+		f.NewName = name
+		return nil
+	}
+	return verifyGitHeaderName(name, f.NewName, f.IsDelete, "new")
+}
+
+func parseGitHeaderOldMode(f *File, line, defaultName string) (err error) {
+	f.OldMode, err = parseMode(strings.TrimSpace(line))
+	return
+}
+
+func parseGitHeaderNewMode(f *File, line, defaultName string) (err error) {
+	f.NewMode, err = parseMode(strings.TrimSpace(line))
+	return
+}
+
+func parseGitHeaderDeletedMode(f *File, line, defaultName string) error {
+	f.IsDelete = true
+	f.OldName = defaultName
+	return parseGitHeaderOldMode(f, line, defaultName)
+}
+
+func parseGitHeaderCreatedMode(f *File, line, defaultName string) error {
+	f.IsNew = true
+	f.NewName = defaultName
+	return parseGitHeaderNewMode(f, line, defaultName)
+}
+
+func parseGitHeaderCopyFrom(f *File, line, defaultName string) (err error) {
+	f.IsCopy = true
+	f.OldName, _, err = parseName(line, 0, 0)
+	return
+}
+
+func parseGitHeaderCopyTo(f *File, line, defaultName string) (err error) {
+	f.IsCopy = true
+	f.NewName, _, err = parseName(line, 0, 0)
+	return
+}
+
+func parseGitHeaderRenameFrom(f *File, line, defaultName string) (err error) {
+	f.IsRename = true
+	f.OldName, _, err = parseName(line, 0, 0)
+	return
+}
+
+func parseGitHeaderRenameTo(f *File, line, defaultName string) (err error) {
+	f.IsRename = true
+	f.NewName, _, err = parseName(line, 0, 0)
+	return
+}
+
+func parseGitHeaderScore(f *File, line, defaultName string) error {
+	score, err := strconv.ParseInt(strings.TrimSuffix(line, "%"), 10, 32)
+	if err != nil {
+		nerr := err.(*strconv.NumError)
+		return fmt.Errorf("invalid score line: %v", nerr.Err)
+	}
+	if score <= 100 {
+		f.Score = int(score)
+	}
+	return nil
+}
+
+func parseGitHeaderIndex(f *File, line, defaultName string) error {
+	const sep = ".."
+
+	// note that git stops parsing if the OIDs are too long to be valid
+	// checking this requires knowing if the repository uses SHA1 or SHA256
+	// hashes, which we don't know, so we just skip that check
+
+	parts := strings.SplitN(line, " ", 2)
+	oids := strings.SplitN(parts[0], sep, 2)
+
+	if len(oids) < 2 {
+		return fmt.Errorf("invalid index line: missing %q", sep)
+	}
+	f.OldOIDPrefix, f.NewOIDPrefix = oids[0], oids[1]
+
+	if len(parts) > 1 {
+		return parseGitHeaderOldMode(f, parts[1], defaultName)
+	}
+	return nil
+}
+
+func parseMode(s string) (os.FileMode, error) {
+	mode, err := strconv.ParseInt(s, 8, 32)
+	if err != nil {
+		nerr := err.(*strconv.NumError)
+		return os.FileMode(0), fmt.Errorf("invalid mode line: %v", nerr.Err)
+	}
+	return os.FileMode(mode), nil
+}
+
+// parseName extracts a file name from the start of a string and returns the
+// name and the index of the first character after the name. If the name is
+// unquoted and term is non-zero, parsing stops at the first occurrence of
+// term.
+//
+// If the name is exactly "/dev/null", no further processing occurs. Otherwise,
+// if dropPrefix is greater than zero, that number of prefix components
+// separated by forward slashes are dropped from the name and any duplicate
+// slashes are collapsed.
+func parseName(s string, term byte, dropPrefix int) (name string, n int, err error) {
+	if len(s) > 0 && s[0] == '"' {
+		name, n, err = parseQuotedName(s)
+	} else {
+		name, n, err = parseUnquotedName(s, term)
+	}
+	if err != nil {
+		return "", 0, err
+	}
+	if name == devNull {
+		return name, n, nil
+	}
+	return cleanName(name, dropPrefix), n, nil
+}
+
+func parseQuotedName(s string) (name string, n int, err error) {
+	for n = 1; n < len(s); n++ {
+		if s[n] == '"' && s[n-1] != '\\' {
+			n++
+			break
+		}
+	}
+	if n == 2 {
+		return "", 0, fmt.Errorf("missing name")
+	}
+	if name, err = strconv.Unquote(s[:n]); err != nil {
+		return "", 0, err
+	}
+	return name, n, err
+}
+
+func parseUnquotedName(s string, term byte) (name string, n int, err error) {
+	for n = 0; n < len(s); n++ {
+		if s[n] == '\n' {
+			break
+		}
+		if term > 0 && s[n] == term {
+			break
+		}
+	}
+	if n == 0 {
+		return "", 0, fmt.Errorf("missing name")
+	}
+	return s[:n], n, nil
+}
+
+// verifyGitHeaderName checks a parsed name against state set by previous lines
+func verifyGitHeaderName(parsed, existing string, isNull bool, side string) error {
+	if existing != "" {
+		if isNull {
+			return fmt.Errorf("expected %s, but filename is set to %s", devNull, existing)
+		}
+		if existing != parsed {
+			return fmt.Errorf("inconsistent %s filename", side)
+		}
+	}
+	if isNull && parsed != devNull {
+		return fmt.Errorf("expected %s", devNull)
+	}
+	return nil
+}
+
+// cleanName removes double slashes and drops prefix segments.
+func cleanName(name string, drop int) string {
+	var b strings.Builder
+	for i := 0; i < len(name); i++ {
+		if name[i] == '/' {
+			if i < len(name)-1 && name[i+1] == '/' {
+				continue
+			}
+			if drop > 0 {
+				drop--
+				b.Reset()
+				continue
+			}
+		}
+		b.WriteByte(name[i])
+	}
+	return b.String()
+}
+
+// trimTreePrefix removes up to n leading directory components from name.
+func trimTreePrefix(name string, n int) string {
+	i := 0
+	for ; i < len(name) && n > 0; i++ {
+		if name[i] == '/' {
+			n--
+		}
+	}
+	return name[i:]
+}
+
+// hasEpochTimestamp returns true if the string ends with a POSIX-formatted
+// timestamp for the UNIX epoch after a tab character. According to git, this
+// is used by GNU diff to mark creations and deletions.
+func hasEpochTimestamp(s string) bool {
+	const posixTimeLayout = "2006-01-02 15:04:05.9 -0700"
+
+	start := strings.IndexRune(s, '\t')
+	if start < 0 {
+		return false
+	}
+
+	ts := strings.TrimSuffix(s[start+1:], "\n")
+
+	// a valid timestamp can have optional ':' in zone specifier
+	// remove that if it exists so we have a single format
+	if len(ts) >= 3 && ts[len(ts)-3] == ':' {
+		ts = ts[:len(ts)-3] + ts[len(ts)-2:]
+	}
+
+	t, err := time.Parse(posixTimeLayout, ts)
+	if err != nil {
+		return false
+	}
+	if !t.Equal(time.Unix(0, 0)) {
+		return false
+	}
+	return true
+}
+
+func isSpace(c byte) bool {
+	return c == ' ' || c == '\t' || c == '\n'
+}
diff --git a/internal/gitdiff/format.go b/internal/gitdiff/format.go
new file mode 100644
index 0000000..d97aba9
--- /dev/null
+++ b/internal/gitdiff/format.go
@@ -0,0 +1,281 @@
+package gitdiff
+
+import (
+	"bytes"
+	"compress/zlib"
+	"fmt"
+	"io"
+	"strconv"
+)
+
+type formatter struct {
+	w   io.Writer
+	err error
+}
+
+func newFormatter(w io.Writer) *formatter {
+	return &formatter{w: w}
+}
+
+func (fm *formatter) Write(p []byte) (int, error) {
+	if fm.err != nil {
+		return len(p), nil
+	}
+	if _, err := fm.w.Write(p); err != nil {
+		fm.err = err
+	}
+	return len(p), nil
+}
+
+func (fm *formatter) WriteString(s string) (int, error) {
+	fm.Write([]byte(s))
+	return len(s), nil
+}
+
+func (fm *formatter) WriteByte(c byte) error {
+	fm.Write([]byte{c})
+	return nil
+}
+
+func (fm *formatter) WriteQuotedName(s string) {
+	qpos := 0
+	for i := 0; i < len(s); i++ {
+		ch := s[i]
+		if q, quoted := quoteByte(ch); quoted {
+			if qpos == 0 {
+				fm.WriteByte('"')
+			}
+			fm.WriteString(s[qpos:i])
+			fm.Write(q)
+			qpos = i + 1
+		}
+	}
+	fm.WriteString(s[qpos:])
+	if qpos > 0 {
+		fm.WriteByte('"')
+	}
+}
+
+var quoteEscapeTable = map[byte]byte{
+	'\a': 'a',
+	'\b': 'b',
+	'\t': 't',
+	'\n': 'n',
+	'\v': 'v',
+	'\f': 'f',
+	'\r': 'r',
+	'"':  '"',
+	'\\': '\\',
+}
+
+func quoteByte(b byte) ([]byte, bool) {
+	if q, ok := quoteEscapeTable[b]; ok {
+		return []byte{'\\', q}, true
+	}
+	if b < 0x20 || b >= 0x7F {
+		return []byte{
+			'\\',
+			'0' + (b>>6)&0o3,
+			'0' + (b>>3)&0o7,
+			'0' + (b>>0)&0o7,
+		}, true
+	}
+	return nil, false
+}
+
+func (fm *formatter) FormatFile(f *File) {
+	fm.WriteString("diff --git ")
+
+	var aName, bName string
+	switch {
+	case f.OldName == "":
+		aName = f.NewName
+		bName = f.NewName
+
+	case f.NewName == "":
+		aName = f.OldName
+		bName = f.OldName
+
+	default:
+		aName = f.OldName
+		bName = f.NewName
+	}
+
+	fm.WriteQuotedName("a/" + aName)
+	fm.WriteByte(' ')
+	fm.WriteQuotedName("b/" + bName)
+	fm.WriteByte('\n')
+
+	if f.OldMode != 0 {
+		if f.IsDelete {
+			fmt.Fprintf(fm, "deleted file mode %o\n", f.OldMode)
+		} else if f.NewMode != 0 {
+			fmt.Fprintf(fm, "old mode %o\n", f.OldMode)
+		}
+	}
+
+	if f.NewMode != 0 {
+		if f.IsNew {
+			fmt.Fprintf(fm, "new file mode %o\n", f.NewMode)
+		} else if f.OldMode != 0 {
+			fmt.Fprintf(fm, "new mode %o\n", f.NewMode)
+		}
+	}
+
+	if f.Score > 0 {
+		if f.IsCopy || f.IsRename {
+			fmt.Fprintf(fm, "similarity index %d%%\n", f.Score)
+		} else {
+			fmt.Fprintf(fm, "dissimilarity index %d%%\n", f.Score)
+		}
+	}
+
+	if f.IsCopy {
+		if f.OldName != "" {
+			fm.WriteString("copy from ")
+			fm.WriteQuotedName(f.OldName)
+			fm.WriteByte('\n')
+		}
+		if f.NewName != "" {
+			fm.WriteString("copy to ")
+			fm.WriteQuotedName(f.NewName)
+			fm.WriteByte('\n')
+		}
+	}
+
+	if f.IsRename {
+		if f.OldName != "" {
+			fm.WriteString("rename from ")
+			fm.WriteQuotedName(f.OldName)
+			fm.WriteByte('\n')
+		}
+		if f.NewName != "" {
+			fm.WriteString("rename to ")
+			fm.WriteQuotedName(f.NewName)
+			fm.WriteByte('\n')
+		}
+	}
+
+	if f.OldOIDPrefix != "" && f.NewOIDPrefix != "" {
+		fmt.Fprintf(fm, "index %s..%s", f.OldOIDPrefix, f.NewOIDPrefix)
+
+		// Mode is only included on the index line when it is not changing
+		if f.OldMode != 0 && ((f.NewMode == 0 && !f.IsDelete) || f.OldMode == f.NewMode) {
+			fmt.Fprintf(fm, " %o", f.OldMode)
+		}
+
+		fm.WriteByte('\n')
+	}
+
+	if f.IsBinary {
+		if f.BinaryFragment == nil {
+			fm.WriteString("Binary files ")
+			fm.WriteQuotedName("a/" + aName)
+			fm.WriteString(" and ")
+			fm.WriteQuotedName("b/" + bName)
+			fm.WriteString(" differ\n")
+		} else {
+			fm.WriteString("GIT binary patch\n")
+			fm.FormatBinaryFragment(f.BinaryFragment)
+			if f.ReverseBinaryFragment != nil {
+				fm.FormatBinaryFragment(f.ReverseBinaryFragment)
+			}
+		}
+	}
+
+	// The "---" and "+++" lines only appear for text patches with fragments
+	if len(f.TextFragments) > 0 {
+		fm.WriteString("--- ")
+		if f.OldName == "" {
+			fm.WriteString("/dev/null")
+		} else {
+			fm.WriteQuotedName("a/" + f.OldName)
+		}
+		fm.WriteByte('\n')
+
+		fm.WriteString("+++ ")
+		if f.NewName == "" {
+			fm.WriteString("/dev/null")
+		} else {
+			fm.WriteQuotedName("b/" + f.NewName)
+		}
+		fm.WriteByte('\n')
+
+		for _, frag := range f.TextFragments {
+			fm.FormatTextFragment(frag)
+		}
+	}
+}
+
+func (fm *formatter) FormatTextFragment(f *TextFragment) {
+	fm.FormatTextFragmentHeader(f)
+	fm.WriteByte('\n')
+
+	for _, line := range f.Lines {
+		fm.WriteString(line.Op.String())
+		fm.WriteString(line.Line)
+		if line.NoEOL() {
+			fm.WriteString("\n\\ No newline at end of file\n")
+		}
+	}
+}
+
+func (fm *formatter) FormatTextFragmentHeader(f *TextFragment) {
+	fmt.Fprintf(fm, "@@ -%d,%d +%d,%d @@", f.OldPosition, f.OldLines, f.NewPosition, f.NewLines)
+	if f.Comment != "" {
+		fm.WriteByte(' ')
+		fm.WriteString(f.Comment)
+	}
+}
+
+func (fm *formatter) FormatBinaryFragment(f *BinaryFragment) {
+	const (
+		maxBytesPerLine = 52
+	)
+
+	switch f.Method {
+	case BinaryPatchDelta:
+		fm.WriteString("delta ")
+	case BinaryPatchLiteral:
+		fm.WriteString("literal ")
+	}
+	fm.Write(strconv.AppendInt(nil, f.Size, 10))
+	fm.WriteByte('\n')
+
+	data := deflateBinaryChunk(f.Data)
+	n := (len(data) / maxBytesPerLine) * maxBytesPerLine
+
+	buf := make([]byte, base85Len(maxBytesPerLine))
+	for i := 0; i < n; i += maxBytesPerLine {
+		base85Encode(buf, data[i:i+maxBytesPerLine])
+		fm.WriteByte('z')
+		fm.Write(buf)
+		fm.WriteByte('\n')
+	}
+	if remainder := len(data) - n; remainder > 0 {
+		buf = buf[0:base85Len(remainder)]
+
+		sizeChar := byte(remainder)
+		if remainder <= 26 {
+			sizeChar = 'A' + sizeChar - 1
+		} else {
+			sizeChar = 'a' + sizeChar - 27
+		}
+
+		base85Encode(buf, data[n:])
+		fm.WriteByte(sizeChar)
+		fm.Write(buf)
+		fm.WriteByte('\n')
+	}
+	fm.WriteByte('\n')
+}
+
+func deflateBinaryChunk(data []byte) []byte {
+	var b bytes.Buffer
+
+	zw := zlib.NewWriter(&b)
+	_, _ = zw.Write(data)
+	_ = zw.Close()
+
+	return b.Bytes()
+}
diff --git a/internal/gitdiff/gitdiff.go b/internal/gitdiff/gitdiff.go
new file mode 100644
index 0000000..5365645
--- /dev/null
+++ b/internal/gitdiff/gitdiff.go
@@ -0,0 +1,230 @@
+package gitdiff
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+)
+
+// File describes changes to a single file. It can be either a text file or a
+// binary file.
+type File struct {
+	OldName string
+	NewName string
+
+	IsNew    bool
+	IsDelete bool
+	IsCopy   bool
+	IsRename bool
+
+	OldMode os.FileMode
+	NewMode os.FileMode
+
+	OldOIDPrefix string
+	NewOIDPrefix string
+	Score        int
+
+	// TextFragments contains the fragments describing changes to a text file. It
+	// may be empty if the file is empty or if only the mode changes.
+	TextFragments []*TextFragment
+
+	// IsBinary is true if the file is a binary file. If the patch includes
+	// binary data, BinaryFragment will be non-nil and describe the changes to
+	// the data. If the patch is reversible, ReverseBinaryFragment will also be
+	// non-nil and describe the changes needed to restore the original file
+	// after applying the changes in BinaryFragment.
+	IsBinary              bool
+	BinaryFragment        *BinaryFragment
+	ReverseBinaryFragment *BinaryFragment
+}
+
+// String returns a git diff representation of this file. The value can be
+// parsed by this library to obtain the same File, but may not be the same as
+// the original input.
+func (f *File) String() string {
+	var diff strings.Builder
+	newFormatter(&diff).FormatFile(f)
+	return diff.String()
+}
+
+// TextFragment describes changed lines starting at a specific line in a text file.
+type TextFragment struct {
+	Comment string
+
+	OldPosition int64
+	OldLines    int64
+
+	NewPosition int64
+	NewLines    int64
+
+	LinesAdded   int64
+	LinesDeleted int64
+
+	LeadingContext  int64
+	TrailingContext int64
+
+	Lines []Line
+}
+
+// String returns a git diff format of this fragment. See [File.String] for
+// more details on this format.
+func (f *TextFragment) String() string {
+	var diff strings.Builder
+	newFormatter(&diff).FormatTextFragment(f)
+	return diff.String()
+}
+
+// Header returns a git diff header of this fragment. See [File.String] for
+// more details on this format.
+func (f *TextFragment) Header() string {
+	var hdr strings.Builder
+	newFormatter(&hdr).FormatTextFragmentHeader(f)
+	return hdr.String()
+}
+
+// Validate checks that the fragment is self-consistent and appliable. Validate
+// returns an error if and only if the fragment is invalid.
+func (f *TextFragment) Validate() error {
+	if f == nil {
+		return errors.New("nil fragment")
+	}
+
+	var (
+		oldLines, newLines                     int64
+		leadingContext, trailingContext        int64
+		contextLines, addedLines, deletedLines int64
+	)
+
+	// count the types of lines in the fragment content
+	for i, line := range f.Lines {
+		switch line.Op {
+		case OpContext:
+			oldLines++
+			newLines++
+			contextLines++
+			if addedLines == 0 && deletedLines == 0 {
+				leadingContext++
+			} else {
+				trailingContext++
+			}
+		case OpAdd:
+			newLines++
+			addedLines++
+			trailingContext = 0
+		case OpDelete:
+			oldLines++
+			deletedLines++
+			trailingContext = 0
+		default:
+			return fmt.Errorf("unknown operator %q on line %d", line.Op, i+1)
+		}
+	}
+
+	// check the actual counts against the reported counts
+	if oldLines != f.OldLines {
+		return lineCountErr("old", oldLines, f.OldLines)
+	}
+	if newLines != f.NewLines {
+		return lineCountErr("new", newLines, f.NewLines)
+	}
+	if leadingContext != f.LeadingContext {
+		return lineCountErr("leading context", leadingContext, f.LeadingContext)
+	}
+	if trailingContext != f.TrailingContext {
+		return lineCountErr("trailing context", trailingContext, f.TrailingContext)
+	}
+	if addedLines != f.LinesAdded {
+		return lineCountErr("added", addedLines, f.LinesAdded)
+	}
+	if deletedLines != f.LinesDeleted {
+		return lineCountErr("deleted", deletedLines, f.LinesDeleted)
+	}
+
+	// if a file is being created, it can only contain additions
+	if f.OldPosition == 0 && f.OldLines != 0 {
+		return errors.New("file creation fragment contains context or deletion lines")
+	}
+
+	return nil
+}
+
+func lineCountErr(kind string, actual, reported int64) error {
+	return fmt.Errorf("fragment contains %d %s lines but reports %d", actual, kind, reported)
+}
+
+// Line is a line in a text fragment.
+type Line struct {
+	Op   LineOp
+	Line string
+}
+
+func (fl Line) String() string {
+	return fl.Op.String() + fl.Line
+}
+
+// Old returns true if the line appears in the old content of the fragment.
+func (fl Line) Old() bool {
+	return fl.Op == OpContext || fl.Op == OpDelete
+}
+
+// New returns true if the line appears in the new content of the fragment.
+func (fl Line) New() bool {
+	return fl.Op == OpContext || fl.Op == OpAdd
+}
+
+// NoEOL returns true if the line is missing a trailing newline character.
+func (fl Line) NoEOL() bool {
+	return len(fl.Line) == 0 || fl.Line[len(fl.Line)-1] != '\n'
+}
+
+// LineOp describes the type of a text fragment line: context, added, or removed.
+type LineOp int
+
+const (
+	// OpContext indicates a context line
+	OpContext LineOp = iota
+	// OpDelete indicates a deleted line
+	OpDelete
+	// OpAdd indicates an added line
+	OpAdd
+)
+
+func (op LineOp) String() string {
+	switch op {
+	case OpContext:
+		return " "
+	case OpDelete:
+		return "-"
+	case OpAdd:
+		return "+"
+	}
+	return "?"
+}
+
+// BinaryFragment describes changes to a binary file.
+type BinaryFragment struct {
+	Method BinaryPatchMethod
+	Size   int64
+	Data   []byte
+}
+
+// BinaryPatchMethod is the method used to create and apply the binary patch.
+type BinaryPatchMethod int
+
+const (
+	// BinaryPatchDelta indicates the data uses Git's packfile encoding
+	BinaryPatchDelta BinaryPatchMethod = iota
+	// BinaryPatchLiteral indicates the data is the exact file content
+	BinaryPatchLiteral
+)
+
+// String returns a git diff format of this fragment. Due to differences in
+// zlib implementation between Go and Git, encoded binary data in the result
+// will likely differ from what Git produces for the same input. See
+// [File.String] for more details on this format.
+func (f *BinaryFragment) String() string {
+	var diff strings.Builder
+	newFormatter(&diff).FormatBinaryFragment(f)
+	return diff.String()
+}
diff --git a/internal/gitdiff/io.go b/internal/gitdiff/io.go
new file mode 100644
index 0000000..8143238
--- /dev/null
+++ b/internal/gitdiff/io.go
@@ -0,0 +1,220 @@
+package gitdiff
+
+import (
+	"errors"
+	"io"
+)
+
+const (
+	byteBufferSize  = 32 * 1024 // from io.Copy
+	lineBufferSize  = 32
+	indexBufferSize = 1024
+)
+
+// LineReaderAt is the interface that wraps the ReadLinesAt method.
+//
+// ReadLinesAt reads len(lines) into lines starting at line offset. It returns
+// the number of lines read (0 <= n <= len(lines)) and any error encountered.
+// Line numbers are zero-indexed.
+//
+// If n < len(lines), ReadLinesAt returns a non-nil error explaining why more
+// lines were not returned.
+//
+// Lines read by ReadLinesAt include the newline character. The last line does
+// not have a final newline character if the input ends without one.
+type LineReaderAt interface {
+	ReadLinesAt(lines [][]byte, offset int64) (n int, err error)
+}
+
+type lineReaderAt struct {
+	r     io.ReaderAt
+	index []int64
+	eof   bool
+}
+
+func (r *lineReaderAt) ReadLinesAt(lines [][]byte, offset int64) (n int, err error) {
+	if offset < 0 {
+		return 0, errors.New("ReadLinesAt: negative offset")
+	}
+	if len(lines) == 0 {
+		return 0, nil
+	}
+
+	count := len(lines)
+	startLine := offset
+	endLine := startLine + int64(count)
+
+	if endLine > int64(len(r.index)) && !r.eof {
+		if err := r.indexTo(endLine); err != nil {
+			return 0, err
+		}
+	}
+	if startLine >= int64(len(r.index)) {
+		return 0, io.EOF
+	}
+
+	buf, byteOffset, err := r.readBytes(startLine, int64(count))
+	if err != nil {
+		return 0, err
+	}
+
+	for n = 0; n < count && startLine+int64(n) < int64(len(r.index)); n++ {
+		lineno := startLine + int64(n)
+		start, end := int64(0), r.index[lineno]-byteOffset
+		if lineno > 0 {
+			start = r.index[lineno-1] - byteOffset
+		}
+		lines[n] = buf[start:end]
+	}
+
+	if n < count {
+		return n, io.EOF
+	}
+	return n, nil
+}
+
+// indexTo reads data and computes the line index until there is information
+// for line or a read returns io.EOF. It returns an error if and only if there
+// is an error reading data.
+func (r *lineReaderAt) indexTo(line int64) error {
+	var buf [indexBufferSize]byte
+
+	offset := r.lastOffset()
+	for int64(len(r.index)) < line {
+		n, err := r.r.ReadAt(buf[:], offset)
+		if err != nil && err != io.EOF {
+			return err
+		}
+		for _, b := range buf[:n] {
+			offset++
+			if b == '\n' {
+				r.index = append(r.index, offset)
+			}
+		}
+		if err == io.EOF {
+			if offset > r.lastOffset() {
+				r.index = append(r.index, offset)
+			}
+			r.eof = true
+			break
+		}
+	}
+	return nil
+}
+
+func (r *lineReaderAt) lastOffset() int64 {
+	if n := len(r.index); n > 0 {
+		return r.index[n-1]
+	}
+	return 0
+}
+
+// readBytes reads the bytes of the n lines starting at line and returns the
+// bytes and the offset of the first byte in the underlying source.
+func (r *lineReaderAt) readBytes(line, n int64) (b []byte, offset int64, err error) {
+	indexLen := int64(len(r.index))
+
+	var size int64
+	if line > indexLen {
+		offset = r.index[indexLen-1]
+	} else if line > 0 {
+		offset = r.index[line-1]
+	}
+	if n > 0 {
+		if line+n > indexLen {
+			size = r.index[indexLen-1] - offset
+		} else {
+			size = r.index[line+n-1] - offset
+		}
+	}
+
+	b = make([]byte, size)
+	if _, err := r.r.ReadAt(b, offset); err != nil {
+		if err == io.EOF {
+			err = errors.New("ReadLinesAt: corrupt line index or changed source data")
+		}
+		return nil, 0, err
+	}
+	return b, offset, nil
+}
+
+func isLen(r io.ReaderAt, n int64) (bool, error) {
+	off := n - 1
+	if off < 0 {
+		off = 0
+	}
+
+	var b [2]byte
+	nr, err := r.ReadAt(b[:], off)
+	if err == io.EOF {
+		return (n == 0 && nr == 0) || (n > 0 && nr == 1), nil
+	}
+	return false, err
+}
+
+// copyFrom writes bytes starting from offset off in src to dst stopping at the
+// end of src or at the first error. copyFrom returns the number of bytes
+// written and any error.
+func copyFrom(dst io.Writer, src io.ReaderAt, off int64) (written int64, err error) {
+	buf := make([]byte, byteBufferSize)
+	for {
+		nr, rerr := src.ReadAt(buf, off)
+		if nr > 0 {
+			nw, werr := dst.Write(buf[0:nr])
+			if nw > 0 {
+				written += int64(nw)
+			}
+			if werr != nil {
+				err = werr
+				break
+			}
+			if nr != nw {
+				err = io.ErrShortWrite
+				break
+			}
+			off += int64(nr)
+		}
+		if rerr != nil {
+			if rerr != io.EOF {
+				err = rerr
+			}
+			break
+		}
+	}
+	return written, err
+}
+
+// copyLinesFrom writes lines starting from line off in src to dst stopping at
+// the end of src or at the first error. copyLinesFrom returns the number of
+// lines written and any error.
+func copyLinesFrom(dst io.Writer, src LineReaderAt, off int64) (written int64, err error) {
+	buf := make([][]byte, lineBufferSize)
+ReadLoop:
+	for {
+		nr, rerr := src.ReadLinesAt(buf, off)
+		if nr > 0 {
+			for _, line := range buf[0:nr] {
+				nw, werr := dst.Write(line)
+				if nw > 0 {
+					written++
+				}
+				if werr != nil {
+					err = werr
+					break ReadLoop
+				}
+				if len(line) != nw {
+					err = io.ErrShortWrite
+					break ReadLoop
+				}
+			}
+			off += int64(nr)
+		}
+		if rerr != nil {
+			if rerr != io.EOF {
+				err = rerr
+			}
+			break
+		}
+	}
+	return written, err
+}
diff --git a/internal/gitdiff/parser.go b/internal/gitdiff/parser.go
new file mode 100644
index 0000000..e8f8430
--- /dev/null
+++ b/internal/gitdiff/parser.go
@@ -0,0 +1,142 @@
+// Package gitdiff parses and applies patches generated by Git. It supports
+// line-oriented text patches, binary patches, and can also parse standard
+// unified diffs generated by other tools.
+package gitdiff
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+)
+
+// Parse parses a patch with changes to one or more files. Any content before
+// the first file is returned as the second value. If an error occurs while
+// parsing, it returns all files parsed before the error.
+//
+// Parse expects to receive a single patch. If the input may contain multiple
+// patches (for example, if it is an mbox file), callers should split it into
+// individual patches and call Parse on each one.
+func Parse(r io.Reader) ([]*File, string, error) {
+	p := newParser(r)
+
+	if err := p.Next(); err != nil {
+		if err == io.EOF {
+			return nil, "", nil
+		}
+		return nil, "", err
+	}
+
+	var preamble string
+	var files []*File
+	for {
+		file, pre, err := p.ParseNextFileHeader()
+		if err != nil {
+			return files, preamble, err
+		}
+		if len(files) == 0 {
+			preamble = pre
+		}
+		if file == nil {
+			break
+		}
+
+		for _, fn := range []func(*File) (int, error){
+			p.ParseTextFragments,
+			p.ParseBinaryFragments,
+		} {
+			n, err := fn(file)
+			if err != nil {
+				return files, preamble, err
+			}
+			if n > 0 {
+				break
+			}
+		}
+
+		files = append(files, file)
+	}
+
+	return files, preamble, nil
+}
+
+// TODO(bkeyes): consider exporting the parser type with configuration
+// this would enable OID validation, p-value guessing, and prefix stripping
+// by allowing users to set or override defaults
+
+// parser invariants:
+// - methods that parse objects:
+//     - start with the parser on the first line of the first object
+//     - if returning nil, do not advance
+//     - if returning an error, do not advance past the object
+//     - if returning an object, advance to the first line after the object
+// - any exported parsing methods must initialize the parser by calling Next()
+
+type stringReader interface {
+	ReadString(delim byte) (string, error)
+}
+
+type parser struct {
+	r stringReader
+
+	eof    bool
+	lineno int64
+	lines  [3]string
+}
+
+func newParser(r io.Reader) *parser {
+	if r, ok := r.(stringReader); ok {
+		return &parser{r: r}
+	}
+	return &parser{r: bufio.NewReader(r)}
+}
+
+// Next advances the parser by one line. It returns any error encountered while
+// reading the line, including io.EOF when the end of stream is reached.
+func (p *parser) Next() error {
+	if p.eof {
+		return io.EOF
+	}
+
+	if p.lineno == 0 {
+		// on first call to next, need to shift in all lines
+		for i := 0; i < len(p.lines)-1; i++ {
+			if err := p.shiftLines(); err != nil && err != io.EOF {
+				return err
+			}
+		}
+	}
+
+	err := p.shiftLines()
+	if err != nil && err != io.EOF {
+		return err
+	}
+
+	p.lineno++
+	if p.lines[0] == "" {
+		p.eof = true
+		return io.EOF
+	}
+	return nil
+}
+
+func (p *parser) shiftLines() (err error) {
+	for i := 0; i < len(p.lines)-1; i++ {
+		p.lines[i] = p.lines[i+1]
+	}
+	p.lines[len(p.lines)-1], err = p.r.ReadString('\n')
+	return
+}
+
+// Line returns a line from the parser without advancing it. A delta of 0
+// returns the current line, while higher deltas return read-ahead lines. It
+// returns an empty string if the delta is higher than the available lines,
+// either because of the buffer size or because the parser reached the end of
+// the input. Valid lines always contain at least a newline character.
+func (p *parser) Line(delta uint) string {
+	return p.lines[delta]
+}
+
+// Errorf generates an error and appends the current line information.
+func (p *parser) Errorf(delta int64, msg string, args ...interface{}) error {
+	return fmt.Errorf("gitdiff: line %d: %s", p.lineno+delta, fmt.Sprintf(msg, args...))
+}
diff --git a/internal/gitdiff/patch_header.go b/internal/gitdiff/patch_header.go
new file mode 100644
index 0000000..f047059
--- /dev/null
+++ b/internal/gitdiff/patch_header.go
@@ -0,0 +1,470 @@
+package gitdiff
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/quotedprintable"
+	"net/mail"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+)
+
+const (
+	mailHeaderPrefix        = "From "
+	prettyHeaderPrefix      = "commit "
+	mailMinimumHeaderPrefix = "From:"
+)
+
+// PatchHeader is a parsed version of the preamble content that appears before
+// the first diff in a patch. It includes metadata about the patch, such as the
+// author and a subject.
+type PatchHeader struct {
+	// The SHA of the commit the patch was generated from. Empty if the SHA is
+	// not included in the header.
+	SHA string
+
+	// The author details of the patch. If these details are not included in
+	// the header, Author is nil and AuthorDate is the zero time.
+	Author     *PatchIdentity
+	AuthorDate time.Time
+
+	// The committer details of the patch. If these details are not included in
+	// the header, Committer is nil and CommitterDate is the zero time.
+	Committer     *PatchIdentity
+	CommitterDate time.Time
+
+	// The title and body of the commit message describing the changes in the
+	// patch. Empty if no message is included in the header.
+	Title string
+	Body  string
+
+	// If the preamble looks like an email, ParsePatchHeader will
+	// remove prefixes such as `Re: ` and `[PATCH v3 5/17]` from the
+	// Title and place them here.
+	SubjectPrefix string
+
+	// If the preamble looks like an email, and it contains a `---`
+	// line, that line will be removed and everything after it will be
+	// placed in BodyAppendix.
+	BodyAppendix string
+}
+
+// Message returns the commit message for the header. The message consists of
+// the title and the body separated by an empty line.
+func (h *PatchHeader) Message() string {
+	var msg strings.Builder
+	if h != nil {
+		msg.WriteString(h.Title)
+		if h.Body != "" {
+			msg.WriteString("\n\n")
+			msg.WriteString(h.Body)
+		}
+	}
+	return msg.String()
+}
+
+// ParsePatchDate parses a patch date string. It returns the parsed time or an
+// error if s has an unknown format. ParsePatchDate supports the iso, rfc,
+// short, raw, unix, and default formats (with local variants) used by the
+// --date flag in Git.
+func ParsePatchDate(s string) (time.Time, error) {
+	const (
+		isoFormat          = "2006-01-02 15:04:05 -0700"
+		isoStrictFormat    = "2006-01-02T15:04:05-07:00"
+		rfc2822Format      = "Mon, 2 Jan 2006 15:04:05 -0700"
+		shortFormat        = "2006-01-02"
+		defaultFormat      = "Mon Jan 2 15:04:05 2006 -0700"
+		defaultLocalFormat = "Mon Jan 2 15:04:05 2006"
+	)
+
+	if s == "" {
+		return time.Time{}, nil
+	}
+
+	for _, fmt := range []string{
+		isoFormat,
+		isoStrictFormat,
+		rfc2822Format,
+		shortFormat,
+		defaultFormat,
+		defaultLocalFormat,
+	} {
+		if t, err := time.ParseInLocation(fmt, s, time.Local); err == nil {
+			return t, nil
+		}
+	}
+
+	// unix format
+	if unix, err := strconv.ParseInt(s, 10, 64); err == nil {
+		return time.Unix(unix, 0), nil
+	}
+
+	// raw format
+	if space := strings.IndexByte(s, ' '); space > 0 {
+		unix, uerr := strconv.ParseInt(s[:space], 10, 64)
+		zone, zerr := time.Parse("-0700", s[space+1:])
+		if uerr == nil && zerr == nil {
+			return time.Unix(unix, 0).In(zone.Location()), nil
+		}
+	}
+
+	return time.Time{}, fmt.Errorf("unknown date format: %s", s)
+}
+
+// A PatchHeaderOption modifies the behavior of ParsePatchHeader.
+type PatchHeaderOption func(*patchHeaderOptions)
+
+// SubjectCleanMode controls how ParsePatchHeader cleans subject lines when
+// parsing mail-formatted patches.
+type SubjectCleanMode int
+
+const (
+	// SubjectCleanWhitespace removes leading and trailing whitespace.
+	SubjectCleanWhitespace SubjectCleanMode = iota
+
+	// SubjectCleanAll removes leading and trailing whitespace, leading "Re:",
+	// "re:", and ":" strings, and leading strings enclosed by '[' and ']'.
+	// This is the default behavior of git (see `git mailinfo`) and this
+	// package.
+	SubjectCleanAll
+
+	// SubjectCleanPatchOnly is the same as SubjectCleanAll, but only removes
+	// leading strings enclosed by '[' and ']' if they start with "PATCH".
+	SubjectCleanPatchOnly
+)
+
+// WithSubjectCleanMode sets the SubjectCleanMode for header parsing. By
+// default, uses SubjectCleanAll.
+func WithSubjectCleanMode(m SubjectCleanMode) PatchHeaderOption {
+	return func(opts *patchHeaderOptions) {
+		opts.subjectCleanMode = m
+	}
+}
+
+type patchHeaderOptions struct {
+	subjectCleanMode SubjectCleanMode
+}
+
+// ParsePatchHeader parses the preamble string returned by [Parse] into a
+// PatchHeader. Due to the variety of header formats, some fields of the parsed
+// PatchHeader may be unset after parsing.
+//
+// Supported formats are the short, medium, full, fuller, and email pretty
+// formats used by `git diff`, `git log`, and `git show` and the UNIX mailbox
+// format used by `git format-patch`.
+//
+// When parsing mail-formatted headers, ParsePatchHeader tries to remove
+// email-specific content from the title and body:
+//
+//   - Based on the SubjectCleanMode, remove prefixes like reply markers and
+//     "[PATCH]" strings from the subject, saving any removed content in the
+//     SubjectPrefix field. Parsing always discards leading and trailing
+//     whitespace from the subject line. The default mode is SubjectCleanAll.
+//
+//   - If the body contains a "---" line (3 hyphens), remove that line and any
+//     content after it from the body and save it in the BodyAppendix field.
+//
+// ParsePatchHeader tries to process content it does not understand wthout
+// returning errors, but will return errors if well-identified content like
+// dates or identies uses unknown or invalid formats.
+func ParsePatchHeader(header string, options ...PatchHeaderOption) (*PatchHeader, error) {
+	opts := patchHeaderOptions{
+		subjectCleanMode: SubjectCleanAll, // match git defaults
+	}
+	for _, optFn := range options {
+		optFn(&opts)
+	}
+
+	header = strings.TrimSpace(header)
+	if header == "" {
+		return &PatchHeader{}, nil
+	}
+
+	var firstLine, rest string
+	if idx := strings.IndexByte(header, '\n'); idx >= 0 {
+		firstLine = header[:idx]
+		rest = header[idx+1:]
+	} else {
+		firstLine = header
+		rest = ""
+	}
+
+	switch {
+	case strings.HasPrefix(firstLine, mailHeaderPrefix):
+		return parseHeaderMail(firstLine, strings.NewReader(rest), opts)
+
+	case strings.HasPrefix(firstLine, mailMinimumHeaderPrefix):
+		// With a minimum header, the first line is part of the actual mail
+		// content and needs to be parsed as part of the "rest"
+		return parseHeaderMail("", strings.NewReader(header), opts)
+
+	case strings.HasPrefix(firstLine, prettyHeaderPrefix):
+		return parseHeaderPretty(firstLine, strings.NewReader(rest))
+	}
+
+	return nil, errors.New("unrecognized patch header format")
+}
+
+func parseHeaderPretty(prettyLine string, r io.Reader) (*PatchHeader, error) {
+	const (
+		authorPrefix     = "Author:"
+		commitPrefix     = "Commit:"
+		datePrefix       = "Date:"
+		authorDatePrefix = "AuthorDate:"
+		commitDatePrefix = "CommitDate:"
+	)
+
+	h := &PatchHeader{}
+
+	prettyLine = strings.TrimPrefix(prettyLine, prettyHeaderPrefix)
+	if i := strings.IndexByte(prettyLine, ' '); i > 0 {
+		h.SHA = prettyLine[:i]
+	} else {
+		h.SHA = prettyLine
+	}
+
+	s := bufio.NewScanner(r)
+	for s.Scan() {
+		line := s.Text()
+
+		// empty line marks end of fields, remaining lines are title/message
+		if strings.TrimSpace(line) == "" {
+			break
+		}
+
+		switch {
+		case strings.HasPrefix(line, authorPrefix):
+			u, err := ParsePatchIdentity(line[len(authorPrefix):])
+			if err != nil {
+				return nil, err
+			}
+			h.Author = &u
+
+		case strings.HasPrefix(line, commitPrefix):
+			u, err := ParsePatchIdentity(line[len(commitPrefix):])
+			if err != nil {
+				return nil, err
+			}
+			h.Committer = &u
+
+		case strings.HasPrefix(line, datePrefix):
+			d, err := ParsePatchDate(strings.TrimSpace(line[len(datePrefix):]))
+			if err != nil {
+				return nil, err
+			}
+			h.AuthorDate = d
+
+		case strings.HasPrefix(line, authorDatePrefix):
+			d, err := ParsePatchDate(strings.TrimSpace(line[len(authorDatePrefix):]))
+			if err != nil {
+				return nil, err
+			}
+			h.AuthorDate = d
+
+		case strings.HasPrefix(line, commitDatePrefix):
+			d, err := ParsePatchDate(strings.TrimSpace(line[len(commitDatePrefix):]))
+			if err != nil {
+				return nil, err
+			}
+			h.CommitterDate = d
+		}
+	}
+	if s.Err() != nil {
+		return nil, s.Err()
+	}
+
+	title, indent := scanMessageTitle(s)
+	if s.Err() != nil {
+		return nil, s.Err()
+	}
+	h.Title = title
+
+	if title != "" {
+		// Don't check for an appendix, pretty headers do not contain them
+		body, _ := scanMessageBody(s, indent, false)
+		if s.Err() != nil {
+			return nil, s.Err()
+		}
+		h.Body = body
+	}
+
+	return h, nil
+}
+
+func scanMessageTitle(s *bufio.Scanner) (title string, indent string) {
+	var b strings.Builder
+	for i := 0; s.Scan(); i++ {
+		line := s.Text()
+		trimLine := strings.TrimSpace(line)
+		if trimLine == "" {
+			break
+		}
+
+		if i == 0 {
+			if start := strings.IndexFunc(line, func(c rune) bool { return !unicode.IsSpace(c) }); start > 0 {
+				indent = line[:start]
+			}
+		}
+		if b.Len() > 0 {
+			b.WriteByte(' ')
+		}
+		b.WriteString(trimLine)
+	}
+	return b.String(), indent
+}
+
+func scanMessageBody(s *bufio.Scanner, indent string, separateAppendix bool) (string, string) {
+	// Body and appendix
+	var body, appendix strings.Builder
+	c := &body
+	var empty int
+	for i := 0; s.Scan(); i++ {
+		line := s.Text()
+
+		line = strings.TrimRightFunc(line, unicode.IsSpace)
+		line = strings.TrimPrefix(line, indent)
+
+		if line == "" {
+			empty++
+			continue
+		}
+
+		// If requested, parse out "appendix" information (often added
+		// by `git format-patch` and removed by `git am`).
+		if separateAppendix && c == &body && line == "---" {
+			c = &appendix
+			continue
+		}
+
+		if c.Len() > 0 {
+			c.WriteByte('\n')
+			if empty > 0 {
+				c.WriteByte('\n')
+			}
+		}
+		empty = 0
+
+		c.WriteString(line)
+	}
+	return body.String(), appendix.String()
+}
+
+func parseHeaderMail(mailLine string, r io.Reader, opts patchHeaderOptions) (*PatchHeader, error) {
+	msg, err := mail.ReadMessage(r)
+	if err != nil {
+		return nil, err
+	}
+
+	h := &PatchHeader{}
+
+	if strings.HasPrefix(mailLine, mailHeaderPrefix) {
+		mailLine = strings.TrimPrefix(mailLine, mailHeaderPrefix)
+		if i := strings.IndexByte(mailLine, ' '); i > 0 {
+			h.SHA = mailLine[:i]
+		}
+	}
+
+	from := msg.Header.Get("From")
+	if from != "" {
+		u, err := ParsePatchIdentity(from)
+		if err != nil {
+			return nil, err
+		}
+		h.Author = &u
+	}
+
+	date := msg.Header.Get("Date")
+	if date != "" {
+		d, err := ParsePatchDate(date)
+		if err != nil {
+			return nil, err
+		}
+		h.AuthorDate = d
+	}
+
+	subject := msg.Header.Get("Subject")
+	h.SubjectPrefix, h.Title = cleanSubject(subject, opts.subjectCleanMode)
+
+	s := bufio.NewScanner(msg.Body)
+	h.Body, h.BodyAppendix = scanMessageBody(s, "", true)
+	if s.Err() != nil {
+		return nil, s.Err()
+	}
+
+	return h, nil
+}
+
+func cleanSubject(s string, mode SubjectCleanMode) (prefix string, subject string) {
+	switch mode {
+	case SubjectCleanAll, SubjectCleanPatchOnly:
+	case SubjectCleanWhitespace:
+		return "", strings.TrimSpace(decodeSubject(s))
+	default:
+		panic(fmt.Sprintf("unknown clean mode: %d", mode))
+	}
+
+	// Based on the algorithm from Git in mailinfo.c:cleanup_subject()
+	// If compatibility with `git am` drifts, go there to see if there are any updates.
+
+	at := 0
+	for at < len(s) {
+		switch s[at] {
+		case 'r', 'R':
+			// Detect re:, Re:, rE: and RE:
+			if at+2 < len(s) && (s[at+1] == 'e' || s[at+1] == 'E') && s[at+2] == ':' {
+				at += 3
+				continue
+			}
+
+		case ' ', '\t', ':':
+			// Delete whitespace and duplicate ':' characters
+			at++
+			continue
+
+		case '[':
+			if i := strings.IndexByte(s[at:], ']'); i > 0 {
+				if mode == SubjectCleanAll || strings.Contains(s[at:at+i+1], "PATCH") {
+					at += i + 1
+					continue
+				}
+			}
+		}
+
+		// Nothing was removed, end processing
+		break
+	}
+
+	prefix = strings.TrimLeftFunc(s[:at], unicode.IsSpace)
+	subject = strings.TrimRightFunc(decodeSubject(s[at:]), unicode.IsSpace)
+	return
+}
+
+// Decodes a subject line. Currently only supports quoted-printable UTF-8. This format is the result
+// of a `git format-patch` when the commit title has a non-ASCII character (i.e. an emoji).
+// See for reference: https://stackoverflow.com/questions/27695749/gmail-api-not-respecting-utf-encoding-in-subject
+func decodeSubject(encoded string) string {
+	if !strings.HasPrefix(encoded, "=?UTF-8?q?") {
+		// not UTF-8 encoded
+		return encoded
+	}
+
+	// If the subject is too long, `git format-patch` may produce a subject line across
+	// multiple lines. When parsed, this can look like the following:
+	// <UTF8-prefix><first-line> <UTF8-prefix><second-line>
+	payload := " " + encoded
+	payload = strings.ReplaceAll(payload, " =?UTF-8?q?", "")
+	payload = strings.ReplaceAll(payload, "?=", "")
+
+	decoded, err := ioutil.ReadAll(quotedprintable.NewReader(strings.NewReader(payload)))
+	if err != nil {
+		// if err, abort decoding and return original subject
+		return encoded
+	}
+
+	return string(decoded)
+}
diff --git a/internal/gitdiff/patch_identity.go b/internal/gitdiff/patch_identity.go
new file mode 100644
index 0000000..018f80c
--- /dev/null
+++ b/internal/gitdiff/patch_identity.go
@@ -0,0 +1,166 @@
+package gitdiff
+
+import (
+	"fmt"
+	"strings"
+)
+
+// PatchIdentity identifies a person who authored or committed a patch.
+type PatchIdentity struct {
+	Name  string
+	Email string
+}
+
+func (i PatchIdentity) String() string {
+	name := i.Name
+	if name == "" {
+		name = `""`
+	}
+	return fmt.Sprintf("%s <%s>", name, i.Email)
+}
+
+// ParsePatchIdentity parses a patch identity string. A patch identity contains
+// an email address and an optional name in [RFC 5322] format. This is either a
+// plain email adddress or a name followed by an address in angle brackets:
+//
+//	author@example.com
+//	Author Name <author@example.com>
+//
+// If the input is not one of these formats, ParsePatchIdentity applies a
+// heuristic to separate the name and email portions. If both the name and
+// email are missing or empty, ParsePatchIdentity returns an error. It
+// otherwise does not validate the result.
+//
+// [RFC 5322]: https://datatracker.ietf.org/doc/html/rfc5322
+func ParsePatchIdentity(s string) (PatchIdentity, error) {
+	s = normalizeSpace(s)
+	s = unquotePairs(s)
+
+	var name, email string
+	if at := strings.IndexByte(s, '@'); at >= 0 {
+		start, end := at, at
+		for start >= 0 && !isRFC5332Space(s[start]) && s[start] != '<' {
+			start--
+		}
+		for end < len(s) && !isRFC5332Space(s[end]) && s[end] != '>' {
+			end++
+		}
+		email = s[start+1 : end]
+
+		// Adjust the boundaries so that we drop angle brackets, but keep
+		// spaces when removing the email to form the name.
+		if start < 0 || s[start] != '<' {
+			start++
+		}
+		if end >= len(s) || s[end] != '>' {
+			end--
+		}
+		name = s[:start] + s[end+1:]
+	} else {
+		start, end := 0, 0
+		for i := 0; i < len(s); i++ {
+			if s[i] == '<' && start == 0 {
+				start = i + 1
+			}
+			if s[i] == '>' && start > 0 {
+				end = i
+				break
+			}
+		}
+		if start > 0 && end >= start {
+			email = strings.TrimSpace(s[start:end])
+			name = s[:start-1]
+		}
+	}
+
+	// After extracting the email, the name might contain extra whitespace
+	// again and may be surrounded by comment characters. The git source gives
+	// these examples of when this can happen:
+	//
+	//   "Name <email@domain>"
+	//   "email@domain (Name)"
+	//   "Name <email@domain> (Comment)"
+	//
+	name = normalizeSpace(name)
+	if strings.HasPrefix(name, "(") && strings.HasSuffix(name, ")") {
+		name = name[1 : len(name)-1]
+	}
+	name = strings.TrimSpace(name)
+
+	// If the name is empty or contains email-like characters, use the email
+	// instead (assuming one exists)
+	if name == "" || strings.ContainsAny(name, "@<>") {
+		name = email
+	}
+
+	if name == "" && email == "" {
+		return PatchIdentity{}, fmt.Errorf("invalid identity string %q", s)
+	}
+	return PatchIdentity{Name: name, Email: email}, nil
+}
+
+// unquotePairs process the RFC5322 tokens "quoted-string" and "comment" to
+// remove any "quoted-pairs" (backslash-espaced characters). It also removes
+// the quotes from any quoted strings, but leaves the comment delimiters.
+func unquotePairs(s string) string {
+	quote := false
+	comments := 0
+	escaped := false
+
+	var out strings.Builder
+	for i := 0; i < len(s); i++ {
+		if escaped {
+			escaped = false
+		} else {
+			switch s[i] {
+			case '\\':
+				// quoted-pair is only allowed in quoted-string/comment
+				if quote || comments > 0 {
+					escaped = true
+					continue // drop '\' character
+				}
+
+			case '"':
+				if comments == 0 {
+					quote = !quote
+					continue // drop '"' character
+				}
+
+			case '(':
+				if !quote {
+					comments++
+				}
+			case ')':
+				if comments > 0 {
+					comments--
+				}
+			}
+		}
+		out.WriteByte(s[i])
+	}
+	return out.String()
+}
+
+// normalizeSpace trims leading and trailing whitespace from s and converts
+// inner sequences of one or more whitespace characters to single spaces.
+func normalizeSpace(s string) string {
+	var sb strings.Builder
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if !isRFC5332Space(c) {
+			if sb.Len() > 0 && isRFC5332Space(s[i-1]) {
+				sb.WriteByte(' ')
+			}
+			sb.WriteByte(c)
+		}
+	}
+	return sb.String()
+}
+
+func isRFC5332Space(c byte) bool {
+	switch c {
+	case '\t', '\n', '\r', ' ':
+		return true
+	}
+	return false
+}
diff --git a/internal/gitdiff/text.go b/internal/gitdiff/text.go
new file mode 100644
index 0000000..ee30792
--- /dev/null
+++ b/internal/gitdiff/text.go
@@ -0,0 +1,192 @@
+package gitdiff
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+// ParseTextFragments parses text fragments until the next file header or the
+// end of the stream and attaches them to the given file. It returns the number
+// of fragments that were added.
+func (p *parser) ParseTextFragments(f *File) (n int, err error) {
+	for {
+		frag, err := p.ParseTextFragmentHeader()
+		if err != nil {
+			return n, err
+		}
+		if frag == nil {
+			return n, nil
+		}
+
+		if f.IsNew && frag.OldLines > 0 {
+			return n, p.Errorf(-1, "new file depends on old contents")
+		}
+		if f.IsDelete && frag.NewLines > 0 {
+			return n, p.Errorf(-1, "deleted file still has contents")
+		}
+
+		if err := p.ParseTextChunk(frag); err != nil {
+			return n, err
+		}
+
+		f.TextFragments = append(f.TextFragments, frag)
+		n++
+	}
+}
+
+func (p *parser) ParseTextFragmentHeader() (*TextFragment, error) {
+	const (
+		startMark = "@@ -"
+		endMark   = " @@"
+	)
+
+	if !strings.HasPrefix(p.Line(0), startMark) {
+		return nil, nil
+	}
+
+	parts := strings.SplitAfterN(p.Line(0), endMark, 2)
+	if len(parts) < 2 {
+		return nil, p.Errorf(0, "invalid fragment header")
+	}
+
+	f := &TextFragment{}
+	f.Comment = strings.TrimSpace(parts[1])
+
+	header := parts[0][len(startMark) : len(parts[0])-len(endMark)]
+	ranges := strings.Split(header, " +")
+	if len(ranges) != 2 {
+		return nil, p.Errorf(0, "invalid fragment header")
+	}
+
+	var err error
+	if f.OldPosition, f.OldLines, err = parseRange(ranges[0]); err != nil {
+		return nil, p.Errorf(0, "invalid fragment header: %v", err)
+	}
+	if f.NewPosition, f.NewLines, err = parseRange(ranges[1]); err != nil {
+		return nil, p.Errorf(0, "invalid fragment header: %v", err)
+	}
+
+	if err := p.Next(); err != nil && err != io.EOF {
+		return nil, err
+	}
+	return f, nil
+}
+
+func (p *parser) ParseTextChunk(frag *TextFragment) error {
+	if p.Line(0) == "" {
+		return p.Errorf(0, "no content following fragment header")
+	}
+
+	oldLines, newLines := frag.OldLines, frag.NewLines
+	for oldLines > 0 || newLines > 0 {
+		line := p.Line(0)
+		op, data := line[0], line[1:]
+
+		switch op {
+		case '\n':
+			data = "\n"
+			fallthrough // newer GNU diff versions create empty context lines
+		case ' ':
+			oldLines--
+			newLines--
+			if frag.LinesAdded == 0 && frag.LinesDeleted == 0 {
+				frag.LeadingContext++
+			} else {
+				frag.TrailingContext++
+			}
+			frag.Lines = append(frag.Lines, Line{OpContext, data})
+		case '-':
+			oldLines--
+			frag.LinesDeleted++
+			frag.TrailingContext = 0
+			frag.Lines = append(frag.Lines, Line{OpDelete, data})
+		case '+':
+			newLines--
+			frag.LinesAdded++
+			frag.TrailingContext = 0
+			frag.Lines = append(frag.Lines, Line{OpAdd, data})
+		case '\\':
+			// this may appear in middle of fragment if it's for a deleted line
+			if isNoNewlineMarker(line) {
+				removeLastNewline(frag)
+				break
+			}
+			fallthrough
+		default:
+			// TODO(bkeyes): if this is because we hit the next header, it
+			// would be helpful to return the miscounts line error. We could
+			// either test for the common headers ("@@ -", "diff --git") or
+			// assume any invalid op ends the fragment; git returns the same
+			// generic error in all cases so either is compatible
+			return p.Errorf(0, "invalid line operation: %q", op)
+		}
+
+		if err := p.Next(); err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+	}
+
+	if oldLines != 0 || newLines != 0 {
+		hdr := max(frag.OldLines-oldLines, frag.NewLines-newLines) + 1
+		return p.Errorf(-hdr, "fragment header miscounts lines: %+d old, %+d new", -oldLines, -newLines)
+	}
+	if frag.LinesAdded == 0 && frag.LinesDeleted == 0 {
+		return p.Errorf(0, "fragment contains no changes")
+	}
+
+	// check for a final "no newline" marker since it is not included in the
+	// counters used to stop the loop above
+	if isNoNewlineMarker(p.Line(0)) {
+		removeLastNewline(frag)
+		if err := p.Next(); err != nil && err != io.EOF {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func isNoNewlineMarker(s string) bool {
+	// test for "\ No newline at end of file" by prefix because the text
+	// changes by locale (git claims all versions are at least 12 chars)
+	return len(s) >= 12 && s[:2] == "\\ "
+}
+
+func removeLastNewline(frag *TextFragment) {
+	if len(frag.Lines) > 0 {
+		last := &frag.Lines[len(frag.Lines)-1]
+		last.Line = strings.TrimSuffix(last.Line, "\n")
+	}
+}
+
+func parseRange(s string) (start int64, end int64, err error) {
+	parts := strings.SplitN(s, ",", 2)
+
+	if start, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
+		nerr := err.(*strconv.NumError)
+		return 0, 0, fmt.Errorf("bad start of range: %s: %v", parts[0], nerr.Err)
+	}
+
+	if len(parts) > 1 {
+		if end, err = strconv.ParseInt(parts[1], 10, 64); err != nil {
+			nerr := err.(*strconv.NumError)
+			return 0, 0, fmt.Errorf("bad end of range: %s: %v", parts[1], nerr.Err)
+		}
+	} else {
+		end = 1
+	}
+
+	return
+}
+
+func max(a, b int64) int64 {
+	if a > b {
+		return a
+	}
+	return b
+}