Deleted vendor folder

1 files changed, 0 insertions, 808 deletions

diff --git a/vendor/png/src/common.rs b/vendor/png/src/common.rs
deleted file mode 100644
index 6e5dbff..0000000
--- a/vendor/png/src/common.rs
+++ /dev/null
@@ -1,808 +0,0 @@
-//! Common types shared between the encoder and decoder
-use crate::text_metadata::{EncodableTextChunk, ITXtChunk, TEXtChunk, ZTXtChunk};
-use crate::{chunk, encoder};
-use io::Write;
-use std::{borrow::Cow, convert::TryFrom, fmt, io};
-
-/// Describes how a pixel is encoded.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-pub enum ColorType {
-    /// 1 grayscale sample.
-    Grayscale = 0,
-    /// 1 red sample, 1 green sample, 1 blue sample.
-    Rgb = 2,
-    /// 1 sample for the palette index.
-    Indexed = 3,
-    /// 1 grayscale sample, then 1 alpha sample.
-    GrayscaleAlpha = 4,
-    /// 1 red sample, 1 green sample, 1 blue sample, and finally, 1 alpha sample.
-    Rgba = 6,
-}
-
-impl ColorType {
-    /// Returns the number of samples used per pixel encoded in this way.
-    pub fn samples(self) -> usize {
-        self.samples_u8().into()
-    }
-
-    pub(crate) fn samples_u8(self) -> u8 {
-        use self::ColorType::*;
-        match self {
-            Grayscale | Indexed => 1,
-            Rgb => 3,
-            GrayscaleAlpha => 2,
-            Rgba => 4,
-        }
-    }
-
-    /// u8 -> Self. Temporary solution until Rust provides a canonical one.
-    pub fn from_u8(n: u8) -> Option<ColorType> {
-        match n {
-            0 => Some(ColorType::Grayscale),
-            2 => Some(ColorType::Rgb),
-            3 => Some(ColorType::Indexed),
-            4 => Some(ColorType::GrayscaleAlpha),
-            6 => Some(ColorType::Rgba),
-            _ => None,
-        }
-    }
-
-    pub(crate) fn checked_raw_row_length(self, depth: BitDepth, width: u32) -> Option<usize> {
-        // No overflow can occur in 64 bits, we multiply 32-bit with 5 more bits.
-        let bits = u64::from(width) * u64::from(self.samples_u8()) * u64::from(depth.into_u8());
-        TryFrom::try_from(1 + (bits + 7) / 8).ok()
-    }
-
-    pub(crate) fn raw_row_length_from_width(self, depth: BitDepth, width: u32) -> usize {
-        let samples = width as usize * self.samples();
-        1 + match depth {
-            BitDepth::Sixteen => samples * 2,
-            BitDepth::Eight => samples,
-            subbyte => {
-                let samples_per_byte = 8 / subbyte as usize;
-                let whole = samples / samples_per_byte;
-                let fract = usize::from(samples % samples_per_byte > 0);
-                whole + fract
-            }
-        }
-    }
-
-    pub(crate) fn is_combination_invalid(self, bit_depth: BitDepth) -> bool {
-        // Section 11.2.2 of the PNG standard disallows several combinations
-        // of bit depth and color type
-        ((bit_depth == BitDepth::One || bit_depth == BitDepth::Two || bit_depth == BitDepth::Four)
-            && (self == ColorType::Rgb
-                || self == ColorType::GrayscaleAlpha
-                || self == ColorType::Rgba))
-            || (bit_depth == BitDepth::Sixteen && self == ColorType::Indexed)
-    }
-}
-
-/// Bit depth of the PNG file.
-/// Specifies the number of bits per sample.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-pub enum BitDepth {
-    One = 1,
-    Two = 2,
-    Four = 4,
-    Eight = 8,
-    Sixteen = 16,
-}
-
-/// Internal count of bytes per pixel.
-/// This is used for filtering which never uses sub-byte units. This essentially reduces the number
-/// of possible byte chunk lengths to a very small set of values appropriate to be defined as an
-/// enum.
-#[derive(Debug, Clone, Copy)]
-#[repr(u8)]
-pub(crate) enum BytesPerPixel {
-    One = 1,
-    Two = 2,
-    Three = 3,
-    Four = 4,
-    Six = 6,
-    Eight = 8,
-}
-
-impl BitDepth {
-    /// u8 -> Self. Temporary solution until Rust provides a canonical one.
-    pub fn from_u8(n: u8) -> Option<BitDepth> {
-        match n {
-            1 => Some(BitDepth::One),
-            2 => Some(BitDepth::Two),
-            4 => Some(BitDepth::Four),
-            8 => Some(BitDepth::Eight),
-            16 => Some(BitDepth::Sixteen),
-            _ => None,
-        }
-    }
-
-    pub(crate) fn into_u8(self) -> u8 {
-        self as u8
-    }
-}
-
-/// Pixel dimensions information
-#[derive(Clone, Copy, Debug)]
-pub struct PixelDimensions {
-    /// Pixels per unit, X axis
-    pub xppu: u32,
-    /// Pixels per unit, Y axis
-    pub yppu: u32,
-    /// Either *Meter* or *Unspecified*
-    pub unit: Unit,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-/// Physical unit of the pixel dimensions
-pub enum Unit {
-    Unspecified = 0,
-    Meter = 1,
-}
-
-impl Unit {
-    /// u8 -> Self. Temporary solution until Rust provides a canonical one.
-    pub fn from_u8(n: u8) -> Option<Unit> {
-        match n {
-            0 => Some(Unit::Unspecified),
-            1 => Some(Unit::Meter),
-            _ => None,
-        }
-    }
-}
-
-/// How to reset buffer of an animated png (APNG) at the end of a frame.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-pub enum DisposeOp {
-    /// Leave the buffer unchanged.
-    None = 0,
-    /// Clear buffer with the background color.
-    Background = 1,
-    /// Reset the buffer to the state before the current frame.
-    Previous = 2,
-}
-
-impl DisposeOp {
-    /// u8 -> Self. Using enum_primitive or transmute is probably the right thing but this will do for now.
-    pub fn from_u8(n: u8) -> Option<DisposeOp> {
-        match n {
-            0 => Some(DisposeOp::None),
-            1 => Some(DisposeOp::Background),
-            2 => Some(DisposeOp::Previous),
-            _ => None,
-        }
-    }
-}
-
-impl fmt::Display for DisposeOp {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let name = match *self {
-            DisposeOp::None => "DISPOSE_OP_NONE",
-            DisposeOp::Background => "DISPOSE_OP_BACKGROUND",
-            DisposeOp::Previous => "DISPOSE_OP_PREVIOUS",
-        };
-        write!(f, "{}", name)
-    }
-}
-
-/// How pixels are written into the buffer.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-pub enum BlendOp {
-    /// Pixels overwrite the value at their position.
-    Source = 0,
-    /// The new pixels are blended into the current state based on alpha.
-    Over = 1,
-}
-
-impl BlendOp {
-    /// u8 -> Self. Using enum_primitive or transmute is probably the right thing but this will do for now.
-    pub fn from_u8(n: u8) -> Option<BlendOp> {
-        match n {
-            0 => Some(BlendOp::Source),
-            1 => Some(BlendOp::Over),
-            _ => None,
-        }
-    }
-}
-
-impl fmt::Display for BlendOp {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let name = match *self {
-            BlendOp::Source => "BLEND_OP_SOURCE",
-            BlendOp::Over => "BLEND_OP_OVER",
-        };
-        write!(f, "{}", name)
-    }
-}
-
-/// Frame control information
-#[derive(Clone, Copy, Debug)]
-pub struct FrameControl {
-    /// Sequence number of the animation chunk, starting from 0
-    pub sequence_number: u32,
-    /// Width of the following frame
-    pub width: u32,
-    /// Height of the following frame
-    pub height: u32,
-    /// X position at which to render the following frame
-    pub x_offset: u32,
-    /// Y position at which to render the following frame
-    pub y_offset: u32,
-    /// Frame delay fraction numerator
-    pub delay_num: u16,
-    /// Frame delay fraction denominator
-    pub delay_den: u16,
-    /// Type of frame area disposal to be done after rendering this frame
-    pub dispose_op: DisposeOp,
-    /// Type of frame area rendering for this frame
-    pub blend_op: BlendOp,
-}
-
-impl Default for FrameControl {
-    fn default() -> FrameControl {
-        FrameControl {
-            sequence_number: 0,
-            width: 0,
-            height: 0,
-            x_offset: 0,
-            y_offset: 0,
-            delay_num: 1,
-            delay_den: 30,
-            dispose_op: DisposeOp::None,
-            blend_op: BlendOp::Source,
-        }
-    }
-}
-
-impl FrameControl {
-    pub fn set_seq_num(&mut self, s: u32) {
-        self.sequence_number = s;
-    }
-
-    pub fn inc_seq_num(&mut self, i: u32) {
-        self.sequence_number += i;
-    }
-
-    pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
-        let mut data = [0u8; 26];
-        data[..4].copy_from_slice(&self.sequence_number.to_be_bytes());
-        data[4..8].copy_from_slice(&self.width.to_be_bytes());
-        data[8..12].copy_from_slice(&self.height.to_be_bytes());
-        data[12..16].copy_from_slice(&self.x_offset.to_be_bytes());
-        data[16..20].copy_from_slice(&self.y_offset.to_be_bytes());
-        data[20..22].copy_from_slice(&self.delay_num.to_be_bytes());
-        data[22..24].copy_from_slice(&self.delay_den.to_be_bytes());
-        data[24] = self.dispose_op as u8;
-        data[25] = self.blend_op as u8;
-
-        encoder::write_chunk(w, chunk::fcTL, &data)
-    }
-}
-
-/// Animation control information
-#[derive(Clone, Copy, Debug)]
-pub struct AnimationControl {
-    /// Number of frames
-    pub num_frames: u32,
-    /// Number of times to loop this APNG.  0 indicates infinite looping.
-    pub num_plays: u32,
-}
-
-impl AnimationControl {
-    pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
-        let mut data = [0; 8];
-        data[..4].copy_from_slice(&self.num_frames.to_be_bytes());
-        data[4..].copy_from_slice(&self.num_plays.to_be_bytes());
-        encoder::write_chunk(w, chunk::acTL, &data)
-    }
-}
-
-/// The type and strength of applied compression.
-#[derive(Debug, Clone, Copy)]
-pub enum Compression {
-    /// Default level
-    Default,
-    /// Fast minimal compression
-    Fast,
-    /// Higher compression level
-    ///
-    /// Best in this context isn't actually the highest possible level
-    /// the encoder can do, but is meant to emulate the `Best` setting in the `Flate2`
-    /// library.
-    Best,
-    #[deprecated(
-        since = "0.17.6",
-        note = "use one of the other compression levels instead, such as 'fast'"
-    )]
-    Huffman,
-    #[deprecated(
-        since = "0.17.6",
-        note = "use one of the other compression levels instead, such as 'fast'"
-    )]
-    Rle,
-}
-
-impl Default for Compression {
-    fn default() -> Self {
-        Self::Default
-    }
-}
-
-/// An unsigned integer scaled version of a floating point value,
-/// equivalent to an integer quotient with fixed denominator (100_000)).
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ScaledFloat(u32);
-
-impl ScaledFloat {
-    const SCALING: f32 = 100_000.0;
-
-    /// Gets whether the value is within the clamped range of this type.
-    pub fn in_range(value: f32) -> bool {
-        value >= 0.0 && (value * Self::SCALING).floor() <= std::u32::MAX as f32
-    }
-
-    /// Gets whether the value can be exactly converted in round-trip.
-    #[allow(clippy::float_cmp)] // Stupid tool, the exact float compare is _the entire point_.
-    pub fn exact(value: f32) -> bool {
-        let there = Self::forward(value);
-        let back = Self::reverse(there);
-        value == back
-    }
-
-    fn forward(value: f32) -> u32 {
-        (value.max(0.0) * Self::SCALING).floor() as u32
-    }
-
-    fn reverse(encoded: u32) -> f32 {
-        encoded as f32 / Self::SCALING
-    }
-
-    /// Slightly inaccurate scaling and quantization.
-    /// Clamps the value into the representable range if it is negative or too large.
-    pub fn new(value: f32) -> Self {
-        Self(Self::forward(value))
-    }
-
-    /// Fully accurate construction from a value scaled as per specification.
-    pub fn from_scaled(val: u32) -> Self {
-        Self(val)
-    }
-
-    /// Get the accurate encoded value.
-    pub fn into_scaled(self) -> u32 {
-        self.0
-    }
-
-    /// Get the unscaled value as a floating point.
-    pub fn into_value(self) -> f32 {
-        Self::reverse(self.0)
-    }
-
-    pub(crate) fn encode_gama<W: Write>(self, w: &mut W) -> encoder::Result<()> {
-        encoder::write_chunk(w, chunk::gAMA, &self.into_scaled().to_be_bytes())
-    }
-}
-
-/// Chromaticities of the color space primaries
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct SourceChromaticities {
-    pub white: (ScaledFloat, ScaledFloat),
-    pub red: (ScaledFloat, ScaledFloat),
-    pub green: (ScaledFloat, ScaledFloat),
-    pub blue: (ScaledFloat, ScaledFloat),
-}
-
-impl SourceChromaticities {
-    pub fn new(white: (f32, f32), red: (f32, f32), green: (f32, f32), blue: (f32, f32)) -> Self {
-        SourceChromaticities {
-            white: (ScaledFloat::new(white.0), ScaledFloat::new(white.1)),
-            red: (ScaledFloat::new(red.0), ScaledFloat::new(red.1)),
-            green: (ScaledFloat::new(green.0), ScaledFloat::new(green.1)),
-            blue: (ScaledFloat::new(blue.0), ScaledFloat::new(blue.1)),
-        }
-    }
-
-    #[rustfmt::skip]
-    pub fn to_be_bytes(self) -> [u8; 32] {
-        let white_x = self.white.0.into_scaled().to_be_bytes();
-        let white_y = self.white.1.into_scaled().to_be_bytes();
-        let red_x   = self.red.0.into_scaled().to_be_bytes();
-        let red_y   = self.red.1.into_scaled().to_be_bytes();
-        let green_x = self.green.0.into_scaled().to_be_bytes();
-        let green_y = self.green.1.into_scaled().to_be_bytes();
-        let blue_x  = self.blue.0.into_scaled().to_be_bytes();
-        let blue_y  = self.blue.1.into_scaled().to_be_bytes();
-        [
-            white_x[0], white_x[1], white_x[2], white_x[3],
-            white_y[0], white_y[1], white_y[2], white_y[3],
-            red_x[0],   red_x[1],   red_x[2],   red_x[3],
-            red_y[0],   red_y[1],   red_y[2],   red_y[3],
-            green_x[0], green_x[1], green_x[2], green_x[3],
-            green_y[0], green_y[1], green_y[2], green_y[3],
-            blue_x[0],  blue_x[1],  blue_x[2],  blue_x[3],
-            blue_y[0],  blue_y[1],  blue_y[2],  blue_y[3],
-        ]
-    }
-
-    pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
-        encoder::write_chunk(w, chunk::cHRM, &self.to_be_bytes())
-    }
-}
-
-/// The rendering intent for an sRGB image.
-///
-/// Presence of this data also indicates that the image conforms to the sRGB color space.
-#[repr(u8)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum SrgbRenderingIntent {
-    /// For images preferring good adaptation to the output device gamut at the expense of colorimetric accuracy, such as photographs.
-    Perceptual = 0,
-    /// For images requiring colour appearance matching (relative to the output device white point), such as logos.
-    RelativeColorimetric = 1,
-    /// For images preferring preservation of saturation at the expense of hue and lightness, such as charts and graphs.
-    Saturation = 2,
-    /// For images requiring preservation of absolute colorimetry, such as previews of images destined for a different output device (proofs).
-    AbsoluteColorimetric = 3,
-}
-
-impl SrgbRenderingIntent {
-    pub(crate) fn into_raw(self) -> u8 {
-        self as u8
-    }
-
-    pub(crate) fn from_raw(raw: u8) -> Option<Self> {
-        match raw {
-            0 => Some(SrgbRenderingIntent::Perceptual),
-            1 => Some(SrgbRenderingIntent::RelativeColorimetric),
-            2 => Some(SrgbRenderingIntent::Saturation),
-            3 => Some(SrgbRenderingIntent::AbsoluteColorimetric),
-            _ => None,
-        }
-    }
-
-    pub fn encode<W: Write>(self, w: &mut W) -> encoder::Result<()> {
-        encoder::write_chunk(w, chunk::sRGB, &[self.into_raw()])
-    }
-}
-
-/// PNG info struct
-#[derive(Clone, Debug)]
-#[non_exhaustive]
-pub struct Info<'a> {
-    pub width: u32,
-    pub height: u32,
-    pub bit_depth: BitDepth,
-    /// How colors are stored in the image.
-    pub color_type: ColorType,
-    pub interlaced: bool,
-    /// The image's `tRNS` chunk, if present; contains the alpha channel of the image's palette, 1 byte per entry.
-    pub trns: Option<Cow<'a, [u8]>>,
-    pub pixel_dims: Option<PixelDimensions>,
-    /// The image's `PLTE` chunk, if present; contains the RGB channels (in that order) of the image's palettes, 3 bytes per entry (1 per channel).
-    pub palette: Option<Cow<'a, [u8]>>,
-    /// The contents of the image's gAMA chunk, if present.
-    /// Prefer `source_gamma` to also get the derived replacement gamma from sRGB chunks.
-    pub gama_chunk: Option<ScaledFloat>,
-    /// The contents of the image's `cHRM` chunk, if present.
-    /// Prefer `source_chromaticities` to also get the derived replacements from sRGB chunks.
-    pub chrm_chunk: Option<SourceChromaticities>,
-
-    pub frame_control: Option<FrameControl>,
-    pub animation_control: Option<AnimationControl>,
-    pub compression: Compression,
-    /// Gamma of the source system.
-    /// Set by both `gAMA` as well as to a replacement by `sRGB` chunk.
-    pub source_gamma: Option<ScaledFloat>,
-    /// Chromaticities of the source system.
-    /// Set by both `cHRM` as well as to a replacement by `sRGB` chunk.
-    pub source_chromaticities: Option<SourceChromaticities>,
-    /// The rendering intent of an SRGB image.
-    ///
-    /// Presence of this value also indicates that the image conforms to the SRGB color space.
-    pub srgb: Option<SrgbRenderingIntent>,
-    /// The ICC profile for the image.
-    pub icc_profile: Option<Cow<'a, [u8]>>,
-    /// tEXt field
-    pub uncompressed_latin1_text: Vec<TEXtChunk>,
-    /// zTXt field
-    pub compressed_latin1_text: Vec<ZTXtChunk>,
-    /// iTXt field
-    pub utf8_text: Vec<ITXtChunk>,
-}
-
-impl Default for Info<'_> {
-    fn default() -> Info<'static> {
-        Info {
-            width: 0,
-            height: 0,
-            bit_depth: BitDepth::Eight,
-            color_type: ColorType::Grayscale,
-            interlaced: false,
-            palette: None,
-            trns: None,
-            gama_chunk: None,
-            chrm_chunk: None,
-            pixel_dims: None,
-            frame_control: None,
-            animation_control: None,
-            // Default to `deflate::Compression::Fast` and `filter::FilterType::Sub`
-            // to maintain backward compatible output.
-            compression: Compression::Fast,
-            source_gamma: None,
-            source_chromaticities: None,
-            srgb: None,
-            icc_profile: None,
-            uncompressed_latin1_text: Vec::new(),
-            compressed_latin1_text: Vec::new(),
-            utf8_text: Vec::new(),
-        }
-    }
-}
-
-impl Info<'_> {
-    /// A utility constructor for a default info with width and height.
-    pub fn with_size(width: u32, height: u32) -> Self {
-        Info {
-            width,
-            height,
-            ..Default::default()
-        }
-    }
-
-    /// Size of the image, width then height.
-    pub fn size(&self) -> (u32, u32) {
-        (self.width, self.height)
-    }
-
-    /// Returns true if the image is an APNG image.
-    pub fn is_animated(&self) -> bool {
-        self.frame_control.is_some() && self.animation_control.is_some()
-    }
-
-    /// Returns the frame control information of the image.
-    pub fn animation_control(&self) -> Option<&AnimationControl> {
-        self.animation_control.as_ref()
-    }
-
-    /// Returns the frame control information of the current frame
-    pub fn frame_control(&self) -> Option<&FrameControl> {
-        self.frame_control.as_ref()
-    }
-
-    /// Returns the number of bits per pixel.
-    pub fn bits_per_pixel(&self) -> usize {
-        self.color_type.samples() * self.bit_depth as usize
-    }
-
-    /// Returns the number of bytes per pixel.
-    pub fn bytes_per_pixel(&self) -> usize {
-        // If adjusting this for expansion or other transformation passes, remember to keep the old
-        // implementation for bpp_in_prediction, which is internal to the png specification.
-        self.color_type.samples() * ((self.bit_depth as usize + 7) >> 3)
-    }
-
-    /// Return the number of bytes for this pixel used in prediction.
-    ///
-    /// Some filters use prediction, over the raw bytes of a scanline. Where a previous pixel is
-    /// require for such forms the specification instead references previous bytes. That is, for
-    /// a gray pixel of bit depth 2, the pixel used in prediction is actually 4 pixels prior. This
-    /// has the consequence that the number of possible values is rather small. To make this fact
-    /// more obvious in the type system and the optimizer we use an explicit enum here.
-    pub(crate) fn bpp_in_prediction(&self) -> BytesPerPixel {
-        match self.bytes_per_pixel() {
-            1 => BytesPerPixel::One,
-            2 => BytesPerPixel::Two,
-            3 => BytesPerPixel::Three,
-            4 => BytesPerPixel::Four,
-            6 => BytesPerPixel::Six,   // Only rgb×16bit
-            8 => BytesPerPixel::Eight, // Only rgba×16bit
-            _ => unreachable!("Not a possible byte rounded pixel width"),
-        }
-    }
-
-    /// Returns the number of bytes needed for one deinterlaced image.
-    pub fn raw_bytes(&self) -> usize {
-        self.height as usize * self.raw_row_length()
-    }
-
-    /// Returns the number of bytes needed for one deinterlaced row.
-    pub fn raw_row_length(&self) -> usize {
-        self.raw_row_length_from_width(self.width)
-    }
-
-    pub(crate) fn checked_raw_row_length(&self) -> Option<usize> {
-        self.color_type
-            .checked_raw_row_length(self.bit_depth, self.width)
-    }
-
-    /// Returns the number of bytes needed for one deinterlaced row of width `width`.
-    pub fn raw_row_length_from_width(&self, width: u32) -> usize {
-        self.color_type
-            .raw_row_length_from_width(self.bit_depth, width)
-    }
-
-    /// Encode this header to the writer.
-    ///
-    /// Note that this does _not_ include the PNG signature, it starts with the IHDR chunk and then
-    /// includes other chunks that were added to the header.
-    pub fn encode<W: Write>(&self, mut w: W) -> encoder::Result<()> {
-        // Encode the IHDR chunk
-        let mut data = [0; 13];
-        data[..4].copy_from_slice(&self.width.to_be_bytes());
-        data[4..8].copy_from_slice(&self.height.to_be_bytes());
-        data[8] = self.bit_depth as u8;
-        data[9] = self.color_type as u8;
-        data[12] = self.interlaced as u8;
-        encoder::write_chunk(&mut w, chunk::IHDR, &data)?;
-        // Encode the pHYs chunk
-        if let Some(pd) = self.pixel_dims {
-            let mut phys_data = [0; 9];
-            phys_data[0..4].copy_from_slice(&pd.xppu.to_be_bytes());
-            phys_data[4..8].copy_from_slice(&pd.yppu.to_be_bytes());
-            match pd.unit {
-                Unit::Meter => phys_data[8] = 1,
-                Unit::Unspecified => phys_data[8] = 0,
-            }
-            encoder::write_chunk(&mut w, chunk::pHYs, &phys_data)?;
-        }
-
-        if let Some(p) = &self.palette {
-            encoder::write_chunk(&mut w, chunk::PLTE, p)?;
-        };
-
-        if let Some(t) = &self.trns {
-            encoder::write_chunk(&mut w, chunk::tRNS, t)?;
-        }
-
-        // If specified, the sRGB information overrides the source gamma and chromaticities.
-        if let Some(srgb) = &self.srgb {
-            let gamma = crate::srgb::substitute_gamma();
-            let chromaticities = crate::srgb::substitute_chromaticities();
-            srgb.encode(&mut w)?;
-            gamma.encode_gama(&mut w)?;
-            chromaticities.encode(&mut w)?;
-        } else {
-            if let Some(gma) = self.source_gamma {
-                gma.encode_gama(&mut w)?
-            }
-            if let Some(chrms) = self.source_chromaticities {
-                chrms.encode(&mut w)?;
-            }
-        }
-        if let Some(actl) = self.animation_control {
-            actl.encode(&mut w)?;
-        }
-
-        for text_chunk in &self.uncompressed_latin1_text {
-            text_chunk.encode(&mut w)?;
-        }
-
-        for text_chunk in &self.compressed_latin1_text {
-            text_chunk.encode(&mut w)?;
-        }
-
-        for text_chunk in &self.utf8_text {
-            text_chunk.encode(&mut w)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl BytesPerPixel {
-    pub(crate) fn into_usize(self) -> usize {
-        self as usize
-    }
-}
-
-bitflags! {
-    /// Output transformations
-    ///
-    /// Many flags from libpng are not yet supported. A PR discussing/adding them would be nice.
-    ///
-    #[doc = "
-    ```c
-    /// Discard the alpha channel
-    const STRIP_ALPHA         = 0x0002; // read only
-    /// Expand 1; 2 and 4-bit samples to bytes
-    const PACKING             = 0x0004; // read and write
-    /// Change order of packed pixels to LSB first
-    const PACKSWAP            = 0x0008; // read and write
-    /// Invert monochrome images
-    const INVERT_MONO         = 0x0020; // read and write
-    /// Normalize pixels to the sBIT depth
-    const SHIFT               = 0x0040; // read and write
-    /// Flip RGB to BGR; RGBA to BGRA
-    const BGR                 = 0x0080; // read and write
-    /// Flip RGBA to ARGB or GA to AG
-    const SWAP_ALPHA          = 0x0100; // read and write
-    /// Byte-swap 16-bit samples
-    const SWAP_ENDIAN         = 0x0200; // read and write
-    /// Change alpha from opacity to transparency
-    const INVERT_ALPHA        = 0x0400; // read and write
-    const STRIP_FILLER        = 0x0800; // write only
-    const STRIP_FILLER_BEFORE = 0x0800; // write only
-    const STRIP_FILLER_AFTER  = 0x1000; // write only
-    const GRAY_TO_RGB         = 0x2000; // read only
-    const EXPAND_16           = 0x4000; // read only
-    /// Similar to STRIP_16 but in libpng considering gamma?
-    /// Not entirely sure the documentation says it is more
-    /// accurate but doesn't say precisely how.
-    const SCALE_16            = 0x8000; // read only
-    ```
-    "]
-    pub struct Transformations: u32 {
-        /// No transformation
-        const IDENTITY            = 0x00000; // read and write */
-        /// Strip 16-bit samples to 8 bits
-        const STRIP_16            = 0x00001; // read only */
-        /// Expand paletted images to RGB; expand grayscale images of
-        /// less than 8-bit depth to 8-bit depth; and expand tRNS chunks
-        /// to alpha channels.
-        const EXPAND              = 0x00010; // read only */
-        /// Expand paletted images to include an alpha channel. Implies `EXPAND`.
-        const ALPHA               = 0x10000; // read only */
-    }
-}
-
-impl Transformations {
-    /// Transform every input to 8bit grayscale or color.
-    ///
-    /// This sets `EXPAND` and `STRIP_16` which is similar to the default transformation used by
-    /// this library prior to `0.17`.
-    pub fn normalize_to_color8() -> Transformations {
-        Transformations::EXPAND | Transformations::STRIP_16
-    }
-}
-
-/// Instantiate the default transformations, the identity transform.
-impl Default for Transformations {
-    fn default() -> Transformations {
-        Transformations::IDENTITY
-    }
-}
-
-#[derive(Debug)]
-pub struct ParameterError {
-    inner: ParameterErrorKind,
-}
-
-#[derive(Debug)]
-pub(crate) enum ParameterErrorKind {
-    /// A provided buffer must be have the exact size to hold the image data. Where the buffer can
-    /// be allocated by the caller, they must ensure that it has a minimum size as hinted previously.
-    /// Even though the size is calculated from image data, this does counts as a parameter error
-    /// because they must react to a value produced by this library, which can have been subjected
-    /// to limits.
-    ImageBufferSize { expected: usize, actual: usize },
-    /// A bit like return `None` from an iterator.
-    /// We use it to differentiate between failing to seek to the next image in a sequence and the
-    /// absence of a next image. This is an error of the caller because they should have checked
-    /// the number of images by inspecting the header data returned when opening the image. This
-    /// library will perform the checks necessary to ensure that data was accurate or error with a
-    /// format error otherwise.
-    PolledAfterEndOfImage,
-}
-
-impl From<ParameterErrorKind> for ParameterError {
-    fn from(inner: ParameterErrorKind) -> Self {
-        ParameterError { inner }
-    }
-}
-
-impl fmt::Display for ParameterError {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        use ParameterErrorKind::*;
-        match self.inner {
-            ImageBufferSize { expected, actual } => {
-                write!(fmt, "wrong data size, expected {} got {}", expected, actual)
-            }
-            PolledAfterEndOfImage => write!(fmt, "End of image has been reached"),
-        }
-    }
-}