Deleted vendor folder

1 files changed, 0 insertions, 337 deletions

diff --git a/vendor/miniz_oxide/src/inflate/mod.rs b/vendor/miniz_oxide/src/inflate/mod.rs
deleted file mode 100644
index bb19e37..0000000
--- a/vendor/miniz_oxide/src/inflate/mod.rs
+++ /dev/null
@@ -1,337 +0,0 @@
-//! This module contains functionality for decompression.
-
-#[cfg(feature = "with-alloc")]
-use crate::alloc::{boxed::Box, vec, vec::Vec};
-use ::core::usize;
-#[cfg(all(feature = "std", feature = "with-alloc"))]
-use std::error::Error;
-
-pub mod core;
-mod output_buffer;
-pub mod stream;
-use self::core::*;
-
-const TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS: i32 = -4;
-const TINFL_STATUS_BAD_PARAM: i32 = -3;
-const TINFL_STATUS_ADLER32_MISMATCH: i32 = -2;
-const TINFL_STATUS_FAILED: i32 = -1;
-const TINFL_STATUS_DONE: i32 = 0;
-const TINFL_STATUS_NEEDS_MORE_INPUT: i32 = 1;
-const TINFL_STATUS_HAS_MORE_OUTPUT: i32 = 2;
-
-/// Return status codes.
-#[repr(i8)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub enum TINFLStatus {
-    /// More input data was expected, but the caller indicated that there was no more data, so the
-    /// input stream is likely truncated.
-    ///
-    /// This can't happen if you have provided the
-    /// [`TINFL_FLAG_HAS_MORE_INPUT`][core::inflate_flags::TINFL_FLAG_HAS_MORE_INPUT] flag to the
-    /// decompression.  By setting that flag, you indicate more input exists but is not provided,
-    /// and so reaching the end of the input data without finding the end of the compressed stream
-    /// would instead return a [`NeedsMoreInput`][Self::NeedsMoreInput] status.
-    FailedCannotMakeProgress = TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS as i8,
-
-    /// The output buffer is an invalid size; consider the `flags` parameter.
-    BadParam = TINFL_STATUS_BAD_PARAM as i8,
-
-    /// The decompression went fine, but the adler32 checksum did not match the one
-    /// provided in the header.
-    Adler32Mismatch = TINFL_STATUS_ADLER32_MISMATCH as i8,
-
-    /// Failed to decompress due to invalid data.
-    Failed = TINFL_STATUS_FAILED as i8,
-
-    /// Finished decompression without issues.
-    ///
-    /// This indicates the end of the compressed stream has been reached.
-    Done = TINFL_STATUS_DONE as i8,
-
-    /// The decompressor needs more input data to continue decompressing.
-    ///
-    /// This occurs when there's no more consumable input, but the end of the stream hasn't been
-    /// reached, and you have supplied the
-    /// [`TINFL_FLAG_HAS_MORE_INPUT`][core::inflate_flags::TINFL_FLAG_HAS_MORE_INPUT] flag to the
-    /// decompressor.  Had you not supplied that flag (which would mean you were asserting that you
-    /// believed all the data was available) you would have gotten a
-    /// [`FailedCannotMakeProcess`][Self::FailedCannotMakeProgress] instead.
-    NeedsMoreInput = TINFL_STATUS_NEEDS_MORE_INPUT as i8,
-
-    /// There is still pending data that didn't fit in the output buffer.
-    HasMoreOutput = TINFL_STATUS_HAS_MORE_OUTPUT as i8,
-}
-
-impl TINFLStatus {
-    pub fn from_i32(value: i32) -> Option<TINFLStatus> {
-        use self::TINFLStatus::*;
-        match value {
-            TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS => Some(FailedCannotMakeProgress),
-            TINFL_STATUS_BAD_PARAM => Some(BadParam),
-            TINFL_STATUS_ADLER32_MISMATCH => Some(Adler32Mismatch),
-            TINFL_STATUS_FAILED => Some(Failed),
-            TINFL_STATUS_DONE => Some(Done),
-            TINFL_STATUS_NEEDS_MORE_INPUT => Some(NeedsMoreInput),
-            TINFL_STATUS_HAS_MORE_OUTPUT => Some(HasMoreOutput),
-            _ => None,
-        }
-    }
-}
-
-/// Struct return when decompress_to_vec functions fail.
-#[cfg(feature = "with-alloc")]
-#[derive(Debug)]
-pub struct DecompressError {
-    /// Decompressor status on failure. See [TINFLStatus] for details.
-    pub status: TINFLStatus,
-    /// The currently decompressed data if any.
-    pub output: Vec<u8>,
-}
-
-#[cfg(feature = "with-alloc")]
-impl alloc::fmt::Display for DecompressError {
-    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
-        f.write_str(match self.status {
-            TINFLStatus::FailedCannotMakeProgress => "Truncated input stream",
-            TINFLStatus::BadParam => "Invalid output buffer size",
-            TINFLStatus::Adler32Mismatch => "Adler32 checksum mismatch",
-            TINFLStatus::Failed => "Invalid input data",
-            TINFLStatus::Done => unreachable!(),
-            TINFLStatus::NeedsMoreInput => "Truncated input stream",
-            TINFLStatus::HasMoreOutput => "Output size exceeded the specified limit",
-        })
-    }
-}
-
-/// Implement Error trait only if std feature is requested as it requires std.
-#[cfg(all(feature = "std", feature = "with-alloc"))]
-impl Error for DecompressError {}
-
-#[cfg(feature = "with-alloc")]
-fn decompress_error(status: TINFLStatus, output: Vec<u8>) -> Result<Vec<u8>, DecompressError> {
-    Err(DecompressError { status, output })
-}
-
-/// Decompress the deflate-encoded data in `input` to a vector.
-///
-/// NOTE: This function will not bound the output, so if the output is large enough it can result in an out of memory error.
-/// It is therefore suggested to not use this for anything other than test programs, use the functions with a specified limit, or
-/// ideally streaming decompression via the [flate2](https://github.com/alexcrichton/flate2-rs) library instead.
-///
-/// Returns a [`Result`] containing the [`Vec`] of decompressed data on success, and a [struct][DecompressError] containing the status and so far decompressed data if any on failure.
-#[inline]
-#[cfg(feature = "with-alloc")]
-pub fn decompress_to_vec(input: &[u8]) -> Result<Vec<u8>, DecompressError> {
-    decompress_to_vec_inner(input, 0, usize::max_value())
-}
-
-/// Decompress the deflate-encoded data (with a zlib wrapper) in `input` to a vector.
-///
-/// NOTE: This function will not bound the output, so if the output is large enough it can result in an out of memory error.
-/// It is therefore suggested to not use this for anything other than test programs, use the functions with a specified limit, or
-/// ideally streaming decompression via the [flate2](https://github.com/alexcrichton/flate2-rs) library instead.
-///
-/// Returns a [`Result`] containing the [`Vec`] of decompressed data on success, and a [struct][DecompressError] containing the status and so far decompressed data if any on failure.
-#[inline]
-#[cfg(feature = "with-alloc")]
-pub fn decompress_to_vec_zlib(input: &[u8]) -> Result<Vec<u8>, DecompressError> {
-    decompress_to_vec_inner(
-        input,
-        inflate_flags::TINFL_FLAG_PARSE_ZLIB_HEADER,
-        usize::max_value(),
-    )
-}
-
-/// Decompress the deflate-encoded data in `input` to a vector.
-///
-/// The vector is grown to at most `max_size` bytes; if the data does not fit in that size,
-/// the error [struct][DecompressError] will contain the status [`TINFLStatus::HasMoreOutput`] and the data that was decompressed on failure.
-///
-/// As this function tries to decompress everything in one go, it's not ideal for general use outside of tests or where the output size is expected to be small.
-/// It is suggested to use streaming decompression via the [flate2](https://github.com/alexcrichton/flate2-rs) library instead.
-///
-/// Returns a [`Result`] containing the [`Vec`] of decompressed data on success, and a [struct][DecompressError] on failure.
-#[inline]
-#[cfg(feature = "with-alloc")]
-pub fn decompress_to_vec_with_limit(
-    input: &[u8],
-    max_size: usize,
-) -> Result<Vec<u8>, DecompressError> {
-    decompress_to_vec_inner(input, 0, max_size)
-}
-
-/// Decompress the deflate-encoded data (with a zlib wrapper) in `input` to a vector.
-/// The vector is grown to at most `max_size` bytes; if the data does not fit in that size,
-/// the error [struct][DecompressError] will contain the status [`TINFLStatus::HasMoreOutput`] and the data that was decompressed on failure.
-///
-/// As this function tries to decompress everything in one go, it's not ideal for general use outside of tests or where the output size is expected to be small.
-/// It is suggested to use streaming decompression via the [flate2](https://github.com/alexcrichton/flate2-rs) library instead.
-///
-/// Returns a [`Result`] containing the [`Vec`] of decompressed data on success, and a [struct][DecompressError] on failure.
-#[inline]
-#[cfg(feature = "with-alloc")]
-pub fn decompress_to_vec_zlib_with_limit(
-    input: &[u8],
-    max_size: usize,
-) -> Result<Vec<u8>, DecompressError> {
-    decompress_to_vec_inner(input, inflate_flags::TINFL_FLAG_PARSE_ZLIB_HEADER, max_size)
-}
-
-/// Backend of various to-[`Vec`] decompressions.
-///
-/// Returns [`Vec`] of decompressed data on success and the [error struct][DecompressError] with details on failure.
-#[cfg(feature = "with-alloc")]
-fn decompress_to_vec_inner(
-    input: &[u8],
-    flags: u32,
-    max_output_size: usize,
-) -> Result<Vec<u8>, DecompressError> {
-    let flags = flags | inflate_flags::TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF;
-    let mut ret: Vec<u8> = vec![0; input.len().saturating_mul(2).min(max_output_size)];
-
-    let mut decomp = Box::<DecompressorOxide>::default();
-
-    let mut in_pos = 0;
-    let mut out_pos = 0;
-    loop {
-        // Wrap the whole output slice so we know we have enough of the
-        // decompressed data for matches.
-        let (status, in_consumed, out_consumed) =
-            decompress(&mut decomp, &input[in_pos..], &mut ret, out_pos, flags);
-        in_pos += in_consumed;
-        out_pos += out_consumed;
-
-        match status {
-            TINFLStatus::Done => {
-                ret.truncate(out_pos);
-                return Ok(ret);
-            }
-
-            TINFLStatus::HasMoreOutput => {
-                // if the buffer has already reached the size limit, return an error
-                if ret.len() >= max_output_size {
-                    return decompress_error(TINFLStatus::HasMoreOutput, ret);
-                }
-                // calculate the new length, capped at `max_output_size`
-                let new_len = ret.len().saturating_mul(2).min(max_output_size);
-                ret.resize(new_len, 0);
-            }
-
-            _ => return decompress_error(status, ret),
-        }
-    }
-}
-
-/// Decompress one or more source slices from an iterator into the output slice.
-///
-/// * On success, returns the number of bytes that were written.
-/// * On failure, returns the failure status code.
-///
-/// This will fail if the output buffer is not large enough, but in that case
-/// the output buffer will still contain the partial decompression.
-///
-/// * `out` the output buffer.
-/// * `it` the iterator of input slices.
-/// * `zlib_header` if the first slice out of the iterator is expected to have a
-///   Zlib header. Otherwise the slices are assumed to be the deflate data only.
-/// * `ignore_adler32` if the adler32 checksum should be calculated or not.
-pub fn decompress_slice_iter_to_slice<'out, 'inp>(
-    out: &'out mut [u8],
-    it: impl Iterator<Item = &'inp [u8]>,
-    zlib_header: bool,
-    ignore_adler32: bool,
-) -> Result<usize, TINFLStatus> {
-    use self::core::inflate_flags::*;
-
-    let mut it = it.peekable();
-    let r = &mut DecompressorOxide::new();
-    let mut out_pos = 0;
-    while let Some(in_buf) = it.next() {
-        let has_more = it.peek().is_some();
-        let flags = {
-            let mut f = TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF;
-            if zlib_header {
-                f |= TINFL_FLAG_PARSE_ZLIB_HEADER;
-            }
-            if ignore_adler32 {
-                f |= TINFL_FLAG_IGNORE_ADLER32;
-            }
-            if has_more {
-                f |= TINFL_FLAG_HAS_MORE_INPUT;
-            }
-            f
-        };
-        let (status, _input_read, bytes_written) = decompress(r, in_buf, out, out_pos, flags);
-        out_pos += bytes_written;
-        match status {
-            TINFLStatus::NeedsMoreInput => continue,
-            TINFLStatus::Done => return Ok(out_pos),
-            e => return Err(e),
-        }
-    }
-    // If we ran out of source slices without getting a `Done` from the
-    // decompression we can call it a failure.
-    Err(TINFLStatus::FailedCannotMakeProgress)
-}
-
-#[cfg(test)]
-mod test {
-    use super::{
-        decompress_slice_iter_to_slice, decompress_to_vec_zlib, decompress_to_vec_zlib_with_limit,
-        DecompressError, TINFLStatus,
-    };
-    const ENCODED: [u8; 20] = [
-        120, 156, 243, 72, 205, 201, 201, 215, 81, 168, 202, 201, 76, 82, 4, 0, 27, 101, 4, 19,
-    ];
-
-    #[test]
-    fn decompress_vec() {
-        let res = decompress_to_vec_zlib(&ENCODED[..]).unwrap();
-        assert_eq!(res.as_slice(), &b"Hello, zlib!"[..]);
-    }
-
-    #[test]
-    fn decompress_vec_with_high_limit() {
-        let res = decompress_to_vec_zlib_with_limit(&ENCODED[..], 100_000).unwrap();
-        assert_eq!(res.as_slice(), &b"Hello, zlib!"[..]);
-    }
-
-    #[test]
-    fn fail_to_decompress_with_limit() {
-        let res = decompress_to_vec_zlib_with_limit(&ENCODED[..], 8);
-        match res {
-            Err(DecompressError {
-                status: TINFLStatus::HasMoreOutput,
-                ..
-            }) => (), // expected result
-            _ => panic!("Decompression output size limit was not enforced"),
-        }
-    }
-
-    #[test]
-    fn test_decompress_slice_iter_to_slice() {
-        // one slice
-        let mut out = [0_u8; 12_usize];
-        let r =
-            decompress_slice_iter_to_slice(&mut out, Some(&ENCODED[..]).into_iter(), true, false);
-        assert_eq!(r, Ok(12));
-        assert_eq!(&out[..12], &b"Hello, zlib!"[..]);
-
-        // some chunks at a time
-        for chunk_size in 1..13 {
-            // Note: because of https://github.com/Frommi/miniz_oxide/issues/110 our
-            // out buffer needs to have +1 byte available when the chunk size cuts
-            // the adler32 data off from the last actual data.
-            let mut out = [0_u8; 12_usize + 1];
-            let r =
-                decompress_slice_iter_to_slice(&mut out, ENCODED.chunks(chunk_size), true, false);
-            assert_eq!(r, Ok(12));
-            assert_eq!(&out[..12], &b"Hello, zlib!"[..]);
-        }
-
-        // output buffer too small
-        let mut out = [0_u8; 3_usize];
-        let r = decompress_slice_iter_to_slice(&mut out, ENCODED.chunks(7), true, false);
-        assert!(r.is_err());
-    }
-}