Deleted vendor folder

3 files changed, 0 insertions, 668 deletions

diff --git a/vendor/flate2/src/ffi/c.rs b/vendor/flate2/src/ffi/c.rs
deleted file mode 100644
index 32864f8..0000000
--- a/vendor/flate2/src/ffi/c.rs
+++ /dev/null
@@ -1,433 +0,0 @@
-//! Implementation for C backends.
-use std::alloc::{self, Layout};
-use std::cmp;
-use std::convert::TryFrom;
-use std::fmt;
-use std::marker;
-use std::ops::{Deref, DerefMut};
-use std::os::raw::{c_int, c_uint, c_void};
-use std::ptr;
-
-use super::*;
-use crate::mem::{self, FlushDecompress, Status};
-
-#[derive(Default)]
-pub struct ErrorMessage(Option<&'static str>);
-
-impl ErrorMessage {
-    pub fn get(&self) -> Option<&str> {
-        self.0
-    }
-}
-
-pub struct StreamWrapper {
-    pub inner: Box<mz_stream>,
-}
-
-impl fmt::Debug for StreamWrapper {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(f, "StreamWrapper")
-    }
-}
-
-impl Default for StreamWrapper {
-    fn default() -> StreamWrapper {
-        StreamWrapper {
-            inner: Box::new(mz_stream {
-                next_in: ptr::null_mut(),
-                avail_in: 0,
-                total_in: 0,
-                next_out: ptr::null_mut(),
-                avail_out: 0,
-                total_out: 0,
-                msg: ptr::null_mut(),
-                adler: 0,
-                data_type: 0,
-                reserved: 0,
-                opaque: ptr::null_mut(),
-                state: ptr::null_mut(),
-                #[cfg(all(feature = "any_zlib", not(feature = "cloudflare-zlib-sys")))]
-                zalloc,
-                #[cfg(all(feature = "any_zlib", not(feature = "cloudflare-zlib-sys")))]
-                zfree,
-                #[cfg(not(all(feature = "any_zlib", not(feature = "cloudflare-zlib-sys"))))]
-                zalloc: Some(zalloc),
-                #[cfg(not(all(feature = "any_zlib", not(feature = "cloudflare-zlib-sys"))))]
-                zfree: Some(zfree),
-            }),
-        }
-    }
-}
-
-const ALIGN: usize = std::mem::align_of::<usize>();
-
-fn align_up(size: usize, align: usize) -> usize {
-    (size + align - 1) & !(align - 1)
-}
-
-extern "C" fn zalloc(_ptr: *mut c_void, items: AllocSize, item_size: AllocSize) -> *mut c_void {
-    // We need to multiply `items` and `item_size` to get the actual desired
-    // allocation size. Since `zfree` doesn't receive a size argument we
-    // also need to allocate space for a `usize` as a header so we can store
-    // how large the allocation is to deallocate later.
-    let size = match items
-        .checked_mul(item_size)
-        .and_then(|i| usize::try_from(i).ok())
-        .map(|size| align_up(size, ALIGN))
-        .and_then(|i| i.checked_add(std::mem::size_of::<usize>()))
-    {
-        Some(i) => i,
-        None => return ptr::null_mut(),
-    };
-
-    // Make sure the `size` isn't too big to fail `Layout`'s restrictions
-    let layout = match Layout::from_size_align(size, ALIGN) {
-        Ok(layout) => layout,
-        Err(_) => return ptr::null_mut(),
-    };
-
-    unsafe {
-        // Allocate the data, and if successful store the size we allocated
-        // at the beginning and then return an offset pointer.
-        let ptr = alloc::alloc(layout) as *mut usize;
-        if ptr.is_null() {
-            return ptr as *mut c_void;
-        }
-        *ptr = size;
-        ptr.add(1) as *mut c_void
-    }
-}
-
-extern "C" fn zfree(_ptr: *mut c_void, address: *mut c_void) {
-    unsafe {
-        // Move our address being freed back one pointer, read the size we
-        // stored in `zalloc`, and then free it using the standard Rust
-        // allocator.
-        let ptr = (address as *mut usize).offset(-1);
-        let size = *ptr;
-        let layout = Layout::from_size_align_unchecked(size, ALIGN);
-        alloc::dealloc(ptr as *mut u8, layout)
-    }
-}
-
-impl Deref for StreamWrapper {
-    type Target = mz_stream;
-
-    fn deref(&self) -> &Self::Target {
-        &*self.inner
-    }
-}
-
-impl DerefMut for StreamWrapper {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut *self.inner
-    }
-}
-
-unsafe impl<D: Direction> Send for Stream<D> {}
-unsafe impl<D: Direction> Sync for Stream<D> {}
-
-/// Trait used to call the right destroy/end function on the inner
-/// stream object on drop.
-pub trait Direction {
-    unsafe fn destroy(stream: *mut mz_stream) -> c_int;
-}
-
-#[derive(Debug)]
-pub enum DirCompress {}
-#[derive(Debug)]
-pub enum DirDecompress {}
-
-#[derive(Debug)]
-pub struct Stream<D: Direction> {
-    pub stream_wrapper: StreamWrapper,
-    pub total_in: u64,
-    pub total_out: u64,
-    pub _marker: marker::PhantomData<D>,
-}
-
-impl<D: Direction> Stream<D> {
-    pub fn msg(&self) -> ErrorMessage {
-        let msg = self.stream_wrapper.msg;
-        ErrorMessage(if msg.is_null() {
-            None
-        } else {
-            let s = unsafe { std::ffi::CStr::from_ptr(msg) };
-            std::str::from_utf8(s.to_bytes()).ok()
-        })
-    }
-}
-
-impl<D: Direction> Drop for Stream<D> {
-    fn drop(&mut self) {
-        unsafe {
-            let _ = D::destroy(&mut *self.stream_wrapper);
-        }
-    }
-}
-
-impl Direction for DirCompress {
-    unsafe fn destroy(stream: *mut mz_stream) -> c_int {
-        mz_deflateEnd(stream)
-    }
-}
-impl Direction for DirDecompress {
-    unsafe fn destroy(stream: *mut mz_stream) -> c_int {
-        mz_inflateEnd(stream)
-    }
-}
-
-#[derive(Debug)]
-pub struct Inflate {
-    pub inner: Stream<DirDecompress>,
-}
-
-impl InflateBackend for Inflate {
-    fn make(zlib_header: bool, window_bits: u8) -> Self {
-        unsafe {
-            let mut state = StreamWrapper::default();
-            let ret = mz_inflateInit2(
-                &mut *state,
-                if zlib_header {
-                    window_bits as c_int
-                } else {
-                    -(window_bits as c_int)
-                },
-            );
-            assert_eq!(ret, 0);
-            Inflate {
-                inner: Stream {
-                    stream_wrapper: state,
-                    total_in: 0,
-                    total_out: 0,
-                    _marker: marker::PhantomData,
-                },
-            }
-        }
-    }
-
-    fn decompress(
-        &mut self,
-        input: &[u8],
-        output: &mut [u8],
-        flush: FlushDecompress,
-    ) -> Result<Status, DecompressError> {
-        let raw = &mut *self.inner.stream_wrapper;
-        raw.msg = ptr::null_mut();
-        raw.next_in = input.as_ptr() as *mut u8;
-        raw.avail_in = cmp::min(input.len(), c_uint::MAX as usize) as c_uint;
-        raw.next_out = output.as_mut_ptr();
-        raw.avail_out = cmp::min(output.len(), c_uint::MAX as usize) as c_uint;
-
-        let rc = unsafe { mz_inflate(raw, flush as c_int) };
-
-        // Unfortunately the total counters provided by zlib might be only
-        // 32 bits wide and overflow while processing large amounts of data.
-        self.inner.total_in += (raw.next_in as usize - input.as_ptr() as usize) as u64;
-        self.inner.total_out += (raw.next_out as usize - output.as_ptr() as usize) as u64;
-
-        // reset these pointers so we don't accidentally read them later
-        raw.next_in = ptr::null_mut();
-        raw.avail_in = 0;
-        raw.next_out = ptr::null_mut();
-        raw.avail_out = 0;
-
-        match rc {
-            MZ_DATA_ERROR | MZ_STREAM_ERROR => mem::decompress_failed(self.inner.msg()),
-            MZ_OK => Ok(Status::Ok),
-            MZ_BUF_ERROR => Ok(Status::BufError),
-            MZ_STREAM_END => Ok(Status::StreamEnd),
-            MZ_NEED_DICT => mem::decompress_need_dict(raw.adler as u32),
-            c => panic!("unknown return code: {}", c),
-        }
-    }
-
-    fn reset(&mut self, zlib_header: bool) {
-        let bits = if zlib_header {
-            MZ_DEFAULT_WINDOW_BITS
-        } else {
-            -MZ_DEFAULT_WINDOW_BITS
-        };
-        unsafe {
-            inflateReset2(&mut *self.inner.stream_wrapper, bits);
-        }
-        self.inner.total_out = 0;
-        self.inner.total_in = 0;
-    }
-}
-
-impl Backend for Inflate {
-    #[inline]
-    fn total_in(&self) -> u64 {
-        self.inner.total_in
-    }
-
-    #[inline]
-    fn total_out(&self) -> u64 {
-        self.inner.total_out
-    }
-}
-
-#[derive(Debug)]
-pub struct Deflate {
-    pub inner: Stream<DirCompress>,
-}
-
-impl DeflateBackend for Deflate {
-    fn make(level: Compression, zlib_header: bool, window_bits: u8) -> Self {
-        unsafe {
-            let mut state = StreamWrapper::default();
-            let ret = mz_deflateInit2(
-                &mut *state,
-                level.0 as c_int,
-                MZ_DEFLATED,
-                if zlib_header {
-                    window_bits as c_int
-                } else {
-                    -(window_bits as c_int)
-                },
-                8,
-                MZ_DEFAULT_STRATEGY,
-            );
-            assert_eq!(ret, 0);
-            Deflate {
-                inner: Stream {
-                    stream_wrapper: state,
-                    total_in: 0,
-                    total_out: 0,
-                    _marker: marker::PhantomData,
-                },
-            }
-        }
-    }
-    fn compress(
-        &mut self,
-        input: &[u8],
-        output: &mut [u8],
-        flush: FlushCompress,
-    ) -> Result<Status, CompressError> {
-        let raw = &mut *self.inner.stream_wrapper;
-        raw.msg = ptr::null_mut();
-        raw.next_in = input.as_ptr() as *mut _;
-        raw.avail_in = cmp::min(input.len(), c_uint::MAX as usize) as c_uint;
-        raw.next_out = output.as_mut_ptr();
-        raw.avail_out = cmp::min(output.len(), c_uint::MAX as usize) as c_uint;
-
-        let rc = unsafe { mz_deflate(raw, flush as c_int) };
-
-        // Unfortunately the total counters provided by zlib might be only
-        // 32 bits wide and overflow while processing large amounts of data.
-        self.inner.total_in += (raw.next_in as usize - input.as_ptr() as usize) as u64;
-        self.inner.total_out += (raw.next_out as usize - output.as_ptr() as usize) as u64;
-
-        // reset these pointers so we don't accidentally read them later
-        raw.next_in = ptr::null_mut();
-        raw.avail_in = 0;
-        raw.next_out = ptr::null_mut();
-        raw.avail_out = 0;
-
-        match rc {
-            MZ_OK => Ok(Status::Ok),
-            MZ_BUF_ERROR => Ok(Status::BufError),
-            MZ_STREAM_END => Ok(Status::StreamEnd),
-            MZ_STREAM_ERROR => mem::compress_failed(self.inner.msg()),
-            c => panic!("unknown return code: {}", c),
-        }
-    }
-
-    fn reset(&mut self) {
-        self.inner.total_in = 0;
-        self.inner.total_out = 0;
-        let rc = unsafe { mz_deflateReset(&mut *self.inner.stream_wrapper) };
-        assert_eq!(rc, MZ_OK);
-    }
-}
-
-impl Backend for Deflate {
-    #[inline]
-    fn total_in(&self) -> u64 {
-        self.inner.total_in
-    }
-
-    #[inline]
-    fn total_out(&self) -> u64 {
-        self.inner.total_out
-    }
-}
-
-pub use self::c_backend::*;
-
-/// For backwards compatibility, we provide symbols as `mz_` to mimic the miniz API
-#[allow(bad_style)]
-mod c_backend {
-    use std::mem;
-    use std::os::raw::{c_char, c_int};
-
-    #[cfg(feature = "zlib-ng")]
-    use libz_ng_sys as libz;
-
-    #[cfg(all(not(feature = "zlib-ng"), feature = "cloudflare_zlib"))]
-    use cloudflare_zlib_sys as libz;
-
-    #[cfg(all(not(feature = "cloudflare_zlib"), not(feature = "zlib-ng")))]
-    use libz_sys as libz;
-
-    pub use libz::deflate as mz_deflate;
-    pub use libz::deflateEnd as mz_deflateEnd;
-    pub use libz::deflateReset as mz_deflateReset;
-    pub use libz::inflate as mz_inflate;
-    pub use libz::inflateEnd as mz_inflateEnd;
-    pub use libz::z_stream as mz_stream;
-    pub use libz::*;
-
-    pub use libz::Z_BLOCK as MZ_BLOCK;
-    pub use libz::Z_BUF_ERROR as MZ_BUF_ERROR;
-    pub use libz::Z_DATA_ERROR as MZ_DATA_ERROR;
-    pub use libz::Z_DEFAULT_STRATEGY as MZ_DEFAULT_STRATEGY;
-    pub use libz::Z_DEFLATED as MZ_DEFLATED;
-    pub use libz::Z_FINISH as MZ_FINISH;
-    pub use libz::Z_FULL_FLUSH as MZ_FULL_FLUSH;
-    pub use libz::Z_NEED_DICT as MZ_NEED_DICT;
-    pub use libz::Z_NO_FLUSH as MZ_NO_FLUSH;
-    pub use libz::Z_OK as MZ_OK;
-    pub use libz::Z_PARTIAL_FLUSH as MZ_PARTIAL_FLUSH;
-    pub use libz::Z_STREAM_END as MZ_STREAM_END;
-    pub use libz::Z_STREAM_ERROR as MZ_STREAM_ERROR;
-    pub use libz::Z_SYNC_FLUSH as MZ_SYNC_FLUSH;
-    pub type AllocSize = libz::uInt;
-
-    pub const MZ_DEFAULT_WINDOW_BITS: c_int = 15;
-
-    #[cfg(feature = "zlib-ng")]
-    const ZLIB_VERSION: &'static str = "2.1.0.devel\0";
-    #[cfg(not(feature = "zlib-ng"))]
-    const ZLIB_VERSION: &'static str = "1.2.8\0";
-
-    pub unsafe extern "C" fn mz_deflateInit2(
-        stream: *mut mz_stream,
-        level: c_int,
-        method: c_int,
-        window_bits: c_int,
-        mem_level: c_int,
-        strategy: c_int,
-    ) -> c_int {
-        libz::deflateInit2_(
-            stream,
-            level,
-            method,
-            window_bits,
-            mem_level,
-            strategy,
-            ZLIB_VERSION.as_ptr() as *const c_char,
-            mem::size_of::<mz_stream>() as c_int,
-        )
-    }
-    pub unsafe extern "C" fn mz_inflateInit2(stream: *mut mz_stream, window_bits: c_int) -> c_int {
-        libz::inflateInit2_(
-            stream,
-            window_bits,
-            ZLIB_VERSION.as_ptr() as *const c_char,
-            mem::size_of::<mz_stream>() as c_int,
-        )
-    }
-}
diff --git a/vendor/flate2/src/ffi/mod.rs b/vendor/flate2/src/ffi/mod.rs
deleted file mode 100644
index 20b3cae..0000000
--- a/vendor/flate2/src/ffi/mod.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-//! This module contains backend-specific code.
-
-use crate::mem::{CompressError, DecompressError, FlushCompress, FlushDecompress, Status};
-use crate::Compression;
-
-/// Traits specifying the interface of the backends.
-///
-/// Sync + Send are added as a condition to ensure they are available
-/// for the frontend.
-pub trait Backend: Sync + Send {
-    fn total_in(&self) -> u64;
-    fn total_out(&self) -> u64;
-}
-
-pub trait InflateBackend: Backend {
-    fn make(zlib_header: bool, window_bits: u8) -> Self;
-    fn decompress(
-        &mut self,
-        input: &[u8],
-        output: &mut [u8],
-        flush: FlushDecompress,
-    ) -> Result<Status, DecompressError>;
-    fn reset(&mut self, zlib_header: bool);
-}
-
-pub trait DeflateBackend: Backend {
-    fn make(level: Compression, zlib_header: bool, window_bits: u8) -> Self;
-    fn compress(
-        &mut self,
-        input: &[u8],
-        output: &mut [u8],
-        flush: FlushCompress,
-    ) -> Result<Status, CompressError>;
-    fn reset(&mut self);
-}
-
-// Default to Rust implementation unless explicitly opted in to a different backend.
-#[cfg(feature = "any_zlib")]
-mod c;
-#[cfg(feature = "any_zlib")]
-pub use self::c::*;
-
-#[cfg(all(not(feature = "any_zlib"), feature = "miniz_oxide"))]
-mod rust;
-#[cfg(all(not(feature = "any_zlib"), feature = "miniz_oxide"))]
-pub use self::rust::*;
-
-impl std::fmt::Debug for ErrorMessage {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        self.get().fmt(f)
-    }
-}
diff --git a/vendor/flate2/src/ffi/rust.rs b/vendor/flate2/src/ffi/rust.rs
deleted file mode 100644
index bed6629..0000000
--- a/vendor/flate2/src/ffi/rust.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-//! Implementation for `miniz_oxide` rust backend.
-
-use std::convert::TryInto;
-use std::fmt;
-
-use miniz_oxide::deflate::core::CompressorOxide;
-use miniz_oxide::inflate::stream::InflateState;
-pub use miniz_oxide::*;
-
-pub const MZ_NO_FLUSH: isize = MZFlush::None as isize;
-pub const MZ_PARTIAL_FLUSH: isize = MZFlush::Partial as isize;
-pub const MZ_SYNC_FLUSH: isize = MZFlush::Sync as isize;
-pub const MZ_FULL_FLUSH: isize = MZFlush::Full as isize;
-pub const MZ_FINISH: isize = MZFlush::Finish as isize;
-
-use super::*;
-use crate::mem;
-
-// miniz_oxide doesn't provide any error messages (yet?)
-#[derive(Default)]
-pub struct ErrorMessage;
-
-impl ErrorMessage {
-    pub fn get(&self) -> Option<&str> {
-        None
-    }
-}
-
-fn format_from_bool(zlib_header: bool) -> DataFormat {
-    if zlib_header {
-        DataFormat::Zlib
-    } else {
-        DataFormat::Raw
-    }
-}
-
-pub struct Inflate {
-    inner: Box<InflateState>,
-    total_in: u64,
-    total_out: u64,
-}
-
-impl fmt::Debug for Inflate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(
-            f,
-            "miniz_oxide inflate internal state. total_in: {}, total_out: {}",
-            self.total_in, self.total_out,
-        )
-    }
-}
-
-impl InflateBackend for Inflate {
-    fn make(zlib_header: bool, _window_bits: u8) -> Self {
-        let format = format_from_bool(zlib_header);
-
-        Inflate {
-            inner: InflateState::new_boxed(format),
-            total_in: 0,
-            total_out: 0,
-        }
-    }
-
-    fn decompress(
-        &mut self,
-        input: &[u8],
-        output: &mut [u8],
-        flush: FlushDecompress,
-    ) -> Result<Status, DecompressError> {
-        let flush = MZFlush::new(flush as i32).unwrap();
-
-        let res = inflate::stream::inflate(&mut self.inner, input, output, flush);
-        self.total_in += res.bytes_consumed as u64;
-        self.total_out += res.bytes_written as u64;
-
-        match res.status {
-            Ok(status) => match status {
-                MZStatus::Ok => Ok(Status::Ok),
-                MZStatus::StreamEnd => Ok(Status::StreamEnd),
-                MZStatus::NeedDict => {
-                    mem::decompress_need_dict(self.inner.decompressor().adler32().unwrap_or(0))
-                }
-            },
-            Err(status) => match status {
-                MZError::Buf => Ok(Status::BufError),
-                _ => mem::decompress_failed(ErrorMessage),
-            },
-        }
-    }
-
-    fn reset(&mut self, zlib_header: bool) {
-        self.inner.reset(format_from_bool(zlib_header));
-        self.total_in = 0;
-        self.total_out = 0;
-    }
-}
-
-impl Backend for Inflate {
-    #[inline]
-    fn total_in(&self) -> u64 {
-        self.total_in
-    }
-
-    #[inline]
-    fn total_out(&self) -> u64 {
-        self.total_out
-    }
-}
-
-pub struct Deflate {
-    inner: Box<CompressorOxide>,
-    total_in: u64,
-    total_out: u64,
-}
-
-impl fmt::Debug for Deflate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(
-            f,
-            "miniz_oxide deflate internal state. total_in: {}, total_out: {}",
-            self.total_in, self.total_out,
-        )
-    }
-}
-
-impl DeflateBackend for Deflate {
-    fn make(level: Compression, zlib_header: bool, _window_bits: u8) -> Self {
-        // Check in case the integer value changes at some point.
-        debug_assert!(level.level() <= 10);
-
-        let mut inner: Box<CompressorOxide> = Box::default();
-        let format = format_from_bool(zlib_header);
-        inner.set_format_and_level(format, level.level().try_into().unwrap_or(1));
-
-        Deflate {
-            inner,
-            total_in: 0,
-            total_out: 0,
-        }
-    }
-
-    fn compress(
-        &mut self,
-        input: &[u8],
-        output: &mut [u8],
-        flush: FlushCompress,
-    ) -> Result<Status, CompressError> {
-        let flush = MZFlush::new(flush as i32).unwrap();
-        let res = deflate::stream::deflate(&mut self.inner, input, output, flush);
-        self.total_in += res.bytes_consumed as u64;
-        self.total_out += res.bytes_written as u64;
-
-        match res.status {
-            Ok(status) => match status {
-                MZStatus::Ok => Ok(Status::Ok),
-                MZStatus::StreamEnd => Ok(Status::StreamEnd),
-                MZStatus::NeedDict => mem::compress_failed(ErrorMessage),
-            },
-            Err(status) => match status {
-                MZError::Buf => Ok(Status::BufError),
-                _ => mem::compress_failed(ErrorMessage),
-            },
-        }
-    }
-
-    fn reset(&mut self) {
-        self.total_in = 0;
-        self.total_out = 0;
-        self.inner.reset();
-    }
-}
-
-impl Backend for Deflate {
-    #[inline]
-    fn total_in(&self) -> u64 {
-        self.total_in
-    }
-
-    #[inline]
-    fn total_out(&self) -> u64 {
-        self.total_out
-    }
-}