Deleted vendor folder

2 files changed, 0 insertions, 433 deletions

diff --git a/vendor/adler/src/algo.rs b/vendor/adler/src/algo.rs
deleted file mode 100644
index 650cffa..0000000
--- a/vendor/adler/src/algo.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-use crate::Adler32;
-use std::ops::{AddAssign, MulAssign, RemAssign};
-
-impl Adler32 {
-    pub(crate) fn compute(&mut self, bytes: &[u8]) {
-        // The basic algorithm is, for every byte:
-        //   a = (a + byte) % MOD
-        //   b = (b + a) % MOD
-        // where MOD = 65521.
-        //
-        // For efficiency, we can defer the `% MOD` operations as long as neither a nor b overflows:
-        // - Between calls to `write`, we ensure that a and b are always in range 0..MOD.
-        // - We use 32-bit arithmetic in this function.
-        // - Therefore, a and b must not increase by more than 2^32-MOD without performing a `% MOD`
-        //   operation.
-        //
-        // According to Wikipedia, b is calculated as follows for non-incremental checksumming:
-        //   b = n×D1 + (n−1)×D2 + (n−2)×D3 + ... + Dn + n*1 (mod 65521)
-        // Where n is the number of bytes and Di is the i-th Byte. We need to change this to account
-        // for the previous values of a and b, as well as treat every input Byte as being 255:
-        //   b_inc = n×255 + (n-1)×255 + ... + 255 + n*65520
-        // Or in other words:
-        //   b_inc = n*65520 + n(n+1)/2*255
-        // The max chunk size is thus the largest value of n so that b_inc <= 2^32-65521.
-        //   2^32-65521 = n*65520 + n(n+1)/2*255
-        // Plugging this into an equation solver since I can't math gives n = 5552.18..., so 5552.
-        //
-        // On top of the optimization outlined above, the algorithm can also be parallelized with a
-        // bit more work:
-        //
-        // Note that b is a linear combination of a vector of input bytes (D1, ..., Dn).
-        //
-        // If we fix some value k<N and rewrite indices 1, ..., N as
-        //
-        //   1_1, 1_2, ..., 1_k, 2_1, ..., 2_k, ..., (N/k)_k,
-        //
-        // then we can express a and b in terms of sums of smaller sequences kb and ka:
-        //
-        //   ka(j) := D1_j + D2_j + ... + D(N/k)_j where j <= k
-        //   kb(j) := (N/k)*D1_j + (N/k-1)*D2_j + ... + D(N/k)_j where j <= k
-        //
-        //  a = ka(1) + ka(2) + ... + ka(k) + 1
-        //  b = k*(kb(1) + kb(2) + ... + kb(k)) - 1*ka(2) - ...  - (k-1)*ka(k) + N
-        //
-        // We use this insight to unroll the main loop and process k=4 bytes at a time.
-        // The resulting code is highly amenable to SIMD acceleration, although the immediate speedups
-        // stem from increased pipeline parallelism rather than auto-vectorization.
-        //
-        // This technique is described in-depth (here:)[https://software.intel.com/content/www/us/\
-        // en/develop/articles/fast-computation-of-fletcher-checksums.html]
-
-        const MOD: u32 = 65521;
-        const CHUNK_SIZE: usize = 5552 * 4;
-
-        let mut a = u32::from(self.a);
-        let mut b = u32::from(self.b);
-        let mut a_vec = U32X4([0; 4]);
-        let mut b_vec = a_vec;
-
-        let (bytes, remainder) = bytes.split_at(bytes.len() - bytes.len() % 4);
-
-        // iterate over 4 bytes at a time
-        let chunk_iter = bytes.chunks_exact(CHUNK_SIZE);
-        let remainder_chunk = chunk_iter.remainder();
-        for chunk in chunk_iter {
-            for byte_vec in chunk.chunks_exact(4) {
-                let val = U32X4::from(byte_vec);
-                a_vec += val;
-                b_vec += a_vec;
-            }
-            b += CHUNK_SIZE as u32 * a;
-            a_vec %= MOD;
-            b_vec %= MOD;
-            b %= MOD;
-        }
-        // special-case the final chunk because it may be shorter than the rest
-        for byte_vec in remainder_chunk.chunks_exact(4) {
-            let val = U32X4::from(byte_vec);
-            a_vec += val;
-            b_vec += a_vec;
-        }
-        b += remainder_chunk.len() as u32 * a;
-        a_vec %= MOD;
-        b_vec %= MOD;
-        b %= MOD;
-
-        // combine the sub-sum results into the main sum
-        b_vec *= 4;
-        b_vec.0[1] += MOD - a_vec.0[1];
-        b_vec.0[2] += (MOD - a_vec.0[2]) * 2;
-        b_vec.0[3] += (MOD - a_vec.0[3]) * 3;
-        for &av in a_vec.0.iter() {
-            a += av;
-        }
-        for &bv in b_vec.0.iter() {
-            b += bv;
-        }
-
-        // iterate over the remaining few bytes in serial
-        for &byte in remainder.iter() {
-            a += u32::from(byte);
-            b += a;
-        }
-
-        self.a = (a % MOD) as u16;
-        self.b = (b % MOD) as u16;
-    }
-}
-
-#[derive(Copy, Clone)]
-struct U32X4([u32; 4]);
-
-impl U32X4 {
-    fn from(bytes: &[u8]) -> Self {
-        U32X4([
-            u32::from(bytes[0]),
-            u32::from(bytes[1]),
-            u32::from(bytes[2]),
-            u32::from(bytes[3]),
-        ])
-    }
-}
-
-impl AddAssign<Self> for U32X4 {
-    fn add_assign(&mut self, other: Self) {
-        for (s, o) in self.0.iter_mut().zip(other.0.iter()) {
-            *s += o;
-        }
-    }
-}
-
-impl RemAssign<u32> for U32X4 {
-    fn rem_assign(&mut self, quotient: u32) {
-        for s in self.0.iter_mut() {
-            *s %= quotient;
-        }
-    }
-}
-
-impl MulAssign<u32> for U32X4 {
-    fn mul_assign(&mut self, rhs: u32) {
-        for s in self.0.iter_mut() {
-            *s *= rhs;
-        }
-    }
-}
diff --git a/vendor/adler/src/lib.rs b/vendor/adler/src/lib.rs
deleted file mode 100644
index c7aa380..0000000
--- a/vendor/adler/src/lib.rs
+++ /dev/null
@@ -1,287 +0,0 @@
-//! Adler-32 checksum implementation.
-//!
-//! This implementation features:
-//!
-//! - Permissively licensed (0BSD) clean-room implementation.
-//! - Zero dependencies.
-//! - Zero `unsafe`.
-//! - Decent performance (3-4 GB/s).
-//! - `#![no_std]` support (with `default-features = false`).
-
-#![doc(html_root_url = "https://docs.rs/adler/1.0.2")]
-// Deny a few warnings in doctests, since rustdoc `allow`s many warnings by default
-#![doc(test(attr(deny(unused_imports, unused_must_use))))]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-#![warn(missing_debug_implementations)]
-#![forbid(unsafe_code)]
-#![cfg_attr(not(feature = "std"), no_std)]
-
-#[cfg(not(feature = "std"))]
-extern crate core as std;
-
-mod algo;
-
-use std::hash::Hasher;
-
-#[cfg(feature = "std")]
-use std::io::{self, BufRead};
-
-/// Adler-32 checksum calculator.
-///
-/// An instance of this type is equivalent to an Adler-32 checksum: It can be created in the default
-/// state via [`new`] (or the provided `Default` impl), or from a precalculated checksum via
-/// [`from_checksum`], and the currently stored checksum can be fetched via [`checksum`].
-///
-/// This type also implements `Hasher`, which makes it easy to calculate Adler-32 checksums of any
-/// type that implements or derives `Hash`. This also allows using Adler-32 in a `HashMap`, although
-/// that is not recommended (while every checksum is a hash function, they are not necessarily a
-/// good one).
-///
-/// # Examples
-///
-/// Basic, piecewise checksum calculation:
-///
-/// ```
-/// use adler::Adler32;
-///
-/// let mut adler = Adler32::new();
-///
-/// adler.write_slice(&[0, 1, 2]);
-/// adler.write_slice(&[3, 4, 5]);
-///
-/// assert_eq!(adler.checksum(), 0x00290010);
-/// ```
-///
-/// Using `Hash` to process structures:
-///
-/// ```
-/// use std::hash::Hash;
-/// use adler::Adler32;
-///
-/// #[derive(Hash)]
-/// struct Data {
-///     byte: u8,
-///     word: u16,
-///     big: u64,
-/// }
-///
-/// let mut adler = Adler32::new();
-///
-/// let data = Data { byte: 0x1F, word: 0xABCD, big: !0 };
-/// data.hash(&mut adler);
-///
-/// // hash value depends on architecture endianness
-/// if cfg!(target_endian = "little") {
-///     assert_eq!(adler.checksum(), 0x33410990);
-/// }
-/// if cfg!(target_endian = "big") {
-///     assert_eq!(adler.checksum(), 0x331F0990);
-/// }
-///
-/// ```
-///
-/// [`new`]: #method.new
-/// [`from_checksum`]: #method.from_checksum
-/// [`checksum`]: #method.checksum
-#[derive(Debug, Copy, Clone)]
-pub struct Adler32 {
-    a: u16,
-    b: u16,
-}
-
-impl Adler32 {
-    /// Creates a new Adler-32 instance with default state.
-    #[inline]
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Creates an `Adler32` instance from a precomputed Adler-32 checksum.
-    ///
-    /// This allows resuming checksum calculation without having to keep the `Adler32` instance
-    /// around.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use adler::Adler32;
-    /// let parts = [
-    ///     "rust",
-    ///     "acean",
-    /// ];
-    /// let whole = adler::adler32_slice(b"rustacean");
-    ///
-    /// let mut sum = Adler32::new();
-    /// sum.write_slice(parts[0].as_bytes());
-    /// let partial = sum.checksum();
-    ///
-    /// // ...later
-    ///
-    /// let mut sum = Adler32::from_checksum(partial);
-    /// sum.write_slice(parts[1].as_bytes());
-    /// assert_eq!(sum.checksum(), whole);
-    /// ```
-    #[inline]
-    pub fn from_checksum(sum: u32) -> Self {
-        Adler32 {
-            a: sum as u16,
-            b: (sum >> 16) as u16,
-        }
-    }
-
-    /// Returns the calculated checksum at this point in time.
-    #[inline]
-    pub fn checksum(&self) -> u32 {
-        (u32::from(self.b) << 16) | u32::from(self.a)
-    }
-
-    /// Adds `bytes` to the checksum calculation.
-    ///
-    /// If efficiency matters, this should be called with Byte slices that contain at least a few
-    /// thousand Bytes.
-    pub fn write_slice(&mut self, bytes: &[u8]) {
-        self.compute(bytes);
-    }
-}
-
-impl Default for Adler32 {
-    #[inline]
-    fn default() -> Self {
-        Adler32 { a: 1, b: 0 }
-    }
-}
-
-impl Hasher for Adler32 {
-    #[inline]
-    fn finish(&self) -> u64 {
-        u64::from(self.checksum())
-    }
-
-    fn write(&mut self, bytes: &[u8]) {
-        self.write_slice(bytes);
-    }
-}
-
-/// Calculates the Adler-32 checksum of a byte slice.
-///
-/// This is a convenience function around the [`Adler32`] type.
-///
-/// [`Adler32`]: struct.Adler32.html
-pub fn adler32_slice(data: &[u8]) -> u32 {
-    let mut h = Adler32::new();
-    h.write_slice(data);
-    h.checksum()
-}
-
-/// Calculates the Adler-32 checksum of a `BufRead`'s contents.
-///
-/// The passed `BufRead` implementor will be read until it reaches EOF (or until it reports an
-/// error).
-///
-/// If you only have a `Read` implementor, you can wrap it in `std::io::BufReader` before calling
-/// this function.
-///
-/// # Errors
-///
-/// Any error returned by the reader are bubbled up by this function.
-///
-/// # Examples
-///
-/// ```no_run
-/// # fn run() -> Result<(), Box<dyn std::error::Error>> {
-/// use adler::adler32;
-///
-/// use std::fs::File;
-/// use std::io::BufReader;
-///
-/// let file = File::open("input.txt")?;
-/// let mut file = BufReader::new(file);
-///
-/// adler32(&mut file)?;
-/// # Ok(()) }
-/// # fn main() { run().unwrap() }
-/// ```
-#[cfg(feature = "std")]
-#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
-pub fn adler32<R: BufRead>(mut reader: R) -> io::Result<u32> {
-    let mut h = Adler32::new();
-    loop {
-        let len = {
-            let buf = reader.fill_buf()?;
-            if buf.is_empty() {
-                return Ok(h.checksum());
-            }
-
-            h.write_slice(buf);
-            buf.len()
-        };
-        reader.consume(len);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn zeroes() {
-        assert_eq!(adler32_slice(&[]), 1);
-        assert_eq!(adler32_slice(&[0]), 1 | 1 << 16);
-        assert_eq!(adler32_slice(&[0, 0]), 1 | 2 << 16);
-        assert_eq!(adler32_slice(&[0; 100]), 0x00640001);
-        assert_eq!(adler32_slice(&[0; 1024]), 0x04000001);
-        assert_eq!(adler32_slice(&[0; 1024 * 1024]), 0x00f00001);
-    }
-
-    #[test]
-    fn ones() {
-        assert_eq!(adler32_slice(&[0xff; 1024]), 0x79a6fc2e);
-        assert_eq!(adler32_slice(&[0xff; 1024 * 1024]), 0x8e88ef11);
-    }
-
-    #[test]
-    fn mixed() {
-        assert_eq!(adler32_slice(&[1]), 2 | 2 << 16);
-        assert_eq!(adler32_slice(&[40]), 41 | 41 << 16);
-
-        assert_eq!(adler32_slice(&[0xA5; 1024 * 1024]), 0xd5009ab1);
-    }
-
-    /// Example calculation from https://en.wikipedia.org/wiki/Adler-32.
-    #[test]
-    fn wiki() {
-        assert_eq!(adler32_slice(b"Wikipedia"), 0x11E60398);
-    }
-
-    #[test]
-    fn resume() {
-        let mut adler = Adler32::new();
-        adler.write_slice(&[0xff; 1024]);
-        let partial = adler.checksum();
-        assert_eq!(partial, 0x79a6fc2e); // from above
-        adler.write_slice(&[0xff; 1024 * 1024 - 1024]);
-        assert_eq!(adler.checksum(), 0x8e88ef11); // from above
-
-        // Make sure that we can resume computing from the partial checksum via `from_checksum`.
-        let mut adler = Adler32::from_checksum(partial);
-        adler.write_slice(&[0xff; 1024 * 1024 - 1024]);
-        assert_eq!(adler.checksum(), 0x8e88ef11); // from above
-    }
-
-    #[cfg(feature = "std")]
-    #[test]
-    fn bufread() {
-        use std::io::BufReader;
-        fn test(data: &[u8], checksum: u32) {
-            // `BufReader` uses an 8 KB buffer, so this will test buffer refilling.
-            let mut buf = BufReader::new(data);
-            let real_sum = adler32(&mut buf).unwrap();
-            assert_eq!(checksum, real_sum);
-        }
-
-        test(&[], 1);
-        test(&[0; 1024], 0x04000001);
-        test(&[0; 1024 * 1024], 0x00f00001);
-        test(&[0xA5; 1024 * 1024], 0xd5009ab1);
-    }
-}