Deleted vendor folder

1 files changed, 0 insertions, 389 deletions

diff --git a/vendor/anstream/src/macros.rs b/vendor/anstream/src/macros.rs
deleted file mode 100644
index bd1accb..0000000
--- a/vendor/anstream/src/macros.rs
+++ /dev/null
@@ -1,389 +0,0 @@
-/// Prints to [`stdout`][crate::stdout].
-///
-/// Equivalent to the [`println!`] macro except that a newline is not printed at
-/// the end of the message.
-///
-/// Note that stdout is frequently line-buffered by default so it may be
-/// necessary to use [`std::io::Write::flush()`] to ensure the output is emitted
-/// immediately.
-///
-/// **NOTE:** The `print!` macro will lock the standard output on each call. If you call
-/// `print!` within a hot loop, this behavior may be the bottleneck of the loop.
-/// To avoid this, lock stdout with [`AutoStream::lock`][crate::AutoStream::lock]:
-/// ```
-/// #  #[cfg(feature = "auto")] {
-/// use std::io::Write as _;
-///
-/// let mut lock = anstream::stdout().lock();
-/// write!(lock, "hello world").unwrap();
-/// # }
-/// ```
-///
-/// Use `print!` only for the primary output of your program. Use
-/// [`eprint!`] instead to print error and progress messages.
-///
-/// **NOTE:** Not all `print!` calls will be captured in tests like [`std::print!`]
-/// - Capturing will automatically be activated in test binaries
-/// - Otherwise, only when the `test` feature is enabled
-///
-/// # Panics
-///
-/// Panics if writing to `stdout` fails for any reason **except** broken pipe.
-///
-/// Writing to non-blocking stdout can cause an error, which will lead
-/// this macro to panic.
-///
-/// # Examples
-///
-/// ```
-/// #  #[cfg(feature = "auto")] {
-/// use std::io::Write as _;
-/// use anstream::print;
-/// use anstream::stdout;
-///
-/// print!("this ");
-/// print!("will ");
-/// print!("be ");
-/// print!("on ");
-/// print!("the ");
-/// print!("same ");
-/// print!("line ");
-///
-/// stdout().flush().unwrap();
-///
-/// print!("this string has a newline, why not choose println! instead?\n");
-///
-/// stdout().flush().unwrap();
-/// # }
-/// ```
-#[cfg(feature = "auto")]
-#[macro_export]
-macro_rules! print {
-    ($($arg:tt)*) => {{
-        if cfg!(any(feature = "test", test)) {
-            use std::io::Write as _;
-
-            let stdio = std::io::stdout();
-            let choice = $crate::AutoStream::choice(&stdio);
-            let buffer = Vec::new();
-            let mut stream = $crate::AutoStream::new(buffer, choice);
-            // Ignore errors rather than panic
-            let _ = ::std::write!(&mut stream, $($arg)*);
-            let buffer = stream.into_inner();
-            // Should be UTF-8 but not wanting to panic
-            let buffer = String::from_utf8_lossy(&buffer);
-            ::std::print!("{}", buffer)
-        } else {
-            use std::io::Write as _;
-
-            let mut stream = $crate::stdout();
-            match ::std::write!(&mut stream, $($arg)*) {
-                Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
-                    ::std::panic!("failed printing to stdout: {e}");
-                }
-                Err(_) | Ok(_) => {}
-            }
-        }
-    }};
-}
-
-/// Prints to [`stdout`][crate::stdout], with a newline.
-///
-/// On all platforms, the newline is the LINE FEED character (`\n`/`U+000A`) alone
-/// (no additional CARRIAGE RETURN (`\r`/`U+000D`)).
-///
-/// This macro uses the same syntax as [`format!`], but writes to the standard output instead.
-/// See [`std::fmt`] for more information.
-///
-/// **NOTE:** The `println!` macro will lock the standard output on each call. If you call
-/// `println!` within a hot loop, this behavior may be the bottleneck of the loop.
-/// To avoid this, lock stdout with [`AutoStream::lock`][crate::AutoStream::lock]:
-/// ```
-/// #  #[cfg(feature = "auto")] {
-/// use std::io::Write as _;
-///
-/// let mut lock = anstream::stdout().lock();
-/// writeln!(lock, "hello world").unwrap();
-/// # }
-/// ```
-///
-/// Use `println!` only for the primary output of your program. Use
-/// [`eprintln!`] instead to print error and progress messages.
-///
-/// **NOTE:** Not all `println!` calls will be captured in tests like [`std::println!`]
-/// - Capturing will automatically be activated in test binaries
-/// - Otherwise, only when the `test` feature is enabled
-///
-/// # Panics
-///
-/// Panics if writing to `stdout` fails for any reason **except** broken pipe.
-///
-/// Writing to non-blocking stdout can cause an error, which will lead
-/// this macro to panic.
-///
-/// # Examples
-///
-/// ```
-/// #  #[cfg(feature = "auto")] {
-/// use anstream::println;
-///
-/// println!(); // prints just a newline
-/// println!("hello there!");
-/// println!("format {} arguments", "some");
-/// let local_variable = "some";
-/// println!("format {local_variable} arguments");
-/// # }
-/// ```
-#[cfg(feature = "auto")]
-#[macro_export]
-macro_rules! println {
-    () => {
-        $crate::print!("\n")
-    };
-    ($($arg:tt)*) => {{
-        if cfg!(any(feature = "test", test)) {
-            use std::io::Write as _;
-
-            let stdio = std::io::stdout();
-            let choice = $crate::AutoStream::choice(&stdio);
-            let buffer = Vec::new();
-            let mut stream = $crate::AutoStream::new(buffer, choice);
-            // Ignore errors rather than panic
-            let _ = ::std::write!(&mut stream, $($arg)*);
-            let buffer = stream.into_inner();
-            // Should be UTF-8 but not wanting to panic
-            let buffer = String::from_utf8_lossy(&buffer);
-            ::std::println!("{}", buffer)
-        } else {
-            use std::io::Write as _;
-
-            let mut stream = $crate::stdout();
-            match ::std::writeln!(&mut stream, $($arg)*) {
-                Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
-                    ::std::panic!("failed printing to stdout: {e}");
-                }
-                Err(_) | Ok(_) => {}
-            }
-        }
-    }};
-}
-
-/// Prints to [`stderr`][crate::stderr].
-///
-/// Equivalent to the [`print!`] macro, except that output goes to
-/// `stderr` instead of `stdout`. See [`print!`] for
-/// example usage.
-///
-/// Use `eprint!` only for error and progress messages. Use `print!`
-/// instead for the primary output of your program.
-///
-/// **NOTE:** Not all `eprint!` calls will be captured in tests like [`std::eprint!`]
-/// - Capturing will automatically be activated in test binaries
-/// - Otherwise, only when the `test` feature is enabled
-///
-/// # Panics
-///
-/// Panics if writing to `stderr` fails for any reason **except** broken pipe.
-///
-/// Writing to non-blocking stdout can cause an error, which will lead
-/// this macro to panic.
-///
-/// # Examples
-///
-/// ```
-/// #  #[cfg(feature = "auto")] {
-/// use anstream::eprint;
-///
-/// eprint!("Error: Could not complete task");
-/// # }
-/// ```
-#[cfg(feature = "auto")]
-#[macro_export]
-macro_rules! eprint {
-    ($($arg:tt)*) => {{
-        if cfg!(any(feature = "test", test)) {
-            use std::io::Write as _;
-
-            let stdio = std::io::stderr();
-            let choice = $crate::AutoStream::choice(&stdio);
-            let buffer = Vec::new();
-            let mut stream = $crate::AutoStream::new(buffer, choice);
-            // Ignore errors rather than panic
-            let _ = ::std::write!(&mut stream, $($arg)*);
-            let buffer = stream.into_inner();
-            // Should be UTF-8 but not wanting to panic
-            let buffer = String::from_utf8_lossy(&buffer);
-            ::std::eprint!("{}", buffer)
-        } else {
-            use std::io::Write as _;
-
-            let mut stream = $crate::stderr();
-            match ::std::write!(&mut stream, $($arg)*) {
-                Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
-                    ::std::panic!("failed printing to stdout: {e}");
-                }
-                Err(_) | Ok(_) => {}
-            }
-        }
-    }};
-}
-
-/// Prints to [`stderr`][crate::stderr], with a newline.
-///
-/// Equivalent to the [`println!`] macro, except that output goes to
-/// `stderr` instead of `stdout`. See [`println!`] for
-/// example usage.
-///
-/// Use `eprintln!` only for error and progress messages. Use `println!`
-/// instead for the primary output of your program.
-///
-/// **NOTE:** Not all `eprintln!` calls will be captured in tests like [`std::eprintln!`]
-/// - Capturing will automatically be activated in test binaries
-/// - Otherwise, only when the `test` feature is enabled
-///
-/// # Panics
-///
-/// Panics if writing to `stderr` fails for any reason **except** broken pipe.
-///
-/// Writing to non-blocking stdout can cause an error, which will lead
-/// this macro to panic.
-///
-/// # Examples
-///
-/// ```
-/// #  #[cfg(feature = "auto")] {
-/// use anstream::eprintln;
-///
-/// eprintln!("Error: Could not complete task");
-/// # }
-/// ```
-#[cfg(feature = "auto")]
-#[macro_export]
-macro_rules! eprintln {
-    () => {
-        $crate::eprint!("\n")
-    };
-    ($($arg:tt)*) => {{
-        if cfg!(any(feature = "test", test)) {
-            use std::io::Write as _;
-
-            let stdio = std::io::stderr();
-            let choice = $crate::AutoStream::choice(&stdio);
-            let buffer = Vec::new();
-            let mut stream = $crate::AutoStream::new(buffer, choice);
-            // Ignore errors rather than panic
-            let _ = ::std::write!(&mut stream, $($arg)*);
-            let buffer = stream.into_inner();
-            // Should be UTF-8 but not wanting to panic
-            let buffer = String::from_utf8_lossy(&buffer);
-            ::std::eprintln!("{}", buffer)
-        } else {
-            use std::io::Write as _;
-
-            let mut stream = $crate::stderr();
-            match ::std::writeln!(&mut stream, $($arg)*) {
-                Err(e) if e.kind() != ::std::io::ErrorKind::BrokenPipe => {
-                    ::std::panic!("failed printing to stdout: {e}");
-                }
-                Err(_) | Ok(_) => {}
-            }
-        }
-    }};
-}
-
-/// Panics the current thread.
-///
-/// This allows a program to terminate immediately and provide feedback
-/// to the caller of the program.
-///
-/// This macro is the perfect way to assert conditions in example code and in
-/// tests. `panic!` is closely tied with the `unwrap` method of both
-/// [`Option`][ounwrap] and [`Result`][runwrap] enums. Both implementations call
-/// `panic!` when they are set to [`None`] or [`Err`] variants.
-///
-/// When using `panic!()` you can specify a string payload, that is built using
-/// the [`format!`] syntax. That payload is used when injecting the panic into
-/// the calling Rust thread, causing the thread to panic entirely.
-///
-/// The behavior of the default `std` hook, i.e. the code that runs directly
-/// after the panic is invoked, is to print the message payload to
-/// `stderr` along with the file/line/column information of the `panic!()`
-/// call. You can override the panic hook using [`std::panic::set_hook()`].
-/// Inside the hook a panic can be accessed as a `&dyn Any + Send`,
-/// which contains either a `&str` or `String` for regular `panic!()` invocations.
-/// To panic with a value of another other type, [`panic_any`] can be used.
-///
-/// See also the macro [`compile_error!`], for raising errors during compilation.
-///
-/// # When to use `panic!` vs `Result`
-///
-/// The Rust language provides two complementary systems for constructing /
-/// representing, reporting, propagating, reacting to, and discarding errors. These
-/// responsibilities are collectively known as "error handling." `panic!` and
-/// `Result` are similar in that they are each the primary interface of their
-/// respective error handling systems; however, the meaning these interfaces attach
-/// to their errors and the responsibilities they fulfill within their respective
-/// error handling systems differ.
-///
-/// The `panic!` macro is used to construct errors that represent a bug that has
-/// been detected in your program. With `panic!` you provide a message that
-/// describes the bug and the language then constructs an error with that message,
-/// reports it, and propagates it for you.
-///
-/// `Result` on the other hand is used to wrap other types that represent either
-/// the successful result of some computation, `Ok(T)`, or error types that
-/// represent an anticipated runtime failure mode of that computation, `Err(E)`.
-/// `Result` is used alongside user defined types which represent the various
-/// anticipated runtime failure modes that the associated computation could
-/// encounter. `Result` must be propagated manually, often with the the help of the
-/// `?` operator and `Try` trait, and they must be reported manually, often with
-/// the help of the `Error` trait.
-///
-/// For more detailed information about error handling check out the [book] or the
-/// [`std::result`] module docs.
-///
-/// [ounwrap]: Option::unwrap
-/// [runwrap]: Result::unwrap
-/// [`std::panic::set_hook()`]: ../std/panic/fn.set_hook.html
-/// [`panic_any`]: ../std/panic/fn.panic_any.html
-/// [`Box`]: ../std/boxed/struct.Box.html
-/// [`Any`]: crate::any::Any
-/// [`format!`]: ../std/macro.format.html
-/// [book]: ../book/ch09-00-error-handling.html
-/// [`std::result`]: ../std/result/index.html
-///
-/// # Current implementation
-///
-/// If the main thread panics it will terminate all your threads and end your
-/// program with code `101`.
-///
-/// # Examples
-///
-/// ```should_panic
-/// # #![allow(unreachable_code)]
-/// use anstream::panic;
-/// panic!();
-/// panic!("this is a terrible mistake!");
-/// panic!("this is a {} {message}", "fancy", message = "message");
-/// ```
-#[cfg(feature = "auto")]
-#[macro_export]
-macro_rules! panic {
-    () => {
-        ::std::panic!()
-    };
-    ($($arg:tt)*) => {{
-        use std::io::Write as _;
-
-        let panic_stream = std::io::stderr();
-        let choice = $crate::AutoStream::choice(&panic_stream);
-        let buffer = Vec::new();
-        let mut stream = $crate::AutoStream::new(buffer, choice);
-        // Ignore errors rather than panic
-        let _ = ::std::write!(&mut stream, $($arg)*);
-        let buffer = stream.into_inner();
-        // Should be UTF-8 but not wanting to panic
-        let buffer = String::from_utf8_lossy(&buffer).into_owned();
-        ::std::panic!("{}", buffer)
-    }};
-}