Deleted vendor folder

5 files changed, 0 insertions, 2927 deletions

diff --git a/vendor/tiff/src/decoder/ifd.rs b/vendor/tiff/src/decoder/ifd.rs
deleted file mode 100644
index b05513d..0000000
--- a/vendor/tiff/src/decoder/ifd.rs
+++ /dev/null
@@ -1,670 +0,0 @@
-//! Function for reading TIFF tags
-
-use std::collections::HashMap;
-use std::convert::{TryFrom, TryInto};
-use std::io::{self, Read, Seek};
-use std::mem;
-use std::str;
-
-use super::stream::{ByteOrder, EndianReader, SmartReader};
-use crate::tags::{Tag, Type};
-use crate::{TiffError, TiffFormatError, TiffResult};
-
-use self::Value::{
-    Ascii, Byte, Double, Float, Ifd, IfdBig, List, Rational, RationalBig, SRational, SRationalBig,
-    Short, Signed, SignedBig, Unsigned, UnsignedBig,
-};
-
-#[allow(unused_qualifications)]
-#[derive(Debug, Clone, PartialEq)]
-#[non_exhaustive]
-pub enum Value {
-    Byte(u8),
-    Short(u16),
-    Signed(i32),
-    SignedBig(i64),
-    Unsigned(u32),
-    UnsignedBig(u64),
-    Float(f32),
-    Double(f64),
-    List(Vec<Value>),
-    Rational(u32, u32),
-    RationalBig(u64, u64),
-    SRational(i32, i32),
-    SRationalBig(i64, i64),
-    Ascii(String),
-    Ifd(u32),
-    IfdBig(u64),
-}
-
-impl Value {
-    pub fn into_u8(self) -> TiffResult<u8> {
-        match self {
-            Byte(val) => Ok(val),
-            val => Err(TiffError::FormatError(TiffFormatError::ByteExpected(val))),
-        }
-    }
-
-    pub fn into_u16(self) -> TiffResult<u16> {
-        match self {
-            Short(val) => Ok(val),
-            Unsigned(val) => Ok(u16::try_from(val)?),
-            UnsignedBig(val) => Ok(u16::try_from(val)?),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_u32(self) -> TiffResult<u32> {
-        match self {
-            Short(val) => Ok(val.into()),
-            Unsigned(val) => Ok(val),
-            UnsignedBig(val) => Ok(u32::try_from(val)?),
-            Ifd(val) => Ok(val),
-            IfdBig(val) => Ok(u32::try_from(val)?),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_i32(self) -> TiffResult<i32> {
-        match self {
-            Signed(val) => Ok(val),
-            SignedBig(val) => Ok(i32::try_from(val)?),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_u64(self) -> TiffResult<u64> {
-        match self {
-            Short(val) => Ok(val.into()),
-            Unsigned(val) => Ok(val.into()),
-            UnsignedBig(val) => Ok(val),
-            Ifd(val) => Ok(val.into()),
-            IfdBig(val) => Ok(val),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_i64(self) -> TiffResult<i64> {
-        match self {
-            Signed(val) => Ok(val.into()),
-            SignedBig(val) => Ok(val),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_f32(self) -> TiffResult<f32> {
-        match self {
-            Float(val) => Ok(val),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_f64(self) -> TiffResult<f64> {
-        match self {
-            Double(val) => Ok(val),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_string(self) -> TiffResult<String> {
-        match self {
-            Ascii(val) => Ok(val),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_u32_vec(self) -> TiffResult<Vec<u32>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    new_vec.push(v.into_u32()?)
-                }
-                Ok(new_vec)
-            }
-            Unsigned(val) => Ok(vec![val]),
-            UnsignedBig(val) => Ok(vec![u32::try_from(val)?]),
-            Rational(numerator, denominator) => Ok(vec![numerator, denominator]),
-            RationalBig(numerator, denominator) => {
-                Ok(vec![u32::try_from(numerator)?, u32::try_from(denominator)?])
-            }
-            Ifd(val) => Ok(vec![val]),
-            IfdBig(val) => Ok(vec![u32::try_from(val)?]),
-            Ascii(val) => Ok(val.chars().map(u32::from).collect()),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_u8_vec(self) -> TiffResult<Vec<u8>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    new_vec.push(v.into_u8()?)
-                }
-                Ok(new_vec)
-            }
-            Byte(val) => Ok(vec![val]),
-
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_u16_vec(self) -> TiffResult<Vec<u16>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    new_vec.push(v.into_u16()?)
-                }
-                Ok(new_vec)
-            }
-            Short(val) => Ok(vec![val]),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_i32_vec(self) -> TiffResult<Vec<i32>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    match v {
-                        SRational(numerator, denominator) => {
-                            new_vec.push(numerator);
-                            new_vec.push(denominator);
-                        }
-                        SRationalBig(numerator, denominator) => {
-                            new_vec.push(i32::try_from(numerator)?);
-                            new_vec.push(i32::try_from(denominator)?);
-                        }
-                        _ => new_vec.push(v.into_i32()?),
-                    }
-                }
-                Ok(new_vec)
-            }
-            Signed(val) => Ok(vec![val]),
-            SignedBig(val) => Ok(vec![i32::try_from(val)?]),
-            SRational(numerator, denominator) => Ok(vec![numerator, denominator]),
-            SRationalBig(numerator, denominator) => {
-                Ok(vec![i32::try_from(numerator)?, i32::try_from(denominator)?])
-            }
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_f32_vec(self) -> TiffResult<Vec<f32>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    new_vec.push(v.into_f32()?)
-                }
-                Ok(new_vec)
-            }
-            Float(val) => Ok(vec![val]),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_f64_vec(self) -> TiffResult<Vec<f64>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    new_vec.push(v.into_f64()?)
-                }
-                Ok(new_vec)
-            }
-            Double(val) => Ok(vec![val]),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_u64_vec(self) -> TiffResult<Vec<u64>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    new_vec.push(v.into_u64()?)
-                }
-                Ok(new_vec)
-            }
-            Unsigned(val) => Ok(vec![val.into()]),
-            UnsignedBig(val) => Ok(vec![val]),
-            Rational(numerator, denominator) => Ok(vec![numerator.into(), denominator.into()]),
-            RationalBig(numerator, denominator) => Ok(vec![numerator, denominator]),
-            Ifd(val) => Ok(vec![val.into()]),
-            IfdBig(val) => Ok(vec![val]),
-            Ascii(val) => Ok(val.chars().map(u32::from).map(u64::from).collect()),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::UnsignedIntegerExpected(val),
-            )),
-        }
-    }
-
-    pub fn into_i64_vec(self) -> TiffResult<Vec<i64>> {
-        match self {
-            List(vec) => {
-                let mut new_vec = Vec::with_capacity(vec.len());
-                for v in vec {
-                    match v {
-                        SRational(numerator, denominator) => {
-                            new_vec.push(numerator.into());
-                            new_vec.push(denominator.into());
-                        }
-                        SRationalBig(numerator, denominator) => {
-                            new_vec.push(numerator);
-                            new_vec.push(denominator);
-                        }
-                        _ => new_vec.push(v.into_i64()?),
-                    }
-                }
-                Ok(new_vec)
-            }
-            Signed(val) => Ok(vec![val.into()]),
-            SignedBig(val) => Ok(vec![val]),
-            SRational(numerator, denominator) => Ok(vec![numerator.into(), denominator.into()]),
-            SRationalBig(numerator, denominator) => Ok(vec![numerator, denominator]),
-            val => Err(TiffError::FormatError(
-                TiffFormatError::SignedIntegerExpected(val),
-            )),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct Entry {
-    type_: Type,
-    count: u64,
-    offset: [u8; 8],
-}
-
-impl ::std::fmt::Debug for Entry {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
-        fmt.write_str(&format!(
-            "Entry {{ type_: {:?}, count: {:?}, offset: {:?} }}",
-            self.type_, self.count, &self.offset
-        ))
-    }
-}
-
-impl Entry {
-    pub fn new(type_: Type, count: u32, offset: [u8; 4]) -> Entry {
-        let mut offset = offset.to_vec();
-        offset.append(&mut vec![0; 4]);
-        Entry::new_u64(type_, count.into(), offset[..].try_into().unwrap())
-    }
-
-    pub fn new_u64(type_: Type, count: u64, offset: [u8; 8]) -> Entry {
-        Entry {
-            type_,
-            count,
-            offset,
-        }
-    }
-
-    /// Returns a mem_reader for the offset/value field
-    fn r(&self, byte_order: ByteOrder) -> SmartReader<io::Cursor<Vec<u8>>> {
-        SmartReader::wrap(io::Cursor::new(self.offset.to_vec()), byte_order)
-    }
-
-    pub fn val<R: Read + Seek>(
-        &self,
-        limits: &super::Limits,
-        bigtiff: bool,
-        reader: &mut SmartReader<R>,
-    ) -> TiffResult<Value> {
-        // Case 1: there are no values so we can return immediately.
-        if self.count == 0 {
-            return Ok(List(Vec::new()));
-        }
-
-        let bo = reader.byte_order();
-
-        let tag_size = match self.type_ {
-            Type::BYTE | Type::SBYTE | Type::ASCII | Type::UNDEFINED => 1,
-            Type::SHORT | Type::SSHORT => 2,
-            Type::LONG | Type::SLONG | Type::FLOAT | Type::IFD => 4,
-            Type::LONG8
-            | Type::SLONG8
-            | Type::DOUBLE
-            | Type::RATIONAL
-            | Type::SRATIONAL
-            | Type::IFD8 => 8,
-        };
-
-        let value_bytes = match self.count.checked_mul(tag_size) {
-            Some(n) => n,
-            None => {
-                return Err(TiffError::LimitsExceeded);
-            }
-        };
-
-        // Case 2: there is one value.
-        if self.count == 1 {
-            // 2a: the value is 5-8 bytes and we're in BigTiff mode.
-            if bigtiff && value_bytes > 4 && value_bytes <= 8 {
-                return Ok(match self.type_ {
-                    Type::LONG8 => UnsignedBig(self.r(bo).read_u64()?),
-                    Type::SLONG8 => SignedBig(self.r(bo).read_i64()?),
-                    Type::DOUBLE => Double(self.r(bo).read_f64()?),
-                    Type::RATIONAL => {
-                        let mut r = self.r(bo);
-                        Rational(r.read_u32()?, r.read_u32()?)
-                    }
-                    Type::SRATIONAL => {
-                        let mut r = self.r(bo);
-                        SRational(r.read_i32()?, r.read_i32()?)
-                    }
-                    Type::IFD8 => IfdBig(self.r(bo).read_u64()?),
-                    Type::BYTE
-                    | Type::SBYTE
-                    | Type::ASCII
-                    | Type::UNDEFINED
-                    | Type::SHORT
-                    | Type::SSHORT
-                    | Type::LONG
-                    | Type::SLONG
-                    | Type::FLOAT
-                    | Type::IFD => unreachable!(),
-                });
-            }
-
-            // 2b: the value is at most 4 bytes or doesn't fit in the offset field.
-            return Ok(match self.type_ {
-                Type::BYTE => Unsigned(u32::from(self.offset[0])),
-                Type::SBYTE => Signed(i32::from(self.offset[0] as i8)),
-                Type::UNDEFINED => Byte(self.offset[0]),
-                Type::SHORT => Unsigned(u32::from(self.r(bo).read_u16()?)),
-                Type::SSHORT => Signed(i32::from(self.r(bo).read_i16()?)),
-                Type::LONG => Unsigned(self.r(bo).read_u32()?),
-                Type::SLONG => Signed(self.r(bo).read_i32()?),
-                Type::FLOAT => Float(self.r(bo).read_f32()?),
-                Type::ASCII => {
-                    if self.offset[0] == 0 {
-                        Ascii("".to_string())
-                    } else {
-                        return Err(TiffError::FormatError(TiffFormatError::InvalidTag));
-                    }
-                }
-                Type::LONG8 => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    UnsignedBig(reader.read_u64()?)
-                }
-                Type::SLONG8 => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    SignedBig(reader.read_i64()?)
-                }
-                Type::DOUBLE => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    Double(reader.read_f64()?)
-                }
-                Type::RATIONAL => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    Rational(reader.read_u32()?, reader.read_u32()?)
-                }
-                Type::SRATIONAL => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    SRational(reader.read_i32()?, reader.read_i32()?)
-                }
-                Type::IFD => Ifd(self.r(bo).read_u32()?),
-                Type::IFD8 => {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?;
-                    IfdBig(reader.read_u64()?)
-                }
-            });
-        }
-
-        // Case 3: There is more than one value, but it fits in the offset field.
-        if value_bytes <= 4 || bigtiff && value_bytes <= 8 {
-            match self.type_ {
-                Type::BYTE => return offset_to_bytes(self.count as usize, self),
-                Type::SBYTE => return offset_to_sbytes(self.count as usize, self),
-                Type::ASCII => {
-                    let mut buf = vec![0; self.count as usize];
-                    self.r(bo).read_exact(&mut buf)?;
-                    if buf.is_ascii() && buf.ends_with(&[0]) {
-                        let v = str::from_utf8(&buf)?;
-                        let v = v.trim_matches(char::from(0));
-                        return Ok(Ascii(v.into()));
-                    } else {
-                        return Err(TiffError::FormatError(TiffFormatError::InvalidTag));
-                    }
-                }
-                Type::UNDEFINED => {
-                    return Ok(List(
-                        self.offset[0..self.count as usize]
-                            .iter()
-                            .map(|&b| Byte(b))
-                            .collect(),
-                    ));
-                }
-                Type::SHORT => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Short(r.read_u16()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::SSHORT => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Signed(i32::from(r.read_i16()?)));
-                    }
-                    return Ok(List(v));
-                }
-                Type::LONG => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Unsigned(r.read_u32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::SLONG => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Signed(r.read_i32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::FLOAT => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Float(r.read_f32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::IFD => {
-                    let mut r = self.r(bo);
-                    let mut v = Vec::new();
-                    for _ in 0..self.count {
-                        v.push(Ifd(r.read_u32()?));
-                    }
-                    return Ok(List(v));
-                }
-                Type::LONG8
-                | Type::SLONG8
-                | Type::RATIONAL
-                | Type::SRATIONAL
-                | Type::DOUBLE
-                | Type::IFD8 => {
-                    unreachable!()
-                }
-            }
-        }
-
-        // Case 4: there is more than one value, and it doesn't fit in the offset field.
-        match self.type_ {
-            // TODO check if this could give wrong results
-            // at a different endianess of file/computer.
-            Type::BYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                let mut buf = [0; 1];
-                reader.read_exact(&mut buf)?;
-                Ok(UnsignedBig(u64::from(buf[0])))
-            }),
-            Type::SBYTE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(SignedBig(i64::from(reader.read_i8()? as i8)))
-            }),
-            Type::SHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(UnsignedBig(u64::from(reader.read_u16()?)))
-            }),
-            Type::SSHORT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(SignedBig(i64::from(reader.read_i16()?)))
-            }),
-            Type::LONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Unsigned(reader.read_u32()?))
-            }),
-            Type::SLONG => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Signed(reader.read_i32()?))
-            }),
-            Type::FLOAT => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Float(reader.read_f32()?))
-            }),
-            Type::DOUBLE => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Double(reader.read_f64()?))
-            }),
-            Type::RATIONAL => {
-                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    Ok(Rational(reader.read_u32()?, reader.read_u32()?))
-                })
-            }
-            Type::SRATIONAL => {
-                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    Ok(SRational(reader.read_i32()?, reader.read_i32()?))
-                })
-            }
-            Type::LONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(UnsignedBig(reader.read_u64()?))
-            }),
-            Type::SLONG8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(SignedBig(reader.read_i64()?))
-            }),
-            Type::IFD => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(Ifd(reader.read_u32()?))
-            }),
-            Type::IFD8 => self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                Ok(IfdBig(reader.read_u64()?))
-            }),
-            Type::UNDEFINED => {
-                self.decode_offset(self.count, bo, bigtiff, limits, reader, |reader| {
-                    let mut buf = [0; 1];
-                    reader.read_exact(&mut buf)?;
-                    Ok(Byte(buf[0]))
-                })
-            }
-            Type::ASCII => {
-                let n = usize::try_from(self.count)?;
-                if n > limits.decoding_buffer_size {
-                    return Err(TiffError::LimitsExceeded);
-                }
-
-                if bigtiff {
-                    reader.goto_offset(self.r(bo).read_u64()?)?
-                } else {
-                    reader.goto_offset(self.r(bo).read_u32()?.into())?
-                }
-
-                let mut out = vec![0; n];
-                reader.read_exact(&mut out)?;
-                // Strings may be null-terminated, so we trim anything downstream of the null byte
-                if let Some(first) = out.iter().position(|&b| b == 0) {
-                    out.truncate(first);
-                }
-                Ok(Ascii(String::from_utf8(out)?))
-            }
-        }
-    }
-
-    #[inline]
-    fn decode_offset<R, F>(
-        &self,
-        value_count: u64,
-        bo: ByteOrder,
-        bigtiff: bool,
-        limits: &super::Limits,
-        reader: &mut SmartReader<R>,
-        decode_fn: F,
-    ) -> TiffResult<Value>
-    where
-        R: Read + Seek,
-        F: Fn(&mut SmartReader<R>) -> TiffResult<Value>,
-    {
-        let value_count = usize::try_from(value_count)?;
-        if value_count > limits.decoding_buffer_size / mem::size_of::<Value>() {
-            return Err(TiffError::LimitsExceeded);
-        }
-
-        let mut v = Vec::with_capacity(value_count);
-
-        let offset = if bigtiff {
-            self.r(bo).read_u64()?
-        } else {
-            self.r(bo).read_u32()?.into()
-        };
-        reader.goto_offset(offset)?;
-
-        for _ in 0..value_count {
-            v.push(decode_fn(reader)?)
-        }
-        Ok(List(v))
-    }
-}
-
-/// Extracts a list of BYTE tags stored in an offset
-#[inline]
-fn offset_to_bytes(n: usize, entry: &Entry) -> TiffResult<Value> {
-    Ok(List(
-        entry.offset[0..n]
-            .iter()
-            .map(|&e| Unsigned(u32::from(e)))
-            .collect(),
-    ))
-}
-
-/// Extracts a list of SBYTE tags stored in an offset
-#[inline]
-fn offset_to_sbytes(n: usize, entry: &Entry) -> TiffResult<Value> {
-    Ok(List(
-        entry.offset[0..n]
-            .iter()
-            .map(|&e| Signed(i32::from(e as i8)))
-            .collect(),
-    ))
-}
-
-/// Type representing an Image File Directory
-pub type Directory = HashMap<Tag, Entry>;
diff --git a/vendor/tiff/src/decoder/image.rs b/vendor/tiff/src/decoder/image.rs
deleted file mode 100644
index c037e31..0000000
--- a/vendor/tiff/src/decoder/image.rs
+++ /dev/null
@@ -1,601 +0,0 @@
-use super::ifd::{Directory, Value};
-use super::stream::{ByteOrder, DeflateReader, JpegReader, LZWReader, PackBitsReader};
-use super::tag_reader::TagReader;
-use super::{fp_predict_f32, fp_predict_f64, DecodingBuffer, Limits};
-use super::{stream::SmartReader, ChunkType};
-use crate::tags::{CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag};
-use crate::{ColorType, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError};
-use std::convert::{TryFrom, TryInto};
-use std::io::{self, Cursor, Read, Seek};
-use std::sync::Arc;
-
-#[derive(Debug)]
-pub(crate) struct StripDecodeState {
-    pub rows_per_strip: u32,
-}
-
-#[derive(Debug)]
-/// Computed values useful for tile decoding
-pub(crate) struct TileAttributes {
-    pub image_width: usize,
-    pub image_height: usize,
-
-    pub tile_width: usize,
-    pub tile_length: usize,
-}
-
-impl TileAttributes {
-    pub fn tiles_across(&self) -> usize {
-        (self.image_width + self.tile_width - 1) / self.tile_width
-    }
-    pub fn tiles_down(&self) -> usize {
-        (self.image_height + self.tile_length - 1) / self.tile_length
-    }
-    fn padding_right(&self) -> usize {
-        (self.tile_width - self.image_width % self.tile_width) % self.tile_width
-    }
-    fn padding_down(&self) -> usize {
-        (self.tile_length - self.image_height % self.tile_length) % self.tile_length
-    }
-    pub fn get_padding(&self, tile: usize) -> (usize, usize) {
-        let row = tile / self.tiles_across();
-        let column = tile % self.tiles_across();
-
-        let padding_right = if column == self.tiles_across() - 1 {
-            self.padding_right()
-        } else {
-            0
-        };
-
-        let padding_down = if row == self.tiles_down() - 1 {
-            self.padding_down()
-        } else {
-            0
-        };
-
-        (padding_right, padding_down)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Image {
-    pub ifd: Option<Directory>,
-    pub width: u32,
-    pub height: u32,
-    pub bits_per_sample: Vec<u8>,
-    #[allow(unused)]
-    pub samples: u8,
-    pub sample_format: Vec<SampleFormat>,
-    pub photometric_interpretation: PhotometricInterpretation,
-    pub compression_method: CompressionMethod,
-    pub predictor: Predictor,
-    pub jpeg_tables: Option<Arc<Vec<u8>>>,
-    pub chunk_type: ChunkType,
-    pub strip_decoder: Option<StripDecodeState>,
-    pub tile_attributes: Option<TileAttributes>,
-    pub chunk_offsets: Vec<u64>,
-    pub chunk_bytes: Vec<u64>,
-}
-
-impl Image {
-    pub fn from_reader<R: Read + Seek>(
-        reader: &mut SmartReader<R>,
-        ifd: Directory,
-        limits: &Limits,
-        bigtiff: bool,
-    ) -> TiffResult<Image> {
-        let mut tag_reader = TagReader {
-            reader,
-            limits,
-            ifd: &ifd,
-            bigtiff,
-        };
-
-        let width = tag_reader.require_tag(Tag::ImageWidth)?.into_u32()?;
-        let height = tag_reader.require_tag(Tag::ImageLength)?.into_u32()?;
-        if width == 0 || height == 0 {
-            return Err(TiffError::FormatError(TiffFormatError::InvalidDimensions(
-                width, height,
-            )));
-        }
-
-        let photometric_interpretation = tag_reader
-            .find_tag(Tag::PhotometricInterpretation)?
-            .map(Value::into_u16)
-            .transpose()?
-            .and_then(PhotometricInterpretation::from_u16)
-            .ok_or(TiffUnsupportedError::UnknownInterpretation)?;
-
-        // Try to parse both the compression method and the number, format, and bits of the included samples.
-        // If they are not explicitly specified, those tags are reset to their default values and not carried from previous images.
-        let compression_method = match tag_reader.find_tag(Tag::Compression)? {
-            Some(val) => CompressionMethod::from_u16(val.into_u16()?)
-                .ok_or(TiffUnsupportedError::UnknownCompressionMethod)?,
-            None => CompressionMethod::None,
-        };
-
-        let jpeg_tables = if compression_method == CompressionMethod::ModernJPEG
-            && ifd.contains_key(&Tag::JPEGTables)
-        {
-            let vec = tag_reader
-                .find_tag(Tag::JPEGTables)?
-                .unwrap()
-                .into_u8_vec()?;
-            if vec.len() < 2 {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::InvalidTagValueType(Tag::JPEGTables),
-                ));
-            }
-
-            Some(Arc::new(vec))
-        } else {
-            None
-        };
-
-        let samples = tag_reader
-            .find_tag(Tag::SamplesPerPixel)?
-            .map(Value::into_u16)
-            .transpose()?
-            .unwrap_or(1)
-            .try_into()?;
-
-        let sample_format = match tag_reader.find_tag_uint_vec(Tag::SampleFormat)? {
-            Some(vals) => {
-                let sample_format: Vec<_> = vals
-                    .into_iter()
-                    .map(SampleFormat::from_u16_exhaustive)
-                    .collect();
-
-                // TODO: for now, only homogenous formats across samples are supported.
-                if !sample_format.windows(2).all(|s| s[0] == s[1]) {
-                    return Err(TiffUnsupportedError::UnsupportedSampleFormat(sample_format).into());
-                }
-
-                sample_format
-            }
-            None => vec![SampleFormat::Uint],
-        };
-
-        let bits_per_sample = match samples {
-            1 | 3 | 4 => tag_reader
-                .find_tag_uint_vec(Tag::BitsPerSample)?
-                .unwrap_or_else(|| vec![1]),
-            _ => return Err(TiffUnsupportedError::UnsupportedSampleDepth(samples).into()),
-        };
-
-        let predictor = tag_reader
-            .find_tag(Tag::Predictor)?
-            .map(Value::into_u16)
-            .transpose()?
-            .map(|p| {
-                Predictor::from_u16(p)
-                    .ok_or(TiffError::FormatError(TiffFormatError::UnknownPredictor(p)))
-            })
-            .transpose()?
-            .unwrap_or(Predictor::None);
-
-        let chunk_type;
-        let chunk_offsets;
-        let chunk_bytes;
-        let strip_decoder;
-        let tile_attributes;
-        match (
-            ifd.contains_key(&Tag::StripByteCounts),
-            ifd.contains_key(&Tag::StripOffsets),
-            ifd.contains_key(&Tag::TileByteCounts),
-            ifd.contains_key(&Tag::TileOffsets),
-        ) {
-            (true, true, false, false) => {
-                chunk_type = ChunkType::Strip;
-
-                chunk_offsets = tag_reader
-                    .find_tag(Tag::StripOffsets)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                chunk_bytes = tag_reader
-                    .find_tag(Tag::StripByteCounts)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                let rows_per_strip = tag_reader
-                    .find_tag(Tag::RowsPerStrip)?
-                    .map(Value::into_u32)
-                    .transpose()?
-                    .unwrap_or(height);
-                strip_decoder = Some(StripDecodeState { rows_per_strip });
-                tile_attributes = None;
-
-                if chunk_offsets.len() != chunk_bytes.len()
-                    || rows_per_strip == 0
-                    || u32::try_from(chunk_offsets.len())?
-                        != height.saturating_sub(1) / rows_per_strip + 1
-                {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InconsistentSizesEncountered,
-                    ));
-                }
-            }
-            (false, false, true, true) => {
-                chunk_type = ChunkType::Tile;
-
-                let tile_width =
-                    usize::try_from(tag_reader.require_tag(Tag::TileWidth)?.into_u32()?)?;
-                let tile_length =
-                    usize::try_from(tag_reader.require_tag(Tag::TileLength)?.into_u32()?)?;
-
-                if tile_width == 0 {
-                    return Err(TiffFormatError::InvalidTagValueType(Tag::TileWidth).into());
-                } else if tile_length == 0 {
-                    return Err(TiffFormatError::InvalidTagValueType(Tag::TileLength).into());
-                }
-
-                strip_decoder = None;
-                tile_attributes = Some(TileAttributes {
-                    image_width: usize::try_from(width)?,
-                    image_height: usize::try_from(height)?,
-                    tile_width,
-                    tile_length,
-                });
-                chunk_offsets = tag_reader
-                    .find_tag(Tag::TileOffsets)?
-                    .unwrap()
-                    .into_u64_vec()?;
-                chunk_bytes = tag_reader
-                    .find_tag(Tag::TileByteCounts)?
-                    .unwrap()
-                    .into_u64_vec()?;
-
-                let tile = tile_attributes.as_ref().unwrap();
-                if chunk_offsets.len() != chunk_bytes.len()
-                    || chunk_offsets.len() != tile.tiles_down() * tile.tiles_across()
-                {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InconsistentSizesEncountered,
-                    ));
-                }
-            }
-            (_, _, _, _) => {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::StripTileTagConflict,
-                ))
-            }
-        };
-
-        Ok(Image {
-            ifd: Some(ifd),
-            width,
-            height,
-            bits_per_sample,
-            samples,
-            sample_format,
-            photometric_interpretation,
-            compression_method,
-            jpeg_tables,
-            predictor,
-            chunk_type,
-            strip_decoder,
-            tile_attributes,
-            chunk_offsets,
-            chunk_bytes,
-        })
-    }
-
-    pub(crate) fn colortype(&self) -> TiffResult<ColorType> {
-        match self.photometric_interpretation {
-            PhotometricInterpretation::RGB => match self.bits_per_sample[..] {
-                [r, g, b] if [r, r] == [g, b] => Ok(ColorType::RGB(r)),
-                [r, g, b, a] if [r, r, r] == [g, b, a] => Ok(ColorType::RGBA(r)),
-                // FIXME: We should _ignore_ other components. In particular:
-                // > Beware of extra components. Some TIFF files may have more components per pixel
-                // than you think. A Baseline TIFF reader must skip over them gracefully,using the
-                // values of the SamplesPerPixel and BitsPerSample fields.
-                // > -- TIFF 6.0 Specification, Section 7, Additional Baseline requirements.
-                _ => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::InterpretationWithBits(
-                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
-                    ),
-                )),
-            },
-            PhotometricInterpretation::CMYK => match self.bits_per_sample[..] {
-                [c, m, y, k] if [c, c, c] == [m, y, k] => Ok(ColorType::CMYK(c)),
-                _ => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::InterpretationWithBits(
-                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
-                    ),
-                )),
-            },
-            PhotometricInterpretation::YCbCr => match self.bits_per_sample[..] {
-                [y, cb, cr] if [y, y] == [cb, cr] => Ok(ColorType::YCbCr(y)),
-                _ => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::InterpretationWithBits(
-                        self.photometric_interpretation,
-                        self.bits_per_sample.clone(),
-                    ),
-                )),
-            },
-            PhotometricInterpretation::BlackIsZero | PhotometricInterpretation::WhiteIsZero
-                if self.bits_per_sample.len() == 1 =>
-            {
-                Ok(ColorType::Gray(self.bits_per_sample[0]))
-            }
-
-            // TODO: this is bad we should not fail at this point
-            _ => Err(TiffError::UnsupportedError(
-                TiffUnsupportedError::InterpretationWithBits(
-                    self.photometric_interpretation,
-                    self.bits_per_sample.clone(),
-                ),
-            )),
-        }
-    }
-
-    fn create_reader<'r, R: 'r + Read>(
-        reader: R,
-        photometric_interpretation: PhotometricInterpretation,
-        compression_method: CompressionMethod,
-        compressed_length: u64,
-        jpeg_tables: Option<Arc<Vec<u8>>>,
-    ) -> TiffResult<Box<dyn Read + 'r>> {
-        Ok(match compression_method {
-            CompressionMethod::None => Box::new(reader),
-            CompressionMethod::LZW => {
-                Box::new(LZWReader::new(reader, usize::try_from(compressed_length)?))
-            }
-            CompressionMethod::PackBits => Box::new(PackBitsReader::new(reader, compressed_length)),
-            CompressionMethod::Deflate | CompressionMethod::OldDeflate => {
-                Box::new(DeflateReader::new(reader))
-            }
-            CompressionMethod::ModernJPEG => {
-                if jpeg_tables.is_some() && compressed_length < 2 {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::InvalidTagValueType(Tag::JPEGTables),
-                    ));
-                }
-
-                let jpeg_reader = JpegReader::new(reader, compressed_length, jpeg_tables)?;
-                let mut decoder = jpeg::Decoder::new(jpeg_reader);
-
-                match photometric_interpretation {
-                    PhotometricInterpretation::RGB => {
-                        decoder.set_color_transform(jpeg::ColorTransform::RGB)
-                    }
-                    PhotometricInterpretation::WhiteIsZero => {
-                        decoder.set_color_transform(jpeg::ColorTransform::None)
-                    }
-                    PhotometricInterpretation::BlackIsZero => {
-                        decoder.set_color_transform(jpeg::ColorTransform::None)
-                    }
-                    PhotometricInterpretation::TransparencyMask => {
-                        decoder.set_color_transform(jpeg::ColorTransform::None)
-                    }
-                    PhotometricInterpretation::CMYK => {
-                        decoder.set_color_transform(jpeg::ColorTransform::CMYK)
-                    }
-                    PhotometricInterpretation::YCbCr => {
-                        decoder.set_color_transform(jpeg::ColorTransform::YCbCr)
-                    }
-                    photometric_interpretation => {
-                        return Err(TiffError::UnsupportedError(
-                            TiffUnsupportedError::UnsupportedInterpretation(
-                                photometric_interpretation,
-                            ),
-                        ));
-                    }
-                }
-
-                let data = decoder.decode()?;
-
-                Box::new(Cursor::new(data))
-            }
-            method => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::UnsupportedCompressionMethod(method),
-                ))
-            }
-        })
-    }
-
-    pub(crate) fn chunk_file_range(&self, chunk: u32) -> TiffResult<(u64, u64)> {
-        let file_offset = self
-            .chunk_offsets
-            .get(chunk as usize)
-            .ok_or(TiffError::FormatError(
-                TiffFormatError::InconsistentSizesEncountered,
-            ))?;
-
-        let compressed_bytes =
-            self.chunk_bytes
-                .get(chunk as usize)
-                .ok_or(TiffError::FormatError(
-                    TiffFormatError::InconsistentSizesEncountered,
-                ))?;
-
-        Ok((*file_offset, *compressed_bytes))
-    }
-
-    pub(crate) fn chunk_dimensions(&self) -> TiffResult<(u32, u32)> {
-        match self.chunk_type {
-            ChunkType::Strip => {
-                let strip_attrs = self.strip_decoder.as_ref().unwrap();
-                Ok((self.width, strip_attrs.rows_per_strip))
-            }
-            ChunkType::Tile => {
-                let tile_attrs = self.tile_attributes.as_ref().unwrap();
-                Ok((
-                    u32::try_from(tile_attrs.tile_width)?,
-                    u32::try_from(tile_attrs.tile_length)?,
-                ))
-            }
-        }
-    }
-
-    pub(crate) fn chunk_data_dimensions(&self, chunk_index: u32) -> TiffResult<(u32, u32)> {
-        let dims = self.chunk_dimensions()?;
-
-        match self.chunk_type {
-            ChunkType::Strip => {
-                let strip_height_without_padding = chunk_index
-                    .checked_mul(dims.1)
-                    .and_then(|x| self.height.checked_sub(x))
-                    .ok_or(TiffError::UsageError(UsageError::InvalidChunkIndex(
-                        chunk_index,
-                    )))?;
-
-                // Ignore potential vertical padding on the bottommost strip
-                let strip_height = dims.1.min(strip_height_without_padding);
-
-                Ok((dims.0, strip_height))
-            }
-            ChunkType::Tile => {
-                let tile_attrs = self.tile_attributes.as_ref().unwrap();
-                let (padding_right, padding_down) = tile_attrs.get_padding(chunk_index as usize);
-
-                let tile_width = tile_attrs.tile_width - padding_right;
-                let tile_length = tile_attrs.tile_length - padding_down;
-
-                Ok((u32::try_from(tile_width)?, u32::try_from(tile_length)?))
-            }
-        }
-    }
-
-    pub(crate) fn expand_chunk(
-        &self,
-        reader: impl Read,
-        mut buffer: DecodingBuffer,
-        output_width: usize,
-        byte_order: ByteOrder,
-        chunk_index: u32,
-    ) -> TiffResult<()> {
-        // Validate that the provided buffer is of the expected type.
-        let color_type = self.colortype()?;
-        match (color_type, &buffer) {
-            (ColorType::RGB(n), _)
-            | (ColorType::RGBA(n), _)
-            | (ColorType::CMYK(n), _)
-            | (ColorType::YCbCr(n), _)
-            | (ColorType::Gray(n), _)
-                if usize::from(n) == buffer.byte_len() * 8 => {}
-            (ColorType::Gray(n), DecodingBuffer::U8(_)) if n < 8 => match self.predictor {
-                Predictor::None => {}
-                Predictor::Horizontal => {
-                    return Err(TiffError::UnsupportedError(
-                        TiffUnsupportedError::HorizontalPredictor(color_type),
-                    ))
-                }
-                Predictor::FloatingPoint => {
-                    return Err(TiffError::UnsupportedError(
-                        TiffUnsupportedError::FloatingPointPredictor(color_type),
-                    ));
-                }
-            },
-            (type_, _) => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::UnsupportedColorType(type_),
-                ))
-            }
-        }
-
-        // Validate that the predictor is supported for the sample type.
-        match (self.predictor, &buffer) {
-            (Predictor::Horizontal, DecodingBuffer::F32(_))
-            | (Predictor::Horizontal, DecodingBuffer::F64(_)) => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::HorizontalPredictor(color_type),
-                ));
-            }
-            (Predictor::FloatingPoint, DecodingBuffer::F32(_))
-            | (Predictor::FloatingPoint, DecodingBuffer::F64(_)) => {}
-            (Predictor::FloatingPoint, _) => {
-                return Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::FloatingPointPredictor(color_type),
-                ));
-            }
-            _ => {}
-        }
-
-        let compressed_bytes =
-            self.chunk_bytes
-                .get(chunk_index as usize)
-                .ok_or(TiffError::FormatError(
-                    TiffFormatError::InconsistentSizesEncountered,
-                ))?;
-
-        let byte_len = buffer.byte_len();
-        let compression_method = self.compression_method;
-        let photometric_interpretation = self.photometric_interpretation;
-        let predictor = self.predictor;
-        let samples = self.bits_per_sample.len();
-
-        let chunk_dims = self.chunk_dimensions()?;
-        let data_dims = self.chunk_data_dimensions(chunk_index)?;
-
-        let padding_right = chunk_dims.0 - data_dims.0;
-
-        let jpeg_tables = self.jpeg_tables.clone();
-        let mut reader = Self::create_reader(
-            reader,
-            photometric_interpretation,
-            compression_method,
-            *compressed_bytes,
-            jpeg_tables,
-        )?;
-
-        if output_width == data_dims.0 as usize && padding_right == 0 {
-            let total_samples = data_dims.0 as usize * data_dims.1 as usize * samples;
-            let tile = &mut buffer.as_bytes_mut()[..total_samples * byte_len];
-            reader.read_exact(tile)?;
-
-            for row in 0..data_dims.1 as usize {
-                let row_start = row as usize * output_width as usize * samples;
-                let row_end = (row + 1) * output_width as usize * samples;
-                let row = buffer.subrange(row_start..row_end);
-                super::fix_endianness_and_predict(row, samples, byte_order, predictor);
-            }
-            if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                super::invert_colors(&mut buffer.subrange(0..total_samples), color_type);
-            }
-        } else if padding_right > 0 && self.predictor == Predictor::FloatingPoint {
-            // The floating point predictor shuffles the padding bytes into the encoded output, so
-            // this case is handled specially when needed.
-            let mut encoded = vec![0u8; chunk_dims.0 as usize * samples * byte_len];
-
-            for row in 0..data_dims.1 as usize {
-                let row_start = row * output_width as usize * samples;
-                let row_end = row_start + data_dims.0 as usize * samples;
-
-                reader.read_exact(&mut encoded)?;
-                match buffer.subrange(row_start..row_end) {
-                    DecodingBuffer::F32(buf) => fp_predict_f32(&mut encoded, buf, samples),
-                    DecodingBuffer::F64(buf) => fp_predict_f64(&mut encoded, buf, samples),
-                    _ => unreachable!(),
-                }
-                if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                    super::invert_colors(&mut buffer.subrange(row_start..row_end), color_type);
-                }
-            }
-        } else {
-            for row in 0..data_dims.1 as usize {
-                let row_start = row * output_width as usize * samples;
-                let row_end = row_start + data_dims.0 as usize * samples;
-
-                let row = &mut buffer.as_bytes_mut()[(row_start * byte_len)..(row_end * byte_len)];
-                reader.read_exact(row)?;
-
-                // Skip horizontal padding
-                if padding_right > 0 {
-                    let len = u64::try_from(padding_right as usize * samples * byte_len)?;
-                    io::copy(&mut reader.by_ref().take(len), &mut io::sink())?;
-                }
-
-                let mut row = buffer.subrange(row_start..row_end);
-                super::fix_endianness_and_predict(row.copy(), samples, byte_order, predictor);
-                if photometric_interpretation == PhotometricInterpretation::WhiteIsZero {
-                    super::invert_colors(&mut row, color_type);
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
diff --git a/vendor/tiff/src/decoder/mod.rs b/vendor/tiff/src/decoder/mod.rs
deleted file mode 100644
index 5fa1812..0000000
--- a/vendor/tiff/src/decoder/mod.rs
+++ /dev/null
@@ -1,1176 +0,0 @@
-use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
-use std::io::{self, Read, Seek};
-use std::ops::Range;
-
-use crate::{
-    bytecast, ColorType, TiffError, TiffFormatError, TiffResult, TiffUnsupportedError, UsageError,
-};
-
-use self::ifd::Directory;
-use self::image::Image;
-use crate::tags::{
-    CompressionMethod, PhotometricInterpretation, Predictor, SampleFormat, Tag, Type,
-};
-
-use self::stream::{ByteOrder, EndianReader, SmartReader};
-
-pub mod ifd;
-mod image;
-mod stream;
-mod tag_reader;
-
-/// Result of a decoding process
-#[derive(Debug)]
-pub enum DecodingResult {
-    /// A vector of unsigned bytes
-    U8(Vec<u8>),
-    /// A vector of unsigned words
-    U16(Vec<u16>),
-    /// A vector of 32 bit unsigned ints
-    U32(Vec<u32>),
-    /// A vector of 64 bit unsigned ints
-    U64(Vec<u64>),
-    /// A vector of 32 bit IEEE floats
-    F32(Vec<f32>),
-    /// A vector of 64 bit IEEE floats
-    F64(Vec<f64>),
-    /// A vector of 8 bit signed ints
-    I8(Vec<i8>),
-    /// A vector of 16 bit signed ints
-    I16(Vec<i16>),
-    /// A vector of 32 bit signed ints
-    I32(Vec<i32>),
-    /// A vector of 64 bit signed ints
-    I64(Vec<i64>),
-}
-
-impl DecodingResult {
-    fn new_u8(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::U8(vec![0; size]))
-        }
-    }
-
-    fn new_u16(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / 2 {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::U16(vec![0; size]))
-        }
-    }
-
-    fn new_u32(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / 4 {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::U32(vec![0; size]))
-        }
-    }
-
-    fn new_u64(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / 8 {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::U64(vec![0; size]))
-        }
-    }
-
-    fn new_f32(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / std::mem::size_of::<f32>() {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::F32(vec![0.0; size]))
-        }
-    }
-
-    fn new_f64(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / std::mem::size_of::<f64>() {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::F64(vec![0.0; size]))
-        }
-    }
-
-    fn new_i8(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / std::mem::size_of::<i8>() {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::I8(vec![0; size]))
-        }
-    }
-
-    fn new_i16(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / 2 {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::I16(vec![0; size]))
-        }
-    }
-
-    fn new_i32(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / 4 {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::I32(vec![0; size]))
-        }
-    }
-
-    fn new_i64(size: usize, limits: &Limits) -> TiffResult<DecodingResult> {
-        if size > limits.decoding_buffer_size / 8 {
-            Err(TiffError::LimitsExceeded)
-        } else {
-            Ok(DecodingResult::I64(vec![0; size]))
-        }
-    }
-
-    pub fn as_buffer(&mut self, start: usize) -> DecodingBuffer {
-        match *self {
-            DecodingResult::U8(ref mut buf) => DecodingBuffer::U8(&mut buf[start..]),
-            DecodingResult::U16(ref mut buf) => DecodingBuffer::U16(&mut buf[start..]),
-            DecodingResult::U32(ref mut buf) => DecodingBuffer::U32(&mut buf[start..]),
-            DecodingResult::U64(ref mut buf) => DecodingBuffer::U64(&mut buf[start..]),
-            DecodingResult::F32(ref mut buf) => DecodingBuffer::F32(&mut buf[start..]),
-            DecodingResult::F64(ref mut buf) => DecodingBuffer::F64(&mut buf[start..]),
-            DecodingResult::I8(ref mut buf) => DecodingBuffer::I8(&mut buf[start..]),
-            DecodingResult::I16(ref mut buf) => DecodingBuffer::I16(&mut buf[start..]),
-            DecodingResult::I32(ref mut buf) => DecodingBuffer::I32(&mut buf[start..]),
-            DecodingResult::I64(ref mut buf) => DecodingBuffer::I64(&mut buf[start..]),
-        }
-    }
-}
-
-// A buffer for image decoding
-pub enum DecodingBuffer<'a> {
-    /// A slice of unsigned bytes
-    U8(&'a mut [u8]),
-    /// A slice of unsigned words
-    U16(&'a mut [u16]),
-    /// A slice of 32 bit unsigned ints
-    U32(&'a mut [u32]),
-    /// A slice of 64 bit unsigned ints
-    U64(&'a mut [u64]),
-    /// A slice of 32 bit IEEE floats
-    F32(&'a mut [f32]),
-    /// A slice of 64 bit IEEE floats
-    F64(&'a mut [f64]),
-    /// A slice of 8 bits signed ints
-    I8(&'a mut [i8]),
-    /// A slice of 16 bits signed ints
-    I16(&'a mut [i16]),
-    /// A slice of 32 bits signed ints
-    I32(&'a mut [i32]),
-    /// A slice of 64 bits signed ints
-    I64(&'a mut [i64]),
-}
-
-impl<'a> DecodingBuffer<'a> {
-    fn byte_len(&self) -> usize {
-        match *self {
-            DecodingBuffer::U8(_) => 1,
-            DecodingBuffer::U16(_) => 2,
-            DecodingBuffer::U32(_) => 4,
-            DecodingBuffer::U64(_) => 8,
-            DecodingBuffer::F32(_) => 4,
-            DecodingBuffer::F64(_) => 8,
-            DecodingBuffer::I8(_) => 1,
-            DecodingBuffer::I16(_) => 2,
-            DecodingBuffer::I32(_) => 4,
-            DecodingBuffer::I64(_) => 8,
-        }
-    }
-
-    fn copy<'b>(&'b mut self) -> DecodingBuffer<'b>
-    where
-        'a: 'b,
-    {
-        match *self {
-            DecodingBuffer::U8(ref mut buf) => DecodingBuffer::U8(buf),
-            DecodingBuffer::U16(ref mut buf) => DecodingBuffer::U16(buf),
-            DecodingBuffer::U32(ref mut buf) => DecodingBuffer::U32(buf),
-            DecodingBuffer::U64(ref mut buf) => DecodingBuffer::U64(buf),
-            DecodingBuffer::F32(ref mut buf) => DecodingBuffer::F32(buf),
-            DecodingBuffer::F64(ref mut buf) => DecodingBuffer::F64(buf),
-            DecodingBuffer::I8(ref mut buf) => DecodingBuffer::I8(buf),
-            DecodingBuffer::I16(ref mut buf) => DecodingBuffer::I16(buf),
-            DecodingBuffer::I32(ref mut buf) => DecodingBuffer::I32(buf),
-            DecodingBuffer::I64(ref mut buf) => DecodingBuffer::I64(buf),
-        }
-    }
-
-    fn subrange<'b>(&'b mut self, range: Range<usize>) -> DecodingBuffer<'b>
-    where
-        'a: 'b,
-    {
-        match *self {
-            DecodingBuffer::U8(ref mut buf) => DecodingBuffer::U8(&mut buf[range]),
-            DecodingBuffer::U16(ref mut buf) => DecodingBuffer::U16(&mut buf[range]),
-            DecodingBuffer::U32(ref mut buf) => DecodingBuffer::U32(&mut buf[range]),
-            DecodingBuffer::U64(ref mut buf) => DecodingBuffer::U64(&mut buf[range]),
-            DecodingBuffer::F32(ref mut buf) => DecodingBuffer::F32(&mut buf[range]),
-            DecodingBuffer::F64(ref mut buf) => DecodingBuffer::F64(&mut buf[range]),
-            DecodingBuffer::I8(ref mut buf) => DecodingBuffer::I8(&mut buf[range]),
-            DecodingBuffer::I16(ref mut buf) => DecodingBuffer::I16(&mut buf[range]),
-            DecodingBuffer::I32(ref mut buf) => DecodingBuffer::I32(&mut buf[range]),
-            DecodingBuffer::I64(ref mut buf) => DecodingBuffer::I64(&mut buf[range]),
-        }
-    }
-
-    fn as_bytes_mut(&mut self) -> &mut [u8] {
-        match self {
-            DecodingBuffer::U8(buf) => &mut *buf,
-            DecodingBuffer::I8(buf) => bytecast::i8_as_ne_mut_bytes(buf),
-            DecodingBuffer::U16(buf) => bytecast::u16_as_ne_mut_bytes(buf),
-            DecodingBuffer::I16(buf) => bytecast::i16_as_ne_mut_bytes(buf),
-            DecodingBuffer::U32(buf) => bytecast::u32_as_ne_mut_bytes(buf),
-            DecodingBuffer::I32(buf) => bytecast::i32_as_ne_mut_bytes(buf),
-            DecodingBuffer::U64(buf) => bytecast::u64_as_ne_mut_bytes(buf),
-            DecodingBuffer::I64(buf) => bytecast::i64_as_ne_mut_bytes(buf),
-            DecodingBuffer::F32(buf) => bytecast::f32_as_ne_mut_bytes(buf),
-            DecodingBuffer::F64(buf) => bytecast::f64_as_ne_mut_bytes(buf),
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-/// Chunk type of the internal representation
-pub enum ChunkType {
-    Strip,
-    Tile,
-}
-
-/// Decoding limits
-#[derive(Clone, Debug)]
-pub struct Limits {
-    /// The maximum size of any `DecodingResult` in bytes, the default is
-    /// 256MiB. If the entire image is decoded at once, then this will
-    /// be the maximum size of the image. If it is decoded one strip at a
-    /// time, this will be the maximum size of a strip.
-    pub decoding_buffer_size: usize,
-    /// The maximum size of any ifd value in bytes, the default is
-    /// 1MiB.
-    pub ifd_value_size: usize,
-    /// Maximum size for intermediate buffer which may be used to limit the amount of data read per
-    /// segment even if the entire image is decoded at once.
-    pub intermediate_buffer_size: usize,
-    /// The purpose of this is to prevent all the fields of the struct from
-    /// being public, as this would make adding new fields a major version
-    /// bump.
-    _non_exhaustive: (),
-}
-
-impl Limits {
-    /// A configuration that does not impose any limits.
-    ///
-    /// This is a good start if the caller only wants to impose selective limits, contrary to the
-    /// default limits which allows selectively disabling limits.
-    ///
-    /// Note that this configuration is likely to crash on excessively large images since,
-    /// naturally, the machine running the program does not have infinite memory.
-    pub fn unlimited() -> Limits {
-        Limits {
-            decoding_buffer_size: usize::max_value(),
-            ifd_value_size: usize::max_value(),
-            intermediate_buffer_size: usize::max_value(),
-            _non_exhaustive: (),
-        }
-    }
-}
-
-impl Default for Limits {
-    fn default() -> Limits {
-        Limits {
-            decoding_buffer_size: 256 * 1024 * 1024,
-            intermediate_buffer_size: 128 * 1024 * 1024,
-            ifd_value_size: 1024 * 1024,
-            _non_exhaustive: (),
-        }
-    }
-}
-
-/// The representation of a TIFF decoder
-///
-/// Currently does not support decoding of interlaced images
-#[derive(Debug)]
-pub struct Decoder<R>
-where
-    R: Read + Seek,
-{
-    reader: SmartReader<R>,
-    bigtiff: bool,
-    limits: Limits,
-    next_ifd: Option<u64>,
-    ifd_offsets: Vec<u64>,
-    seen_ifds: HashSet<u64>,
-    image: Image,
-}
-
-trait Wrapping {
-    fn wrapping_add(&self, other: Self) -> Self;
-}
-
-impl Wrapping for u8 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        u8::wrapping_add(*self, other)
-    }
-}
-
-impl Wrapping for u16 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        u16::wrapping_add(*self, other)
-    }
-}
-
-impl Wrapping for u32 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        u32::wrapping_add(*self, other)
-    }
-}
-
-impl Wrapping for u64 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        u64::wrapping_add(*self, other)
-    }
-}
-
-impl Wrapping for i8 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        i8::wrapping_add(*self, other)
-    }
-}
-
-impl Wrapping for i16 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        i16::wrapping_add(*self, other)
-    }
-}
-
-impl Wrapping for i32 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        i32::wrapping_add(*self, other)
-    }
-}
-
-impl Wrapping for i64 {
-    fn wrapping_add(&self, other: Self) -> Self {
-        i64::wrapping_add(*self, other)
-    }
-}
-
-fn rev_hpredict_nsamp<T: Copy + Wrapping>(image: &mut [T], samples: usize) {
-    for col in samples..image.len() {
-        image[col] = image[col].wrapping_add(image[col - samples]);
-    }
-}
-
-pub fn fp_predict_f32(input: &mut [u8], output: &mut [f32], samples: usize) {
-    rev_hpredict_nsamp(input, samples);
-    for i in 0..output.len() {
-        // TODO: use f32::from_be_bytes() when we can (version 1.40)
-        output[i] = f32::from_bits(u32::from_be_bytes([
-            input[input.len() / 4 * 0 + i],
-            input[input.len() / 4 * 1 + i],
-            input[input.len() / 4 * 2 + i],
-            input[input.len() / 4 * 3 + i],
-        ]));
-    }
-}
-
-pub fn fp_predict_f64(input: &mut [u8], output: &mut [f64], samples: usize) {
-    rev_hpredict_nsamp(input, samples);
-    for i in 0..output.len() {
-        // TODO: use f64::from_be_bytes() when we can (version 1.40)
-        output[i] = f64::from_bits(u64::from_be_bytes([
-            input[input.len() / 8 * 0 + i],
-            input[input.len() / 8 * 1 + i],
-            input[input.len() / 8 * 2 + i],
-            input[input.len() / 8 * 3 + i],
-            input[input.len() / 8 * 4 + i],
-            input[input.len() / 8 * 5 + i],
-            input[input.len() / 8 * 6 + i],
-            input[input.len() / 8 * 7 + i],
-        ]));
-    }
-}
-
-fn fix_endianness_and_predict(
-    mut image: DecodingBuffer,
-    samples: usize,
-    byte_order: ByteOrder,
-    predictor: Predictor,
-) {
-    match predictor {
-        Predictor::None => {
-            fix_endianness(&mut image, byte_order);
-        }
-        Predictor::Horizontal => {
-            fix_endianness(&mut image, byte_order);
-            match image {
-                DecodingBuffer::U8(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::U16(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::U32(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::U64(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::I8(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::I16(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::I32(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::I64(buf) => rev_hpredict_nsamp(buf, samples),
-                DecodingBuffer::F32(_) | DecodingBuffer::F64(_) => {
-                    unreachable!("Caller should have validated arguments. Please file a bug.")
-                }
-            }
-        }
-        Predictor::FloatingPoint => {
-            let mut buffer_copy = image.as_bytes_mut().to_vec();
-            match image {
-                DecodingBuffer::F32(buf) => fp_predict_f32(&mut buffer_copy, buf, samples),
-                DecodingBuffer::F64(buf) => fp_predict_f64(&mut buffer_copy, buf, samples),
-                _ => unreachable!("Caller should have validated arguments. Please file a bug."),
-            }
-        }
-    }
-}
-
-fn invert_colors_unsigned<T>(buffer: &mut [T], max: T)
-where
-    T: std::ops::Sub<T> + std::ops::Sub<Output = T> + Copy,
-{
-    for datum in buffer.iter_mut() {
-        *datum = max - *datum
-    }
-}
-
-fn invert_colors_fp<T>(buffer: &mut [T], max: T)
-where
-    T: std::ops::Sub<T> + std::ops::Sub<Output = T> + Copy,
-{
-    for datum in buffer.iter_mut() {
-        // FIXME: assumes [0, 1) range for floats
-        *datum = max - *datum
-    }
-}
-
-fn invert_colors(buf: &mut DecodingBuffer, color_type: ColorType) {
-    match (color_type, buf) {
-        (ColorType::Gray(64), DecodingBuffer::U64(ref mut buffer)) => {
-            invert_colors_unsigned(buffer, 0xffff_ffff_ffff_ffff);
-        }
-        (ColorType::Gray(32), DecodingBuffer::U32(ref mut buffer)) => {
-            invert_colors_unsigned(buffer, 0xffff_ffff);
-        }
-        (ColorType::Gray(16), DecodingBuffer::U16(ref mut buffer)) => {
-            invert_colors_unsigned(buffer, 0xffff);
-        }
-        (ColorType::Gray(n), DecodingBuffer::U8(ref mut buffer)) if n <= 8 => {
-            invert_colors_unsigned(buffer, 0xff);
-        }
-        (ColorType::Gray(32), DecodingBuffer::F32(ref mut buffer)) => {
-            invert_colors_fp(buffer, 1.0);
-        }
-        (ColorType::Gray(64), DecodingBuffer::F64(ref mut buffer)) => {
-            invert_colors_fp(buffer, 1.0);
-        }
-        _ => {}
-    }
-}
-
-/// Fix endianness. If `byte_order` matches the host, then conversion is a no-op.
-fn fix_endianness(buf: &mut DecodingBuffer, byte_order: ByteOrder) {
-    match byte_order {
-        ByteOrder::LittleEndian => match buf {
-            DecodingBuffer::U8(_) | DecodingBuffer::I8(_) => {}
-            DecodingBuffer::U16(b) => b.iter_mut().for_each(|v| *v = u16::from_le(*v)),
-            DecodingBuffer::I16(b) => b.iter_mut().for_each(|v| *v = i16::from_le(*v)),
-            DecodingBuffer::U32(b) => b.iter_mut().for_each(|v| *v = u32::from_le(*v)),
-            DecodingBuffer::I32(b) => b.iter_mut().for_each(|v| *v = i32::from_le(*v)),
-            DecodingBuffer::U64(b) => b.iter_mut().for_each(|v| *v = u64::from_le(*v)),
-            DecodingBuffer::I64(b) => b.iter_mut().for_each(|v| *v = i64::from_le(*v)),
-            DecodingBuffer::F32(b) => b
-                .iter_mut()
-                .for_each(|v| *v = f32::from_bits(u32::from_le(v.to_bits()))),
-            DecodingBuffer::F64(b) => b
-                .iter_mut()
-                .for_each(|v| *v = f64::from_bits(u64::from_le(v.to_bits()))),
-        },
-        ByteOrder::BigEndian => match buf {
-            DecodingBuffer::U8(_) | DecodingBuffer::I8(_) => {}
-            DecodingBuffer::U16(b) => b.iter_mut().for_each(|v| *v = u16::from_be(*v)),
-            DecodingBuffer::I16(b) => b.iter_mut().for_each(|v| *v = i16::from_be(*v)),
-            DecodingBuffer::U32(b) => b.iter_mut().for_each(|v| *v = u32::from_be(*v)),
-            DecodingBuffer::I32(b) => b.iter_mut().for_each(|v| *v = i32::from_be(*v)),
-            DecodingBuffer::U64(b) => b.iter_mut().for_each(|v| *v = u64::from_be(*v)),
-            DecodingBuffer::I64(b) => b.iter_mut().for_each(|v| *v = i64::from_be(*v)),
-            DecodingBuffer::F32(b) => b
-                .iter_mut()
-                .for_each(|v| *v = f32::from_bits(u32::from_be(v.to_bits()))),
-            DecodingBuffer::F64(b) => b
-                .iter_mut()
-                .for_each(|v| *v = f64::from_bits(u64::from_be(v.to_bits()))),
-        },
-    };
-}
-
-impl<R: Read + Seek> Decoder<R> {
-    /// Create a new decoder that decodes from the stream ```r```
-    pub fn new(mut r: R) -> TiffResult<Decoder<R>> {
-        let mut endianess = Vec::with_capacity(2);
-        (&mut r).take(2).read_to_end(&mut endianess)?;
-        let byte_order = match &*endianess {
-            b"II" => ByteOrder::LittleEndian,
-            b"MM" => ByteOrder::BigEndian,
-            _ => {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::TiffSignatureNotFound,
-                ))
-            }
-        };
-        let mut reader = SmartReader::wrap(r, byte_order);
-
-        let bigtiff = match reader.read_u16()? {
-            42 => false,
-            43 => {
-                // Read bytesize of offsets (in bigtiff it's alway 8 but provide a way to move to 16 some day)
-                if reader.read_u16()? != 8 {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::TiffSignatureNotFound,
-                    ));
-                }
-                // This constant should always be 0
-                if reader.read_u16()? != 0 {
-                    return Err(TiffError::FormatError(
-                        TiffFormatError::TiffSignatureNotFound,
-                    ));
-                }
-                true
-            }
-            _ => {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::TiffSignatureInvalid,
-                ))
-            }
-        };
-        let next_ifd = if bigtiff {
-            Some(reader.read_u64()?)
-        } else {
-            Some(u64::from(reader.read_u32()?))
-        };
-
-        let mut seen_ifds = HashSet::new();
-        seen_ifds.insert(*next_ifd.as_ref().unwrap());
-        let ifd_offsets = vec![*next_ifd.as_ref().unwrap()];
-
-        let mut decoder = Decoder {
-            reader,
-            bigtiff,
-            limits: Default::default(),
-            next_ifd,
-            ifd_offsets,
-            seen_ifds,
-            image: Image {
-                ifd: None,
-                width: 0,
-                height: 0,
-                bits_per_sample: vec![1],
-                samples: 1,
-                sample_format: vec![SampleFormat::Uint],
-                photometric_interpretation: PhotometricInterpretation::BlackIsZero,
-                compression_method: CompressionMethod::None,
-                jpeg_tables: None,
-                predictor: Predictor::None,
-                chunk_type: ChunkType::Strip,
-                strip_decoder: None,
-                tile_attributes: None,
-                chunk_offsets: Vec::new(),
-                chunk_bytes: Vec::new(),
-            },
-        };
-        decoder.next_image()?;
-        Ok(decoder)
-    }
-
-    pub fn with_limits(mut self, limits: Limits) -> Decoder<R> {
-        self.limits = limits;
-        self
-    }
-
-    pub fn dimensions(&mut self) -> TiffResult<(u32, u32)> {
-        Ok((self.image().width, self.image().height))
-    }
-
-    pub fn colortype(&mut self) -> TiffResult<ColorType> {
-        self.image().colortype()
-    }
-
-    fn image(&self) -> &Image {
-        &self.image
-    }
-
-    /// Loads the IFD at the specified index in the list, if one exists
-    pub fn seek_to_image(&mut self, ifd_index: usize) -> TiffResult<()> {
-        // Check whether we have seen this IFD before, if so then the index will be less than the length of the list of ifd offsets
-        if ifd_index >= self.ifd_offsets.len() {
-            // We possibly need to load in the next IFD
-            if self.next_ifd.is_none() {
-                return Err(TiffError::FormatError(
-                    TiffFormatError::ImageFileDirectoryNotFound,
-                ));
-            }
-
-            loop {
-                // Follow the list until we find the one we want, or we reach the end, whichever happens first
-                let (_ifd, next_ifd) = self.next_ifd()?;
-
-                if next_ifd.is_none() {
-                    break;
-                }
-
-                if ifd_index < self.ifd_offsets.len() {
-                    break;
-                }
-            }
-        }
-
-        // If the index is within the list of ifds then we can load the selected image/IFD
-        if let Some(ifd_offset) = self.ifd_offsets.get(ifd_index) {
-            let (ifd, _next_ifd) = Self::read_ifd(&mut self.reader, self.bigtiff, *ifd_offset)?;
-
-            self.image = Image::from_reader(&mut self.reader, ifd, &self.limits, self.bigtiff)?;
-
-            Ok(())
-        } else {
-            Err(TiffError::FormatError(
-                TiffFormatError::ImageFileDirectoryNotFound,
-            ))
-        }
-    }
-
-    fn next_ifd(&mut self) -> TiffResult<(Directory, Option<u64>)> {
-        if self.next_ifd.is_none() {
-            return Err(TiffError::FormatError(
-                TiffFormatError::ImageFileDirectoryNotFound,
-            ));
-        }
-
-        let (ifd, next_ifd) = Self::read_ifd(
-            &mut self.reader,
-            self.bigtiff,
-            self.next_ifd.take().unwrap(),
-        )?;
-
-        if let Some(next) = next_ifd {
-            if !self.seen_ifds.insert(next) {
-                return Err(TiffError::FormatError(TiffFormatError::CycleInOffsets));
-            }
-            self.next_ifd = Some(next);
-            self.ifd_offsets.push(next);
-        }
-
-        Ok((ifd, next_ifd))
-    }
-
-    /// Reads in the next image.
-    /// If there is no further image in the TIFF file a format error is returned.
-    /// To determine whether there are more images call `TIFFDecoder::more_images` instead.
-    pub fn next_image(&mut self) -> TiffResult<()> {
-        let (ifd, _next_ifd) = self.next_ifd()?;
-
-        self.image = Image::from_reader(&mut self.reader, ifd, &self.limits, self.bigtiff)?;
-        Ok(())
-    }
-
-    /// Returns `true` if there is at least one more image available.
-    pub fn more_images(&self) -> bool {
-        self.next_ifd.is_some()
-    }
-
-    /// Returns the byte_order
-    pub fn byte_order(&self) -> ByteOrder {
-        self.reader.byte_order
-    }
-
-    #[inline]
-    pub fn read_ifd_offset(&mut self) -> Result<u64, io::Error> {
-        if self.bigtiff {
-            self.read_long8()
-        } else {
-            self.read_long().map(u64::from)
-        }
-    }
-
-    /// Reads a TIFF byte value
-    #[inline]
-    pub fn read_byte(&mut self) -> Result<u8, io::Error> {
-        let mut buf = [0; 1];
-        self.reader.read_exact(&mut buf)?;
-        Ok(buf[0])
-    }
-
-    /// Reads a TIFF short value
-    #[inline]
-    pub fn read_short(&mut self) -> Result<u16, io::Error> {
-        self.reader.read_u16()
-    }
-
-    /// Reads a TIFF sshort value
-    #[inline]
-    pub fn read_sshort(&mut self) -> Result<i16, io::Error> {
-        self.reader.read_i16()
-    }
-
-    /// Reads a TIFF long value
-    #[inline]
-    pub fn read_long(&mut self) -> Result<u32, io::Error> {
-        self.reader.read_u32()
-    }
-
-    /// Reads a TIFF slong value
-    #[inline]
-    pub fn read_slong(&mut self) -> Result<i32, io::Error> {
-        self.reader.read_i32()
-    }
-
-    /// Reads a TIFF float value
-    #[inline]
-    pub fn read_float(&mut self) -> Result<f32, io::Error> {
-        self.reader.read_f32()
-    }
-
-    /// Reads a TIFF double value
-    #[inline]
-    pub fn read_double(&mut self) -> Result<f64, io::Error> {
-        self.reader.read_f64()
-    }
-
-    #[inline]
-    pub fn read_long8(&mut self) -> Result<u64, io::Error> {
-        self.reader.read_u64()
-    }
-
-    #[inline]
-    pub fn read_slong8(&mut self) -> Result<i64, io::Error> {
-        self.reader.read_i64()
-    }
-
-    /// Reads a string
-    #[inline]
-    pub fn read_string(&mut self, length: usize) -> TiffResult<String> {
-        let mut out = vec![0; length];
-        self.reader.read_exact(&mut out)?;
-        // Strings may be null-terminated, so we trim anything downstream of the null byte
-        if let Some(first) = out.iter().position(|&b| b == 0) {
-            out.truncate(first);
-        }
-        Ok(String::from_utf8(out)?)
-    }
-
-    /// Reads a TIFF IFA offset/value field
-    #[inline]
-    pub fn read_offset(&mut self) -> TiffResult<[u8; 4]> {
-        if self.bigtiff {
-            return Err(TiffError::FormatError(
-                TiffFormatError::InconsistentSizesEncountered,
-            ));
-        }
-        let mut val = [0; 4];
-        self.reader.read_exact(&mut val)?;
-        Ok(val)
-    }
-
-    /// Reads a TIFF IFA offset/value field
-    #[inline]
-    pub fn read_offset_u64(&mut self) -> Result<[u8; 8], io::Error> {
-        let mut val = [0; 8];
-        self.reader.read_exact(&mut val)?;
-        Ok(val)
-    }
-
-    /// Moves the cursor to the specified offset
-    #[inline]
-    pub fn goto_offset(&mut self, offset: u32) -> io::Result<()> {
-        self.goto_offset_u64(offset.into())
-    }
-
-    #[inline]
-    pub fn goto_offset_u64(&mut self, offset: u64) -> io::Result<()> {
-        self.reader.seek(io::SeekFrom::Start(offset)).map(|_| ())
-    }
-
-    /// Reads a IFD entry.
-    // An IFD entry has four fields:
-    //
-    // Tag   2 bytes
-    // Type  2 bytes
-    // Count 4 bytes
-    // Value 4 bytes either a pointer the value itself
-    fn read_entry(
-        reader: &mut SmartReader<R>,
-        bigtiff: bool,
-    ) -> TiffResult<Option<(Tag, ifd::Entry)>> {
-        let tag = Tag::from_u16_exhaustive(reader.read_u16()?);
-        let type_ = match Type::from_u16(reader.read_u16()?) {
-            Some(t) => t,
-            None => {
-                // Unknown type. Skip this entry according to spec.
-                reader.read_u32()?;
-                reader.read_u32()?;
-                return Ok(None);
-            }
-        };
-        let entry = if bigtiff {
-            let mut offset = [0; 8];
-
-            let count = reader.read_u64()?;
-            reader.read_exact(&mut offset)?;
-            ifd::Entry::new_u64(type_, count, offset)
-        } else {
-            let mut offset = [0; 4];
-
-            let count = reader.read_u32()?;
-            reader.read_exact(&mut offset)?;
-            ifd::Entry::new(type_, count, offset)
-        };
-        Ok(Some((tag, entry)))
-    }
-
-    /// Reads the IFD starting at the indicated location.
-    fn read_ifd(
-        reader: &mut SmartReader<R>,
-        bigtiff: bool,
-        ifd_location: u64,
-    ) -> TiffResult<(Directory, Option<u64>)> {
-        reader.goto_offset(ifd_location)?;
-
-        let mut dir: Directory = HashMap::new();
-
-        let num_tags = if bigtiff {
-            reader.read_u64()?
-        } else {
-            reader.read_u16()?.into()
-        };
-        for _ in 0..num_tags {
-            let (tag, entry) = match Self::read_entry(reader, bigtiff)? {
-                Some(val) => val,
-                None => {
-                    continue;
-                } // Unknown data type in tag, skip
-            };
-            dir.insert(tag, entry);
-        }
-
-        let next_ifd = if bigtiff {
-            reader.read_u64()?
-        } else {
-            reader.read_u32()?.into()
-        };
-
-        let next_ifd = match next_ifd {
-            0 => None,
-            _ => Some(next_ifd),
-        };
-
-        Ok((dir, next_ifd))
-    }
-
-    /// Tries to retrieve a tag.
-    /// Return `Ok(None)` if the tag is not present.
-    pub fn find_tag(&mut self, tag: Tag) -> TiffResult<Option<ifd::Value>> {
-        let entry = match self.image().ifd.as_ref().unwrap().get(&tag) {
-            None => return Ok(None),
-            Some(entry) => entry.clone(),
-        };
-
-        Ok(Some(entry.val(
-            &self.limits,
-            self.bigtiff,
-            &mut self.reader,
-        )?))
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired unsigned type.
-    pub fn find_tag_unsigned<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<Option<T>> {
-        self.find_tag(tag)?
-            .map(|v| v.into_u64())
-            .transpose()?
-            .map(|value| {
-                T::try_from(value).map_err(|_| TiffFormatError::InvalidTagValueType(tag).into())
-            })
-            .transpose()
-    }
-
-    /// Tries to retrieve a vector of all a tag's values and convert them to
-    /// the desired unsigned type.
-    pub fn find_tag_unsigned_vec<T: TryFrom<u64>>(
-        &mut self,
-        tag: Tag,
-    ) -> TiffResult<Option<Vec<T>>> {
-        self.find_tag(tag)?
-            .map(|v| v.into_u64_vec())
-            .transpose()?
-            .map(|v| {
-                v.into_iter()
-                    .map(|u| {
-                        T::try_from(u).map_err(|_| TiffFormatError::InvalidTagValueType(tag).into())
-                    })
-                    .collect()
-            })
-            .transpose()
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired unsigned type.
-    /// Returns an error if the tag is not present.
-    pub fn get_tag_unsigned<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<T> {
-        self.find_tag_unsigned(tag)?
-            .ok_or_else(|| TiffFormatError::RequiredTagNotFound(tag).into())
-    }
-
-    /// Tries to retrieve a tag.
-    /// Returns an error if the tag is not present
-    pub fn get_tag(&mut self, tag: Tag) -> TiffResult<ifd::Value> {
-        match self.find_tag(tag)? {
-            Some(val) => Ok(val),
-            None => Err(TiffError::FormatError(
-                TiffFormatError::RequiredTagNotFound(tag),
-            )),
-        }
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired type.
-    pub fn get_tag_u32(&mut self, tag: Tag) -> TiffResult<u32> {
-        self.get_tag(tag)?.into_u32()
-    }
-    pub fn get_tag_u64(&mut self, tag: Tag) -> TiffResult<u64> {
-        self.get_tag(tag)?.into_u64()
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired type.
-    pub fn get_tag_f32(&mut self, tag: Tag) -> TiffResult<f32> {
-        self.get_tag(tag)?.into_f32()
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired type.
-    pub fn get_tag_f64(&mut self, tag: Tag) -> TiffResult<f64> {
-        self.get_tag(tag)?.into_f64()
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired type.
-    pub fn get_tag_u32_vec(&mut self, tag: Tag) -> TiffResult<Vec<u32>> {
-        self.get_tag(tag)?.into_u32_vec()
-    }
-
-    pub fn get_tag_u16_vec(&mut self, tag: Tag) -> TiffResult<Vec<u16>> {
-        self.get_tag(tag)?.into_u16_vec()
-    }
-    pub fn get_tag_u64_vec(&mut self, tag: Tag) -> TiffResult<Vec<u64>> {
-        self.get_tag(tag)?.into_u64_vec()
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired type.
-    pub fn get_tag_f32_vec(&mut self, tag: Tag) -> TiffResult<Vec<f32>> {
-        self.get_tag(tag)?.into_f32_vec()
-    }
-
-    /// Tries to retrieve a tag and convert it to the desired type.
-    pub fn get_tag_f64_vec(&mut self, tag: Tag) -> TiffResult<Vec<f64>> {
-        self.get_tag(tag)?.into_f64_vec()
-    }
-
-    /// Tries to retrieve a tag and convert it to a 8bit vector.
-    pub fn get_tag_u8_vec(&mut self, tag: Tag) -> TiffResult<Vec<u8>> {
-        self.get_tag(tag)?.into_u8_vec()
-    }
-
-    /// Tries to retrieve a tag and convert it to a ascii vector.
-    pub fn get_tag_ascii_string(&mut self, tag: Tag) -> TiffResult<String> {
-        self.get_tag(tag)?.into_string()
-    }
-
-    fn check_chunk_type(&self, expected: ChunkType) -> TiffResult<()> {
-        if expected != self.image().chunk_type {
-            return Err(TiffError::UsageError(UsageError::InvalidChunkType(
-                expected,
-                self.image().chunk_type,
-            )));
-        }
-
-        Ok(())
-    }
-
-    /// The chunk type (Strips / Tiles) of the image
-    pub fn get_chunk_type(&self) -> ChunkType {
-        self.image().chunk_type
-    }
-
-    /// Number of strips in image
-    pub fn strip_count(&mut self) -> TiffResult<u32> {
-        self.check_chunk_type(ChunkType::Strip)?;
-        let rows_per_strip = self.image().strip_decoder.as_ref().unwrap().rows_per_strip;
-
-        if rows_per_strip == 0 {
-            return Ok(0);
-        }
-
-        // rows_per_strip - 1 can never fail since we know it's at least 1
-        let height = match self.image().height.checked_add(rows_per_strip - 1) {
-            Some(h) => h,
-            None => return Err(TiffError::IntSizeError),
-        };
-
-        Ok(height / rows_per_strip)
-    }
-
-    /// Number of tiles in image
-    pub fn tile_count(&mut self) -> TiffResult<u32> {
-        self.check_chunk_type(ChunkType::Tile)?;
-        Ok(u32::try_from(self.image().chunk_offsets.len())?)
-    }
-
-    pub fn read_chunk_to_buffer(
-        &mut self,
-        mut buffer: DecodingBuffer,
-        chunk_index: u32,
-        output_width: usize,
-    ) -> TiffResult<()> {
-        let offset = self.image.chunk_file_range(chunk_index)?.0;
-        self.goto_offset_u64(offset)?;
-
-        let byte_order = self.reader.byte_order;
-
-        self.image.expand_chunk(
-            &mut self.reader,
-            buffer.copy(),
-            output_width,
-            byte_order,
-            chunk_index,
-        )?;
-
-        Ok(())
-    }
-
-    fn result_buffer(&self, width: usize, height: usize) -> TiffResult<DecodingResult> {
-        let buffer_size = match width
-            .checked_mul(height)
-            .and_then(|x| x.checked_mul(self.image().bits_per_sample.len()))
-        {
-            Some(s) => s,
-            None => return Err(TiffError::LimitsExceeded),
-        };
-
-        let max_sample_bits = self
-            .image()
-            .bits_per_sample
-            .iter()
-            .cloned()
-            .max()
-            .unwrap_or(8);
-        match self
-            .image()
-            .sample_format
-            .first()
-            .unwrap_or(&SampleFormat::Uint)
-        {
-            SampleFormat::Uint => match max_sample_bits {
-                n if n <= 8 => DecodingResult::new_u8(buffer_size, &self.limits),
-                n if n <= 16 => DecodingResult::new_u16(buffer_size, &self.limits),
-                n if n <= 32 => DecodingResult::new_u32(buffer_size, &self.limits),
-                n if n <= 64 => DecodingResult::new_u64(buffer_size, &self.limits),
-                n => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::UnsupportedBitsPerChannel(n),
-                )),
-            },
-            SampleFormat::IEEEFP => match max_sample_bits {
-                32 => DecodingResult::new_f32(buffer_size, &self.limits),
-                64 => DecodingResult::new_f64(buffer_size, &self.limits),
-                n => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::UnsupportedBitsPerChannel(n),
-                )),
-            },
-            SampleFormat::Int => match max_sample_bits {
-                n if n <= 8 => DecodingResult::new_i8(buffer_size, &self.limits),
-                n if n <= 16 => DecodingResult::new_i16(buffer_size, &self.limits),
-                n if n <= 32 => DecodingResult::new_i32(buffer_size, &self.limits),
-                n if n <= 64 => DecodingResult::new_i64(buffer_size, &self.limits),
-                n => Err(TiffError::UnsupportedError(
-                    TiffUnsupportedError::UnsupportedBitsPerChannel(n),
-                )),
-            },
-            format => {
-                Err(TiffUnsupportedError::UnsupportedSampleFormat(vec![format.clone()]).into())
-            }
-        }
-    }
-
-    /// Read the specified chunk (at index `chunk_index`) and return the binary data as a Vector.
-    pub fn read_chunk(&mut self, chunk_index: u32) -> TiffResult<DecodingResult> {
-        let data_dims = self.image().chunk_data_dimensions(chunk_index)?;
-
-        let mut result = self.result_buffer(data_dims.0 as usize, data_dims.1 as usize)?;
-
-        self.read_chunk_to_buffer(result.as_buffer(0), chunk_index, data_dims.0 as usize)?;
-
-        Ok(result)
-    }
-
-    /// Returns the default chunk size for the current image. Any given chunk in the image is at most as large as
-    /// the value returned here. For the size of the data (chunk minus padding), use `chunk_data_dimensions`.
-    pub fn chunk_dimensions(&self) -> (u32, u32) {
-        self.image().chunk_dimensions().unwrap()
-    }
-
-    /// Returns the size of the data in the chunk with the specified index. This is the default size of the chunk,
-    /// minus any padding.
-    pub fn chunk_data_dimensions(&self, chunk_index: u32) -> (u32, u32) {
-        self.image()
-            .chunk_data_dimensions(chunk_index)
-            .expect("invalid chunk_index")
-    }
-
-    /// Decodes the entire image and return it as a Vector
-    pub fn read_image(&mut self) -> TiffResult<DecodingResult> {
-        let width = self.image().width;
-        let height = self.image().height;
-        let mut result = self.result_buffer(width as usize, height as usize)?;
-        if width == 0 || height == 0 {
-            return Ok(result);
-        }
-
-        let chunk_dimensions = self.image().chunk_dimensions()?;
-        let chunk_dimensions = (
-            chunk_dimensions.0.min(width),
-            chunk_dimensions.1.min(height),
-        );
-        if chunk_dimensions.0 == 0 || chunk_dimensions.1 == 0 {
-            return Err(TiffError::FormatError(
-                TiffFormatError::InconsistentSizesEncountered,
-            ));
-        }
-
-        let samples = self.image().bits_per_sample.len();
-        if samples == 0 {
-            return Err(TiffError::FormatError(
-                TiffFormatError::InconsistentSizesEncountered,
-            ));
-        }
-
-        let chunks_across = ((width - 1) / chunk_dimensions.0 + 1) as usize;
-        let strip_samples = width as usize * chunk_dimensions.1 as usize * samples;
-
-        for chunk in 0..self.image().chunk_offsets.len() {
-            self.goto_offset_u64(self.image().chunk_offsets[chunk])?;
-
-            let x = chunk % chunks_across;
-            let y = chunk / chunks_across;
-            let buffer_offset = y * strip_samples + x * chunk_dimensions.0 as usize * samples;
-            let byte_order = self.reader.byte_order;
-            self.image.expand_chunk(
-                &mut self.reader,
-                result.as_buffer(buffer_offset).copy(),
-                width as usize,
-                byte_order,
-                chunk as u32,
-            )?;
-        }
-
-        Ok(result)
-    }
-}
diff --git a/vendor/tiff/src/decoder/stream.rs b/vendor/tiff/src/decoder/stream.rs
deleted file mode 100644
index e0323c2..0000000
--- a/vendor/tiff/src/decoder/stream.rs
+++ /dev/null
@@ -1,435 +0,0 @@
-//! All IO functionality needed for TIFF decoding
-
-use std::convert::TryFrom;
-use std::io::{self, BufRead, BufReader, Read, Seek, SeekFrom, Take};
-use std::sync::Arc;
-
-/// Byte order of the TIFF file.
-#[derive(Clone, Copy, Debug)]
-pub enum ByteOrder {
-    /// little endian byte order
-    LittleEndian,
-    /// big endian byte order
-    BigEndian,
-}
-
-/// Reader that is aware of the byte order.
-pub trait EndianReader: Read {
-    /// Byte order that should be adhered to
-    fn byte_order(&self) -> ByteOrder;
-
-    /// Reads an u16
-    #[inline(always)]
-    fn read_u16(&mut self) -> Result<u16, io::Error> {
-        let mut n = [0u8; 2];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => u16::from_le_bytes(n),
-            ByteOrder::BigEndian => u16::from_be_bytes(n),
-        })
-    }
-
-    /// Reads an i8
-    #[inline(always)]
-    fn read_i8(&mut self) -> Result<i8, io::Error> {
-        let mut n = [0u8; 1];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => i8::from_le_bytes(n),
-            ByteOrder::BigEndian => i8::from_be_bytes(n),
-        })
-    }
-
-    /// Reads an i16
-    #[inline(always)]
-    fn read_i16(&mut self) -> Result<i16, io::Error> {
-        let mut n = [0u8; 2];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => i16::from_le_bytes(n),
-            ByteOrder::BigEndian => i16::from_be_bytes(n),
-        })
-    }
-
-    /// Reads an u32
-    #[inline(always)]
-    fn read_u32(&mut self) -> Result<u32, io::Error> {
-        let mut n = [0u8; 4];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => u32::from_le_bytes(n),
-            ByteOrder::BigEndian => u32::from_be_bytes(n),
-        })
-    }
-
-    /// Reads an i32
-    #[inline(always)]
-    fn read_i32(&mut self) -> Result<i32, io::Error> {
-        let mut n = [0u8; 4];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => i32::from_le_bytes(n),
-            ByteOrder::BigEndian => i32::from_be_bytes(n),
-        })
-    }
-
-    /// Reads an u64
-    #[inline(always)]
-    fn read_u64(&mut self) -> Result<u64, io::Error> {
-        let mut n = [0u8; 8];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => u64::from_le_bytes(n),
-            ByteOrder::BigEndian => u64::from_be_bytes(n),
-        })
-    }
-
-    /// Reads an i64
-    #[inline(always)]
-    fn read_i64(&mut self) -> Result<i64, io::Error> {
-        let mut n = [0u8; 8];
-        self.read_exact(&mut n)?;
-        Ok(match self.byte_order() {
-            ByteOrder::LittleEndian => i64::from_le_bytes(n),
-            ByteOrder::BigEndian => i64::from_be_bytes(n),
-        })
-    }
-
-    /// Reads an f32
-    #[inline(always)]
-    fn read_f32(&mut self) -> Result<f32, io::Error> {
-        let mut n = [0u8; 4];
-        self.read_exact(&mut n)?;
-        Ok(f32::from_bits(match self.byte_order() {
-            ByteOrder::LittleEndian => u32::from_le_bytes(n),
-            ByteOrder::BigEndian => u32::from_be_bytes(n),
-        }))
-    }
-
-    /// Reads an f64
-    #[inline(always)]
-    fn read_f64(&mut self) -> Result<f64, io::Error> {
-        let mut n = [0u8; 8];
-        self.read_exact(&mut n)?;
-        Ok(f64::from_bits(match self.byte_order() {
-            ByteOrder::LittleEndian => u64::from_le_bytes(n),
-            ByteOrder::BigEndian => u64::from_be_bytes(n),
-        }))
-    }
-}
-
-///
-/// # READERS
-///
-
-///
-/// ## Deflate Reader
-///
-
-pub type DeflateReader<R> = flate2::read::ZlibDecoder<R>;
-
-///
-/// ## LZW Reader
-///
-
-/// Reader that decompresses LZW streams
-pub struct LZWReader<R: Read> {
-    reader: BufReader<Take<R>>,
-    decoder: weezl::decode::Decoder,
-}
-
-impl<R: Read> LZWReader<R> {
-    /// Wraps a reader
-    pub fn new(reader: R, compressed_length: usize) -> LZWReader<R> {
-        Self {
-            reader: BufReader::with_capacity(
-                (32 * 1024).min(compressed_length),
-                reader.take(u64::try_from(compressed_length).unwrap()),
-            ),
-            decoder: weezl::decode::Decoder::with_tiff_size_switch(weezl::BitOrder::Msb, 8),
-        }
-    }
-}
-
-impl<R: Read> Read for LZWReader<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        loop {
-            let result = self.decoder.decode_bytes(self.reader.fill_buf()?, buf);
-            self.reader.consume(result.consumed_in);
-
-            match result.status {
-                Ok(weezl::LzwStatus::Ok) => {
-                    if result.consumed_out == 0 {
-                        continue;
-                    } else {
-                        return Ok(result.consumed_out);
-                    }
-                }
-                Ok(weezl::LzwStatus::NoProgress) => {
-                    assert_eq!(result.consumed_in, 0);
-                    assert_eq!(result.consumed_out, 0);
-                    assert!(self.reader.buffer().is_empty());
-                    return Err(io::Error::new(
-                        io::ErrorKind::UnexpectedEof,
-                        "no lzw end code found",
-                    ));
-                }
-                Ok(weezl::LzwStatus::Done) => {
-                    return Ok(result.consumed_out);
-                }
-                Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidData, err)),
-            }
-        }
-    }
-}
-
-///
-/// ## JPEG Reader (for "new-style" JPEG format (TIFF compression tag 7))
-///
-
-pub(crate) struct JpegReader {
-    jpeg_tables: Option<Arc<Vec<u8>>>,
-
-    buffer: io::Cursor<Vec<u8>>,
-
-    offset: usize,
-}
-
-impl JpegReader {
-    /// Constructs new JpegReader wrapping a SmartReader.
-    /// Because JPEG compression in TIFF allows to save quantization and/or huffman tables in one
-    /// central location, the constructor accepts this data as `jpeg_tables` here containing either
-    /// or both.
-    /// These `jpeg_tables` are simply prepended to the remaining jpeg image data.
-    /// Because these `jpeg_tables` start with a `SOI` (HEX: `0xFFD8`) or __start of image__ marker
-    /// which is also at the beginning of the remaining JPEG image data and would
-    /// confuse the JPEG renderer, one of these has to be taken off. In this case the first two
-    /// bytes of the remaining JPEG data is removed because it follows `jpeg_tables`.
-    /// Similary, `jpeg_tables` ends with a `EOI` (HEX: `0xFFD9`) or __end of image__ marker,
-    /// this has to be removed as well (last two bytes of `jpeg_tables`).
-    pub fn new<R: Read>(
-        mut reader: R,
-        length: u64,
-        jpeg_tables: Option<Arc<Vec<u8>>>,
-    ) -> io::Result<JpegReader> {
-        // Read jpeg image data
-        let mut segment = vec![0; length as usize];
-
-        reader.read_exact(&mut segment[..])?;
-
-        match jpeg_tables {
-            Some(jpeg_tables) => {
-                assert!(
-                    jpeg_tables.len() >= 2,
-                    "jpeg_tables, if given, must be at least 2 bytes long. Got {:?}",
-                    jpeg_tables
-                );
-
-                assert!(
-                    length >= 2,
-                    "if jpeg_tables is given, length must be at least 2 bytes long, got {}",
-                    length
-                );
-
-                let mut buffer = io::Cursor::new(segment);
-                // Skip the first two bytes (marker bytes)
-                buffer.seek(SeekFrom::Start(2))?;
-
-                Ok(JpegReader {
-                    buffer,
-                    jpeg_tables: Some(jpeg_tables),
-                    offset: 0,
-                })
-            }
-            None => Ok(JpegReader {
-                buffer: io::Cursor::new(segment),
-                jpeg_tables: None,
-                offset: 0,
-            }),
-        }
-    }
-}
-
-impl Read for JpegReader {
-    // #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let mut start = 0;
-
-        if let Some(jpeg_tables) = &self.jpeg_tables {
-            if jpeg_tables.len() - 2 > self.offset {
-                // Read (rest of) jpeg_tables to buf (without the last two bytes)
-                let size_remaining = jpeg_tables.len() - self.offset - 2;
-                let to_copy = size_remaining.min(buf.len());
-
-                buf[start..start + to_copy]
-                    .copy_from_slice(&jpeg_tables[self.offset..self.offset + to_copy]);
-
-                self.offset += to_copy;
-
-                if to_copy == buf.len() {
-                    return Ok(to_copy);
-                }
-
-                start += to_copy;
-            }
-        }
-
-        let read = self.buffer.read(&mut buf[start..])?;
-        self.offset += read;
-
-        Ok(read + start)
-    }
-}
-
-///
-/// ## PackBits Reader
-///
-
-enum PackBitsReaderState {
-    Header,
-    Literal,
-    Repeat { value: u8 },
-}
-
-/// Reader that unpacks Apple's `PackBits` format
-pub struct PackBitsReader<R: Read> {
-    reader: Take<R>,
-    state: PackBitsReaderState,
-    count: usize,
-}
-
-impl<R: Read> PackBitsReader<R> {
-    /// Wraps a reader
-    pub fn new(reader: R, length: u64) -> Self {
-        Self {
-            reader: reader.take(length),
-            state: PackBitsReaderState::Header,
-            count: 0,
-        }
-    }
-}
-
-impl<R: Read> Read for PackBitsReader<R> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        while let PackBitsReaderState::Header = self.state {
-            if self.reader.limit() == 0 {
-                return Ok(0);
-            }
-            let mut header: [u8; 1] = [0];
-            self.reader.read_exact(&mut header)?;
-            let h = header[0] as i8;
-            if h >= -127 && h <= -1 {
-                let mut data: [u8; 1] = [0];
-                self.reader.read_exact(&mut data)?;
-                self.state = PackBitsReaderState::Repeat { value: data[0] };
-                self.count = (1 - h as isize) as usize;
-            } else if h >= 0 {
-                self.state = PackBitsReaderState::Literal;
-                self.count = h as usize + 1;
-            } else {
-                // h = -128 is a no-op.
-            }
-        }
-
-        let length = buf.len().min(self.count);
-        let actual = match self.state {
-            PackBitsReaderState::Literal => self.reader.read(&mut buf[..length])?,
-            PackBitsReaderState::Repeat { value } => {
-                for b in &mut buf[..length] {
-                    *b = value;
-                }
-
-                length
-            }
-            PackBitsReaderState::Header => unreachable!(),
-        };
-
-        self.count -= actual;
-        if self.count == 0 {
-            self.state = PackBitsReaderState::Header;
-        }
-        return Ok(actual);
-    }
-}
-
-///
-/// ## SmartReader Reader
-///
-
-/// Reader that is aware of the byte order.
-#[derive(Debug)]
-pub struct SmartReader<R>
-where
-    R: Read,
-{
-    reader: R,
-    pub byte_order: ByteOrder,
-}
-
-impl<R> SmartReader<R>
-where
-    R: Read,
-{
-    /// Wraps a reader
-    pub fn wrap(reader: R, byte_order: ByteOrder) -> SmartReader<R> {
-        SmartReader { reader, byte_order }
-    }
-    pub fn into_inner(self) -> R {
-        self.reader
-    }
-}
-impl<R: Read + Seek> SmartReader<R> {
-    pub fn goto_offset(&mut self, offset: u64) -> io::Result<()> {
-        self.seek(io::SeekFrom::Start(offset)).map(|_| ())
-    }
-}
-
-impl<R> EndianReader for SmartReader<R>
-where
-    R: Read,
-{
-    #[inline(always)]
-    fn byte_order(&self) -> ByteOrder {
-        self.byte_order
-    }
-}
-
-impl<R: Read> Read for SmartReader<R> {
-    #[inline]
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.reader.read(buf)
-    }
-}
-
-impl<R: Read + Seek> Seek for SmartReader<R> {
-    #[inline]
-    fn seek(&mut self, pos: io::SeekFrom) -> io::Result<u64> {
-        self.reader.seek(pos)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_packbits() {
-        let encoded = vec![
-            0xFE, 0xAA, 0x02, 0x80, 0x00, 0x2A, 0xFD, 0xAA, 0x03, 0x80, 0x00, 0x2A, 0x22, 0xF7,
-            0xAA,
-        ];
-        let encoded_len = encoded.len();
-
-        let buff = io::Cursor::new(encoded);
-        let mut decoder = PackBitsReader::new(buff, encoded_len as u64);
-
-        let mut decoded = Vec::new();
-        decoder.read_to_end(&mut decoded).unwrap();
-
-        let expected = vec![
-            0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0x80, 0x00, 0x2A, 0x22,
-            0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
-        ];
-        assert_eq!(decoded, expected);
-    }
-}
diff --git a/vendor/tiff/src/decoder/tag_reader.rs b/vendor/tiff/src/decoder/tag_reader.rs
deleted file mode 100644
index 837da40..0000000
--- a/vendor/tiff/src/decoder/tag_reader.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use std::convert::TryFrom;
-use std::io::{Read, Seek};
-
-use crate::tags::Tag;
-use crate::{TiffError, TiffFormatError, TiffResult};
-
-use super::ifd::{Directory, Value};
-use super::stream::SmartReader;
-use super::Limits;
-
-pub(crate) struct TagReader<'a, R: Read + Seek> {
-    pub reader: &'a mut SmartReader<R>,
-    pub ifd: &'a Directory,
-    pub limits: &'a Limits,
-    pub bigtiff: bool,
-}
-impl<'a, R: Read + Seek> TagReader<'a, R> {
-    pub(crate) fn find_tag(&mut self, tag: Tag) -> TiffResult<Option<Value>> {
-        Ok(match self.ifd.get(&tag) {
-            Some(entry) => Some(entry.clone().val(self.limits, self.bigtiff, self.reader)?),
-            None => None,
-        })
-    }
-    pub(crate) fn require_tag(&mut self, tag: Tag) -> TiffResult<Value> {
-        match self.find_tag(tag)? {
-            Some(val) => Ok(val),
-            None => Err(TiffError::FormatError(
-                TiffFormatError::RequiredTagNotFound(tag),
-            )),
-        }
-    }
-    pub fn find_tag_uint_vec<T: TryFrom<u64>>(&mut self, tag: Tag) -> TiffResult<Option<Vec<T>>> {
-        self.find_tag(tag)?
-            .map(|v| v.into_u64_vec())
-            .transpose()?
-            .map(|v| {
-                v.into_iter()
-                    .map(|u| {
-                        T::try_from(u).map_err(|_| TiffFormatError::InvalidTagValueType(tag).into())
-                    })
-                    .collect()
-            })
-            .transpose()
-    }
-}