Deleted vendor folder

1 files changed, 0 insertions, 247 deletions

diff --git a/vendor/bitflags/src/parser.rs b/vendor/bitflags/src/parser.rs
deleted file mode 100644
index 130dc2e..0000000
--- a/vendor/bitflags/src/parser.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-/*!
-Parsing flags from text.
-
-Format and parse a flags value as text using the following grammar:
-
-- _Flags:_ (_Whitespace_ _Flag_ _Whitespace_)`|`*
-- _Flag:_ _Name_ | _Hex Number_
-- _Name:_ The name of any defined flag
-- _Hex Number_: `0x`([0-9a-fA-F])*
-- _Whitespace_: (\s)*
-
-As an example, this is how `Flags::A | Flags::B | 0x0c` can be represented as text:
-
-```text
-A | B | 0x0c
-```
-
-Alternatively, it could be represented without whitespace:
-
-```text
-A|B|0x0C
-```
-
-Note that identifiers are *case-sensitive*, so the following is *not equivalent*:
-
-```text
-a|b|0x0C
-```
-*/
-
-#![allow(clippy::let_unit_value)]
-
-use core::fmt::{self, Write};
-
-use crate::{Bits, Flags};
-
-/**
-Write a flags value as text.
-
-Any bits that aren't part of a contained flag will be formatted as a hex number.
-*/
-pub fn to_writer<B: Flags>(flags: &B, mut writer: impl Write) -> Result<(), fmt::Error>
-where
-    B::Bits: WriteHex,
-{
-    // A formatter for bitflags that produces text output like:
-    //
-    // A | B | 0xf6
-    //
-    // The names of set flags are written in a bar-separated-format,
-    // followed by a hex number of any remaining bits that are set
-    // but don't correspond to any flags.
-
-    // Iterate over known flag values
-    let mut first = true;
-    let mut iter = flags.iter_names();
-    for (name, _) in &mut iter {
-        if !first {
-            writer.write_str(" | ")?;
-        }
-
-        first = false;
-        writer.write_str(name)?;
-    }
-
-    // Append any extra bits that correspond to flags to the end of the format
-    let remaining = iter.remaining().bits();
-    if remaining != B::Bits::EMPTY {
-        if !first {
-            writer.write_str(" | ")?;
-        }
-
-        writer.write_str("0x")?;
-        remaining.write_hex(writer)?;
-    }
-
-    fmt::Result::Ok(())
-}
-
-pub(crate) struct AsDisplay<'a, B>(pub(crate) &'a B);
-
-impl<'a, B: Flags> fmt::Display for AsDisplay<'a, B>
-where
-    B::Bits: WriteHex,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        to_writer(self.0, f)
-    }
-}
-
-/**
-Parse a flags value from text.
-
-This function will fail on any names that don't correspond to defined flags.
-Unknown bits will be retained.
-*/
-pub fn from_str<B: Flags>(input: &str) -> Result<B, ParseError>
-where
-    B::Bits: ParseHex,
-{
-    let mut parsed_flags = B::empty();
-
-    // If the input is empty then return an empty set of flags
-    if input.trim().is_empty() {
-        return Ok(parsed_flags);
-    }
-
-    for flag in input.split('|') {
-        let flag = flag.trim();
-
-        // If the flag is empty then we've got missing input
-        if flag.is_empty() {
-            return Err(ParseError::empty_flag());
-        }
-
-        // If the flag starts with `0x` then it's a hex number
-        // Parse it directly to the underlying bits type
-        let parsed_flag = if let Some(flag) = flag.strip_prefix("0x") {
-            let bits =
-                <B::Bits>::parse_hex(flag).map_err(|_| ParseError::invalid_hex_flag(flag))?;
-
-            B::from_bits_retain(bits)
-        }
-        // Otherwise the flag is a name
-        // The generated flags type will determine whether
-        // or not it's a valid identifier
-        else {
-            B::from_name(flag).ok_or_else(|| ParseError::invalid_named_flag(flag))?
-        };
-
-        parsed_flags.insert(parsed_flag);
-    }
-
-    Ok(parsed_flags)
-}
-
-/**
-Encode a value as a hex string.
-
-Implementors of this trait should not write the `0x` prefix.
-*/
-pub trait WriteHex {
-    /// Write the value as hex.
-    fn write_hex<W: fmt::Write>(&self, writer: W) -> fmt::Result;
-}
-
-/**
-Parse a value from a hex string.
-*/
-pub trait ParseHex {
-    /// Parse the value from hex.
-    fn parse_hex(input: &str) -> Result<Self, ParseError>
-    where
-        Self: Sized;
-}
-
-/// An error encountered while parsing flags from text.
-#[derive(Debug)]
-pub struct ParseError(ParseErrorKind);
-
-#[derive(Debug)]
-#[allow(clippy::enum_variant_names)]
-enum ParseErrorKind {
-    EmptyFlag,
-    InvalidNamedFlag {
-        #[cfg(not(feature = "std"))]
-        got: (),
-        #[cfg(feature = "std")]
-        got: String,
-    },
-    InvalidHexFlag {
-        #[cfg(not(feature = "std"))]
-        got: (),
-        #[cfg(feature = "std")]
-        got: String,
-    },
-}
-
-impl ParseError {
-    /// An invalid hex flag was encountered.
-    pub fn invalid_hex_flag(flag: impl fmt::Display) -> Self {
-        let _flag = flag;
-
-        let got = {
-            #[cfg(feature = "std")]
-            {
-                _flag.to_string()
-            }
-        };
-
-        ParseError(ParseErrorKind::InvalidHexFlag { got })
-    }
-
-    /// A named flag that doesn't correspond to any on the flags type was encountered.
-    pub fn invalid_named_flag(flag: impl fmt::Display) -> Self {
-        let _flag = flag;
-
-        let got = {
-            #[cfg(feature = "std")]
-            {
-                _flag.to_string()
-            }
-        };
-
-        ParseError(ParseErrorKind::InvalidNamedFlag { got })
-    }
-
-    /// A hex or named flag wasn't found between separators.
-    pub const fn empty_flag() -> Self {
-        ParseError(ParseErrorKind::EmptyFlag)
-    }
-}
-
-impl fmt::Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.0 {
-            ParseErrorKind::InvalidNamedFlag { got } => {
-                let _got = got;
-
-                write!(f, "unrecognized named flag")?;
-
-                #[cfg(feature = "std")]
-                {
-                    write!(f, " `{}`", _got)?;
-                }
-            }
-            ParseErrorKind::InvalidHexFlag { got } => {
-                let _got = got;
-
-                write!(f, "invalid hex flag")?;
-
-                #[cfg(feature = "std")]
-                {
-                    write!(f, " `{}`", _got)?;
-                }
-            }
-            ParseErrorKind::EmptyFlag => {
-                write!(f, "encountered empty flag")?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for ParseError {}