Deleted vendor folder

1 files changed, 0 insertions, 370 deletions

diff --git a/vendor/image/src/traits.rs b/vendor/image/src/traits.rs
deleted file mode 100644
index 56daaa0..0000000
--- a/vendor/image/src/traits.rs
+++ /dev/null
@@ -1,370 +0,0 @@
-//! This module provides useful traits that were deprecated in rust
-
-// Note copied from the stdlib under MIT license
-
-use num_traits::{Bounded, Num, NumCast};
-use std::ops::AddAssign;
-
-use crate::color::{ColorType, Luma, LumaA, Rgb, Rgba};
-
-/// Types which are safe to treat as an immutable byte slice in a pixel layout
-/// for image encoding.
-pub trait EncodableLayout: seals::EncodableLayout {
-    /// Get the bytes of this value.
-    fn as_bytes(&self) -> &[u8];
-}
-
-impl EncodableLayout for [u8] {
-    fn as_bytes(&self) -> &[u8] {
-        bytemuck::cast_slice(self)
-    }
-}
-
-impl EncodableLayout for [u16] {
-    fn as_bytes(&self) -> &[u8] {
-        bytemuck::cast_slice(self)
-    }
-}
-
-impl EncodableLayout for [f32] {
-    fn as_bytes(&self) -> &[u8] {
-        bytemuck::cast_slice(self)
-    }
-}
-
-/// The type of each channel in a pixel. For example, this can be `u8`, `u16`, `f32`.
-// TODO rename to `PixelComponent`? Split up into separate traits? Seal?
-pub trait Primitive: Copy + NumCast + Num + PartialOrd<Self> + Clone + Bounded {
-    /// The maximum value for this type of primitive within the context of color.
-    /// For floats, the maximum is `1.0`, whereas the integer types inherit their usual maximum values.
-    const DEFAULT_MAX_VALUE: Self;
-
-    /// The minimum value for this type of primitive within the context of color.
-    /// For floats, the minimum is `0.0`, whereas the integer types inherit their usual minimum values.
-    const DEFAULT_MIN_VALUE: Self;
-}
-
-macro_rules! declare_primitive {
-    ($base:ty: ($from:expr)..$to:expr) => {
-        impl Primitive for $base {
-            const DEFAULT_MAX_VALUE: Self = $to;
-            const DEFAULT_MIN_VALUE: Self = $from;
-        }
-    };
-}
-
-declare_primitive!(usize: (0)..Self::MAX);
-declare_primitive!(u8: (0)..Self::MAX);
-declare_primitive!(u16: (0)..Self::MAX);
-declare_primitive!(u32: (0)..Self::MAX);
-declare_primitive!(u64: (0)..Self::MAX);
-
-declare_primitive!(isize: (Self::MIN)..Self::MAX);
-declare_primitive!(i8: (Self::MIN)..Self::MAX);
-declare_primitive!(i16: (Self::MIN)..Self::MAX);
-declare_primitive!(i32: (Self::MIN)..Self::MAX);
-declare_primitive!(i64: (Self::MIN)..Self::MAX);
-declare_primitive!(f32: (0.0)..1.0);
-declare_primitive!(f64: (0.0)..1.0);
-
-/// An Enlargable::Larger value should be enough to calculate
-/// the sum (average) of a few hundred or thousand Enlargeable values.
-pub trait Enlargeable: Sized + Bounded + NumCast {
-    type Larger: Copy + NumCast + Num + PartialOrd<Self::Larger> + Clone + Bounded + AddAssign;
-
-    fn clamp_from(n: Self::Larger) -> Self {
-        if n > Self::max_value().to_larger() {
-            Self::max_value()
-        } else if n < Self::min_value().to_larger() {
-            Self::min_value()
-        } else {
-            NumCast::from(n).unwrap()
-        }
-    }
-
-    fn to_larger(self) -> Self::Larger {
-        NumCast::from(self).unwrap()
-    }
-}
-
-impl Enlargeable for u8 {
-    type Larger = u32;
-}
-impl Enlargeable for u16 {
-    type Larger = u32;
-}
-impl Enlargeable for u32 {
-    type Larger = u64;
-}
-impl Enlargeable for u64 {
-    type Larger = u128;
-}
-impl Enlargeable for usize {
-    // Note: On 32-bit architectures, u64 should be enough here.
-    type Larger = u128;
-}
-impl Enlargeable for i8 {
-    type Larger = i32;
-}
-impl Enlargeable for i16 {
-    type Larger = i32;
-}
-impl Enlargeable for i32 {
-    type Larger = i64;
-}
-impl Enlargeable for i64 {
-    type Larger = i128;
-}
-impl Enlargeable for isize {
-    // Note: On 32-bit architectures, i64 should be enough here.
-    type Larger = i128;
-}
-impl Enlargeable for f32 {
-    type Larger = f64;
-}
-impl Enlargeable for f64 {
-    type Larger = f64;
-}
-
-/// Linear interpolation without involving floating numbers.
-pub trait Lerp: Bounded + NumCast {
-    type Ratio: Primitive;
-
-    fn lerp(a: Self, b: Self, ratio: Self::Ratio) -> Self {
-        let a = <Self::Ratio as NumCast>::from(a).unwrap();
-        let b = <Self::Ratio as NumCast>::from(b).unwrap();
-
-        let res = a + (b - a) * ratio;
-
-        if res > NumCast::from(Self::max_value()).unwrap() {
-            Self::max_value()
-        } else if res < NumCast::from(0).unwrap() {
-            NumCast::from(0).unwrap()
-        } else {
-            NumCast::from(res).unwrap()
-        }
-    }
-}
-
-impl Lerp for u8 {
-    type Ratio = f32;
-}
-
-impl Lerp for u16 {
-    type Ratio = f32;
-}
-
-impl Lerp for u32 {
-    type Ratio = f64;
-}
-
-impl Lerp for f32 {
-    type Ratio = f32;
-
-    fn lerp(a: Self, b: Self, ratio: Self::Ratio) -> Self {
-        a + (b - a) * ratio
-    }
-}
-
-/// The pixel with an associated `ColorType`.
-/// Not all possible pixels represent one of the predefined `ColorType`s.
-pub trait PixelWithColorType: Pixel + self::private::SealedPixelWithColorType {
-    /// This pixel has the format of one of the predefined `ColorType`s,
-    /// such as `Rgb8`, `La16` or `Rgba32F`.
-    /// This is needed for automatically detecting
-    /// a color format when saving an image as a file.
-    const COLOR_TYPE: ColorType;
-}
-
-impl PixelWithColorType for Rgb<u8> {
-    const COLOR_TYPE: ColorType = ColorType::Rgb8;
-}
-impl PixelWithColorType for Rgb<u16> {
-    const COLOR_TYPE: ColorType = ColorType::Rgb16;
-}
-impl PixelWithColorType for Rgb<f32> {
-    const COLOR_TYPE: ColorType = ColorType::Rgb32F;
-}
-
-impl PixelWithColorType for Rgba<u8> {
-    const COLOR_TYPE: ColorType = ColorType::Rgba8;
-}
-impl PixelWithColorType for Rgba<u16> {
-    const COLOR_TYPE: ColorType = ColorType::Rgba16;
-}
-impl PixelWithColorType for Rgba<f32> {
-    const COLOR_TYPE: ColorType = ColorType::Rgba32F;
-}
-
-impl PixelWithColorType for Luma<u8> {
-    const COLOR_TYPE: ColorType = ColorType::L8;
-}
-impl PixelWithColorType for Luma<u16> {
-    const COLOR_TYPE: ColorType = ColorType::L16;
-}
-impl PixelWithColorType for LumaA<u8> {
-    const COLOR_TYPE: ColorType = ColorType::La8;
-}
-impl PixelWithColorType for LumaA<u16> {
-    const COLOR_TYPE: ColorType = ColorType::La16;
-}
-
-/// Prevents down-stream users from implementing the `Primitive` trait
-mod private {
-    use crate::color::*;
-
-    pub trait SealedPixelWithColorType {}
-    impl SealedPixelWithColorType for Rgb<u8> {}
-    impl SealedPixelWithColorType for Rgb<u16> {}
-    impl SealedPixelWithColorType for Rgb<f32> {}
-
-    impl SealedPixelWithColorType for Rgba<u8> {}
-    impl SealedPixelWithColorType for Rgba<u16> {}
-    impl SealedPixelWithColorType for Rgba<f32> {}
-
-    impl SealedPixelWithColorType for Luma<u8> {}
-    impl SealedPixelWithColorType for LumaA<u8> {}
-
-    impl SealedPixelWithColorType for Luma<u16> {}
-    impl SealedPixelWithColorType for LumaA<u16> {}
-}
-
-/// A generalized pixel.
-///
-/// A pixel object is usually not used standalone but as a view into an image buffer.
-pub trait Pixel: Copy + Clone {
-    /// The scalar type that is used to store each channel in this pixel.
-    type Subpixel: Primitive;
-
-    /// The number of channels of this pixel type.
-    const CHANNEL_COUNT: u8;
-
-    /// Returns the components as a slice.
-    fn channels(&self) -> &[Self::Subpixel];
-
-    /// Returns the components as a mutable slice
-    fn channels_mut(&mut self) -> &mut [Self::Subpixel];
-
-    /// A string that can help to interpret the meaning each channel
-    /// See [gimp babl](http://gegl.org/babl/).
-    const COLOR_MODEL: &'static str;
-
-    /// Returns the channels of this pixel as a 4 tuple. If the pixel
-    /// has less than 4 channels the remainder is filled with the maximum value
-    #[deprecated(since = "0.24.0", note = "Use `channels()` or `channels_mut()`")]
-    fn channels4(
-        &self,
-    ) -> (
-        Self::Subpixel,
-        Self::Subpixel,
-        Self::Subpixel,
-        Self::Subpixel,
-    );
-
-    /// Construct a pixel from the 4 channels a, b, c and d.
-    /// If the pixel does not contain 4 channels the extra are ignored.
-    #[deprecated(
-        since = "0.24.0",
-        note = "Use the constructor of the pixel, for example `Rgba([r,g,b,a])` or `Pixel::from_slice`"
-    )]
-    fn from_channels(
-        a: Self::Subpixel,
-        b: Self::Subpixel,
-        c: Self::Subpixel,
-        d: Self::Subpixel,
-    ) -> Self;
-
-    /// Returns a view into a slice.
-    ///
-    /// Note: The slice length is not checked on creation. Thus the caller has to ensure
-    /// that the slice is long enough to prevent panics if the pixel is used later on.
-    fn from_slice(slice: &[Self::Subpixel]) -> &Self;
-
-    /// Returns mutable view into a mutable slice.
-    ///
-    /// Note: The slice length is not checked on creation. Thus the caller has to ensure
-    /// that the slice is long enough to prevent panics if the pixel is used later on.
-    fn from_slice_mut(slice: &mut [Self::Subpixel]) -> &mut Self;
-
-    /// Convert this pixel to RGB
-    fn to_rgb(&self) -> Rgb<Self::Subpixel>;
-
-    /// Convert this pixel to RGB with an alpha channel
-    fn to_rgba(&self) -> Rgba<Self::Subpixel>;
-
-    /// Convert this pixel to luma
-    fn to_luma(&self) -> Luma<Self::Subpixel>;
-
-    /// Convert this pixel to luma with an alpha channel
-    fn to_luma_alpha(&self) -> LumaA<Self::Subpixel>;
-
-    /// Apply the function ```f``` to each channel of this pixel.
-    fn map<F>(&self, f: F) -> Self
-    where
-        F: FnMut(Self::Subpixel) -> Self::Subpixel;
-
-    /// Apply the function ```f``` to each channel of this pixel.
-    fn apply<F>(&mut self, f: F)
-    where
-        F: FnMut(Self::Subpixel) -> Self::Subpixel;
-
-    /// Apply the function ```f``` to each channel except the alpha channel.
-    /// Apply the function ```g``` to the alpha channel.
-    fn map_with_alpha<F, G>(&self, f: F, g: G) -> Self
-    where
-        F: FnMut(Self::Subpixel) -> Self::Subpixel,
-        G: FnMut(Self::Subpixel) -> Self::Subpixel;
-
-    /// Apply the function ```f``` to each channel except the alpha channel.
-    /// Apply the function ```g``` to the alpha channel. Works in-place.
-    fn apply_with_alpha<F, G>(&mut self, f: F, g: G)
-    where
-        F: FnMut(Self::Subpixel) -> Self::Subpixel,
-        G: FnMut(Self::Subpixel) -> Self::Subpixel;
-
-    /// Apply the function ```f``` to each channel except the alpha channel.
-    fn map_without_alpha<F>(&self, f: F) -> Self
-    where
-        F: FnMut(Self::Subpixel) -> Self::Subpixel,
-    {
-        let mut this = *self;
-        this.apply_with_alpha(f, |x| x);
-        this
-    }
-
-    /// Apply the function ```f``` to each channel except the alpha channel.
-    /// Works in place.
-    fn apply_without_alpha<F>(&mut self, f: F)
-    where
-        F: FnMut(Self::Subpixel) -> Self::Subpixel,
-    {
-        self.apply_with_alpha(f, |x| x);
-    }
-
-    /// Apply the function ```f``` to each channel of this pixel and
-    /// ```other``` pairwise.
-    fn map2<F>(&self, other: &Self, f: F) -> Self
-    where
-        F: FnMut(Self::Subpixel, Self::Subpixel) -> Self::Subpixel;
-
-    /// Apply the function ```f``` to each channel of this pixel and
-    /// ```other``` pairwise. Works in-place.
-    fn apply2<F>(&mut self, other: &Self, f: F)
-    where
-        F: FnMut(Self::Subpixel, Self::Subpixel) -> Self::Subpixel;
-
-    /// Invert this pixel
-    fn invert(&mut self);
-
-    /// Blend the color of a given pixel into ourself, taking into account alpha channels
-    fn blend(&mut self, other: &Self);
-}
-
-/// Private module for supertraits of sealed traits.
-mod seals {
-    pub trait EncodableLayout {}
-
-    impl EncodableLayout for [u8] {}
-    impl EncodableLayout for [u16] {}
-    impl EncodableLayout for [f32] {}
-}