Merging upstream version 1.71.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

46 files changed, 20844 insertions, 0 deletions

diff --git a/vendor/winnow/src/_topic/arithmetic.rs b/vendor/winnow/src/_topic/arithmetic.rs
new file mode 100644
index 000000000..1a6eddcc4
--- /dev/null
+++ b/vendor/winnow/src/_topic/arithmetic.rs
@@ -0,0 +1,13 @@
+//! # Arithmetic
+//!
+//! ## Direct evaluation
+//!
+//! ```rust
+#![doc = include_str!("../../examples/arithmetic/parser.rs")]
+//! ```
+//!
+//! ## Parse to AST
+//!
+//! ```rust
+#![doc = include_str!("../../examples/arithmetic/parser_ast.rs")]
+//! ```
diff --git a/vendor/winnow/src/_topic/error.rs b/vendor/winnow/src/_topic/error.rs
new file mode 100644
index 000000000..abf2f8dbb
--- /dev/null
+++ b/vendor/winnow/src/_topic/error.rs
@@ -0,0 +1,13 @@
+//! # Custom Errors
+//!
+//! The most basic error type is [`ParseError`][crate::error::ParseError]
+//!
+//! Optional traits include:
+//! - [`ContextError`][crate::error::ContextError]
+//! - [`FromExternalError`][crate::error::FromExternalError]
+//!
+//! # Example
+//!
+//!```rust
+#![doc = include_str!("../../examples/custom_error.rs")]
+//!```
diff --git a/vendor/winnow/src/_topic/fromstr.rs b/vendor/winnow/src/_topic/fromstr.rs
new file mode 100644
index 000000000..d126d16bb
--- /dev/null
+++ b/vendor/winnow/src/_topic/fromstr.rs
@@ -0,0 +1,8 @@
+//! # Implementing `FromStr`
+//!
+//! The [`FromStr` trait][std::str::FromStr] provides
+//! a common interface to parse from a string.
+//!
+//! ```rust
+#![doc = include_str!("../../examples/css/parser.rs")]
+//! ```
diff --git a/vendor/winnow/src/_topic/http.rs b/vendor/winnow/src/_topic/http.rs
new file mode 100644
index 000000000..500169402
--- /dev/null
+++ b/vendor/winnow/src/_topic/http.rs
@@ -0,0 +1,5 @@
+//! # HTTP
+//!
+//! ```rust
+#![doc = include_str!("../../examples/http/parser.rs")]
+//! ```
diff --git a/vendor/winnow/src/_topic/ini.rs b/vendor/winnow/src/_topic/ini.rs
new file mode 100644
index 000000000..b78ade5b0
--- /dev/null
+++ b/vendor/winnow/src/_topic/ini.rs
@@ -0,0 +1,5 @@
+//! # INI
+//!
+//! ```rust
+#![doc = include_str!("../../examples/ini/parser.rs")]
+//! ```
diff --git a/vendor/winnow/src/_topic/json.rs b/vendor/winnow/src/_topic/json.rs
new file mode 100644
index 000000000..fb4df3bf9
--- /dev/null
+++ b/vendor/winnow/src/_topic/json.rs
@@ -0,0 +1,5 @@
+//! # json
+//!
+//! ```rust,ignore
+#![doc = include_str!("../../examples/json/parser.rs")]
+//! ```
diff --git a/vendor/winnow/src/_topic/language.rs b/vendor/winnow/src/_topic/language.rs
new file mode 100644
index 000000000..d257c0b18
--- /dev/null
+++ b/vendor/winnow/src/_topic/language.rs
@@ -0,0 +1,318 @@
+//! # Elements of Programming Languages
+//!
+//! These are short recipes for accomplishing common tasks.
+//!
+//! * [Whitespace](#whitespace)
+//!   + [Wrapper combinators that eat whitespace before and after a parser](#wrapper-combinators-that-eat-whitespace-before-and-after-a-parser)
+//! * [Comments](#comments)
+//!   + [`// C++/EOL-style comments`](#-ceol-style-comments)
+//!   + [`/* C-style comments */`](#-c-style-comments-)
+//! * [Identifiers](#identifiers)
+//!   + [`Rust-Style Identifiers`](#rust-style-identifiers)
+//! * [Literal Values](#literal-values)
+//!   + [Escaped Strings](#escaped-strings)
+//!   + [Integers](#integers)
+//!     - [Hexadecimal](#hexadecimal)
+//!     - [Octal](#octal)
+//!     - [Binary](#binary)
+//!     - [Decimal](#decimal)
+//!   + [Floating Point Numbers](#floating-point-numbers)
+//!
+//! ## Whitespace
+//!
+//!
+//!
+//! ### Wrapper combinators that eat whitespace before and after a parser
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   error::ParseError,
+//!   sequence::delimited,
+//!   character::multispace0,
+//! };
+//!
+//! /// A combinator that takes a parser `inner` and produces a parser that also consumes both leading and
+//! /// trailing whitespace, returning the output of `inner`.
+//! fn ws<'a, F, O, E: ParseError<&'a str>>(inner: F) -> impl Parser<&'a str, O, E>
+//!   where
+//!   F: Parser<&'a str, O, E>,
+//! {
+//!   delimited(
+//!     multispace0,
+//!     inner,
+//!     multispace0
+//!   )
+//! }
+//! ```
+//!
+//! To eat only trailing whitespace, replace `delimited(...)` with `terminated(&inner, multispace0)`.
+//! Likewise, the eat only leading whitespace, replace `delimited(...)` with `preceded(multispace0,
+//! &inner)`. You can use your own parser instead of `multispace0` if you want to skip a different set
+//! of lexemes.
+//!
+//! ## Comments
+//!
+//! ### `// C++/EOL-style comments`
+//!
+//! This version uses `%` to start a comment, does not consume the newline character, and returns an
+//! output of `()`.
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   error::ParseError,
+//!   bytes::take_till1,
+//! };
+//!
+//! pub fn peol_comment<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, (), E>
+//! {
+//!   ('%', take_till1("\n\r"))
+//!     .void() // Output is thrown away.
+//!     .parse_next(i)
+//! }
+//! ```
+//!
+//! ### `/* C-style comments */`
+//!
+//! Inline comments surrounded with sentinel tags `(*` and `*)`. This version returns an output of `()`
+//! and does not handle nested comments.
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   error::ParseError,
+//!   bytes::{tag, take_until0},
+//! };
+//!
+//! pub fn pinline_comment<'a, E: ParseError<&'a str>>(i: &'a str) -> IResult<&'a str, (), E> {
+//!   (
+//!     "(*",
+//!     take_until0("*)"),
+//!     "*)"
+//!   )
+//!     .void() // Output is thrown away.
+//!     .parse_next(i)
+//! }
+//! ```
+//!
+//! ## Identifiers
+//!
+//! ### `Rust-Style Identifiers`
+//!
+//! Parsing identifiers that may start with a letter (or underscore) and may contain underscores,
+//! letters and numbers may be parsed like this:
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   stream::AsChar,
+//!   bytes::take_while0,
+//!   bytes::one_of,
+//! };
+//!
+//! pub fn identifier(input: &str) -> IResult<&str, &str> {
+//!   (
+//!       one_of(|c: char| c.is_alpha() || c == '_'),
+//!       take_while0(|c: char| c.is_alphanum() || c == '_')
+//!   )
+//!   .recognize()
+//!   .parse_next(input)
+//! }
+//! ```
+//!
+//! Let's say we apply this to the identifier `hello_world123abc`. The first element of the tuple
+//! would uses [`one_of`][crate::bytes::one_of] which would recognize `h`. The tuple ensures that
+//! `ello_world123abc` will be piped to the next [`take_while0`][crate::bytes::take_while0] parser,
+//! which recognizes every remaining character. However, the tuple returns a tuple of the results
+//! of its sub-parsers. The [`recognize`][crate::Parser::recognize] parser produces a `&str` of the
+//! input text that was parsed, which in this case is the entire `&str` `hello_world123abc`.
+//!
+//! ## Literal Values
+//!
+//! ### Escaped Strings
+//!
+//! ```rust
+#![doc = include_str!("../../examples/string/parser.rs")]
+//! ```
+//!
+//! ### Integers
+//!
+//! The following recipes all return string slices rather than integer values. How to obtain an
+//! integer value instead is demonstrated for hexadecimal integers. The others are similar.
+//!
+//! The parsers allow the grouping character `_`, which allows one to group the digits by byte, for
+//! example: `0xA4_3F_11_28`. If you prefer to exclude the `_` character, the lambda to convert from a
+//! string slice to an integer value is slightly simpler. You can also strip the `_` from the string
+//! slice that is returned, which is demonstrated in the second hexadecimal number parser.
+//!
+//! If you wish to limit the number of digits in a valid integer literal, replace `many1` with
+//! `many_m_n` in the recipes.
+//!
+//! #### Hexadecimal
+//!
+//! The parser outputs the string slice of the digits without the leading `0x`/`0X`.
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   branch::alt,
+//!   multi::{many0, many1},
+//!   sequence::{preceded, terminated},
+//!   bytes::one_of,
+//!   bytes::tag,
+//! };
+//!
+//! fn hexadecimal(input: &str) -> IResult<&str, &str> { // <'a, E: ParseError<&'a str>>
+//!   preceded(
+//!     alt(("0x", "0X")),
+//!     many1(
+//!       terminated(one_of("0123456789abcdefABCDEF"), many0('_').map(|()| ()))
+//!     ).map(|()| ()).recognize()
+//!   ).parse_next(input)
+//! }
+//! ```
+//!
+//! If you want it to return the integer value instead, use map:
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   branch::alt,
+//!   multi::{many0, many1},
+//!   sequence::{preceded, terminated},
+//!   bytes::one_of,
+//!   bytes::tag,
+//! };
+//!
+//! fn hexadecimal_value(input: &str) -> IResult<&str, i64> {
+//!   preceded(
+//!     alt(("0x", "0X")),
+//!     many1(
+//!       terminated(one_of("0123456789abcdefABCDEF"), many0('_').map(|()| ()))
+//!     ).map(|()| ()).recognize()
+//!   ).map_res(
+//!     |out: &str| i64::from_str_radix(&str::replace(&out, "_", ""), 16)
+//!   ).parse_next(input)
+//! }
+//! ```
+//!
+//! #### Octal
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   branch::alt,
+//!   multi::{many0, many1},
+//!   sequence::{preceded, terminated},
+//!   bytes::one_of,
+//!   bytes::tag,
+//! };
+//!
+//! fn octal(input: &str) -> IResult<&str, &str> {
+//!   preceded(
+//!     alt(("0o", "0O")),
+//!     many1(
+//!       terminated(one_of("01234567"), many0('_').map(|()| ()))
+//!     ).map(|()| ()).recognize()
+//!   ).parse_next(input)
+//! }
+//! ```
+//!
+//! #### Binary
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   branch::alt,
+//!   multi::{many0, many1},
+//!   sequence::{preceded, terminated},
+//!   bytes::one_of,
+//!   bytes::tag,
+//! };
+//!
+//! fn binary(input: &str) -> IResult<&str, &str> {
+//!   preceded(
+//!     alt(("0b", "0B")),
+//!     many1(
+//!       terminated(one_of("01"), many0('_').map(|()| ()))
+//!     ).map(|()| ()).recognize()
+//!   ).parse_next(input)
+//! }
+//! ```
+//!
+//! #### Decimal
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   IResult,
+//!   multi::{many0, many1},
+//!   sequence::terminated,
+//!   bytes::one_of,
+//! };
+//!
+//! fn decimal(input: &str) -> IResult<&str, &str> {
+//!   many1(
+//!     terminated(one_of("0123456789"), many0('_').map(|()| ()))
+//!   ).map(|()| ())
+//!     .recognize()
+//!     .parse_next(input)
+//! }
+//! ```
+//!
+//! ### Floating Point Numbers
+//!
+//! The following is adapted from [the Python parser by Valentin Lorentz](https://github.com/ProgVal/rust-python-parser/blob/master/src/numbers.rs).
+//!
+//! ```rust
+//! use winnow::prelude::*;
+//! use winnow::{
+//!   branch::alt,
+//!   multi::{many0, many1},
+//!   combinator::opt,
+//!   sequence::{preceded, terminated},
+//!   bytes::one_of,
+//! };
+//!
+//! fn float(input: &str) -> IResult<&str, &str> {
+//!   alt((
+//!     // Case one: .42
+//!     (
+//!       '.',
+//!       decimal,
+//!       opt((
+//!         one_of("eE"),
+//!         opt(one_of("+-")),
+//!         decimal
+//!       ))
+//!     ).recognize()
+//!     , // Case two: 42e42 and 42.42e42
+//!     (
+//!       decimal,
+//!       opt(preceded(
+//!         '.',
+//!         decimal,
+//!       )),
+//!       one_of("eE"),
+//!       opt(one_of("+-")),
+//!       decimal
+//!     ).recognize()
+//!     , // Case three: 42. and 42.42
+//!     (
+//!       decimal,
+//!       '.',
+//!       opt(decimal)
+//!     ).recognize()
+//!   )).parse_next(input)
+//! }
+//!
+//! fn decimal(input: &str) -> IResult<&str, &str> {
+//!   many1(
+//!     terminated(one_of("0123456789"), many0('_').map(|()| ()))
+//!   ).
+//!   map(|()| ())
+//!     .recognize()
+//!     .parse_next(input)
+//! }
+//! ```
diff --git a/vendor/winnow/src/_topic/mod.rs b/vendor/winnow/src/_topic/mod.rs
new file mode 100644
index 000000000..76687277a
--- /dev/null
+++ b/vendor/winnow/src/_topic/mod.rs
@@ -0,0 +1,33 @@
+//! # Special Topics
+//!
+//! These are short recipes for accomplishing common tasks.
+//!
+//! - [Why `winnow`?][why]
+//! - Formats:
+//!   - [Elements of Programming Languages][language]
+//!   - [Arithmetic][arithmetic]
+//!   - [s-expression][s_expression]
+//!   - [json]
+//!   - [INI][ini]
+//!   - [HTTP][http]
+//! - Special Topics:
+//!   - [Implementing `FromStr`][fromstr]
+//!   - [Parsing Partial Input][partial]
+//!   - [Custom stream][stream]
+//!   - [Custom errors][error]
+//!
+//! See also parsers written with `winnow`:
+//!
+//! - [`toml_edit`](https://crates.io/crates/toml_edit)
+
+pub mod arithmetic;
+pub mod error;
+pub mod fromstr;
+pub mod http;
+pub mod ini;
+pub mod json;
+pub mod language;
+pub mod partial;
+pub mod s_expression;
+pub mod stream;
+pub mod why;
diff --git a/vendor/winnow/src/_topic/partial.rs b/vendor/winnow/src/_topic/partial.rs
new file mode 100644
index 000000000..263d7f127
--- /dev/null
+++ b/vendor/winnow/src/_topic/partial.rs
@@ -0,0 +1,46 @@
+//! # Parsing Partial Input
+//!
+//! Typically, the input being parsed is all in-memory, or is complete.  Some data sources are too
+//! large to fit into memory, only allowing parsing an incomplete or [`Partial`] subset of the
+//! data, requiring incrementally parsing.
+//!
+//! By wrapping a stream, like `&[u8]`, with [`Partial`], parsers will report when the data is
+//! [`Incomplete`] and more input is [`Needed`], allowing the caller to stream-in additional data
+//! to be parsed.  The data is then parsed a chunk at a time.
+//!
+//! Chunks are typically defined by either:
+//! - A header reporting the number of bytes, like with [`length_value`]
+//!   - [`Partial`] can explicitly be changed to being complete once the specified bytes are
+//!     acquired via [`StreamIsPartial::complete`].
+//! - A delimiter, like with [ndjson](http://ndjson.org/)
+//!   - You can parse up-to the delimiter or do a `take_until0(delim).and_then(parser)`
+//!
+//! If the chunks are not homogeneous, a state machine will be needed to track what the expected
+//! parser is for the next chunk.
+//!
+//! Caveats:
+//! - `winnow` takes the approach of re-parsing from scratch.  Chunks should be relatively small to
+//!   prevent the re-parsing overhead from dominating.
+//! - Parsers like [`many0`] do not know when an `eof` is from insufficient data or the end of the
+//!   stream, causing them to always report [`Incomplete`].
+//!
+//! # Example
+//!
+//! `main.rs`:
+//! ```rust,ignore
+#![doc = include_str!("../../examples/ndjson/main.rs")]
+//! ```
+//!
+//! `parser.rs`:
+//! ```rust,ignore
+#![doc = include_str!("../../examples/ndjson/parser.rs")]
+//! ```
+
+#![allow(unused_imports)] // Used for intra-doc links
+
+use crate::error::ErrMode::Incomplete;
+use crate::error::Needed;
+use crate::multi::length_value;
+use crate::multi::many0;
+use crate::stream::Partial;
+use crate::stream::StreamIsPartial;
diff --git a/vendor/winnow/src/_topic/s_expression.rs b/vendor/winnow/src/_topic/s_expression.rs
new file mode 100644
index 000000000..ef6660090
--- /dev/null
+++ b/vendor/winnow/src/_topic/s_expression.rs
@@ -0,0 +1,5 @@
+//! # s-expression
+//!
+//! ```rust
+#![doc = include_str!("../../examples/s_expression/parser.rs")]
+//! ```
diff --git a/vendor/winnow/src/_topic/stream.rs b/vendor/winnow/src/_topic/stream.rs
new file mode 100644
index 000000000..92841eda2
--- /dev/null
+++ b/vendor/winnow/src/_topic/stream.rs
@@ -0,0 +1,54 @@
+//! # Custom [`Stream`][crate::stream::Stream]
+//!
+//! `winnow` is batteries included with support for
+//! - Basic inputs like `&str`, newtypes with
+//! - Improved debug output like [`Bytes`][crate::Bytes]
+//! - [`Stateful`][crate::Stateful] for passing state through your parser, like tracking recursion
+//!   depth
+//! - [`Located`][crate::Located] for looking up the absolute position of a token
+//!
+//! But that won't always cut it for your parser.  For example, you might lex `&str` into
+//! a series of tokens and then want to parse a `TokenStream`.
+//!
+//! ## Implementing a custom stream
+//!
+//! Let's assume we have an input type we'll call `MyStream`. `MyStream` is a sequence of `MyItem` type.
+//! The goal is to define parsers with this signature: `MyStream -> IResult<MyStream, Output>`.
+//!
+//! ```rust
+//! # use winnow::prelude::*;
+//! # use winnow::bytes::tag;
+//! # type MyStream<'i> = &'i str;
+//! # type Output<'i> = &'i str;
+//! fn parser(i: MyStream<'_>) -> IResult<MyStream<'_>, Output<'_>> {
+//!     "test".parse_next(i)
+//! }
+//! ```
+//!
+//! Here are the traits we have to implement for `MyStream`:
+//!
+//! | trait | usage |
+//! |---|---|
+//! | [`Stream`] |Core trait for driving parsing|
+//! | [`StreamIsPartial`] | Marks the input as being the complete buffer or a partial buffer for streaming input |
+//! | [`AsBytes`] |Casts the input type to a byte slice|
+//! | [`AsBStr`] |Casts the input type to a slice of ASCII / UTF-8-like bytes|
+//! | [`Compare`] |Character comparison operations|
+//! | [`FindSlice`] |Look for a substring in self|
+//! | [`Location`] |Calculate location within initial input|
+//! | [`Offset`] |Calculate the offset between slices|
+//!
+//! Here are the traits we have to implement for `MyItem`:
+//!
+//! | trait | usage |
+//! |---|---|
+//! | [`AsChar`] |Transforms common types to a char for basic token parsing|
+//! | [`ContainsToken`] |Look for the token in the given set|
+//!
+//! And traits for slices of `MyItem`:
+//!
+//! | [`SliceLen`] |Calculate the input length|
+//! | [`ParseSlice`] |Used to integrate `&str`'s `parse()` method|
+
+#[allow(unused_imports)] // Here for intra-dock links
+use crate::stream::*;
diff --git a/vendor/winnow/src/_topic/why.rs b/vendor/winnow/src/_topic/why.rs
new file mode 100644
index 000000000..e28181b1a
--- /dev/null
+++ b/vendor/winnow/src/_topic/why.rs
@@ -0,0 +1,98 @@
+//! # Why `winnow`?
+//!
+//! To answer this question, it will be useful to contrast this with other approaches to parsing.
+//!
+//! **Note:** This will focus on principles and priorities.  For a deeper and wider wider
+//! comparison with other Rust parser libraries, see
+//! [parse-rosetta-rs](https://github.com/rosetta-rs/parse-rosetta-rs).
+//!
+//! ## Hand-written parsers
+//!
+//! Typically, a hand-written parser gives you the flexibility to get
+//! - Fast parse performance
+//! - Fast compile-time
+//! - Small binary sizes
+//! - High quality error message
+//! - Fewer dependencies to audit
+//!
+//! However, this comes at the cost of doing it all yourself, including
+//! - Optimizing for each of the above characteristics you are about
+//! - Ensuring the safety of any `unsafe` code (buffer overflows being a common bug with parsers)
+//! - Being aware of, familiar with, and correctly implement the relevant algorithms.
+//!   matklad, who has written two rust compile frontends, commented
+//!   ["I’ve implemented a production-grade Pratt parser once, but I no longer immediately understand that code :-)"](https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html)
+//!
+//! This approach works well if:
+//! - Your format is small and is unlikely to change
+//! - Your format is large but you have people who can focus solely on parsing, like with large
+//!   programming languages
+//!
+//! ## `winnow`
+//!
+//! Unlike traditional programming language parsers that use
+//! [lex](https://en.wikipedia.org/wiki/Lex_(software)) or
+//! [yacc](https://en.wikipedia.org/wiki/Yacc), you can think of `winnow` as a general version of
+//! the helpers you would create along the way to writing a hand-written parser.
+//!
+//! `winnow` includes support for:
+//! - Zero-copy parsing
+//! - [Parse traces][crate::trace] for easier debugging
+//! - [Streaming parsing][crate::Partial] for network communication or large file
+//! - [Stateful][crate::Stateful] parsers
+//!
+//! For binary formats, `winnow` includes:
+//! - [A hexadecimal view][crate::Bytes] in [traces][crate::trace]
+//! - [TLV](https://en.wikipedia.org/wiki/Type-length-value)
+//! - Some common parsers to help get started, like numbers
+//!
+//! For text formats, `winnow` includes:
+//! - [Tracking of spans][crate::Located]
+//! - [A textual view when parsing as bytes][crate::BStr] in [traces][crate::trace]
+//! - Ability to evaluate directly, parse to an AST, or lex and parse the format
+//!
+//! This works well for:
+//! - Prototyping for what will be a hand-written parser
+//! - When you to minimize the work to evolve your format
+//! - When you don't have contributors focused solely on parsing and your grammar is large enough
+//!   to be unwieldy to hand write.
+//!
+//! ## `nom`
+//!
+//! `winnow` is a fork of the venerable [`nom`](https://crates.io/crates/nom).  The difference
+//! between them is largely in priorities.  `nom` prioritizes:
+//! - Lower churn for existing users while `winnow` is trying to find ways to make things better
+//!   for the parsers yet to be written.
+//! - Having a small core, relying on external crates like
+//!   [`nom-locate`](https://crates.io/crates/nom_locate) and
+//!   [`nom-supreme`](https://crates.io/crates/nom-supreme), encouraging flexibility among users
+//!   and to not block users on new features being merged while `winnow` aims to include all the
+//!   fundamentals for parsing to ensure the experience is cohesive and high quality.
+//!
+//! ## `chumsky`
+//!
+//! [`chumsky`](https://crates.io/crates/chumsky) is an up and coming parser-combinator library
+//! that includes advanced features like error recovery.
+//!
+//! Probably the biggest diverging philosophy is `chumsky`s stance:
+//!
+//! > "If you need to implement either `Parser` or `Strategy` by hand, that's a problem that needs fixing".
+//!
+//! This is under "batteries included" but it also ties into the feeling that `chumksy` acts more like
+//! a framework.  Instead of composing together helpers, you are expected to do everything through
+//! their system to the point that it is non-trivial to implement their `Parser` trait and are
+//! encouraged to use the
+//! [`custom`](https://docs.rs/chumsky/0.9.0/chumsky/primitive/fn.custom.html) helper.  This
+//! requires re-framing everything to fit within their model and makes the code harder to understand
+//! and debug as you are working with abstract operations that will eventually be applied
+//! rather than directly with the parsers.
+//!
+//! In contrast, `winnow` is an introspectable toolbox that can easily be customized at any level.
+//! Probably the biggest thing that `winnow` loses out on is optimizations from ["parse modes" via
+//! GATs](https://github.com/zesterer/chumsky/pull/82) which allows downstream parsers to tell
+//! upstream parsers when information will be discarded, allowing bypassing expensive operations,
+//! like allocations.  This requires a lot more complex interaction with parsers that isn't as
+//! trivial to do with bare functions which would lose out on any of that side-band information.
+//! Instead, we work around this with things like the [`Accumulate`] trait.
+
+#![allow(unused_imports)]
+use crate::stream::Accumulate;
diff --git a/vendor/winnow/src/_tutorial/chapter_0.rs b/vendor/winnow/src/_tutorial/chapter_0.rs
new file mode 100644
index 000000000..4c768d8f8
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_0.rs
@@ -0,0 +1,38 @@
+//! # Chapter 0: Introduction
+//!
+//! This tutorial assumes that you are:
+//! - Already familiar with Rust
+//! - Using `winnow` for the first time
+//!
+//! The focus will be on parsing in-memory strings (`&str`). Once done, you might want to check the
+//! [Special Topics][_topic] for more specialized topics or examples.
+//!
+//! ## About
+//!
+//! `winnow` is a parser-combinator library. In other words, it gives you tools to define:
+//! - "parsers", or functions that takes an input and gives back an output
+//! - "combinators", or functions that take parsers and _combine_ them together!
+//!
+//! While "combinator" might be an unfamiliar word, you are likely using them in your rust code
+//! today, like with the [`Iterator`] trait:
+//! ```rust
+//! let data = vec![1, 2, 3, 4, 5];
+//! let even_count = data.iter()
+//!     .copied()  // combinator
+//!     .filter(|d| d % 2 == 0)  // combinator
+//!     .count();  // combinator
+//! ```
+//!
+//! Parser combinators are great because:
+//!
+//! - The parsers are small and easy to write
+//! - The parsers components are easy to reuse (if they're general enough, please add them to winnow!)
+//! - The parsers components are easy to test separately (unit tests and property-based tests)
+//! - The parser combination code looks close to the grammar you would have written
+//! - You can build partial parsers, specific to the data you need at the moment, and ignore the rest
+
+#![allow(unused_imports)]
+use crate::_topic;
+use std::iter::Iterator;
+
+pub use super::chapter_1 as next;
diff --git a/vendor/winnow/src/_tutorial/chapter_1.rs b/vendor/winnow/src/_tutorial/chapter_1.rs
new file mode 100644
index 000000000..d6a45c8b7
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_1.rs
@@ -0,0 +1,89 @@
+//! # Chapter 1: The Winnow Way
+//!
+//! First of all, we need to understand the way that winnow thinks about parsing.
+//! As discussed in the introduction, winnow lets us build simple parsers, and
+//! then combine them (using "combinators").
+//!
+//! Let's discuss what a "parser" actually does. A parser takes an input and returns
+//! a result, where:
+//!  - `Ok` indicates the parser successfully found what it was looking for; or
+//!  - `Err` indicates the parser could not find what it was looking for.
+//!
+//! Parsers do more than just return a binary "success"/"failure" code. If
+//! the parser was successful, then it will return a tuple where the first field
+//! will contain everything the parser did not process. The second will contain
+//! everything the parser processed. The idea is that a parser can happily parse the first
+//! *part* of an input, without being able to parse the whole thing.
+//!
+//! If the parser failed, then there are multiple errors that could be returned.
+//! For simplicity, however, in the next chapters we will leave these unexplored.
+//!
+//! ```text
+//!                                    ┌─► Ok(
+//!                                    │      what the parser didn't touch,
+//!                                    │      what matched the parser
+//!                                    │   )
+//!              ┌─────────┐           │
+//!  my input───►│my parser├──►either──┤
+//!              └─────────┘           └─► Err(...)
+//! ```
+//!
+//!
+//! To represent this model of the world, winnow uses the [`IResult<I, O>`] type.
+//! The `Ok` variant has a tuple of `(remainder: I, output: O)`;
+//! whereas the `Err` variant stores an error.
+//!
+//! You can import that from:
+//!
+//! ```rust
+//! use winnow::IResult;
+//! ```
+//!
+//! You'll note that `I` and `O` are parameterized -- while most of the examples in this book
+//! will be with `&str` (i.e. parsing a string); they do not have to be strings; nor do they
+//! have to be the same type (consider the simple example where `I = &str`, and `O = u64` -- this
+//! parses a string into an unsigned integer.)
+//!
+//! To combine parsers, we need a common way to refer to them which is where the [`Parser`]
+//! trait comes in with [`Parser::parse_next`] being the primary way to drive
+//! parsing forward.
+//!
+//! # Let's write our first parser!
+//!
+//! The simplest parser we can write is one which successfully does nothing.
+//!
+//! To make it easier to implement a [`Parser`], the trait is implemented for
+//! functions of the form `Fn(I) -> IResult<I, O>`.
+//!
+//! This parser function should take in a `&str`:
+//!
+//!  - Since it is supposed to succeed, we know it will return the Ok Variant.
+//!  - Since it does nothing to our input, the remaining input is the same as the input.
+//!  - Since it doesn't parse anything, it also should just return an empty string.
+//!
+//! ```rust
+//! use winnow::IResult;
+//! use winnow::Parser;
+//!
+//! pub fn do_nothing_parser(input: &str) -> IResult<&str, &str> {
+//!     Ok((input, ""))
+//! }
+//!
+//! fn main() {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, output) = do_nothing_parser.parse_next(input).unwrap();
+//!     // Same as:
+//!     // let (remainder, output) = do_nothing_parser(input).unwrap();
+//!
+//!     assert_eq!(remainder, "0x1a2b Hello");
+//!     assert_eq!(output, "");
+//! }
+//! ```
+
+#![allow(unused_imports)]
+use crate::IResult;
+use crate::Parser;
+
+pub use super::chapter_0 as previous;
+pub use super::chapter_2 as next;
diff --git a/vendor/winnow/src/_tutorial/chapter_2.rs b/vendor/winnow/src/_tutorial/chapter_2.rs
new file mode 100644
index 000000000..a7f9ea9e7
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_2.rs
@@ -0,0 +1,156 @@
+//! # Chapter 2: Tokens and Tags
+//!
+//! The simplest *useful* parser you can write is one which matches tokens.
+//!
+//! ## Tokens
+//!
+//! Matching a single token literal is common enough that `Parser` is implemented for
+//! `char`.
+//!
+//! ```rust
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! #
+//! fn parse_prefix(input: &str) -> IResult<&str, char> {
+//!     '0'.parse_next(input)
+//! }
+//!
+//! fn main()  {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, output) = parse_prefix.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, "x1a2b Hello");
+//!     assert_eq!(output, '0');
+//!
+//!     assert!(parse_prefix("d").is_err());
+//! }
+//! ```
+//!
+//! ## Tags
+//!
+//! One of the most frequent way of matching a token is when they are combined into a string.
+//! Again, this is common enough that `Parser` is implemented for `&str`:
+//!
+//! ```rust
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! #
+//! fn parse_prefix(input: &str) -> IResult<&str, &str> {
+//!     "0x".parse_next(input)
+//! }
+//!
+//! fn main()  {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, output) = parse_prefix.parse_next(input).unwrap();
+//!     assert_eq!(remainder, "1a2b Hello");
+//!     assert_eq!(output, "0x");
+//!
+//!     assert!(parse_prefix("0o123").is_err());
+//! }
+//! ```
+//!
+//! In `winnow`, we call this type of parser a [`tag`].
+//!
+//! ## Character Classes
+//!
+//! Selecting a single `char` or a [`tag`] is fairly limited.  Sometimes, you will want to select one of several
+//! `chars` of a specific class, like digits. For this, we use the [`one_of`] parer:
+//!
+//! ```rust
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! use winnow::bytes::one_of;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, char> {
+//!     one_of("0123456789abcdefgABCDEFG").parse_next(input)
+//! }
+//!
+//! fn main() {
+//!     let input = "1a2b Hello";
+//!
+//!     let (remainder, output) = parse_digits.parse_next(input).unwrap();
+//!     assert_eq!(remainder, "a2b Hello");
+//!     assert_eq!(output, '1');
+//!
+//!     assert!(parse_digits("Z").is_err());
+//! }
+//! ```
+//!
+//! > **Aside:** [`one_of`] might look straightforward, a function returning a value that implements `Parser`.
+//! > Let's look at it more closely as its used above (resolving all generic parameters):
+//! > ```rust
+//! > # use winnow::prelude::*;
+//! > # use winnow::error::Error;
+//! > pub fn one_of<'i>(
+//! >     list: &'static str
+//! > ) -> impl Parser<&'i str, char, Error<&'i str>> {
+//! >     // ...
+//! > #    winnow::bytes::one_of(list)
+//! > }
+//! > ```
+//! > If you have not programmed in a language where functions are values, the type signature of the
+//! > [`one_of`] function might be a surprise.
+//! > The function [`one_of`] *returns a function*. The function it returns is a
+//! > `Parser`, taking a `&str` and returning an `IResult`. This is a common pattern in winnow for
+//! > configurable or stateful parsers.
+//!
+//! Some of character classes are common enough that a named parser is provided, like with:
+//! - [`line_ending`][crate::character::line_ending]: Recognizes an end of line (both `\n` and `\r\n`)
+//! - [`newline`][crate::character::newline]: Matches a newline character `\n`
+//! - [`tab`][crate::character::tab]: Matches a tab character `\t`
+//!
+//! You can then capture sequences of these characters with parsers like [`take_while1`].
+//! ```rust
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! use winnow::bytes::take_while1;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, &str> {
+//!     take_while1("0123456789abcdefgABCDEFG").parse_next(input)
+//! }
+//!
+//! fn main() {
+//!     let input = "1a2b Hello";
+//!
+//!     let (remainder, output) = parse_digits.parse_next(input).unwrap();
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(output, "1a2b");
+//!
+//!     assert!(parse_digits("Z").is_err());
+//! }
+//! ```
+//!
+//! We could simplify this further with by using one of the built-in character classes, [`hex_digit1`]:
+//! ```rust
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! use winnow::character::hex_digit1;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, &str> {
+//!     hex_digit1.parse_next(input)
+//! }
+//!
+//! fn main() {
+//!     let input = "1a2b Hello";
+//!
+//!     let (remainder, output) = parse_digits.parse_next(input).unwrap();
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(output, "1a2b");
+//!
+//!     assert!(parse_digits("Z").is_err());
+//! }
+//! ```
+
+#![allow(unused_imports)]
+use crate::bytes::one_of;
+use crate::bytes::tag;
+use crate::bytes::take_while1;
+use crate::character::hex_digit1;
+use crate::stream::ContainsToken;
+use crate::Parser;
+use std::ops::RangeInclusive;
+
+pub use super::chapter_1 as previous;
+pub use super::chapter_3 as next;
diff --git a/vendor/winnow/src/_tutorial/chapter_3.rs b/vendor/winnow/src/_tutorial/chapter_3.rs
new file mode 100644
index 000000000..29c5db457
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_3.rs
@@ -0,0 +1,242 @@
+//! # Chapter 3: Sequencing and Alternatives
+//!
+//! In the last chapter, we saw how to create simple parsers using prebuilt parsers.
+//!
+//! In this chapter, we explore two other widely used features:
+//! alternatives and composition.
+//!
+//! ## Sequencing
+//!
+//! Now that we can create more interesting parsers, we can sequence them together, like:
+//!
+//! ```rust
+//! # use winnow::bytes::take_while1;
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! #
+//! fn parse_prefix(input: &str) -> IResult<&str, &str> {
+//!     "0x".parse_next(input)
+//! }
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, &str> {
+//!     take_while1((
+//!         ('0'..='9'),
+//!         ('A'..='F'),
+//!         ('a'..='f'),
+//!     )).parse_next(input)
+//! }
+//!
+//! fn main()  {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, prefix) = parse_prefix.parse_next(input).unwrap();
+//!     let (remainder, digits) = parse_digits.parse_next(remainder).unwrap();
+//!
+//!     assert_eq!(prefix, "0x");
+//!     assert_eq!(digits, "1a2b");
+//!     assert_eq!(remainder, " Hello");
+//! }
+//! ```
+//!
+//! To sequence these together, you can just put them in a tuple:
+//! ```rust
+//! # use winnow::bytes::take_while1;
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! #
+//! # fn parse_prefix(input: &str) -> IResult<&str, &str> {
+//! #     "0x".parse_next(input)
+//! # }
+//! #
+//! # fn parse_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! //...
+//!
+//! fn main()  {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, (prefix, digits)) = (
+//!         parse_prefix,
+//!         parse_digits
+//!     ).parse_next(input).unwrap();
+//!
+//!     assert_eq!(prefix, "0x");
+//!     assert_eq!(digits, "1a2b");
+//!     assert_eq!(remainder, " Hello");
+//! }
+//! ```
+//!
+//! Frequently, you won't care about the tag and you can instead use one of the provided combinators,
+//! like [`preceded`]:
+//! ```rust
+//! # use winnow::bytes::take_while1;
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! use winnow::sequence::preceded;
+//!
+//! # fn parse_prefix(input: &str) -> IResult<&str, &str> {
+//! #     "0x".parse_next(input)
+//! # }
+//! #
+//! # fn parse_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! //...
+//!
+//! fn main() {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, digits) = preceded(
+//!         parse_prefix,
+//!         parse_digits
+//!     ).parse_next(input).unwrap();
+//!
+//!     assert_eq!(digits, "1a2b");
+//!     assert_eq!(remainder, " Hello");
+//! }
+//! ```
+//!
+//! ## Alternatives
+//!
+//! Sometimes, we might want to choose between two parsers; and we're happy with
+//! either being used.
+//!
+//! The de facto way to do this in winnow is with the [`alt()`] combinator which will execute each
+//! parser in a tuple until it finds one that does not error. If all error, then by default you are
+//! given the error from the last parser.
+//!
+//! We can see a basic example of `alt()` below.
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! use winnow::branch::alt;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, (&str, &str)> {
+//!     alt((
+//!         ("0b", parse_bin_digits),
+//!         ("0o", parse_oct_digits),
+//!         ("0d", parse_dec_digits),
+//!         ("0x", parse_hex_digits),
+//!     )).parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, (prefix, digits)) = parse_digits.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(prefix, "0x");
+//!     assert_eq!(digits, "1a2b");
+//!
+//!     assert!(parse_digits("ghiWorld").is_err());
+//! }
+//! ```
+//!
+//! Sometimes a giant if/else-if ladder can be slow and you'd rather have a `match` statement for
+//! branches of your parser that have unique prefixes.  In this case, you can use the
+//! [`dispatch`][crate::branch::dispatch] macro:
+//!
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! use winnow::branch::dispatch;
+//! use winnow::bytes::take;
+//! use winnow::combinator::fail;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, &str> {
+//!     dispatch!(take(2usize);
+//!         "0b" => parse_bin_digits,
+//!         "0o" => parse_oct_digits,
+//!         "0d" => parse_dec_digits,
+//!         "0x" => parse_hex_digits,
+//!         _ => fail,
+//!     ).parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, digits) = parse_digits.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(digits, "1a2b");
+//!
+//!     assert!(parse_digits("ghiWorld").is_err());
+//! }
+//! ```
+
+#![allow(unused_imports)]
+use crate::branch::alt;
+use crate::branch::dispatch;
+use crate::sequence::preceded;
+
+pub use super::chapter_2 as previous;
+pub use super::chapter_4 as next;
diff --git a/vendor/winnow/src/_tutorial/chapter_4.rs b/vendor/winnow/src/_tutorial/chapter_4.rs
new file mode 100644
index 000000000..5d19a05bc
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_4.rs
@@ -0,0 +1,109 @@
+//! # Chapter 4: Parsers With Custom Return Types
+//!
+//! So far, we have seen mostly functions that take an `&str`, and return a
+//! `IResult<&str, &str>`. Splitting strings into smaller strings and characters is certainly
+//! useful, but it's not the only thing winnow is capable of!
+//!
+//! A useful operation when parsing is to convert between types; for example
+//! parsing from `&str` to another primitive, like [`usize`].
+//!
+//! All we need to do for our parser to return a different type is to change
+//! the second type parameter of [`IResult`] to the desired return type.
+//! For example, to return a `usize`, return a `IResult<&str, usize>`.
+//! Recall that the first type parameter of the `IResult` is the input
+//! type, so even if you're returning something different, if your input
+//! is a `&str`, the first type argument of `IResult` should be also.
+//!
+//! One winnow-native way of doing a type conversion is to use the
+//! [`Parser::parse_to`] combinator
+//! to convert from a successful parse to a particular type using [`FromStr`].
+//!
+//! The following code converts from a string containing a number to `usize`:
+//! ```rust
+//! # use winnow::Parser;
+//! # use winnow::IResult;
+//! # use winnow::character::digit1;
+//! #
+//! fn parse_digits(input: &str) -> IResult<&str, usize> {
+//!     digit1
+//!         .parse_to()
+//!         .parse_next(input)
+//! }
+//!
+//! fn main() {
+//!     let input = "1024 Hello";
+//!
+//!     let (remainder, output) = parse_digits.parse_next(input).unwrap();
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(output, 1024);
+//!
+//!     assert!(parse_digits("Z").is_err());
+//! }
+//! ```
+//!
+//! `Parser::parse_to` is just a convenient form of [`Parser::map_res`] which we can use to handle
+//! all radices of numbers:
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! use winnow::branch::dispatch;
+//! use winnow::bytes::take;
+//! use winnow::combinator::fail;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, usize> {
+//!     dispatch!(take(2usize);
+//!         "0b" => parse_bin_digits.map_res(|s| usize::from_str_radix(s, 2)),
+//!         "0o" => parse_oct_digits.map_res(|s| usize::from_str_radix(s, 8)),
+//!         "0d" => parse_dec_digits.map_res(|s| usize::from_str_radix(s, 10)),
+//!         "0x" => parse_hex_digits.map_res(|s| usize::from_str_radix(s, 16)),
+//!         _ => fail,
+//!     ).parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, digits) = parse_digits.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(digits, 0x1a2b);
+//!
+//!     assert!(parse_digits("ghiWorld").is_err());
+//! }
+//! ```
+
+#![allow(unused_imports)]
+use crate::IResult;
+use crate::Parser;
+use std::str::FromStr;
+
+pub use super::chapter_3 as previous;
+pub use super::chapter_5 as next;
diff --git a/vendor/winnow/src/_tutorial/chapter_5.rs b/vendor/winnow/src/_tutorial/chapter_5.rs
new file mode 100644
index 000000000..b703bcf5c
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_5.rs
@@ -0,0 +1,214 @@
+//! # Chapter 5: Repetition
+//!
+//! In [`chapter_3`], we covered how to sequence different parsers into a tuple but sometimes you need to run a
+//! single parser many times into a [`Vec`].
+//!
+//! Let's take our `parse_digits` and collect a list of them with [`many0`]:
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! # use winnow::branch::dispatch;
+//! # use winnow::bytes::take;
+//! # use winnow::combinator::fail;
+//! use winnow::combinator::opt;
+//! use winnow::multi::many0;
+//! use winnow::sequence::terminated;
+//!
+//! fn parse_list(input: &str) -> IResult<&str, Vec<usize>> {
+//!     many0(terminated(parse_digits, opt(','))).parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_digits(input: &str) -> IResult<&str, usize> {
+//! #     dispatch!(take(2usize);
+//! #          "0b" => parse_bin_digits.map_res(|s| usize::from_str_radix(s, 2)),
+//! #          "0o" => parse_oct_digits.map_res(|s| usize::from_str_radix(s, 8)),
+//! #          "0d" => parse_dec_digits.map_res(|s| usize::from_str_radix(s, 10)),
+//! #          "0x" => parse_hex_digits.map_res(|s| usize::from_str_radix(s, 16)),
+//! #          _ => fail,
+//! #      ).parse_next(input)
+//! # }
+//! #
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b,0x3c4d,0x5e6f Hello";
+//!
+//!     let (remainder, digits) = parse_list.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(digits, vec![0x1a2b, 0x3c4d, 0x5e6f]);
+//!
+//!     assert!(parse_digits("ghiWorld").is_err());
+//! }
+//! ```
+//!
+//! You'll notice that the above allows trailing `,` when we intended to not support that.  We can
+//! easily fix this by using [`separated0`]:
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! # use winnow::branch::dispatch;
+//! # use winnow::bytes::take;
+//! # use winnow::combinator::fail;
+//! use winnow::multi::separated0;
+//!
+//! fn parse_list(input: &str) -> IResult<&str, Vec<usize>> {
+//!     separated0(parse_digits, ",").parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_digits(input: &str) -> IResult<&str, usize> {
+//! #     dispatch!(take(2usize);
+//! #          "0b" => parse_bin_digits.map_res(|s| usize::from_str_radix(s, 2)),
+//! #          "0o" => parse_oct_digits.map_res(|s| usize::from_str_radix(s, 8)),
+//! #          "0d" => parse_dec_digits.map_res(|s| usize::from_str_radix(s, 10)),
+//! #          "0x" => parse_hex_digits.map_res(|s| usize::from_str_radix(s, 16)),
+//! #          _ => fail,
+//! #      ).parse_next(input)
+//! # }
+//! #
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b,0x3c4d,0x5e6f Hello";
+//!
+//!     let (remainder, digits) = parse_list.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(digits, vec![0x1a2b, 0x3c4d, 0x5e6f]);
+//!
+//!     assert!(parse_digits("ghiWorld").is_err());
+//! }
+//! ```
+//!
+//! If you look closely at [`many0`], it isn't collecting directly into a [`Vec`] but
+//! [`Accumulate`] to gather the results.  This let's us make more complex parsers than we did in
+//! [`chapter_2`] by accumulating the results into a `()` and [`recognize`][Parser::recognize]-ing the captured input:
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! # use winnow::branch::dispatch;
+//! # use winnow::bytes::take;
+//! # use winnow::combinator::fail;
+//! # use winnow::multi::separated0;
+//! #
+//! fn recognize_list(input: &str) -> IResult<&str, &str> {
+//!     parse_list.recognize().parse_next(input)
+//! }
+//!
+//! fn parse_list(input: &str) -> IResult<&str, ()> {
+//!     separated0(parse_digits, ",").parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_digits(input: &str) -> IResult<&str, usize> {
+//! #     dispatch!(take(2usize);
+//! #          "0b" => parse_bin_digits.map_res(|s| usize::from_str_radix(s, 2)),
+//! #          "0o" => parse_oct_digits.map_res(|s| usize::from_str_radix(s, 8)),
+//! #          "0d" => parse_dec_digits.map_res(|s| usize::from_str_radix(s, 10)),
+//! #          "0x" => parse_hex_digits.map_res(|s| usize::from_str_radix(s, 16)),
+//! #          _ => fail,
+//! #      ).parse_next(input)
+//! # }
+//! #
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b,0x3c4d,0x5e6f Hello";
+//!
+//!     let (remainder, digits) = recognize_list.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(digits, "0x1a2b,0x3c4d,0x5e6f");
+//!
+//!     assert!(parse_digits("ghiWorld").is_err());
+//! }
+//! ```
+
+#![allow(unused_imports)]
+use super::chapter_2;
+use super::chapter_3;
+use crate::multi::many0;
+use crate::multi::separated0;
+use crate::stream::Accumulate;
+use crate::Parser;
+use std::vec::Vec;
+
+pub use super::chapter_4 as previous;
+pub use super::chapter_6 as next;
diff --git a/vendor/winnow/src/_tutorial/chapter_6.rs b/vendor/winnow/src/_tutorial/chapter_6.rs
new file mode 100644
index 000000000..74169429d
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_6.rs
@@ -0,0 +1,158 @@
+//! # Chapter 6: Error Reporting
+//!
+//! ## `Error`
+//!
+//! Back in [`chapter_1`], we glossed over the `Err` side of [`IResult`].  `IResult<I, O>` is
+//! actually short for `IResult<I, O, E=Error>` where [`Error`] is a cheap, universal error type
+//! for getting started.  When humans are producing the file, like with `toml`, you might want to
+//! sacrifice some performance for providing more details on how to resolve the problem
+//!
+//! winnow includes [`VerboseError`] for this but you can [customize the error as you
+//! wish][_topic::error].  You can use [`Parser::context`] to annotate the error with custom types
+//! while unwinding to further improve the error quality.
+//!
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! # use winnow::branch::alt;
+//! use winnow::error::VerboseError;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, (&str, &str), VerboseError<&str>> {
+//!     alt((
+//!         ("0b", parse_bin_digits).context("binary"),
+//!         ("0o", parse_oct_digits).context("octal"),
+//!         ("0d", parse_dec_digits).context("decimal"),
+//!         ("0x", parse_hex_digits).context("hexadecimal"),
+//!     )).parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, (prefix, digits)) = parse_digits.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(prefix, "0x");
+//!     assert_eq!(digits, "1a2b");
+//! }
+//! ```
+//!
+//! At first glance, this looks correct but what `context` will be reported when parsing `"0b5"`?
+//! If you remember back to [`chapter_3`], [`alt`] will only report the last error by default which
+//! means when parsing `"0b5"`, the `context` will be `"hexadecimal"`.
+//!
+//! ## `ErrMode`
+//!
+//! Let's break down `IResult<I, O, E>` one step further:
+//! ```rust
+//! # use winnow::error::Error;
+//! # use winnow::error::ErrMode;
+//! pub type IResult<I, O, E = Error<I>> = Result<(I, O), ErrMode<E>>;
+//! ```
+//! `IResult` is just a fancy wrapper around `Result` that wraps our error in an [`ErrMode`]
+//! type.
+//!
+//! `ErrMode` is an enum with `Backtrack` and `Cut` variants (ignore `Incomplete` as its only
+//! relevant for [streaming][_topic::stream]).  By default, errors are `Backtrack`, meaning that
+//! other parsing branches will be attempted on failure, like the next case of an `alt`.  `Cut`
+//! shortcircuits all other branches, immediately reporting the error.
+//!
+//! So we can get the correct `context` by modifying the above example with [`cut_err`]:
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::Parser;
+//! # use winnow::bytes::take_while1;
+//! # use winnow::branch::alt;
+//! # use winnow::error::VerboseError;
+//! use winnow::combinator::cut_err;
+//!
+//! fn parse_digits(input: &str) -> IResult<&str, (&str, &str), VerboseError<&str>> {
+//!     alt((
+//!         ("0b", cut_err(parse_bin_digits)).context("binary"),
+//!         ("0o", cut_err(parse_oct_digits)).context("octal"),
+//!         ("0d", cut_err(parse_dec_digits)).context("decimal"),
+//!         ("0x", cut_err(parse_hex_digits)).context("hexadecimal"),
+//!     )).parse_next(input)
+//! }
+//!
+//! // ...
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str, VerboseError<&str>> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b Hello";
+//!
+//!     let (remainder, (prefix, digits)) = parse_digits.parse_next(input).unwrap();
+//!
+//!     assert_eq!(remainder, " Hello");
+//!     assert_eq!(prefix, "0x");
+//!     assert_eq!(digits, "1a2b");
+//! }
+//! ```
+//! Now, when parsing `"0b5"`, the `context` will be `"binary"`.
+
+#![allow(unused_imports)]
+use super::chapter_1;
+use super::chapter_3;
+use crate::branch::alt;
+use crate::combinator::cut_err;
+use crate::error::ErrMode;
+use crate::error::Error;
+use crate::error::VerboseError;
+use crate::IResult;
+use crate::Parser;
+use crate::_topic;
+
+pub use super::chapter_5 as previous;
+pub use super::chapter_7 as next;
diff --git a/vendor/winnow/src/_tutorial/chapter_7.rs b/vendor/winnow/src/_tutorial/chapter_7.rs
new file mode 100644
index 000000000..8c27cb5ad
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/chapter_7.rs
@@ -0,0 +1,111 @@
+//! # Chapter 7: Integrating the Parser
+//!
+//! So far, we've highlighted how to incrementally parse, but how do we bring this all together
+//! into our application?
+//!
+//! The type we've been working with looks like:
+//! ```rust
+//! # use winnow::error::VerboseError;
+//! # use winnow::error::ErrMode;
+//! type IResult<'i, O> = Result<
+//!     (&'i str, O),
+//!     ErrMode<
+//!         VerboseError<&'i str>
+//!     >
+//! >;
+//! ```
+//! 1. We have to decide what to do about the `remainder` of the input.  
+//! 2. The error type is not compatible with the rest of the Rust ecosystem
+//!
+//! Normally, Rust applications want errors that are `std::error::Error + Send + Sync + 'static`
+//! meaning:
+//! - They implement the [`std::error::Error`] trait
+//! - They can be sent across threads
+//! - They are safe to be referenced across threads
+//! - They do not borrow
+//!
+//! winnow provides some helpers for this:
+//! ```rust
+//! # use winnow::IResult;
+//! # use winnow::bytes::take_while1;
+//! # use winnow::branch::dispatch;
+//! # use winnow::bytes::take;
+//! # use winnow::combinator::fail;
+//! use winnow::Parser;
+//! use winnow::error::Error;
+//!
+//! #[derive(Debug, PartialEq, Eq)]
+//! pub struct Hex(usize);
+//!
+//! impl std::str::FromStr for Hex {
+//!     type Err = Error<String>;
+//!
+//!     fn from_str(input: &str) -> Result<Self, Self::Err> {
+//!         parse_digits
+//!             .map(Hex)
+//!             .parse(input)
+//!             .map_err(|e| e.into_owned())
+//!     }
+//! }
+//!
+//! // ...
+//! # fn parse_digits(input: &str) -> IResult<&str, usize> {
+//! #     dispatch!(take(2usize);
+//! #         "0b" => parse_bin_digits.map_res(|s| usize::from_str_radix(s, 2)),
+//! #         "0o" => parse_oct_digits.map_res(|s| usize::from_str_radix(s, 8)),
+//! #         "0d" => parse_dec_digits.map_res(|s| usize::from_str_radix(s, 10)),
+//! #         "0x" => parse_hex_digits.map_res(|s| usize::from_str_radix(s, 16)),
+//! #         _ => fail,
+//! #     ).parse_next(input)
+//! # }
+//! #
+//! # fn parse_bin_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_oct_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='7'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_dec_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #     )).parse_next(input)
+//! # }
+//! #
+//! # fn parse_hex_digits(input: &str) -> IResult<&str, &str> {
+//! #     take_while1((
+//! #         ('0'..='9'),
+//! #         ('A'..='F'),
+//! #         ('a'..='f'),
+//! #     )).parse_next(input)
+//! # }
+//!
+//! fn main() {
+//!     let input = "0x1a2b";
+//!     assert_eq!(input.parse::<Hex>().unwrap(), Hex(0x1a2b));
+//!
+//!     let input = "0x1a2b Hello";
+//!     assert!(input.parse::<Hex>().is_err());
+//!     let input = "ghiHello";
+//!     assert!(input.parse::<Hex>().is_err());
+//! }
+//! ```
+//! - Ensures we hit [`eof`]
+//! - Removes the [`ErrMode`] wrapper
+//!
+//! [`Error::into_owned`]:
+//! - Converts the `&str` in `Error` to `String` which enables support for [`std::error::Error`]
+
+#![allow(unused_imports)]
+use super::chapter_1;
+use crate::combinator::eof;
+use crate::error::ErrMode;
+use crate::error::Error;
+use crate::IResult;
+
+pub use super::chapter_6 as previous;
diff --git a/vendor/winnow/src/_tutorial/mod.rs b/vendor/winnow/src/_tutorial/mod.rs
new file mode 100644
index 000000000..e4b8392f9
--- /dev/null
+++ b/vendor/winnow/src/_tutorial/mod.rs
@@ -0,0 +1,12 @@
+//! # Tutorial
+//!
+//! Table of Content
+
+pub mod chapter_0;
+pub mod chapter_1;
+pub mod chapter_2;
+pub mod chapter_3;
+pub mod chapter_4;
+pub mod chapter_5;
+pub mod chapter_6;
+pub mod chapter_7;
diff --git a/vendor/winnow/src/bits/mod.rs b/vendor/winnow/src/bits/mod.rs
new file mode 100644
index 000000000..18cce6f67
--- /dev/null
+++ b/vendor/winnow/src/bits/mod.rs
@@ -0,0 +1,383 @@
+//! Bit level parsers
+//!
+
+#[cfg(test)]
+mod tests;
+
+use crate::error::{ErrMode, ErrorConvert, ErrorKind, Needed, ParseError};
+use crate::lib::std::ops::{AddAssign, Div, Shl, Shr};
+use crate::stream::{AsBytes, Stream, StreamIsPartial, ToUsize};
+use crate::trace::trace;
+use crate::{IResult, Parser};
+
+/// Converts a byte-level input to a bit-level input
+///
+/// See [`bytes`] to convert it back.
+///
+/// # Example
+/// ```
+/// use winnow::prelude::*;
+/// use winnow::Bytes;
+/// use winnow::bits::{bits, take};
+/// use winnow::error::Error;
+///
+/// type Stream<'i> = &'i Bytes;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Bytes::new(b)
+/// }
+///
+/// fn parse(input: Stream<'_>) -> IResult<Stream<'_>, (u8, u8)> {
+///     bits::<_, _, Error<(_, usize)>, _, _>((take(4usize), take(8usize))).parse_next(input)
+/// }
+///
+/// let input = stream(&[0x12, 0x34, 0xff, 0xff]);
+///
+/// let output = parse(input).expect("We take 1.5 bytes and the input is longer than 2 bytes");
+///
+/// // The first byte is consumed, the second byte is partially consumed and dropped.
+/// let remaining = output.0;
+/// assert_eq!(remaining, stream(&[0xff, 0xff]));
+///
+/// let parsed = output.1;
+/// assert_eq!(parsed.0, 0x01);
+/// assert_eq!(parsed.1, 0x23);
+/// ```
+pub fn bits<I, O, E1, E2, P>(mut parser: P) -> impl Parser<I, O, E2>
+where
+    E1: ParseError<(I, usize)> + ErrorConvert<E2>,
+    E2: ParseError<I>,
+    I: Stream,
+    P: Parser<(I, usize), O, E1>,
+{
+    trace("bits", move |input: I| {
+        match parser.parse_next((input, 0)) {
+            Ok(((rest, offset), result)) => {
+                // If the next byte has been partially read, it will be sliced away as well.
+                // The parser functions might already slice away all fully read bytes.
+                // That's why `offset / 8` isn't necessarily needed at all times.
+                let remaining_bytes_index = offset / 8 + if offset % 8 == 0 { 0 } else { 1 };
+                let (input, _) = rest.next_slice(remaining_bytes_index);
+                Ok((input, result))
+            }
+            Err(ErrMode::Incomplete(n)) => Err(ErrMode::Incomplete(n.map(|u| u.get() / 8 + 1))),
+            Err(e) => Err(e.convert()),
+        }
+    })
+}
+
+/// Convert a [`bits`] stream back into a byte stream
+///
+/// **Warning:** A partial byte remaining in the input will be ignored and the given parser will
+/// start parsing at the next full byte.
+///
+/// ```
+/// use winnow::prelude::*;
+/// use winnow::Bytes;
+/// use winnow::bits::{bits, bytes, take};
+/// use winnow::combinator::rest;
+/// use winnow::error::Error;
+///
+/// type Stream<'i> = &'i Bytes;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Bytes::new(b)
+/// }
+///
+/// fn parse(input: Stream<'_>) -> IResult<Stream<'_>, (u8, u8, &[u8])> {
+///   bits::<_, _, Error<(_, usize)>, _, _>((
+///     take(4usize),
+///     take(8usize),
+///     bytes::<_, _, Error<_>, _, _>(rest)
+///   )).parse_next(input)
+/// }
+///
+/// let input = stream(&[0x12, 0x34, 0xff, 0xff]);
+///
+/// assert_eq!(parse(input), Ok(( stream(&[]), (0x01, 0x23, &[0xff, 0xff][..]) )));
+/// ```
+pub fn bytes<I, O, E1, E2, P>(mut parser: P) -> impl Parser<(I, usize), O, E2>
+where
+    E1: ParseError<I> + ErrorConvert<E2>,
+    E2: ParseError<(I, usize)>,
+    I: Stream<Token = u8>,
+    P: Parser<I, O, E1>,
+{
+    trace("bytes", move |(input, offset): (I, usize)| {
+        let (inner, _) = if offset % 8 != 0 {
+            input.next_slice(1 + offset / 8)
+        } else {
+            input.next_slice(offset / 8)
+        };
+        let i = (input, offset);
+        match parser.parse_next(inner) {
+            Ok((rest, res)) => Ok(((rest, 0), res)),
+            Err(ErrMode::Incomplete(Needed::Unknown)) => Err(ErrMode::Incomplete(Needed::Unknown)),
+            Err(ErrMode::Incomplete(Needed::Size(sz))) => Err(match sz.get().checked_mul(8) {
+                Some(v) => ErrMode::Incomplete(Needed::new(v)),
+                None => ErrMode::Cut(E2::assert(
+                    i,
+                    "overflow in turning needed bytes into needed bits",
+                )),
+            }),
+            Err(e) => Err(e.convert()),
+        }
+    })
+}
+
+/// Parse taking `count` bits
+///
+/// # Example
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::Bytes;
+/// # use winnow::error::{Error, ErrorKind};
+/// use winnow::bits::take;
+///
+/// type Stream<'i> = &'i Bytes;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Bytes::new(b)
+/// }
+///
+/// fn parser(input: (Stream<'_>, usize), count: usize)-> IResult<(Stream<'_>, usize), u8> {
+///  take(count).parse_next(input)
+/// }
+///
+/// // Consumes 0 bits, returns 0
+/// assert_eq!(parser((stream(&[0b00010010]), 0), 0), Ok(((stream(&[0b00010010]), 0), 0)));
+///
+/// // Consumes 4 bits, returns their values and increase offset to 4
+/// assert_eq!(parser((stream(&[0b00010010]), 0), 4), Ok(((stream(&[0b00010010]), 4), 0b00000001)));
+///
+/// // Consumes 4 bits, offset is 4, returns their values and increase offset to 0 of next byte
+/// assert_eq!(parser((stream(&[0b00010010]), 4), 4), Ok(((stream(&[]), 0), 0b00000010)));
+///
+/// // Tries to consume 12 bits but only 8 are available
+/// assert_eq!(parser((stream(&[0b00010010]), 0), 12), Err(winnow::error::ErrMode::Backtrack(Error{input: (stream(&[0b00010010]), 0), kind: ErrorKind::Eof })));
+/// ```
+#[inline(always)]
+pub fn take<I, O, C, E: ParseError<(I, usize)>>(count: C) -> impl Parser<(I, usize), O, E>
+where
+    I: Stream<Token = u8> + AsBytes + StreamIsPartial,
+    C: ToUsize,
+    O: From<u8> + AddAssign + Shl<usize, Output = O> + Shr<usize, Output = O>,
+{
+    let count = count.to_usize();
+    trace("take", move |input: (I, usize)| {
+        if input.is_partial() {
+            streaming_take_internal(input, count)
+        } else {
+            complete_take_internal(input, count)
+        }
+    })
+}
+
+pub(crate) fn streaming_take_internal<I, O, E: ParseError<(I, usize)>>(
+    (input, bit_offset): (I, usize),
+    count: usize,
+) -> IResult<(I, usize), O, E>
+where
+    I: Stream<Token = u8> + AsBytes,
+    O: From<u8> + AddAssign + Shl<usize, Output = O> + Shr<usize, Output = O>,
+{
+    if count == 0 {
+        Ok(((input, bit_offset), 0u8.into()))
+    } else {
+        let cnt = (count + bit_offset).div(8);
+        if input.eof_offset() * 8 < count + bit_offset {
+            Err(ErrMode::Incomplete(Needed::new(count)))
+        } else {
+            let mut acc: O = 0_u8.into();
+            let mut offset: usize = bit_offset;
+            let mut remaining: usize = count;
+            let mut end_offset: usize = 0;
+
+            for byte in input.as_bytes().iter().copied().take(cnt + 1) {
+                if remaining == 0 {
+                    break;
+                }
+                let val: O = if offset == 0 {
+                    byte.into()
+                } else {
+                    (byte << offset >> offset).into()
+                };
+
+                if remaining < 8 - offset {
+                    acc += val >> (8 - offset - remaining);
+                    end_offset = remaining + offset;
+                    break;
+                } else {
+                    acc += val << (remaining - (8 - offset));
+                    remaining -= 8 - offset;
+                    offset = 0;
+                }
+            }
+            let (input, _) = input.next_slice(cnt);
+            Ok(((input, end_offset), acc))
+        }
+    }
+}
+
+pub(crate) fn complete_take_internal<I, O, E: ParseError<(I, usize)>>(
+    (input, bit_offset): (I, usize),
+    count: usize,
+) -> IResult<(I, usize), O, E>
+where
+    I: Stream<Token = u8> + AsBytes,
+    O: From<u8> + AddAssign + Shl<usize, Output = O> + Shr<usize, Output = O>,
+{
+    if count == 0 {
+        Ok(((input, bit_offset), 0u8.into()))
+    } else {
+        let cnt = (count + bit_offset).div(8);
+        if input.eof_offset() * 8 < count + bit_offset {
+            Err(ErrMode::from_error_kind(
+                (input, bit_offset),
+                ErrorKind::Eof,
+            ))
+        } else {
+            let mut acc: O = 0_u8.into();
+            let mut offset: usize = bit_offset;
+            let mut remaining: usize = count;
+            let mut end_offset: usize = 0;
+
+            for byte in input.as_bytes().iter().copied().take(cnt + 1) {
+                if remaining == 0 {
+                    break;
+                }
+                let val: O = if offset == 0 {
+                    byte.into()
+                } else {
+                    (byte << offset >> offset).into()
+                };
+
+                if remaining < 8 - offset {
+                    acc += val >> (8 - offset - remaining);
+                    end_offset = remaining + offset;
+                    break;
+                } else {
+                    acc += val << (remaining - (8 - offset));
+                    remaining -= 8 - offset;
+                    offset = 0;
+                }
+            }
+            let (input, _) = input.next_slice(cnt);
+            Ok(((input, end_offset), acc))
+        }
+    }
+}
+
+/// Parse taking `count` bits and comparing them to `pattern`
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::Bytes;
+/// # use winnow::error::{Error, ErrorKind};
+/// use winnow::bits::tag;
+///
+/// type Stream<'i> = &'i Bytes;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Bytes::new(b)
+/// }
+///
+/// /// Compare the lowest `count` bits of `input` against the lowest `count` bits of `pattern`.
+/// /// Return Ok and the matching section of `input` if there's a match.
+/// /// Return Err if there's no match.
+/// fn parser(pattern: u8, count: u8, input: (Stream<'_>, usize)) -> IResult<(Stream<'_>, usize), u8> {
+///     tag(pattern, count).parse_next(input)
+/// }
+///
+/// // The lowest 4 bits of 0b00001111 match the lowest 4 bits of 0b11111111.
+/// assert_eq!(
+///     parser(0b0000_1111, 4, (stream(&[0b1111_1111]), 0)),
+///     Ok(((stream(&[0b1111_1111]), 4), 0b0000_1111))
+/// );
+///
+/// // The lowest bit of 0b00001111 matches the lowest bit of 0b11111111 (both are 1).
+/// assert_eq!(
+///     parser(0b00000001, 1, (stream(&[0b11111111]), 0)),
+///     Ok(((stream(&[0b11111111]), 1), 0b00000001))
+/// );
+///
+/// // The lowest 2 bits of 0b11111111 and 0b00000001 are different.
+/// assert_eq!(
+///     parser(0b000000_01, 2, (stream(&[0b111111_11]), 0)),
+///     Err(winnow::error::ErrMode::Backtrack(Error {
+///         input: (stream(&[0b11111111]), 0),
+///         kind: ErrorKind::Tag
+///     }))
+/// );
+///
+/// // The lowest 8 bits of 0b11111111 and 0b11111110 are different.
+/// assert_eq!(
+///     parser(0b11111110, 8, (stream(&[0b11111111]), 0)),
+///     Err(winnow::error::ErrMode::Backtrack(Error {
+///         input: (stream(&[0b11111111]), 0),
+///         kind: ErrorKind::Tag
+///     }))
+/// );
+/// ```
+#[inline(always)]
+#[doc(alias = "literal")]
+#[doc(alias = "just")]
+pub fn tag<I, O, C, E: ParseError<(I, usize)>>(
+    pattern: O,
+    count: C,
+) -> impl Parser<(I, usize), O, E>
+where
+    I: Stream<Token = u8> + AsBytes + StreamIsPartial,
+    C: ToUsize,
+    O: From<u8> + AddAssign + Shl<usize, Output = O> + Shr<usize, Output = O> + PartialEq,
+{
+    let count = count.to_usize();
+    trace("tag", move |input: (I, usize)| {
+        let inp = input.clone();
+
+        take(count).parse_next(input).and_then(|(i, o)| {
+            if pattern == o {
+                Ok((i, o))
+            } else {
+                Err(ErrMode::Backtrack(E::from_error_kind(inp, ErrorKind::Tag)))
+            }
+        })
+    })
+}
+
+/// Parses one specific bit as a bool.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::Bytes;
+/// # use winnow::error::{Error, ErrorKind};
+/// use winnow::bits::bool;
+///
+/// type Stream<'i> = &'i Bytes;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Bytes::new(b)
+/// }
+///
+/// fn parse(input: (Stream<'_>, usize)) -> IResult<(Stream<'_>, usize), bool> {
+///     bool.parse_next(input)
+/// }
+///
+/// assert_eq!(parse((stream(&[0b10000000]), 0)), Ok(((stream(&[0b10000000]), 1), true)));
+/// assert_eq!(parse((stream(&[0b10000000]), 1)), Ok(((stream(&[0b10000000]), 2), false)));
+/// ```
+#[doc(alias = "any")]
+pub fn bool<I, E: ParseError<(I, usize)>>(input: (I, usize)) -> IResult<(I, usize), bool, E>
+where
+    I: Stream<Token = u8> + AsBytes + StreamIsPartial,
+{
+    trace("bool", |input: (I, usize)| {
+        let (res, bit): (_, u32) = take(1usize).parse_next(input)?;
+        Ok((res, bit != 0))
+    })
+    .parse_next(input)
+}
diff --git a/vendor/winnow/src/bits/tests.rs b/vendor/winnow/src/bits/tests.rs
new file mode 100644
index 000000000..61dba2c31
--- /dev/null
+++ b/vendor/winnow/src/bits/tests.rs
@@ -0,0 +1,190 @@
+use super::*;
+use crate::error::Error;
+use crate::Partial;
+
+#[test]
+/// Take the `bits` function and assert that remaining bytes are correctly returned, if the
+/// previous bytes are fully consumed
+fn test_complete_byte_consumption_bits() {
+    let input = &[0x12, 0x34, 0x56, 0x78][..];
+
+    // Take 3 bit slices with sizes [4, 8, 4].
+    let result: IResult<&[u8], (u8, u8, u8)> =
+        bits::<_, _, Error<(&[u8], usize)>, _, _>((take(4usize), take(8usize), take(4usize)))
+            .parse_next(input);
+
+    let output = result.expect("We take 2 bytes and the input is longer than 2 bytes");
+
+    let remaining = output.0;
+    assert_eq!(remaining, [0x56, 0x78]);
+
+    let parsed = output.1;
+    assert_eq!(parsed.0, 0x01);
+    assert_eq!(parsed.1, 0x23);
+    assert_eq!(parsed.2, 0x04);
+}
+
+#[test]
+/// Take the `bits` function and assert that remaining bytes are correctly returned, if the
+/// previous bytes are NOT fully consumed. Partially consumed bytes are supposed to be dropped.
+/// I.e. if we consume 1.5 bytes of 4 bytes, 2 bytes will be returned, bits 13-16 will be
+/// dropped.
+fn test_partial_byte_consumption_bits() {
+    let input = &[0x12, 0x34, 0x56, 0x78][..];
+
+    // Take bit slices with sizes [4, 8].
+    let result: IResult<&[u8], (u8, u8)> =
+        bits::<_, _, Error<(&[u8], usize)>, _, _>((take(4usize), take(8usize))).parse_next(input);
+
+    let output = result.expect("We take 1.5 bytes and the input is longer than 2 bytes");
+
+    let remaining = output.0;
+    assert_eq!(remaining, [0x56, 0x78]);
+
+    let parsed = output.1;
+    assert_eq!(parsed.0, 0x01);
+    assert_eq!(parsed.1, 0x23);
+}
+
+#[test]
+#[cfg(feature = "std")]
+/// Ensure that in Incomplete error is thrown, if too few bytes are passed for a given parser.
+fn test_incomplete_bits() {
+    let input = Partial::new(&[0x12][..]);
+
+    // Take bit slices with sizes [4, 8].
+    let result: IResult<_, (u8, u8)> =
+        bits::<_, _, Error<(_, usize)>, _, _>((take(4usize), take(8usize))).parse_next(input);
+
+    assert!(result.is_err());
+    let error = result.err().unwrap();
+    assert_eq!("Parsing requires 2 bytes/chars", error.to_string());
+}
+
+#[test]
+fn test_take_complete_0() {
+    let input = &[0b00010010][..];
+    let count = 0usize;
+    assert_eq!(count, 0usize);
+    let offset = 0usize;
+
+    let result: crate::IResult<(&[u8], usize), usize> = take(count).parse_next((input, offset));
+
+    assert_eq!(result, Ok(((input, offset), 0)));
+}
+
+#[test]
+fn test_take_complete_eof() {
+    let input = &[0b00010010][..];
+
+    let result: crate::IResult<(&[u8], usize), usize> = take(1usize).parse_next((input, 8));
+
+    assert_eq!(
+        result,
+        Err(crate::error::ErrMode::Backtrack(crate::error::Error {
+            input: (input, 8),
+            kind: ErrorKind::Eof
+        }))
+    );
+}
+
+#[test]
+fn test_take_complete_span_over_multiple_bytes() {
+    let input = &[0b00010010, 0b00110100, 0b11111111, 0b11111111][..];
+
+    let result: crate::IResult<(&[u8], usize), usize> = take(24usize).parse_next((input, 4));
+
+    assert_eq!(
+        result,
+        Ok((([0b11111111].as_ref(), 4), 0b1000110100111111111111))
+    );
+}
+
+#[test]
+fn test_take_partial_0() {
+    let input = Partial::new(&[][..]);
+    let count = 0usize;
+    assert_eq!(count, 0usize);
+    let offset = 0usize;
+
+    let result: crate::IResult<(_, usize), usize> = take(count).parse_next((input, offset));
+
+    assert_eq!(result, Ok(((input, offset), 0)));
+}
+
+#[test]
+fn test_tag_partial_ok() {
+    let input = Partial::new(&[0b00011111][..]);
+    let offset = 0usize;
+    let bits_to_take = 4usize;
+    let value_to_tag = 0b0001;
+
+    let result: crate::IResult<(_, usize), usize> =
+        tag(value_to_tag, bits_to_take).parse_next((input, offset));
+
+    assert_eq!(result, Ok(((input, bits_to_take), value_to_tag)));
+}
+
+#[test]
+fn test_tag_partial_err() {
+    let input = Partial::new(&[0b00011111][..]);
+    let offset = 0usize;
+    let bits_to_take = 4usize;
+    let value_to_tag = 0b1111;
+
+    let result: crate::IResult<(_, usize), usize> =
+        tag(value_to_tag, bits_to_take).parse_next((input, offset));
+
+    assert_eq!(
+        result,
+        Err(crate::error::ErrMode::Backtrack(crate::error::Error {
+            input: (input, offset),
+            kind: ErrorKind::Tag
+        }))
+    );
+}
+
+#[test]
+fn test_bool_0_complete() {
+    let input = [0b10000000].as_ref();
+
+    let result: crate::IResult<(&[u8], usize), bool> = bool((input, 0));
+
+    assert_eq!(result, Ok(((input, 1), true)));
+}
+
+#[test]
+fn test_bool_eof_complete() {
+    let input = [0b10000000].as_ref();
+
+    let result: crate::IResult<(&[u8], usize), bool> = bool((input, 8));
+
+    assert_eq!(
+        result,
+        Err(crate::error::ErrMode::Backtrack(crate::error::Error {
+            input: (input, 8),
+            kind: ErrorKind::Eof
+        }))
+    );
+}
+
+#[test]
+fn test_bool_0_partial() {
+    let input = Partial::new([0b10000000].as_ref());
+
+    let result: crate::IResult<(Partial<&[u8]>, usize), bool> = bool((input, 0));
+
+    assert_eq!(result, Ok(((input, 1), true)));
+}
+
+#[test]
+fn test_bool_eof_partial() {
+    let input = Partial::new([0b10000000].as_ref());
+
+    let result: crate::IResult<(Partial<&[u8]>, usize), bool> = bool.parse_next((input, 8));
+
+    assert_eq!(
+        result,
+        Err(crate::error::ErrMode::Incomplete(Needed::new(1)))
+    );
+}
diff --git a/vendor/winnow/src/branch/mod.rs b/vendor/winnow/src/branch/mod.rs
new file mode 100644
index 000000000..6a2c9bc3a
--- /dev/null
+++ b/vendor/winnow/src/branch/mod.rs
@@ -0,0 +1,275 @@
+//! Choice combinators
+
+#[cfg(test)]
+mod tests;
+
+use crate::error::ErrMode;
+use crate::error::ErrorKind;
+use crate::error::ParseError;
+use crate::stream::Stream;
+use crate::trace::trace;
+use crate::{IResult, Parser};
+
+#[doc(inline)]
+pub use crate::dispatch;
+
+/// Helper trait for the [alt()] combinator.
+///
+/// This trait is implemented for tuples of up to 21 elements
+pub trait Alt<I, O, E> {
+    /// Tests each parser in the tuple and returns the result of the first one that succeeds
+    fn choice(&mut self, input: I) -> IResult<I, O, E>;
+}
+
+/// Pick the first successful parser
+///
+/// For tight control over the error, add a final case using [`fail`][crate::combinator::fail].
+/// Alternatively, with a [custom error type][crate::_topic::error], it is possible to track all
+/// errors or return the error of the parser that went the farthest in the input data.
+///
+/// When the alternative cases have unique prefixes, [`dispatch`] can offer better performance.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::Error,error::ErrorKind, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::character::{alpha1, digit1};
+/// use winnow::branch::alt;
+/// # fn main() {
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///   alt((alpha1, digit1)).parse_next(input)
+/// };
+///
+/// // the first parser, alpha1, recognizes the input
+/// assert_eq!(parser("abc"), Ok(("", "abc")));
+///
+/// // the first parser returns an error, so alt tries the second one
+/// assert_eq!(parser("123456"), Ok(("", "123456")));
+///
+/// // both parsers failed, and with the default error type, alt will return the last error
+/// assert_eq!(parser(" "), Err(ErrMode::Backtrack(Error::new(" ", ErrorKind::Slice))));
+/// # }
+/// ```
+#[doc(alias = "choice")]
+pub fn alt<I: Stream, O, E: ParseError<I>, List: Alt<I, O, E>>(
+    mut l: List,
+) -> impl Parser<I, O, E> {
+    trace("alt", move |i: I| l.choice(i))
+}
+
+/// Helper trait for the [permutation()] combinator.
+///
+/// This trait is implemented for tuples of up to 21 elements
+pub trait Permutation<I, O, E> {
+    /// Tries to apply all parsers in the tuple in various orders until all of them succeed
+    fn permutation(&mut self, input: I) -> IResult<I, O, E>;
+}
+
+/// Applies a list of parsers in any order.
+///
+/// Permutation will succeed if all of the child parsers succeeded.
+/// It takes as argument a tuple of parsers, and returns a
+/// tuple of the parser results.
+///
+/// ```rust
+/// # use winnow::{error::ErrMode,error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::character::{alpha1, digit1};
+/// use winnow::branch::permutation;
+/// # fn main() {
+/// fn parser(input: &str) -> IResult<&str, (&str, &str)> {
+///   permutation((alpha1, digit1)).parse_next(input)
+/// }
+///
+/// // permutation recognizes alphabetic characters then digit
+/// assert_eq!(parser("abc123"), Ok(("", ("abc", "123"))));
+///
+/// // but also in inverse order
+/// assert_eq!(parser("123abc"), Ok(("", ("abc", "123"))));
+///
+/// // it will fail if one of the parsers failed
+/// assert_eq!(parser("abc;"), Err(ErrMode::Backtrack(Error::new(";", ErrorKind::Slice))));
+/// # }
+/// ```
+///
+/// The parsers are applied greedily: if there are multiple unapplied parsers
+/// that could parse the next slice of input, the first one is used.
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}};
+/// # use winnow::prelude::*;
+/// use winnow::branch::permutation;
+/// use winnow::bytes::any;
+///
+/// fn parser(input: &str) -> IResult<&str, (char, char)> {
+///   permutation((any, 'a')).parse_next(input)
+/// }
+///
+/// // any parses 'b', then char('a') parses 'a'
+/// assert_eq!(parser("ba"), Ok(("", ('b', 'a'))));
+///
+/// // any parses 'a', then char('a') fails on 'b',
+/// // even though char('a') followed by any would succeed
+/// assert_eq!(parser("ab"), Err(ErrMode::Backtrack(Error::new("b", ErrorKind::Verify))));
+/// ```
+///
+pub fn permutation<I: Stream, O, E: ParseError<I>, List: Permutation<I, O, E>>(
+    mut l: List,
+) -> impl Parser<I, O, E> {
+    trace("permutation", move |i: I| l.permutation(i))
+}
+
+macro_rules! alt_trait(
+  ($first:ident $second:ident $($id: ident)+) => (
+    alt_trait!(__impl $first $second; $($id)+);
+  );
+  (__impl $($current:ident)*; $head:ident $($id: ident)+) => (
+    alt_trait_impl!($($current)*);
+
+    alt_trait!(__impl $($current)* $head; $($id)+);
+  );
+  (__impl $($current:ident)*; $head:ident) => (
+    alt_trait_impl!($($current)*);
+    alt_trait_impl!($($current)* $head);
+  );
+);
+
+macro_rules! alt_trait_impl(
+  ($($id:ident)+) => (
+    impl<
+      I: Clone, Output, Error: ParseError<I>,
+      $($id: Parser<I, Output, Error>),+
+    > Alt<I, Output, Error> for ( $($id),+ ) {
+
+      fn choice(&mut self, input: I) -> IResult<I, Output, Error> {
+        match self.0.parse_next(input.clone()) {
+          Err(ErrMode::Backtrack(e)) => alt_trait_inner!(1, self, input, e, $($id)+),
+          res => res,
+        }
+      }
+    }
+  );
+);
+
+macro_rules! alt_trait_inner(
+  ($it:tt, $self:expr, $input:expr, $err:expr, $head:ident $($id:ident)+) => (
+    match $self.$it.parse_next($input.clone()) {
+      Err(ErrMode::Backtrack(e)) => {
+        let err = $err.or(e);
+        succ!($it, alt_trait_inner!($self, $input, err, $($id)+))
+      }
+      res => res,
+    }
+  );
+  ($it:tt, $self:expr, $input:expr, $err:expr, $head:ident) => (
+    Err(ErrMode::Backtrack($err.append($input, ErrorKind::Alt)))
+  );
+);
+
+alt_trait!(Alt2 Alt3 Alt4 Alt5 Alt6 Alt7 Alt8 Alt9 Alt10 Alt11 Alt12 Alt13 Alt14 Alt15 Alt16 Alt17 Alt18 Alt19 Alt20 Alt21 Alt22);
+
+// Manually implement Alt for (A,), the 1-tuple type
+impl<I, O, E: ParseError<I>, A: Parser<I, O, E>> Alt<I, O, E> for (A,) {
+    fn choice(&mut self, input: I) -> IResult<I, O, E> {
+        self.0.parse_next(input)
+    }
+}
+
+macro_rules! permutation_trait(
+  (
+    $name1:ident $ty1:ident $item1:ident
+    $name2:ident $ty2:ident $item2:ident
+    $($name3:ident $ty3:ident $item3:ident)*
+  ) => (
+    permutation_trait!(__impl $name1 $ty1 $item1, $name2 $ty2 $item2; $($name3 $ty3 $item3)*);
+  );
+  (
+    __impl $($name:ident $ty:ident $item:ident),+;
+    $name1:ident $ty1:ident $item1:ident $($name2:ident $ty2:ident $item2:ident)*
+  ) => (
+    permutation_trait_impl!($($name $ty $item),+);
+    permutation_trait!(__impl $($name $ty $item),+ , $name1 $ty1 $item1; $($name2 $ty2 $item2)*);
+  );
+  (__impl $($name:ident $ty:ident $item:ident),+;) => (
+    permutation_trait_impl!($($name $ty $item),+);
+  );
+);
+
+macro_rules! permutation_trait_impl(
+  ($($name:ident $ty:ident $item:ident),+) => (
+    impl<
+      I: Clone, $($ty),+ , Error: ParseError<I>,
+      $($name: Parser<I, $ty, Error>),+
+    > Permutation<I, ( $($ty),+ ), Error> for ( $($name),+ ) {
+
+      fn permutation(&mut self, mut input: I) -> IResult<I, ( $($ty),+ ), Error> {
+        let mut res = ($(Option::<$ty>::None),+);
+
+        loop {
+          let mut err: Option<Error> = None;
+          permutation_trait_inner!(0, self, input, res, err, $($name)+);
+
+          // If we reach here, every iterator has either been applied before,
+          // or errored on the remaining input
+          if let Some(err) = err {
+            // There are remaining parsers, and all errored on the remaining input
+            return Err(ErrMode::Backtrack(err.append(input, ErrorKind::Alt)));
+          }
+
+          // All parsers were applied
+          match res {
+            ($(Some($item)),+) => return Ok((input, ($($item),+))),
+            _ => unreachable!(),
+          }
+        }
+      }
+    }
+  );
+);
+
+macro_rules! permutation_trait_inner(
+  ($it:tt, $self:expr, $input:ident, $res:expr, $err:expr, $head:ident $($id:ident)*) => (
+    if $res.$it.is_none() {
+      match $self.$it.parse_next($input.clone()) {
+        Ok((i, o)) => {
+          $input = i;
+          $res.$it = Some(o);
+          continue;
+        }
+        Err(ErrMode::Backtrack(e)) => {
+          $err = Some(match $err {
+            Some(err) => err.or(e),
+            None => e,
+          });
+        }
+        Err(e) => return Err(e),
+      };
+    }
+    succ!($it, permutation_trait_inner!($self, $input, $res, $err, $($id)*));
+  );
+  ($it:tt, $self:expr, $input:ident, $res:expr, $err:expr,) => ();
+);
+
+permutation_trait!(
+  P1 O1 o1
+  P2 O2 o2
+  P3 O3 o3
+  P4 O4 o4
+  P5 O5 o5
+  P6 O6 o6
+  P7 O7 o7
+  P8 O8 o8
+  P9 O9 o9
+  P10 O10 o10
+  P11 O11 o11
+  P12 O12 o12
+  P13 O13 o13
+  P14 O14 o14
+  P15 O15 o15
+  P16 O16 o16
+  P17 O17 o17
+  P18 O18 o18
+  P19 O19 o19
+  P20 O20 o20
+  P21 O21 o21
+);
diff --git a/vendor/winnow/src/branch/tests.rs b/vendor/winnow/src/branch/tests.rs
new file mode 100644
index 000000000..80bc163ce
--- /dev/null
+++ b/vendor/winnow/src/branch/tests.rs
@@ -0,0 +1,180 @@
+use crate::branch::{alt, permutation};
+
+use crate::error::ErrMode;
+use crate::error::ErrorKind;
+use crate::error::Needed;
+use crate::IResult;
+use crate::Parser;
+use crate::Partial;
+#[cfg(feature = "alloc")]
+use crate::{
+    error::ParseError,
+    lib::std::{
+        fmt::Debug,
+        string::{String, ToString},
+    },
+};
+
+#[cfg(feature = "alloc")]
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ErrorStr(String);
+
+#[cfg(feature = "alloc")]
+impl From<u32> for ErrorStr {
+    fn from(i: u32) -> Self {
+        ErrorStr(format!("custom error code: {}", i))
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'a> From<&'a str> for ErrorStr {
+    fn from(i: &'a str) -> Self {
+        ErrorStr(format!("custom error message: {}", i))
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<I: Debug> ParseError<I> for ErrorStr {
+    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
+        ErrorStr(format!("custom error message: ({:?}, {:?})", input, kind))
+    }
+
+    fn append(self, input: I, kind: ErrorKind) -> Self {
+        ErrorStr(format!(
+            "custom error message: ({:?}, {:?}) - {:?}",
+            input, kind, self
+        ))
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn alt_test() {
+    fn work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
+        Ok((&b""[..], input))
+    }
+
+    #[allow(unused_variables)]
+    fn dont_work(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
+        Err(ErrMode::Backtrack(ErrorStr("abcd".to_string())))
+    }
+
+    fn work2(input: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
+        Ok((input, &b""[..]))
+    }
+
+    fn alt1(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
+        alt((dont_work, dont_work)).parse_next(i)
+    }
+    fn alt2(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
+        alt((dont_work, work)).parse_next(i)
+    }
+    fn alt3(i: &[u8]) -> IResult<&[u8], &[u8], ErrorStr> {
+        alt((dont_work, dont_work, work2, dont_work)).parse_next(i)
+    }
+    //named!(alt1, alt!(dont_work | dont_work));
+    //named!(alt2, alt!(dont_work | work));
+    //named!(alt3, alt!(dont_work | dont_work | work2 | dont_work));
+
+    let a = &b"abcd"[..];
+    assert_eq!(
+        alt1(a),
+        Err(ErrMode::Backtrack(error_node_position!(
+            a,
+            ErrorKind::Alt,
+            ErrorStr("abcd".to_string())
+        )))
+    );
+    assert_eq!(alt2(a), Ok((&b""[..], a)));
+    assert_eq!(alt3(a), Ok((a, &b""[..])));
+
+    fn alt4(i: &[u8]) -> IResult<&[u8], &[u8]> {
+        alt(("abcd", "efgh")).parse_next(i)
+    }
+    let b = &b"efgh"[..];
+    assert_eq!(alt4(a), Ok((&b""[..], a)));
+    assert_eq!(alt4(b), Ok((&b""[..], b)));
+}
+
+#[test]
+fn alt_incomplete() {
+    fn alt1(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        alt(("a", "bc", "def")).parse_next(i)
+    }
+
+    let a = &b""[..];
+    assert_eq!(
+        alt1(Partial::new(a)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    let a = &b"b"[..];
+    assert_eq!(
+        alt1(Partial::new(a)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    let a = &b"bcd"[..];
+    assert_eq!(
+        alt1(Partial::new(a)),
+        Ok((Partial::new(&b"d"[..]), &b"bc"[..]))
+    );
+    let a = &b"cde"[..];
+    assert_eq!(
+        alt1(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(a),
+            ErrorKind::Tag
+        )))
+    );
+    let a = &b"de"[..];
+    assert_eq!(
+        alt1(Partial::new(a)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    let a = &b"defg"[..];
+    assert_eq!(
+        alt1(Partial::new(a)),
+        Ok((Partial::new(&b"g"[..]), &b"def"[..]))
+    );
+}
+
+#[test]
+fn permutation_test() {
+    #[allow(clippy::type_complexity)]
+    fn perm(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8], &[u8])> {
+        permutation(("abcd", "efg", "hi")).parse_next(i)
+    }
+
+    let expected = (&b"abcd"[..], &b"efg"[..], &b"hi"[..]);
+
+    let a = &b"abcdefghijk"[..];
+    assert_eq!(
+        perm(Partial::new(a)),
+        Ok((Partial::new(&b"jk"[..]), expected))
+    );
+    let b = &b"efgabcdhijk"[..];
+    assert_eq!(
+        perm(Partial::new(b)),
+        Ok((Partial::new(&b"jk"[..]), expected))
+    );
+    let c = &b"hiefgabcdjk"[..];
+    assert_eq!(
+        perm(Partial::new(c)),
+        Ok((Partial::new(&b"jk"[..]), expected))
+    );
+
+    let d = &b"efgxyzabcdefghi"[..];
+    assert_eq!(
+        perm(Partial::new(d)),
+        Err(ErrMode::Backtrack(error_node_position!(
+            Partial::new(&b"efgxyzabcdefghi"[..]),
+            ErrorKind::Alt,
+            error_position!(Partial::new(&b"xyzabcdefghi"[..]), ErrorKind::Tag)
+        )))
+    );
+
+    let e = &b"efgabc"[..];
+    assert_eq!(
+        perm(Partial::new(e)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+}
diff --git a/vendor/winnow/src/bytes/mod.rs b/vendor/winnow/src/bytes/mod.rs
new file mode 100644
index 000000000..0bf8681b7
--- /dev/null
+++ b/vendor/winnow/src/bytes/mod.rs
@@ -0,0 +1,1167 @@
+//! Parsers recognizing bytes streams
+
+#[cfg(test)]
+mod tests;
+
+use crate::error::ErrMode;
+use crate::error::ErrorKind;
+use crate::error::Needed;
+use crate::error::ParseError;
+use crate::lib::std::result::Result::Ok;
+use crate::stream::{
+    split_at_offset1_complete, split_at_offset1_partial, split_at_offset_complete,
+    split_at_offset_partial, Compare, CompareResult, ContainsToken, FindSlice, SliceLen, Stream,
+};
+use crate::stream::{StreamIsPartial, ToUsize};
+use crate::trace::trace;
+use crate::IResult;
+use crate::Parser;
+
+/// Matches one token
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{bytes::any, error::ErrMode, error::{Error, ErrorKind}};
+/// # use winnow::prelude::*;
+/// fn parser(input: &str) -> IResult<&str, char> {
+///     any.parse_next(input)
+/// }
+///
+/// assert_eq!(parser("abc"), Ok(("bc",'a')));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Token))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{bytes::any, error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// assert_eq!(any::<_, Error<_>>.parse_next(Partial::new("abc")), Ok((Partial::new("bc"),'a')));
+/// assert_eq!(any::<_, Error<_>>.parse_next(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+#[doc(alias = "token")]
+pub fn any<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Token, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+{
+    trace("any", move |input: I| {
+        if input.is_partial() {
+            streaming_any(input)
+        } else {
+            complete_any(input)
+        }
+    })
+    .parse_next(input)
+}
+
+pub(crate) fn streaming_any<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Token, E>
+where
+    I: Stream,
+{
+    input
+        .next_token()
+        .ok_or_else(|| ErrMode::Incomplete(Needed::new(1)))
+}
+
+pub(crate) fn complete_any<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Token, E>
+where
+    I: Stream,
+{
+    input
+        .next_token()
+        .ok_or_else(|| ErrMode::from_error_kind(input, ErrorKind::Token))
+}
+
+/// Recognizes a literal
+///
+/// The input data will be compared to the tag combinator's argument and will return the part of
+/// the input that matches the argument
+///
+/// It will return `Err(ErrMode::Backtrack(Error::new(_, ErrorKind::Tag)))` if the input doesn't match the pattern
+///
+/// **Note:** [`Parser`][crate::Parser] is implemented for strings and byte strings as a convenience (complete
+/// only)
+///
+/// # Example
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, &str> {
+///   "Hello".parse_next(s)
+/// }
+///
+/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
+/// assert_eq!(parser("Something"), Err(ErrMode::Backtrack(Error::new("Something", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// ```
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::Partial;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   "Hello".parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new("Hello, World!")), Ok((Partial::new(", World!"), "Hello")));
+/// assert_eq!(parser(Partial::new("Something")), Err(ErrMode::Backtrack(Error::new(Partial::new("Something"), ErrorKind::Tag))));
+/// assert_eq!(parser(Partial::new("S")), Err(ErrMode::Backtrack(Error::new(Partial::new("S"), ErrorKind::Tag))));
+/// assert_eq!(parser(Partial::new("H")), Err(ErrMode::Incomplete(Needed::new(4))));
+/// ```
+#[inline(always)]
+#[doc(alias = "literal")]
+#[doc(alias = "bytes")]
+#[doc(alias = "just")]
+pub fn tag<T, I, Error: ParseError<I>>(tag: T) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream + Compare<T>,
+    T: SliceLen + Clone,
+{
+    trace("tag", move |i: I| {
+        let t = tag.clone();
+        if i.is_partial() {
+            streaming_tag_internal(i, t)
+        } else {
+            complete_tag_internal(i, t)
+        }
+    })
+}
+
+pub(crate) fn streaming_tag_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + Compare<T>,
+    T: SliceLen,
+{
+    let tag_len = t.slice_len();
+    match i.compare(t) {
+        CompareResult::Ok => Ok(i.next_slice(tag_len)),
+        CompareResult::Incomplete => {
+            Err(ErrMode::Incomplete(Needed::new(tag_len - i.eof_offset())))
+        }
+        CompareResult::Error => {
+            let e: ErrorKind = ErrorKind::Tag;
+            Err(ErrMode::from_error_kind(i, e))
+        }
+    }
+}
+
+pub(crate) fn complete_tag_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + Compare<T>,
+    T: SliceLen,
+{
+    let tag_len = t.slice_len();
+    match i.compare(t) {
+        CompareResult::Ok => Ok(i.next_slice(tag_len)),
+        CompareResult::Incomplete | CompareResult::Error => {
+            let e: ErrorKind = ErrorKind::Tag;
+            Err(ErrMode::from_error_kind(i, e))
+        }
+    }
+}
+
+/// Recognizes a case insensitive literal.
+///
+/// The input data will be compared to the tag combinator's argument and will return the part of
+/// the input that matches the argument with no regard to case.
+///
+/// It will return `Err(ErrMode::Backtrack(Error::new(_, ErrorKind::Tag)))` if the input doesn't match the pattern.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::tag_no_case;
+///
+/// fn parser(s: &str) -> IResult<&str, &str> {
+///   tag_no_case("hello").parse_next(s)
+/// }
+///
+/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
+/// assert_eq!(parser("hello, World!"), Ok((", World!", "hello")));
+/// assert_eq!(parser("HeLlO, World!"), Ok((", World!", "HeLlO")));
+/// assert_eq!(parser("Something"), Err(ErrMode::Backtrack(Error::new("Something", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::tag_no_case;
+///
+/// fn parser(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   tag_no_case("hello").parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new("Hello, World!")), Ok((Partial::new(", World!"), "Hello")));
+/// assert_eq!(parser(Partial::new("hello, World!")), Ok((Partial::new(", World!"), "hello")));
+/// assert_eq!(parser(Partial::new("HeLlO, World!")), Ok((Partial::new(", World!"), "HeLlO")));
+/// assert_eq!(parser(Partial::new("Something")), Err(ErrMode::Backtrack(Error::new(Partial::new("Something"), ErrorKind::Tag))));
+/// assert_eq!(parser(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(5))));
+/// ```
+#[inline(always)]
+#[doc(alias = "literal")]
+#[doc(alias = "bytes")]
+#[doc(alias = "just")]
+pub fn tag_no_case<T, I, Error: ParseError<I>>(
+    tag: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream + Compare<T>,
+    T: SliceLen + Clone,
+{
+    trace("tag_no_case", move |i: I| {
+        let t = tag.clone();
+        if i.is_partial() {
+            streaming_tag_no_case_internal(i, t)
+        } else {
+            complete_tag_no_case_internal(i, t)
+        }
+    })
+}
+
+pub(crate) fn streaming_tag_no_case_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + Compare<T>,
+    T: SliceLen,
+{
+    let tag_len = t.slice_len();
+
+    match (i).compare_no_case(t) {
+        CompareResult::Ok => Ok(i.next_slice(tag_len)),
+        CompareResult::Incomplete => {
+            Err(ErrMode::Incomplete(Needed::new(tag_len - i.eof_offset())))
+        }
+        CompareResult::Error => {
+            let e: ErrorKind = ErrorKind::Tag;
+            Err(ErrMode::from_error_kind(i, e))
+        }
+    }
+}
+
+pub(crate) fn complete_tag_no_case_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + Compare<T>,
+    T: SliceLen,
+{
+    let tag_len = t.slice_len();
+
+    match (i).compare_no_case(t) {
+        CompareResult::Ok => Ok(i.next_slice(tag_len)),
+        CompareResult::Incomplete | CompareResult::Error => {
+            let e: ErrorKind = ErrorKind::Tag;
+            Err(ErrMode::from_error_kind(i, e))
+        }
+    }
+}
+
+/// Recognize a token that matches the [pattern][ContainsToken]
+///
+/// **Note:** [`Parser`][crate::Parser] is implemented as a convenience (complete
+/// only) for
+/// - `u8`
+/// - `char`
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::bytes::one_of;
+/// assert_eq!(one_of::<_, _, Error<_>>("abc").parse_next("b"), Ok(("", 'b')));
+/// assert_eq!(one_of::<_, _, Error<_>>("a").parse_next("bc"), Err(ErrMode::Backtrack(Error::new("bc", ErrorKind::Verify))));
+/// assert_eq!(one_of::<_, _, Error<_>>("a").parse_next(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Token))));
+///
+/// fn parser_fn(i: &str) -> IResult<&str, char> {
+///     one_of(|c| c == 'a' || c == 'b').parse_next(i)
+/// }
+/// assert_eq!(parser_fn("abc"), Ok(("bc", 'a')));
+/// assert_eq!(parser_fn("cd"), Err(ErrMode::Backtrack(Error::new("cd", ErrorKind::Verify))));
+/// assert_eq!(parser_fn(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Token))));
+/// ```
+///
+/// ```
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::bytes::one_of;
+/// assert_eq!(one_of::<_, _, Error<_>>("abc").parse_next(Partial::new("b")), Ok((Partial::new(""), 'b')));
+/// assert_eq!(one_of::<_, _, Error<_>>("a").parse_next(Partial::new("bc")), Err(ErrMode::Backtrack(Error::new(Partial::new("bc"), ErrorKind::Verify))));
+/// assert_eq!(one_of::<_, _, Error<_>>("a").parse_next(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+///
+/// fn parser_fn(i: Partial<&str>) -> IResult<Partial<&str>, char> {
+///     one_of(|c| c == 'a' || c == 'b').parse_next(i)
+/// }
+/// assert_eq!(parser_fn(Partial::new("abc")), Ok((Partial::new("bc"), 'a')));
+/// assert_eq!(parser_fn(Partial::new("cd")), Err(ErrMode::Backtrack(Error::new(Partial::new("cd"), ErrorKind::Verify))));
+/// assert_eq!(parser_fn(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+#[doc(alias = "char")]
+#[doc(alias = "token")]
+#[doc(alias = "satisfy")]
+pub fn one_of<I, T, Error: ParseError<I>>(list: T) -> impl Parser<I, <I as Stream>::Token, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: Copy,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    trace(
+        "one_of",
+        any.verify(move |t: &<I as Stream>::Token| list.contains_token(*t)),
+    )
+}
+
+/// Recognize a token that does not match the [pattern][ContainsToken]
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::prelude::*;
+/// # use winnow::bytes::none_of;
+/// assert_eq!(none_of::<_, _, Error<_>>("abc").parse_next("z"), Ok(("", 'z')));
+/// assert_eq!(none_of::<_, _, Error<_>>("ab").parse_next("a"), Err(ErrMode::Backtrack(Error::new("a", ErrorKind::Verify))));
+/// assert_eq!(none_of::<_, _, Error<_>>("a").parse_next(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Token))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// # use winnow::bytes::none_of;
+/// assert_eq!(none_of::<_, _, Error<_>>("abc").parse_next(Partial::new("z")), Ok((Partial::new(""), 'z')));
+/// assert_eq!(none_of::<_, _, Error<_>>("ab").parse_next(Partial::new("a")), Err(ErrMode::Backtrack(Error::new(Partial::new("a"), ErrorKind::Verify))));
+/// assert_eq!(none_of::<_, _, Error<_>>("a").parse_next(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn none_of<I, T, Error: ParseError<I>>(list: T) -> impl Parser<I, <I as Stream>::Token, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: Copy,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    trace(
+        "none_of",
+        any.verify(move |t: &<I as Stream>::Token| !list.contains_token(*t)),
+    )
+}
+
+/// Recognize the longest input slice (if any) that matches the [pattern][ContainsToken]
+///
+/// *Partial version*: will return a `ErrMode::Incomplete(Needed::new(1))` if the pattern reaches the end of the input.
+///
+/// To recognize a series of tokens, use [`many0`][crate::multi::many0] to [`Accumulate`][crate::stream::Accumulate] into a `()` and then [`Parser::recognize`][crate::Parser::recognize].
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take_while0;
+/// use winnow::stream::AsChar;
+///
+/// fn alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   take_while0(AsChar::is_alpha).parse_next(s)
+/// }
+///
+/// assert_eq!(alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
+/// assert_eq!(alpha(b"12345"), Ok((&b"12345"[..], &b""[..])));
+/// assert_eq!(alpha(b"latin"), Ok((&b""[..], &b"latin"[..])));
+/// assert_eq!(alpha(b""), Ok((&b""[..], &b""[..])));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::take_while0;
+/// use winnow::stream::AsChar;
+///
+/// fn alpha(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+///   take_while0(AsChar::is_alpha).parse_next(s)
+/// }
+///
+/// assert_eq!(alpha(Partial::new(b"latin123")), Ok((Partial::new(&b"123"[..]), &b"latin"[..])));
+/// assert_eq!(alpha(Partial::new(b"12345")), Ok((Partial::new(&b"12345"[..]), &b""[..])));
+/// assert_eq!(alpha(Partial::new(b"latin")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(alpha(Partial::new(b"")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn take_while0<T, I, Error: ParseError<I>>(
+    list: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    trace("take_while0", move |i: I| {
+        if i.is_partial() {
+            streaming_take_while_internal(i, &list)
+        } else {
+            complete_take_while_internal(i, &list)
+        }
+    })
+}
+
+pub(crate) fn streaming_take_while_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    split_at_offset_partial(&i, |c| !list.contains_token(c))
+}
+
+pub(crate) fn complete_take_while_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    split_at_offset_complete(&i, |c| !list.contains_token(c))
+}
+
+/// Recognize the longest (at least 1) input slice that matches the [pattern][ContainsToken]
+///
+/// It will return an `Err(ErrMode::Backtrack(Error::new(_, ErrorKind::Slice)))` if the pattern wasn't met.
+///
+/// *Partial version* will return a `ErrMode::Incomplete(Needed::new(1))` or if the pattern reaches the end of the input.
+///
+/// To recognize a series of tokens, use [`many1`][crate::multi::many1] to [`Accumulate`][crate::stream::Accumulate] into a `()` and then [`Parser::recognize`][crate::Parser::recognize].
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take_while1;
+/// use winnow::stream::AsChar;
+///
+/// fn alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   take_while1(AsChar::is_alpha).parse_next(s)
+/// }
+///
+/// assert_eq!(alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
+/// assert_eq!(alpha(b"latin"), Ok((&b""[..], &b"latin"[..])));
+/// assert_eq!(alpha(b"12345"), Err(ErrMode::Backtrack(Error::new(&b"12345"[..], ErrorKind::Slice))));
+///
+/// fn hex(s: &str) -> IResult<&str, &str> {
+///   take_while1("1234567890ABCDEF").parse_next(s)
+/// }
+///
+/// assert_eq!(hex("123 and voila"), Ok((" and voila", "123")));
+/// assert_eq!(hex("DEADBEEF and others"), Ok((" and others", "DEADBEEF")));
+/// assert_eq!(hex("BADBABEsomething"), Ok(("something", "BADBABE")));
+/// assert_eq!(hex("D15EA5E"), Ok(("", "D15EA5E")));
+/// assert_eq!(hex(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::take_while1;
+/// use winnow::stream::AsChar;
+///
+/// fn alpha(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+///   take_while1(AsChar::is_alpha).parse_next(s)
+/// }
+///
+/// assert_eq!(alpha(Partial::new(b"latin123")), Ok((Partial::new(&b"123"[..]), &b"latin"[..])));
+/// assert_eq!(alpha(Partial::new(b"latin")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(alpha(Partial::new(b"12345")), Err(ErrMode::Backtrack(Error::new(Partial::new(&b"12345"[..]), ErrorKind::Slice))));
+///
+/// fn hex(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   take_while1("1234567890ABCDEF").parse_next(s)
+/// }
+///
+/// assert_eq!(hex(Partial::new("123 and voila")), Ok((Partial::new(" and voila"), "123")));
+/// assert_eq!(hex(Partial::new("DEADBEEF and others")), Ok((Partial::new(" and others"), "DEADBEEF")));
+/// assert_eq!(hex(Partial::new("BADBABEsomething")), Ok((Partial::new("something"), "BADBABE")));
+/// assert_eq!(hex(Partial::new("D15EA5E")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(hex(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+#[doc(alias = "is_a")]
+pub fn take_while1<T, I, Error: ParseError<I>>(
+    list: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    trace("take_while1", move |i: I| {
+        if i.is_partial() {
+            streaming_take_while1_internal(i, &list)
+        } else {
+            complete_take_while1_internal(i, &list)
+        }
+    })
+}
+
+pub(crate) fn streaming_take_while1_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    let e: ErrorKind = ErrorKind::Slice;
+    split_at_offset1_partial(&i, |c| !list.contains_token(c), e)
+}
+
+pub(crate) fn complete_take_while1_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    let e: ErrorKind = ErrorKind::Slice;
+    split_at_offset1_complete(&i, |c| !list.contains_token(c), e)
+}
+
+/// Recognize the longest (m <= len <= n) input slice that matches the [pattern][ContainsToken]
+///
+/// It will return an `ErrMode::Backtrack(Error::new(_, ErrorKind::Slice))` if the pattern wasn't met or is out
+/// of range (m <= len <= n).
+///
+/// *Partial version* will return a `ErrMode::Incomplete(Needed::new(1))`  if the pattern reaches the end of the input or is too short.
+///
+/// To recognize a series of tokens, use [`many_m_n`][crate::multi::many_m_n] to [`Accumulate`][crate::stream::Accumulate] into a `()` and then [`Parser::recognize`][crate::Parser::recognize].
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take_while_m_n;
+/// use winnow::stream::AsChar;
+///
+/// fn short_alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   take_while_m_n(3, 6, AsChar::is_alpha).parse_next(s)
+/// }
+///
+/// assert_eq!(short_alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
+/// assert_eq!(short_alpha(b"lengthy"), Ok((&b"y"[..], &b"length"[..])));
+/// assert_eq!(short_alpha(b"latin"), Ok((&b""[..], &b"latin"[..])));
+/// assert_eq!(short_alpha(b"ed"), Err(ErrMode::Backtrack(Error::new(&b"ed"[..], ErrorKind::Slice))));
+/// assert_eq!(short_alpha(b"12345"), Err(ErrMode::Backtrack(Error::new(&b"12345"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::take_while_m_n;
+/// use winnow::stream::AsChar;
+///
+/// fn short_alpha(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+///   take_while_m_n(3, 6, AsChar::is_alpha).parse_next(s)
+/// }
+///
+/// assert_eq!(short_alpha(Partial::new(b"latin123")), Ok((Partial::new(&b"123"[..]), &b"latin"[..])));
+/// assert_eq!(short_alpha(Partial::new(b"lengthy")), Ok((Partial::new(&b"y"[..]), &b"length"[..])));
+/// assert_eq!(short_alpha(Partial::new(b"latin")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(short_alpha(Partial::new(b"ed")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(short_alpha(Partial::new(b"12345")), Err(ErrMode::Backtrack(Error::new(Partial::new(&b"12345"[..]), ErrorKind::Slice))));
+/// ```
+#[inline(always)]
+pub fn take_while_m_n<T, I, Error: ParseError<I>>(
+    m: usize,
+    n: usize,
+    list: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    trace("take_while_m_n", move |i: I| {
+        if i.is_partial() {
+            streaming_take_while_m_n_internal(i, m, n, &list)
+        } else {
+            complete_take_while_m_n_internal(i, m, n, &list)
+        }
+    })
+}
+
+pub(crate) fn streaming_take_while_m_n_internal<T, I, Error: ParseError<I>>(
+    input: I,
+    m: usize,
+    n: usize,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    if n < m {
+        return Err(ErrMode::assert(input, "`m` should be <= `n`"));
+    }
+
+    let mut final_count = 0;
+    for (processed, (offset, token)) in input.iter_offsets().enumerate() {
+        if !list.contains_token(token) {
+            if processed < m {
+                return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
+            } else {
+                return Ok(input.next_slice(offset));
+            }
+        } else {
+            if processed == n {
+                return Ok(input.next_slice(offset));
+            }
+            final_count = processed + 1;
+        }
+    }
+
+    if final_count == n {
+        Ok(input.next_slice(input.eof_offset()))
+    } else {
+        let needed = if m > input.eof_offset() {
+            m - input.eof_offset()
+        } else {
+            1
+        };
+        Err(ErrMode::Incomplete(Needed::new(needed)))
+    }
+}
+
+pub(crate) fn complete_take_while_m_n_internal<T, I, Error: ParseError<I>>(
+    input: I,
+    m: usize,
+    n: usize,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    if n < m {
+        return Err(ErrMode::assert(input, "`m` should be <= `n`"));
+    }
+
+    let mut final_count = 0;
+    for (processed, (offset, token)) in input.iter_offsets().enumerate() {
+        if !list.contains_token(token) {
+            if processed < m {
+                return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
+            } else {
+                return Ok(input.next_slice(offset));
+            }
+        } else {
+            if processed == n {
+                return Ok(input.next_slice(offset));
+            }
+            final_count = processed + 1;
+        }
+    }
+
+    if m <= final_count {
+        Ok(input.next_slice(input.eof_offset()))
+    } else {
+        Err(ErrMode::from_error_kind(input, ErrorKind::Slice))
+    }
+}
+
+/// Recognize the longest input slice (if any) till a [pattern][ContainsToken] is met.
+///
+/// *Partial version* will return a `ErrMode::Incomplete(Needed::new(1))` if the match reaches the
+/// end of input or if there was not match.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take_till0;
+///
+/// fn till_colon(s: &str) -> IResult<&str, &str> {
+///   take_till0(|c| c == ':').parse_next(s)
+/// }
+///
+/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
+/// assert_eq!(till_colon(":empty matched"), Ok((":empty matched", ""))); //allowed
+/// assert_eq!(till_colon("12345"), Ok(("", "12345")));
+/// assert_eq!(till_colon(""), Ok(("", "")));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::take_till0;
+///
+/// fn till_colon(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   take_till0(|c| c == ':').parse_next(s)
+/// }
+///
+/// assert_eq!(till_colon(Partial::new("latin:123")), Ok((Partial::new(":123"), "latin")));
+/// assert_eq!(till_colon(Partial::new(":empty matched")), Ok((Partial::new(":empty matched"), ""))); //allowed
+/// assert_eq!(till_colon(Partial::new("12345")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(till_colon(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn take_till0<T, I, Error: ParseError<I>>(
+    list: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    trace("take_till0", move |i: I| {
+        if i.is_partial() {
+            streaming_take_till_internal(i, &list)
+        } else {
+            complete_take_till_internal(i, &list)
+        }
+    })
+}
+
+pub(crate) fn streaming_take_till_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    split_at_offset_partial(&i, |c| list.contains_token(c))
+}
+
+pub(crate) fn complete_take_till_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    split_at_offset_complete(&i, |c| list.contains_token(c))
+}
+
+/// Recognize the longest (at least 1) input slice till a [pattern][ContainsToken] is met.
+///
+/// It will return `Err(ErrMode::Backtrack(Error::new(_, ErrorKind::Slice)))` if the input is empty or the
+/// predicate matches the first input.
+///
+/// *Partial version* will return a `ErrMode::Incomplete(Needed::new(1))` if the match reaches the
+/// end of input or if there was not match.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take_till1;
+///
+/// fn till_colon(s: &str) -> IResult<&str, &str> {
+///   take_till1(|c| c == ':').parse_next(s)
+/// }
+///
+/// assert_eq!(till_colon("latin:123"), Ok((":123", "latin")));
+/// assert_eq!(till_colon(":empty matched"), Err(ErrMode::Backtrack(Error::new(":empty matched", ErrorKind::Slice))));
+/// assert_eq!(till_colon("12345"), Ok(("", "12345")));
+/// assert_eq!(till_colon(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+///
+/// fn not_space(s: &str) -> IResult<&str, &str> {
+///   take_till1(" \t\r\n").parse_next(s)
+/// }
+///
+/// assert_eq!(not_space("Hello, World!"), Ok((" World!", "Hello,")));
+/// assert_eq!(not_space("Sometimes\t"), Ok(("\t", "Sometimes")));
+/// assert_eq!(not_space("Nospace"), Ok(("", "Nospace")));
+/// assert_eq!(not_space(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::take_till1;
+///
+/// fn till_colon(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   take_till1(|c| c == ':').parse_next(s)
+/// }
+///
+/// assert_eq!(till_colon(Partial::new("latin:123")), Ok((Partial::new(":123"), "latin")));
+/// assert_eq!(till_colon(Partial::new(":empty matched")), Err(ErrMode::Backtrack(Error::new(Partial::new(":empty matched"), ErrorKind::Slice))));
+/// assert_eq!(till_colon(Partial::new("12345")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(till_colon(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+///
+/// fn not_space(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   take_till1(" \t\r\n").parse_next(s)
+/// }
+///
+/// assert_eq!(not_space(Partial::new("Hello, World!")), Ok((Partial::new(" World!"), "Hello,")));
+/// assert_eq!(not_space(Partial::new("Sometimes\t")), Ok((Partial::new("\t"), "Sometimes")));
+/// assert_eq!(not_space(Partial::new("Nospace")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(not_space(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+#[doc(alias = "is_not")]
+pub fn take_till1<T, I, Error: ParseError<I>>(
+    list: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    trace("take_till1", move |i: I| {
+        if i.is_partial() {
+            streaming_take_till1_internal(i, &list)
+        } else {
+            complete_take_till1_internal(i, &list)
+        }
+    })
+}
+
+pub(crate) fn streaming_take_till1_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    let e: ErrorKind = ErrorKind::Slice;
+    split_at_offset1_partial(&i, |c| list.contains_token(c), e)
+}
+
+pub(crate) fn complete_take_till1_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    list: &T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+    T: ContainsToken<<I as Stream>::Token>,
+{
+    let e: ErrorKind = ErrorKind::Slice;
+    split_at_offset1_complete(&i, |c| list.contains_token(c), e)
+}
+
+/// Recognize an input slice containing the first N input elements (I[..N]).
+///
+/// *Complete version*: It will return `Err(ErrMode::Backtrack(Error::new(_, ErrorKind::Slice)))` if the input is shorter than the argument.
+///
+/// *Partial version*: if the input has less than N elements, `take` will
+/// return a `ErrMode::Incomplete(Needed::new(M))` where M is the number of
+/// additional bytes the parser would need to succeed.
+/// It is well defined for `&[u8]` as the number of elements is the byte size,
+/// but for types like `&str`, we cannot know how many bytes correspond for
+/// the next few chars, so the result will be `ErrMode::Incomplete(Needed::Unknown)`
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take;
+///
+/// fn take6(s: &str) -> IResult<&str, &str> {
+///   take(6usize).parse_next(s)
+/// }
+///
+/// assert_eq!(take6("1234567"), Ok(("7", "123456")));
+/// assert_eq!(take6("things"), Ok(("", "things")));
+/// assert_eq!(take6("short"), Err(ErrMode::Backtrack(Error::new("short", ErrorKind::Slice))));
+/// assert_eq!(take6(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// The units that are taken will depend on the input type. For example, for a
+/// `&str` it will take a number of `char`'s, whereas for a `&[u8]` it will
+/// take that many `u8`'s:
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// use winnow::error::Error;
+/// use winnow::bytes::take;
+///
+/// assert_eq!(take::<_, _, Error<_>>(1usize).parse_next("💙"), Ok(("", "💙")));
+/// assert_eq!(take::<_, _, Error<_>>(1usize).parse_next("💙".as_bytes()), Ok((b"\x9F\x92\x99".as_ref(), b"\xF0".as_ref())));
+/// ```
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::Partial;
+/// use winnow::bytes::take;
+///
+/// fn take6(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   take(6usize).parse_next(s)
+/// }
+///
+/// assert_eq!(take6(Partial::new("1234567")), Ok((Partial::new("7"), "123456")));
+/// assert_eq!(take6(Partial::new("things")), Ok((Partial::new(""), "things")));
+/// // `Unknown` as we don't know the number of bytes that `count` corresponds to
+/// assert_eq!(take6(Partial::new("short")), Err(ErrMode::Incomplete(Needed::Unknown)));
+/// ```
+#[inline(always)]
+pub fn take<C, I, Error: ParseError<I>>(count: C) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    C: ToUsize,
+{
+    let c = count.to_usize();
+    trace("take", move |i: I| {
+        if i.is_partial() {
+            streaming_take_internal(i, c)
+        } else {
+            complete_take_internal(i, c)
+        }
+    })
+}
+
+pub(crate) fn streaming_take_internal<I, Error: ParseError<I>>(
+    i: I,
+    c: usize,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+{
+    match i.offset_at(c) {
+        Ok(offset) => Ok(i.next_slice(offset)),
+        Err(i) => Err(ErrMode::Incomplete(i)),
+    }
+}
+
+pub(crate) fn complete_take_internal<I, Error: ParseError<I>>(
+    i: I,
+    c: usize,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream,
+{
+    match i.offset_at(c) {
+        Ok(offset) => Ok(i.next_slice(offset)),
+        Err(_needed) => Err(ErrMode::from_error_kind(i, ErrorKind::Slice)),
+    }
+}
+
+/// Recognize the input slice up to the first occurrence of the literal.
+///
+/// It doesn't consume the pattern.
+///
+/// *Complete version*: It will return `Err(ErrMode::Backtrack(Error::new(_, ErrorKind::Slice)))`
+/// if the pattern wasn't met.
+///
+/// *Partial version*: will return a `ErrMode::Incomplete(Needed::new(N))` if the input doesn't
+/// contain the pattern or if the input is smaller than the pattern.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take_until0;
+///
+/// fn until_eof(s: &str) -> IResult<&str, &str> {
+///   take_until0("eof").parse_next(s)
+/// }
+///
+/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
+/// assert_eq!(until_eof("hello, world"), Err(ErrMode::Backtrack(Error::new("hello, world", ErrorKind::Slice))));
+/// assert_eq!(until_eof(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::take_until0;
+///
+/// fn until_eof(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   take_until0("eof").parse_next(s)
+/// }
+///
+/// assert_eq!(until_eof(Partial::new("hello, worldeof")), Ok((Partial::new("eof"), "hello, world")));
+/// assert_eq!(until_eof(Partial::new("hello, world")), Err(ErrMode::Incomplete(Needed::Unknown)));
+/// assert_eq!(until_eof(Partial::new("hello, worldeo")), Err(ErrMode::Incomplete(Needed::Unknown)));
+/// assert_eq!(until_eof(Partial::new("1eof2eof")), Ok((Partial::new("eof2eof"), "1")));
+/// ```
+#[inline(always)]
+pub fn take_until0<T, I, Error: ParseError<I>>(
+    tag: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream + FindSlice<T>,
+    T: SliceLen + Clone,
+{
+    trace("take_until0", move |i: I| {
+        if i.is_partial() {
+            streaming_take_until_internal(i, tag.clone())
+        } else {
+            complete_take_until_internal(i, tag.clone())
+        }
+    })
+}
+
+pub(crate) fn streaming_take_until_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + FindSlice<T>,
+    T: SliceLen,
+{
+    match i.find_slice(t) {
+        Some(offset) => Ok(i.next_slice(offset)),
+        None => Err(ErrMode::Incomplete(Needed::Unknown)),
+    }
+}
+
+pub(crate) fn complete_take_until_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + FindSlice<T>,
+    T: SliceLen,
+{
+    match i.find_slice(t) {
+        Some(offset) => Ok(i.next_slice(offset)),
+        None => Err(ErrMode::from_error_kind(i, ErrorKind::Slice)),
+    }
+}
+
+/// Recognize the non empty input slice up to the first occurrence of the literal.
+///
+/// It doesn't consume the pattern.
+///
+/// *Complete version*: It will return `Err(ErrMode::Backtrack(Error::new(_, ErrorKind::Slice)))`
+/// if the pattern wasn't met.
+///
+/// *Partial version*: will return a `ErrMode::Incomplete(Needed::new(N))` if the input doesn't
+/// contain the pattern or if the input is smaller than the pattern.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::bytes::take_until1;
+///
+/// fn until_eof(s: &str) -> IResult<&str, &str> {
+///   take_until1("eof").parse_next(s)
+/// }
+///
+/// assert_eq!(until_eof("hello, worldeof"), Ok(("eof", "hello, world")));
+/// assert_eq!(until_eof("hello, world"), Err(ErrMode::Backtrack(Error::new("hello, world", ErrorKind::Slice))));
+/// assert_eq!(until_eof(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// assert_eq!(until_eof("1eof2eof"), Ok(("eof2eof", "1")));
+/// assert_eq!(until_eof("eof"), Err(ErrMode::Backtrack(Error::new("eof", ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::bytes::take_until1;
+///
+/// fn until_eof(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   take_until1("eof").parse_next(s)
+/// }
+///
+/// assert_eq!(until_eof(Partial::new("hello, worldeof")), Ok((Partial::new("eof"), "hello, world")));
+/// assert_eq!(until_eof(Partial::new("hello, world")), Err(ErrMode::Incomplete(Needed::Unknown)));
+/// assert_eq!(until_eof(Partial::new("hello, worldeo")), Err(ErrMode::Incomplete(Needed::Unknown)));
+/// assert_eq!(until_eof(Partial::new("1eof2eof")), Ok((Partial::new("eof2eof"), "1")));
+/// assert_eq!(until_eof(Partial::new("eof")),  Err(ErrMode::Backtrack(Error::new(Partial::new("eof"), ErrorKind::Slice))));
+/// ```
+#[inline(always)]
+pub fn take_until1<T, I, Error: ParseError<I>>(
+    tag: T,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream + FindSlice<T>,
+    T: SliceLen + Clone,
+{
+    trace("take_until1", move |i: I| {
+        if i.is_partial() {
+            streaming_take_until1_internal(i, tag.clone())
+        } else {
+            complete_take_until1_internal(i, tag.clone())
+        }
+    })
+}
+
+pub(crate) fn streaming_take_until1_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + FindSlice<T>,
+    T: SliceLen,
+{
+    match i.find_slice(t) {
+        None => Err(ErrMode::Incomplete(Needed::Unknown)),
+        Some(0) => Err(ErrMode::from_error_kind(i, ErrorKind::Slice)),
+        Some(offset) => Ok(i.next_slice(offset)),
+    }
+}
+
+pub(crate) fn complete_take_until1_internal<T, I, Error: ParseError<I>>(
+    i: I,
+    t: T,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + FindSlice<T>,
+    T: SliceLen,
+{
+    match i.find_slice(t) {
+        None | Some(0) => Err(ErrMode::from_error_kind(i, ErrorKind::Slice)),
+        Some(offset) => Ok(i.next_slice(offset)),
+    }
+}
diff --git a/vendor/winnow/src/bytes/tests.rs b/vendor/winnow/src/bytes/tests.rs
new file mode 100644
index 000000000..c2a1ceefd
--- /dev/null
+++ b/vendor/winnow/src/bytes/tests.rs
@@ -0,0 +1,701 @@
+use super::*;
+
+#[cfg(feature = "std")]
+use proptest::prelude::*;
+
+use crate::bytes::tag;
+use crate::error::ErrMode;
+use crate::error::Error;
+use crate::error::ErrorKind;
+use crate::error::Needed;
+use crate::multi::length_data;
+use crate::sequence::delimited;
+use crate::stream::AsChar;
+use crate::IResult;
+use crate::Parser;
+use crate::Partial;
+
+#[test]
+fn complete_take_while_m_n_utf8_all_matching() {
+    let result: IResult<&str, &str> =
+        take_while_m_n(1, 4, |c: char| c.is_alphabetic()).parse_next("øn");
+    assert_eq!(result, Ok(("", "øn")));
+}
+
+#[test]
+fn complete_take_while_m_n_utf8_all_matching_substring() {
+    let result: IResult<&str, &str> =
+        take_while_m_n(1, 1, |c: char| c.is_alphabetic()).parse_next("øn");
+    assert_eq!(result, Ok(("n", "ø")));
+}
+
+#[cfg(feature = "std")]
+fn model_complete_take_while_m_n(
+    m: usize,
+    n: usize,
+    valid: usize,
+    input: &str,
+) -> IResult<&str, &str> {
+    if n < m {
+        Err(crate::error::ErrMode::from_error_kind(
+            input,
+            crate::error::ErrorKind::Slice,
+        ))
+    } else if m <= valid {
+        let offset = n.min(valid);
+        Ok((&input[offset..], &input[0..offset]))
+    } else {
+        Err(crate::error::ErrMode::from_error_kind(
+            input,
+            crate::error::ErrorKind::Slice,
+        ))
+    }
+}
+
+#[cfg(feature = "std")]
+proptest! {
+  #[test]
+  #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+  fn complete_take_while_m_n_bounds(m in 0..20usize, n in 0..20usize, valid in 0..20usize, invalid in 0..20usize) {
+      let input = format!("{:a<valid$}{:b<invalid$}", "", "", valid=valid, invalid=invalid);
+      let expected = model_complete_take_while_m_n(m, n, valid, &input);
+      if m <= n {
+          let actual = take_while_m_n(m, n, |c: char| c == 'a').parse_next(input.as_str());
+          assert_eq!(expected, actual);
+      }
+  }
+}
+
+#[test]
+fn partial_any_str() {
+    use super::any;
+    assert_eq!(
+        any::<_, Error<Partial<&str>>>(Partial::new("Ә")),
+        Ok((Partial::new(""), 'Ә'))
+    );
+}
+
+#[test]
+fn partial_one_of_test() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+        one_of("ab").parse_next(i)
+    }
+
+    let a = &b"abcd"[..];
+    assert_eq!(f(Partial::new(a)), Ok((Partial::new(&b"bcd"[..]), b'a')));
+
+    let b = &b"cde"[..];
+    assert_eq!(
+        f(Partial::new(b)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(b),
+            ErrorKind::Verify
+        )))
+    );
+
+    fn utf8(i: Partial<&str>) -> IResult<Partial<&str>, char> {
+        one_of("+\u{FF0B}").parse_next(i)
+    }
+
+    assert!(utf8(Partial::new("+")).is_ok());
+    assert!(utf8(Partial::new("\u{FF0B}")).is_ok());
+}
+
+#[test]
+fn char_byteslice() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+        'c'.parse_next(i)
+    }
+
+    let a = &b"abcd"[..];
+    assert_eq!(
+        f(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(a),
+            ErrorKind::Verify
+        )))
+    );
+
+    let b = &b"cde"[..];
+    assert_eq!(f(Partial::new(b)), Ok((Partial::new(&b"de"[..]), b'c')));
+}
+
+#[test]
+fn char_str() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, char> {
+        'c'.parse_next(i)
+    }
+
+    let a = "abcd";
+    assert_eq!(
+        f(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(a),
+            ErrorKind::Verify
+        )))
+    );
+
+    let b = "cde";
+    assert_eq!(f(Partial::new(b)), Ok((Partial::new("de"), 'c')));
+}
+
+#[test]
+fn partial_none_of_test() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+        none_of("ab").parse_next(i)
+    }
+
+    let a = &b"abcd"[..];
+    assert_eq!(
+        f(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(a),
+            ErrorKind::Verify
+        )))
+    );
+
+    let b = &b"cde"[..];
+    assert_eq!(f(Partial::new(b)), Ok((Partial::new(&b"de"[..]), b'c')));
+}
+
+#[test]
+fn partial_is_a() {
+    fn a_or_b(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while1("ab").parse_next(i)
+    }
+
+    let a = Partial::new(&b"abcd"[..]);
+    assert_eq!(a_or_b(a), Ok((Partial::new(&b"cd"[..]), &b"ab"[..])));
+
+    let b = Partial::new(&b"bcde"[..]);
+    assert_eq!(a_or_b(b), Ok((Partial::new(&b"cde"[..]), &b"b"[..])));
+
+    let c = Partial::new(&b"cdef"[..]);
+    assert_eq!(
+        a_or_b(c),
+        Err(ErrMode::Backtrack(error_position!(c, ErrorKind::Slice)))
+    );
+
+    let d = Partial::new(&b"bacdef"[..]);
+    assert_eq!(a_or_b(d), Ok((Partial::new(&b"cdef"[..]), &b"ba"[..])));
+}
+
+#[test]
+fn partial_is_not() {
+    fn a_or_b(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_till1("ab").parse_next(i)
+    }
+
+    let a = Partial::new(&b"cdab"[..]);
+    assert_eq!(a_or_b(a), Ok((Partial::new(&b"ab"[..]), &b"cd"[..])));
+
+    let b = Partial::new(&b"cbde"[..]);
+    assert_eq!(a_or_b(b), Ok((Partial::new(&b"bde"[..]), &b"c"[..])));
+
+    let c = Partial::new(&b"abab"[..]);
+    assert_eq!(
+        a_or_b(c),
+        Err(ErrMode::Backtrack(error_position!(c, ErrorKind::Slice)))
+    );
+
+    let d = Partial::new(&b"cdefba"[..]);
+    assert_eq!(a_or_b(d), Ok((Partial::new(&b"ba"[..]), &b"cdef"[..])));
+
+    let e = Partial::new(&b"e"[..]);
+    assert_eq!(a_or_b(e), Err(ErrMode::Incomplete(Needed::new(1))));
+}
+
+#[test]
+fn partial_take_until_incomplete() {
+    fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_until0("end").parse_next(i)
+    }
+    assert_eq!(
+        y(Partial::new(&b"nd"[..])),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        y(Partial::new(&b"123"[..])),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        y(Partial::new(&b"123en"[..])),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+}
+
+#[test]
+fn partial_take_until_incomplete_s() {
+    fn ys(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_until0("end").parse_next(i)
+    }
+    assert_eq!(
+        ys(Partial::new("123en")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+}
+
+#[test]
+fn partial_recognize() {
+    use crate::character::{
+        alpha1 as alpha, alphanumeric1 as alphanumeric, digit1 as digit, hex_digit1 as hex_digit,
+        multispace1 as multispace, oct_digit1 as oct_digit, space1 as space,
+    };
+
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        delimited("<!--", take(5_usize), "-->")
+            .recognize()
+            .parse_next(i)
+    }
+    let r = x(Partial::new(&b"<!-- abc --> aaa"[..]));
+    assert_eq!(r, Ok((Partial::new(&b" aaa"[..]), &b"<!-- abc -->"[..])));
+
+    let semicolon = &b";"[..];
+
+    fn ya(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        alpha.recognize().parse_next(i)
+    }
+    let ra = ya(Partial::new(&b"abc;"[..]));
+    assert_eq!(ra, Ok((Partial::new(semicolon), &b"abc"[..])));
+
+    fn yd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        digit.recognize().parse_next(i)
+    }
+    let rd = yd(Partial::new(&b"123;"[..]));
+    assert_eq!(rd, Ok((Partial::new(semicolon), &b"123"[..])));
+
+    fn yhd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        hex_digit.recognize().parse_next(i)
+    }
+    let rhd = yhd(Partial::new(&b"123abcDEF;"[..]));
+    assert_eq!(rhd, Ok((Partial::new(semicolon), &b"123abcDEF"[..])));
+
+    fn yod(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        oct_digit.recognize().parse_next(i)
+    }
+    let rod = yod(Partial::new(&b"1234567;"[..]));
+    assert_eq!(rod, Ok((Partial::new(semicolon), &b"1234567"[..])));
+
+    fn yan(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        alphanumeric.recognize().parse_next(i)
+    }
+    let ran = yan(Partial::new(&b"123abc;"[..]));
+    assert_eq!(ran, Ok((Partial::new(semicolon), &b"123abc"[..])));
+
+    fn ys(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        space.recognize().parse_next(i)
+    }
+    let rs = ys(Partial::new(&b" \t;"[..]));
+    assert_eq!(rs, Ok((Partial::new(semicolon), &b" \t"[..])));
+
+    fn yms(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        multispace.recognize().parse_next(i)
+    }
+    let rms = yms(Partial::new(&b" \t\r\n;"[..]));
+    assert_eq!(rms, Ok((Partial::new(semicolon), &b" \t\r\n"[..])));
+}
+
+#[test]
+fn partial_take_while0() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while0(AsChar::is_alpha).parse_next(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"abcd123"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(c)), Ok((Partial::new(d), b)));
+    assert_eq!(f(Partial::new(d)), Ok((Partial::new(d), a)));
+}
+
+#[test]
+fn partial_take_while1() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while1(AsChar::is_alpha).parse_next(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"abcd123"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(f(Partial::new(c)), Ok((Partial::new(&b"123"[..]), b)));
+    assert_eq!(
+        f(Partial::new(d)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(d),
+            ErrorKind::Slice
+        )))
+    );
+}
+
+#[test]
+fn partial_take_while_m_n() {
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while_m_n(2, 4, AsChar::is_alpha).parse_next(i)
+    }
+    let a = &b""[..];
+    let b = &b"a"[..];
+    let c = &b"abc"[..];
+    let d = &b"abc123"[..];
+    let e = &b"abcde"[..];
+    let f = &b"123"[..];
+
+    assert_eq!(x(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(2))));
+    assert_eq!(x(Partial::new(b)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(x(Partial::new(c)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(x(Partial::new(d)), Ok((Partial::new(&b"123"[..]), c)));
+    assert_eq!(
+        x(Partial::new(e)),
+        Ok((Partial::new(&b"e"[..]), &b"abcd"[..]))
+    );
+    assert_eq!(
+        x(Partial::new(f)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(f),
+            ErrorKind::Slice
+        )))
+    );
+}
+
+#[test]
+fn partial_take_till0() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_till0(AsChar::is_alpha).parse_next(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"123abcd"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(
+        f(Partial::new(b)),
+        Ok((Partial::new(&b"abcd"[..]), &b""[..]))
+    );
+    assert_eq!(
+        f(Partial::new(c)),
+        Ok((Partial::new(&b"abcd"[..]), &b"123"[..]))
+    );
+    assert_eq!(f(Partial::new(d)), Err(ErrMode::Incomplete(Needed::new(1))));
+}
+
+#[test]
+fn partial_take_till1() {
+    fn f(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_till1(AsChar::is_alpha).parse_next(i)
+    }
+    let a = &b""[..];
+    let b = &b"abcd"[..];
+    let c = &b"123abcd"[..];
+    let d = &b"123"[..];
+
+    assert_eq!(f(Partial::new(a)), Err(ErrMode::Incomplete(Needed::new(1))));
+    assert_eq!(
+        f(Partial::new(b)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(b),
+            ErrorKind::Slice
+        )))
+    );
+    assert_eq!(
+        f(Partial::new(c)),
+        Ok((Partial::new(&b"abcd"[..]), &b"123"[..]))
+    );
+    assert_eq!(f(Partial::new(d)), Err(ErrMode::Incomplete(Needed::new(1))));
+}
+
+#[test]
+fn partial_take_while_utf8() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while0(|c| c != '點').parse_next(i)
+    }
+
+    assert_eq!(
+        f(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        f(Partial::new("abcd")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(f(Partial::new("abcd點")), Ok((Partial::new("點"), "abcd")));
+    assert_eq!(
+        f(Partial::new("abcd點a")),
+        Ok((Partial::new("點a"), "abcd"))
+    );
+
+    fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while0(|c| c == '點').parse_next(i)
+    }
+
+    assert_eq!(
+        g(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
+    assert_eq!(
+        g(Partial::new("點點點a")),
+        Ok((Partial::new("a"), "點點點"))
+    );
+}
+
+#[test]
+fn partial_take_till0_utf8() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_till0(|c| c == '點').parse_next(i)
+    }
+
+    assert_eq!(
+        f(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        f(Partial::new("abcd")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(f(Partial::new("abcd點")), Ok((Partial::new("點"), "abcd")));
+    assert_eq!(
+        f(Partial::new("abcd點a")),
+        Ok((Partial::new("點a"), "abcd"))
+    );
+
+    fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_till0(|c| c != '點').parse_next(i)
+    }
+
+    assert_eq!(
+        g(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
+    assert_eq!(
+        g(Partial::new("點點點a")),
+        Ok((Partial::new("a"), "點點點"))
+    );
+}
+
+#[test]
+fn partial_take_utf8() {
+    fn f(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take(3_usize).parse_next(i)
+    }
+
+    assert_eq!(
+        f(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        f(Partial::new("ab")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(
+        f(Partial::new("點")),
+        Err(ErrMode::Incomplete(Needed::Unknown))
+    );
+    assert_eq!(f(Partial::new("ab點cd")), Ok((Partial::new("cd"), "ab點")));
+    assert_eq!(f(Partial::new("a點bcd")), Ok((Partial::new("cd"), "a點b")));
+    assert_eq!(f(Partial::new("a點b")), Ok((Partial::new(""), "a點b")));
+
+    fn g(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while0(|c| c == '點').parse_next(i)
+    }
+
+    assert_eq!(
+        g(Partial::new("")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(g(Partial::new("點abcd")), Ok((Partial::new("abcd"), "點")));
+    assert_eq!(
+        g(Partial::new("點點點a")),
+        Ok((Partial::new("a"), "點點點"))
+    );
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_fixed() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while_m_n(1, 1, |c| c == 'A' || c == '😃').parse_next(i)
+    }
+    assert_eq!(parser(Partial::new("A!")), Ok((Partial::new("!"), "A")));
+    assert_eq!(parser(Partial::new("😃!")), Ok((Partial::new("!"), "😃")));
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_range() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while_m_n(1, 2, |c| c == 'A' || c == '😃').parse_next(i)
+    }
+    assert_eq!(parser(Partial::new("A!")), Ok((Partial::new("!"), "A")));
+    assert_eq!(parser(Partial::new("😃!")), Ok((Partial::new("!"), "😃")));
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_full_match_fixed() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while_m_n(1, 1, |c: char| c.is_alphabetic()).parse_next(i)
+    }
+    assert_eq!(parser(Partial::new("øn")), Ok((Partial::new("n"), "ø")));
+}
+
+#[test]
+fn partial_take_while_m_n_utf8_full_match_range() {
+    fn parser(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        take_while_m_n(1, 2, |c: char| c.is_alphabetic()).parse_next(i)
+    }
+    assert_eq!(parser(Partial::new("øn")), Ok((Partial::new(""), "øn")));
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn partial_recognize_take_while0() {
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take_while0(AsChar::is_alphanum).parse_next(i)
+    }
+    fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        x.recognize().parse_next(i)
+    }
+    assert_eq!(
+        x(Partial::new(&b"ab."[..])),
+        Ok((Partial::new(&b"."[..]), &b"ab"[..]))
+    );
+    assert_eq!(
+        y(Partial::new(&b"ab."[..])),
+        Ok((Partial::new(&b"."[..]), &b"ab"[..]))
+    );
+}
+
+#[test]
+fn partial_length_bytes() {
+    use crate::number::le_u8;
+
+    fn x(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        length_data(le_u8).parse_next(i)
+    }
+    assert_eq!(
+        x(Partial::new(b"\x02..>>")),
+        Ok((Partial::new(&b">>"[..]), &b".."[..]))
+    );
+    assert_eq!(
+        x(Partial::new(b"\x02..")),
+        Ok((Partial::new(&[][..]), &b".."[..]))
+    );
+    assert_eq!(
+        x(Partial::new(b"\x02.")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        x(Partial::new(b"\x02")),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+
+    fn y(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        let (i, _) = "magic".parse_next(i)?;
+        length_data(le_u8).parse_next(i)
+    }
+    assert_eq!(
+        y(Partial::new(b"magic\x02..>>")),
+        Ok((Partial::new(&b">>"[..]), &b".."[..]))
+    );
+    assert_eq!(
+        y(Partial::new(b"magic\x02..")),
+        Ok((Partial::new(&[][..]), &b".."[..]))
+    );
+    assert_eq!(
+        y(Partial::new(b"magic\x02.")),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        y(Partial::new(b"magic\x02")),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+}
+
+#[cfg(feature = "alloc")]
+#[test]
+fn partial_case_insensitive() {
+    fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        tag_no_case("ABcd").parse_next(i)
+    }
+    assert_eq!(
+        test(Partial::new(&b"aBCdefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), &b"aBCd"[..]))
+    );
+    assert_eq!(
+        test(Partial::new(&b"abcdefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), &b"abcd"[..]))
+    );
+    assert_eq!(
+        test(Partial::new(&b"ABCDefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), &b"ABCD"[..]))
+    );
+    assert_eq!(
+        test(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        test(Partial::new(&b"Hello"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"Hello"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        test(Partial::new(&b"Hel"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"Hel"[..]),
+            ErrorKind::Tag
+        )))
+    );
+
+    fn test2(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+        tag_no_case("ABcd").parse_next(i)
+    }
+    assert_eq!(
+        test2(Partial::new("aBCdefgh")),
+        Ok((Partial::new("efgh"), "aBCd"))
+    );
+    assert_eq!(
+        test2(Partial::new("abcdefgh")),
+        Ok((Partial::new("efgh"), "abcd"))
+    );
+    assert_eq!(
+        test2(Partial::new("ABCDefgh")),
+        Ok((Partial::new("efgh"), "ABCD"))
+    );
+    assert_eq!(
+        test2(Partial::new("ab")),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        test2(Partial::new("Hello")),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new("Hello"),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        test2(Partial::new("Hel")),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new("Hel"),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn partial_tag_fixed_size_array() {
+    fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        tag([0x42]).parse_next(i)
+    }
+    fn test2(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        tag(&[0x42]).parse_next(i)
+    }
+    let input = Partial::new(&[0x42, 0x00][..]);
+    assert_eq!(test(input), Ok((Partial::new(&b"\x00"[..]), &b"\x42"[..])));
+    assert_eq!(test2(input), Ok((Partial::new(&b"\x00"[..]), &b"\x42"[..])));
+}
diff --git a/vendor/winnow/src/character/mod.rs b/vendor/winnow/src/character/mod.rs
new file mode 100644
index 000000000..89cc9ec09
--- /dev/null
+++ b/vendor/winnow/src/character/mod.rs
@@ -0,0 +1,1808 @@
+//! Character specific parsers and combinators
+//!
+//! Functions recognizing specific characters
+
+#[cfg(test)]
+mod tests;
+
+use crate::lib::std::ops::{Add, Shl};
+
+use crate::branch::alt;
+use crate::bytes::one_of;
+
+use crate::bytes::take_while0;
+use crate::bytes::take_while1;
+use crate::combinator::cut_err;
+use crate::combinator::opt;
+use crate::error::ParseError;
+use crate::error::{ErrMode, ErrorKind, Needed};
+use crate::stream::ContainsToken;
+use crate::stream::{AsBStr, AsChar, Offset, ParseSlice, Stream, StreamIsPartial};
+use crate::stream::{Compare, CompareResult};
+use crate::trace::trace;
+use crate::IResult;
+use crate::Parser;
+
+/// Recognizes the string "\r\n".
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult};
+/// # use winnow::character::crlf;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     crlf(input)
+/// }
+///
+/// assert_eq!(parser("\r\nc"), Ok(("c", "\r\n")));
+/// assert_eq!(parser("ab\r\nc"), Err(ErrMode::Backtrack(Error::new("ab\r\nc", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::crlf;
+/// assert_eq!(crlf::<_, Error<_>>(Partial::new("\r\nc")), Ok((Partial::new("c"), "\r\n")));
+/// assert_eq!(crlf::<_, Error<_>>(Partial::new("ab\r\nc")), Err(ErrMode::Backtrack(Error::new(Partial::new("ab\r\nc"), ErrorKind::Tag))));
+/// assert_eq!(crlf::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+#[inline(always)]
+pub fn crlf<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    I: Compare<&'static str>,
+{
+    trace("crlf", move |input: I| "\r\n".parse_next(input)).parse_next(input)
+}
+
+/// Recognizes a string of any char except '\r\n' or '\n'.
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::not_line_ending;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     not_line_ending(input)
+/// }
+///
+/// assert_eq!(parser("ab\r\nc"), Ok(("\r\nc", "ab")));
+/// assert_eq!(parser("ab\nc"), Ok(("\nc", "ab")));
+/// assert_eq!(parser("abc"), Ok(("", "abc")));
+/// assert_eq!(parser(""), Ok(("", "")));
+/// assert_eq!(parser("a\rb\nc"), Err(ErrMode::Backtrack(Error { input: "a\rb\nc", kind: ErrorKind::Tag })));
+/// assert_eq!(parser("a\rbc"), Err(ErrMode::Backtrack(Error { input: "a\rbc", kind: ErrorKind::Tag })));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::not_line_ending;
+/// assert_eq!(not_line_ending::<_, Error<_>>(Partial::new("ab\r\nc")), Ok((Partial::new("\r\nc"), "ab")));
+/// assert_eq!(not_line_ending::<_, Error<_>>(Partial::new("abc")), Err(ErrMode::Incomplete(Needed::Unknown)));
+/// assert_eq!(not_line_ending::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::Unknown)));
+/// assert_eq!(not_line_ending::<_, Error<_>>(Partial::new("a\rb\nc")), Err(ErrMode::Backtrack(Error::new(Partial::new("a\rb\nc"), ErrorKind::Tag ))));
+/// assert_eq!(not_line_ending::<_, Error<_>>(Partial::new("a\rbc")), Err(ErrMode::Backtrack(Error::new(Partial::new("a\rbc"), ErrorKind::Tag ))));
+/// ```
+#[inline(always)]
+pub fn not_line_ending<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream + AsBStr,
+    I: Compare<&'static str>,
+    <I as Stream>::Token: AsChar,
+{
+    trace("not_line_ending", move |input: I| {
+        if input.is_partial() {
+            streaming_not_line_ending(input)
+        } else {
+            complete_not_line_ending(input)
+        }
+    })
+    .parse_next(input)
+}
+
+pub(crate) fn streaming_not_line_ending<T, E: ParseError<T>>(
+    input: T,
+) -> IResult<T, <T as Stream>::Slice, E>
+where
+    T: Stream + AsBStr,
+    T: Compare<&'static str>,
+    <T as Stream>::Token: AsChar,
+{
+    match input.offset_for(|item| {
+        let c = item.as_char();
+        c == '\r' || c == '\n'
+    }) {
+        None => Err(ErrMode::Incomplete(Needed::Unknown)),
+        Some(offset) => {
+            let (new_input, res) = input.next_slice(offset);
+            let bytes = new_input.as_bstr();
+            let nth = bytes[0];
+            if nth == b'\r' {
+                let comp = new_input.compare("\r\n");
+                match comp {
+                    //FIXME: calculate the right index
+                    CompareResult::Ok => {}
+                    CompareResult::Incomplete => {
+                        return Err(ErrMode::Incomplete(Needed::Unknown));
+                    }
+                    CompareResult::Error => {
+                        let e: ErrorKind = ErrorKind::Tag;
+                        return Err(ErrMode::from_error_kind(input, e));
+                    }
+                }
+            }
+            Ok((new_input, res))
+        }
+    }
+}
+
+pub(crate) fn complete_not_line_ending<T, E: ParseError<T>>(
+    input: T,
+) -> IResult<T, <T as Stream>::Slice, E>
+where
+    T: Stream + AsBStr,
+    T: Compare<&'static str>,
+    <T as Stream>::Token: AsChar,
+{
+    match input.offset_for(|item| {
+        let c = item.as_char();
+        c == '\r' || c == '\n'
+    }) {
+        None => Ok(input.next_slice(input.eof_offset())),
+        Some(offset) => {
+            let (new_input, res) = input.next_slice(offset);
+            let bytes = new_input.as_bstr();
+            let nth = bytes[0];
+            if nth == b'\r' {
+                let comp = new_input.compare("\r\n");
+                match comp {
+                    //FIXME: calculate the right index
+                    CompareResult::Ok => {}
+                    CompareResult::Incomplete | CompareResult::Error => {
+                        let e: ErrorKind = ErrorKind::Tag;
+                        return Err(ErrMode::from_error_kind(input, e));
+                    }
+                }
+            }
+            Ok((new_input, res))
+        }
+    }
+}
+
+/// Recognizes an end of line (both '\n' and '\r\n').
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::line_ending;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     line_ending(input)
+/// }
+///
+/// assert_eq!(parser("\r\nc"), Ok(("c", "\r\n")));
+/// assert_eq!(parser("ab\r\nc"), Err(ErrMode::Backtrack(Error::new("ab\r\nc", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::line_ending;
+/// assert_eq!(line_ending::<_, Error<_>>(Partial::new("\r\nc")), Ok((Partial::new("c"), "\r\n")));
+/// assert_eq!(line_ending::<_, Error<_>>(Partial::new("ab\r\nc")), Err(ErrMode::Backtrack(Error::new(Partial::new("ab\r\nc"), ErrorKind::Tag))));
+/// assert_eq!(line_ending::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn line_ending<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    I: Compare<&'static str>,
+{
+    trace("line_ending", move |input: I| {
+        alt(("\n", "\r\n")).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Matches a newline character '\n'.
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::newline;
+/// fn parser(input: &str) -> IResult<&str, char> {
+///     newline(input)
+/// }
+///
+/// assert_eq!(parser("\nc"), Ok(("c", '\n')));
+/// assert_eq!(parser("\r\nc"), Err(ErrMode::Backtrack(Error::new("\r\nc", ErrorKind::Verify))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Token))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::newline;
+/// assert_eq!(newline::<_, Error<_>>(Partial::new("\nc")), Ok((Partial::new("c"), '\n')));
+/// assert_eq!(newline::<_, Error<_>>(Partial::new("\r\nc")), Err(ErrMode::Backtrack(Error::new(Partial::new("\r\nc"), ErrorKind::Verify))));
+/// assert_eq!(newline::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn newline<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+{
+    trace("newline", move |input: I| {
+        '\n'.map(|c: <I as Stream>::Token| c.as_char())
+            .parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Matches a tab character '\t'.
+///
+/// *Complete version*: Will return an error if there's not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::tab;
+/// fn parser(input: &str) -> IResult<&str, char> {
+///     tab(input)
+/// }
+///
+/// assert_eq!(parser("\tc"), Ok(("c", '\t')));
+/// assert_eq!(parser("\r\nc"), Err(ErrMode::Backtrack(Error::new("\r\nc", ErrorKind::Verify))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Token))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::tab;
+/// assert_eq!(tab::<_, Error<_>>(Partial::new("\tc")), Ok((Partial::new("c"), '\t')));
+/// assert_eq!(tab::<_, Error<_>>(Partial::new("\r\nc")), Err(ErrMode::Backtrack(Error::new(Partial::new("\r\nc"), ErrorKind::Verify))));
+/// assert_eq!(tab::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn tab<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+{
+    trace("tab", move |input: I| {
+        '\t'.map(|c: <I as Stream>::Token| c.as_char())
+            .parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes zero or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z
+///
+/// *Complete version*: Will return the whole input if no terminating token is found (a non
+/// alphabetic character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non alphabetic character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::character::alpha0;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     alpha0(input)
+/// }
+///
+/// assert_eq!(parser("ab1c"), Ok(("1c", "ab")));
+/// assert_eq!(parser("1c"), Ok(("1c", "")));
+/// assert_eq!(parser(""), Ok(("", "")));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::alpha0;
+/// assert_eq!(alpha0::<_, Error<_>>(Partial::new("ab1c")), Ok((Partial::new("1c"), "ab")));
+/// assert_eq!(alpha0::<_, Error<_>>(Partial::new("1c")), Ok((Partial::new("1c"), "")));
+/// assert_eq!(alpha0::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn alpha0<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("alpha0", move |input: I| {
+        take_while0(|c: <I as Stream>::Token| c.is_alpha()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes one or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z
+///
+/// *Complete version*: Will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found  (a non alphabetic character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non alphabetic character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::alpha1;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     alpha1(input)
+/// }
+///
+/// assert_eq!(parser("aB1c"), Ok(("1c", "aB")));
+/// assert_eq!(parser("1c"), Err(ErrMode::Backtrack(Error::new("1c", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::alpha1;
+/// assert_eq!(alpha1::<_, Error<_>>(Partial::new("aB1c")), Ok((Partial::new("1c"), "aB")));
+/// assert_eq!(alpha1::<_, Error<_>>(Partial::new("1c")), Err(ErrMode::Backtrack(Error::new(Partial::new("1c"), ErrorKind::Slice))));
+/// assert_eq!(alpha1::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn alpha1<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("alpha1", move |input: I| {
+        take_while1(|c: <I as Stream>::Token| c.is_alpha()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes zero or more ASCII numerical characters: 0-9
+///
+/// *Complete version*: Will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found (a non digit character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non digit character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::character::digit0;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     digit0(input)
+/// }
+///
+/// assert_eq!(parser("21c"), Ok(("c", "21")));
+/// assert_eq!(parser("21"), Ok(("", "21")));
+/// assert_eq!(parser("a21c"), Ok(("a21c", "")));
+/// assert_eq!(parser(""), Ok(("", "")));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::digit0;
+/// assert_eq!(digit0::<_, Error<_>>(Partial::new("21c")), Ok((Partial::new("c"), "21")));
+/// assert_eq!(digit0::<_, Error<_>>(Partial::new("a21c")), Ok((Partial::new("a21c"), "")));
+/// assert_eq!(digit0::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn digit0<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("digit0", move |input: I| {
+        take_while0(|c: <I as Stream>::Token| c.is_dec_digit()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes one or more ASCII numerical characters: 0-9
+///
+/// *Complete version*: Will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found (a non digit character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non digit character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::digit1;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     digit1(input)
+/// }
+///
+/// assert_eq!(parser("21c"), Ok(("c", "21")));
+/// assert_eq!(parser("c1"), Err(ErrMode::Backtrack(Error::new("c1", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::digit1;
+/// assert_eq!(digit1::<_, Error<_>>(Partial::new("21c")), Ok((Partial::new("c"), "21")));
+/// assert_eq!(digit1::<_, Error<_>>(Partial::new("c1")), Err(ErrMode::Backtrack(Error::new(Partial::new("c1"), ErrorKind::Slice))));
+/// assert_eq!(digit1::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+///
+/// ## Parsing an integer
+///
+/// You can use `digit1` in combination with [`Parser::map_res`][crate::Parser::map_res] to parse an integer:
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed, Parser};
+/// # use winnow::character::digit1;
+/// fn parser(input: &str) -> IResult<&str, u32> {
+///   digit1.map_res(str::parse).parse_next(input)
+/// }
+///
+/// assert_eq!(parser("416"), Ok(("", 416)));
+/// assert_eq!(parser("12b"), Ok(("b", 12)));
+/// assert!(parser("b").is_err());
+/// ```
+#[inline(always)]
+pub fn digit1<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("digit1", move |input: I| {
+        take_while1(|c: <I as Stream>::Token| c.is_dec_digit()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes zero or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f
+///
+/// *Complete version*: Will return the whole input if no terminating token is found (a non hexadecimal digit character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non hexadecimal digit character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::character::hex_digit0;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     hex_digit0(input)
+/// }
+///
+/// assert_eq!(parser("21cZ"), Ok(("Z", "21c")));
+/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));
+/// assert_eq!(parser(""), Ok(("", "")));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::hex_digit0;
+/// assert_eq!(hex_digit0::<_, Error<_>>(Partial::new("21cZ")), Ok((Partial::new("Z"), "21c")));
+/// assert_eq!(hex_digit0::<_, Error<_>>(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));
+/// assert_eq!(hex_digit0::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn hex_digit0<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("hex_digit0", move |input: I| {
+        take_while0(|c: <I as Stream>::Token| c.is_hex_digit()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes one or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f
+///
+/// *Complete version*: Will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found (a non hexadecimal digit character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non hexadecimal digit character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::hex_digit1;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     hex_digit1(input)
+/// }
+///
+/// assert_eq!(parser("21cZ"), Ok(("Z", "21c")));
+/// assert_eq!(parser("H2"), Err(ErrMode::Backtrack(Error::new("H2", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::hex_digit1;
+/// assert_eq!(hex_digit1::<_, Error<_>>(Partial::new("21cZ")), Ok((Partial::new("Z"), "21c")));
+/// assert_eq!(hex_digit1::<_, Error<_>>(Partial::new("H2")), Err(ErrMode::Backtrack(Error::new(Partial::new("H2"), ErrorKind::Slice))));
+/// assert_eq!(hex_digit1::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn hex_digit1<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("hex_digit1", move |input: I| {
+        take_while1(|c: <I as Stream>::Token| c.is_hex_digit()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes zero or more octal characters: 0-7
+///
+/// *Complete version*: Will return the whole input if no terminating token is found (a non octal
+/// digit character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non octal digit character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::character::oct_digit0;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     oct_digit0(input)
+/// }
+///
+/// assert_eq!(parser("21cZ"), Ok(("cZ", "21")));
+/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));
+/// assert_eq!(parser(""), Ok(("", "")));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::oct_digit0;
+/// assert_eq!(oct_digit0::<_, Error<_>>(Partial::new("21cZ")), Ok((Partial::new("cZ"), "21")));
+/// assert_eq!(oct_digit0::<_, Error<_>>(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));
+/// assert_eq!(oct_digit0::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn oct_digit0<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("oct_digit0", move |input: I| {
+        take_while0(|c: <I as Stream>::Token| c.is_oct_digit()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes one or more octal characters: 0-7
+///
+/// *Complete version*: Will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found (a non octal digit character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non octal digit character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::oct_digit1;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     oct_digit1(input)
+/// }
+///
+/// assert_eq!(parser("21cZ"), Ok(("cZ", "21")));
+/// assert_eq!(parser("H2"), Err(ErrMode::Backtrack(Error::new("H2", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::oct_digit1;
+/// assert_eq!(oct_digit1::<_, Error<_>>(Partial::new("21cZ")), Ok((Partial::new("cZ"), "21")));
+/// assert_eq!(oct_digit1::<_, Error<_>>(Partial::new("H2")), Err(ErrMode::Backtrack(Error::new(Partial::new("H2"), ErrorKind::Slice))));
+/// assert_eq!(oct_digit1::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn oct_digit1<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("oct_digit0", move |input: I| {
+        take_while1(|c: <I as Stream>::Token| c.is_oct_digit()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes zero or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z
+///
+/// *Complete version*: Will return the whole input if no terminating token is found (a non
+/// alphanumerical character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non alphanumerical character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::character::alphanumeric0;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     alphanumeric0(input)
+/// }
+///
+/// assert_eq!(parser("21cZ%1"), Ok(("%1", "21cZ")));
+/// assert_eq!(parser("&Z21c"), Ok(("&Z21c", "")));
+/// assert_eq!(parser(""), Ok(("", "")));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::alphanumeric0;
+/// assert_eq!(alphanumeric0::<_, Error<_>>(Partial::new("21cZ%1")), Ok((Partial::new("%1"), "21cZ")));
+/// assert_eq!(alphanumeric0::<_, Error<_>>(Partial::new("&Z21c")), Ok((Partial::new("&Z21c"), "")));
+/// assert_eq!(alphanumeric0::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn alphanumeric0<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("alphanumeric0", move |input: I| {
+        take_while0(|c: <I as Stream>::Token| c.is_alphanum()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes one or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z
+///
+/// *Complete version*: Will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found (a non alphanumerical character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non alphanumerical character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::alphanumeric1;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     alphanumeric1(input)
+/// }
+///
+/// assert_eq!(parser("21cZ%1"), Ok(("%1", "21cZ")));
+/// assert_eq!(parser("&H2"), Err(ErrMode::Backtrack(Error::new("&H2", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::alphanumeric1;
+/// assert_eq!(alphanumeric1::<_, Error<_>>(Partial::new("21cZ%1")), Ok((Partial::new("%1"), "21cZ")));
+/// assert_eq!(alphanumeric1::<_, Error<_>>(Partial::new("&H2")), Err(ErrMode::Backtrack(Error::new(Partial::new("&H2"), ErrorKind::Slice))));
+/// assert_eq!(alphanumeric1::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn alphanumeric1<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar,
+{
+    trace("alphanumeric1", move |input: I| {
+        take_while1(|c: <I as Stream>::Token| c.is_alphanum()).parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes zero or more spaces and tabs.
+///
+/// *Complete version*: Will return the whole input if no terminating token is found (a non space
+/// character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non space character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::space0;
+/// assert_eq!(space0::<_, Error<_>>(Partial::new(" \t21c")), Ok((Partial::new("21c"), " \t")));
+/// assert_eq!(space0::<_, Error<_>>(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));
+/// assert_eq!(space0::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn space0<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+{
+    trace("space0", move |input: I| {
+        take_while0(|c: <I as Stream>::Token| {
+            let ch = c.as_char();
+            matches!(ch, ' ' | '\t')
+        })
+        .parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes one or more spaces and tabs.
+///
+/// *Complete version*: Will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found (a non space character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non space character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::space1;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     space1(input)
+/// }
+///
+/// assert_eq!(parser(" \t21c"), Ok(("21c", " \t")));
+/// assert_eq!(parser("H2"), Err(ErrMode::Backtrack(Error::new("H2", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::space1;
+/// assert_eq!(space1::<_, Error<_>>(Partial::new(" \t21c")), Ok((Partial::new("21c"), " \t")));
+/// assert_eq!(space1::<_, Error<_>>(Partial::new("H2")), Err(ErrMode::Backtrack(Error::new(Partial::new("H2"), ErrorKind::Slice))));
+/// assert_eq!(space1::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn space1<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+{
+    trace("space1", move |input: I| {
+        take_while1(|c: <I as Stream>::Token| {
+            let ch = c.as_char();
+            matches!(ch, ' ' | '\t')
+        })
+        .parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes zero or more spaces, tabs, carriage returns and line feeds.
+///
+/// *Complete version*: will return the whole input if no terminating token is found (a non space
+/// character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non space character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::character::multispace0;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     multispace0(input)
+/// }
+///
+/// assert_eq!(parser(" \t\n\r21c"), Ok(("21c", " \t\n\r")));
+/// assert_eq!(parser("Z21c"), Ok(("Z21c", "")));
+/// assert_eq!(parser(""), Ok(("", "")));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::multispace0;
+/// assert_eq!(multispace0::<_, Error<_>>(Partial::new(" \t\n\r21c")), Ok((Partial::new("21c"), " \t\n\r")));
+/// assert_eq!(multispace0::<_, Error<_>>(Partial::new("Z21c")), Ok((Partial::new("Z21c"), "")));
+/// assert_eq!(multispace0::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn multispace0<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+{
+    trace("multispace0", move |input: I| {
+        take_while0(|c: <I as Stream>::Token| {
+            let ch = c.as_char();
+            matches!(ch, ' ' | '\t' | '\r' | '\n')
+        })
+        .parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Recognizes one or more spaces, tabs, carriage returns and line feeds.
+///
+/// *Complete version*: will return an error if there's not enough input data,
+/// or the whole input if no terminating token is found (a non space character).
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data,
+/// or if no terminating token is found (a non space character).
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult, error::Needed};
+/// # use winnow::character::multispace1;
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///     multispace1(input)
+/// }
+///
+/// assert_eq!(parser(" \t\n\r21c"), Ok(("21c", " \t\n\r")));
+/// assert_eq!(parser("H2"), Err(ErrMode::Backtrack(Error::new("H2", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, error::Needed};
+/// # use winnow::Partial;
+/// # use winnow::character::multispace1;
+/// assert_eq!(multispace1::<_, Error<_>>(Partial::new(" \t\n\r21c")), Ok((Partial::new("21c"), " \t\n\r")));
+/// assert_eq!(multispace1::<_, Error<_>>(Partial::new("H2")), Err(ErrMode::Backtrack(Error::new(Partial::new("H2"), ErrorKind::Slice))));
+/// assert_eq!(multispace1::<_, Error<_>>(Partial::new("")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn multispace1<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+{
+    trace("multispace1", move |input: I| {
+        take_while1(|c: <I as Stream>::Token| {
+            let ch = c.as_char();
+            matches!(ch, ' ' | '\t' | '\r' | '\n')
+        })
+        .parse_next(input)
+    })
+    .parse_next(input)
+}
+
+/// Decode a decimal unsigned integer
+///
+/// *Complete version*: can parse until the end of input.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+#[doc(alias = "u8")]
+#[doc(alias = "u16")]
+#[doc(alias = "u32")]
+#[doc(alias = "u64")]
+#[doc(alias = "u128")]
+pub fn dec_uint<I, O, E: ParseError<I>>(input: I) -> IResult<I, O, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+    O: Uint,
+{
+    trace("dec_uint", move |input: I| {
+        if input.eof_offset() == 0 {
+            if input.is_partial() {
+                return Err(ErrMode::Incomplete(Needed::new(1)));
+            } else {
+                return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
+            }
+        }
+
+        let mut value = O::default();
+        for (offset, c) in input.iter_offsets() {
+            match c.as_char().to_digit(10) {
+                Some(d) => match value.checked_mul(10, sealed::SealedMarker).and_then(|v| {
+                    let d = d as u8;
+                    v.checked_add(d, sealed::SealedMarker)
+                }) {
+                    None => return Err(ErrMode::from_error_kind(input, ErrorKind::Verify)),
+                    Some(v) => value = v,
+                },
+                None => {
+                    if offset == 0 {
+                        return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
+                    } else {
+                        return Ok((input.next_slice(offset).0, value));
+                    }
+                }
+            }
+        }
+
+        if input.is_partial() {
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        } else {
+            Ok((input.next_slice(input.eof_offset()).0, value))
+        }
+    })
+    .parse_next(input)
+}
+
+/// Metadata for parsing unsigned integers, see [`dec_uint`]
+pub trait Uint: Default {
+    #[doc(hidden)]
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self>;
+    #[doc(hidden)]
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self>;
+}
+
+impl Uint for u8 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for u16 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for u32 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for u64 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for u128 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for i8 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for i16 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for i32 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for i64 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+impl Uint for i128 {
+    fn checked_mul(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_mul(by as Self)
+    }
+    fn checked_add(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_add(by as Self)
+    }
+}
+
+/// Decode a decimal signed integer
+///
+/// *Complete version*: can parse until the end of input.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there's not enough input data.
+#[doc(alias = "i8")]
+#[doc(alias = "i16")]
+#[doc(alias = "i32")]
+#[doc(alias = "i64")]
+#[doc(alias = "i128")]
+pub fn dec_int<I, O, E: ParseError<I>>(input: I) -> IResult<I, O, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+    O: Int,
+{
+    trace("dec_int", move |input: I| {
+        fn sign(token: impl AsChar) -> bool {
+            let token = token.as_char();
+            token == '+' || token == '-'
+        }
+        let (input, sign) = opt(crate::bytes::one_of(sign).map(AsChar::as_char))
+            .map(|c| c != Some('-'))
+            .parse_next(input)?;
+
+        if input.eof_offset() == 0 {
+            if input.is_partial() {
+                return Err(ErrMode::Incomplete(Needed::new(1)));
+            } else {
+                return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
+            }
+        }
+
+        let mut value = O::default();
+        for (offset, c) in input.iter_offsets() {
+            match c.as_char().to_digit(10) {
+                Some(d) => match value.checked_mul(10, sealed::SealedMarker).and_then(|v| {
+                    let d = d as u8;
+                    if sign {
+                        v.checked_add(d, sealed::SealedMarker)
+                    } else {
+                        v.checked_sub(d, sealed::SealedMarker)
+                    }
+                }) {
+                    None => return Err(ErrMode::from_error_kind(input, ErrorKind::Verify)),
+                    Some(v) => value = v,
+                },
+                None => {
+                    if offset == 0 {
+                        return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
+                    } else {
+                        return Ok((input.next_slice(offset).0, value));
+                    }
+                }
+            }
+        }
+
+        if input.is_partial() {
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        } else {
+            Ok((input.next_slice(input.eof_offset()).0, value))
+        }
+    })
+    .parse_next(input)
+}
+
+/// Metadata for parsing signed integers, see [`dec_int`]
+pub trait Int: Uint {
+    #[doc(hidden)]
+    fn checked_sub(self, by: u8, _: sealed::SealedMarker) -> Option<Self>;
+}
+
+impl Int for i8 {
+    fn checked_sub(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_sub(by as Self)
+    }
+}
+
+impl Int for i16 {
+    fn checked_sub(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_sub(by as Self)
+    }
+}
+
+impl Int for i32 {
+    fn checked_sub(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_sub(by as Self)
+    }
+}
+
+impl Int for i64 {
+    fn checked_sub(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_sub(by as Self)
+    }
+}
+
+impl Int for i128 {
+    fn checked_sub(self, by: u8, _: sealed::SealedMarker) -> Option<Self> {
+        self.checked_sub(by as Self)
+    }
+}
+
+/// Decode a variable-width hexadecimal integer.
+///
+/// *Complete version*: Will parse until the end of input if it has fewer characters than the type
+/// supports.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if end-of-input
+/// is hit before a hard boundary (non-hex character, more characters than supported).
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// use winnow::character::hex_uint;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u32> {
+///   hex_uint(s)
+/// }
+///
+/// assert_eq!(parser(&b"01AE"[..]), Ok((&b""[..], 0x01AE)));
+/// assert_eq!(parser(&b"abc"[..]), Ok((&b""[..], 0x0ABC)));
+/// assert_eq!(parser(&b"ggg"[..]), Err(ErrMode::Backtrack(Error::new(&b"ggg"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::Partial;
+/// use winnow::character::hex_uint;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+///   hex_uint(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"01AE;"[..])), Ok((Partial::new(&b";"[..]), 0x01AE)));
+/// assert_eq!(parser(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(parser(Partial::new(&b"ggg"[..])), Err(ErrMode::Backtrack(Error::new(Partial::new(&b"ggg"[..]), ErrorKind::Slice))));
+/// ```
+#[inline]
+pub fn hex_uint<I, O, E: ParseError<I>>(input: I) -> IResult<I, O, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    O: HexUint,
+    <I as Stream>::Token: AsChar,
+    <I as Stream>::Slice: AsBStr,
+{
+    trace("hex_uint", move |input: I| {
+        let invalid_offset = input
+            .offset_for(|c| {
+                let c = c.as_char();
+                !"0123456789abcdefABCDEF".contains(c)
+            })
+            .unwrap_or_else(|| input.eof_offset());
+        let max_nibbles = O::max_nibbles(sealed::SealedMarker);
+        let max_offset = input.offset_at(max_nibbles);
+        let offset = match max_offset {
+            Ok(max_offset) => {
+                if max_offset < invalid_offset {
+                    // Overflow
+                    return Err(ErrMode::from_error_kind(input, ErrorKind::Verify));
+                } else {
+                    invalid_offset
+                }
+            }
+            Err(_) => {
+                if input.is_partial() && invalid_offset == input.eof_offset() {
+                    // Only the next byte is guaranteed required
+                    return Err(ErrMode::Incomplete(Needed::new(1)));
+                } else {
+                    invalid_offset
+                }
+            }
+        };
+        if offset == 0 {
+            // Must be at least one digit
+            return Err(ErrMode::from_error_kind(input, ErrorKind::Slice));
+        }
+        let (remaining, parsed) = input.next_slice(offset);
+
+        let mut res = O::default();
+        for c in parsed.as_bstr() {
+            let nibble = *c as char;
+            let nibble = nibble.to_digit(16).unwrap_or(0) as u8;
+            let nibble = O::from(nibble);
+            res = (res << O::from(4)) + nibble;
+        }
+
+        Ok((remaining, res))
+    })
+    .parse_next(input)
+}
+
+/// Metadata for parsing hex numbers, see [`hex_uint`]
+pub trait HexUint:
+    Default + Shl<Self, Output = Self> + Add<Self, Output = Self> + From<u8>
+{
+    #[doc(hidden)]
+    fn max_nibbles(_: sealed::SealedMarker) -> usize;
+}
+
+impl HexUint for u8 {
+    #[inline(always)]
+    fn max_nibbles(_: sealed::SealedMarker) -> usize {
+        2
+    }
+}
+
+impl HexUint for u16 {
+    #[inline(always)]
+    fn max_nibbles(_: sealed::SealedMarker) -> usize {
+        4
+    }
+}
+
+impl HexUint for u32 {
+    #[inline(always)]
+    fn max_nibbles(_: sealed::SealedMarker) -> usize {
+        8
+    }
+}
+
+impl HexUint for u64 {
+    #[inline(always)]
+    fn max_nibbles(_: sealed::SealedMarker) -> usize {
+        16
+    }
+}
+
+impl HexUint for u128 {
+    #[inline(always)]
+    fn max_nibbles(_: sealed::SealedMarker) -> usize {
+        32
+    }
+}
+
+/// Recognizes floating point number in text format and returns a f32 or f64.
+///
+/// *Complete version*: Can parse until the end of input.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::error::Needed::Size;
+/// use winnow::character::float;
+///
+/// fn parser(s: &str) -> IResult<&str, f64> {
+///   float(s)
+/// }
+///
+/// assert_eq!(parser("11e-1"), Ok(("", 1.1)));
+/// assert_eq!(parser("123E-02"), Ok(("", 1.23)));
+/// assert_eq!(parser("123K-01"), Ok(("K-01", 123.0)));
+/// assert_eq!(parser("abc"), Err(ErrMode::Backtrack(Error::new("abc", ErrorKind::Tag))));
+/// ```
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::character::float;
+///
+/// fn parser(s: Partial<&str>) -> IResult<Partial<&str>, f64> {
+///   float(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new("11e-1 ")), Ok((Partial::new(" "), 1.1)));
+/// assert_eq!(parser(Partial::new("11e-1")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(parser(Partial::new("123E-02")), Err(ErrMode::Incomplete(Needed::new(1))));
+/// assert_eq!(parser(Partial::new("123K-01")), Ok((Partial::new("K-01"), 123.0)));
+/// assert_eq!(parser(Partial::new("abc")), Err(ErrMode::Backtrack(Error::new(Partial::new("abc"), ErrorKind::Tag))));
+/// ```
+#[inline(always)]
+#[doc(alias = "f32")]
+#[doc(alias = "double")]
+pub fn float<I, O, E: ParseError<I>>(input: I) -> IResult<I, O, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    I: Offset + Compare<&'static str>,
+    <I as Stream>::Slice: ParseSlice<O>,
+    <I as Stream>::Token: AsChar + Copy,
+    <I as Stream>::IterOffsets: Clone,
+    I: AsBStr,
+    &'static str: ContainsToken<<I as Stream>::Token>,
+{
+    trace("float", move |input: I| {
+        let (i, s) = recognize_float_or_exceptions(input)?;
+        match s.parse_slice() {
+            Some(f) => Ok((i, f)),
+            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+        }
+    })
+    .parse_next(input)
+}
+
+fn recognize_float_or_exceptions<I, E: ParseError<I>>(
+    input: I,
+) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    I: Offset + Compare<&'static str>,
+    <I as Stream>::Token: AsChar + Copy,
+    <I as Stream>::IterOffsets: Clone,
+    I: AsBStr,
+    &'static str: ContainsToken<<I as Stream>::Token>,
+{
+    alt((
+        recognize_float,
+        crate::bytes::tag_no_case("nan"),
+        crate::bytes::tag_no_case("inf"),
+        crate::bytes::tag_no_case("infinity"),
+    ))
+    .parse_next(input)
+}
+
+fn recognize_float<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    I: Offset + Compare<&'static str>,
+    <I as Stream>::Token: AsChar + Copy,
+    <I as Stream>::IterOffsets: Clone,
+    I: AsBStr,
+    &'static str: ContainsToken<<I as Stream>::Token>,
+{
+    (
+        opt(one_of("+-")),
+        alt((
+            (digit1, opt(('.', opt(digit1)))).map(|_| ()),
+            ('.', digit1).map(|_| ()),
+        )),
+        opt((one_of("eE"), opt(one_of("+-")), cut_err(digit1))),
+    )
+        .recognize()
+        .parse_next(input)
+}
+
+/// Matches a byte string with escaped characters.
+///
+/// * The first argument matches the normal characters (it must not accept the control character)
+/// * The second argument is the control character (like `\` in most languages)
+/// * The third argument matches the escaped characters
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed, IResult};
+/// # use winnow::character::digit1;
+/// # use winnow::prelude::*;
+/// use winnow::character::escaped;
+/// use winnow::bytes::one_of;
+///
+/// fn esc(s: &str) -> IResult<&str, &str> {
+///   escaped(digit1, '\\', one_of(r#""n\"#)).parse_next(s)
+/// }
+///
+/// assert_eq!(esc("123;"), Ok((";", "123")));
+/// assert_eq!(esc(r#"12\"34;"#), Ok((";", r#"12\"34"#)));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed, IResult};
+/// # use winnow::character::digit1;
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::character::escaped;
+/// use winnow::bytes::one_of;
+///
+/// fn esc(s: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   escaped(digit1, '\\', one_of("\"n\\")).parse_next(s)
+/// }
+///
+/// assert_eq!(esc(Partial::new("123;")), Ok((Partial::new(";"), "123")));
+/// assert_eq!(esc(Partial::new("12\\\"34;")), Ok((Partial::new(";"), "12\\\"34")));
+/// ```
+#[inline(always)]
+pub fn escaped<'a, I: 'a, Error, F, G, O1, O2>(
+    mut normal: F,
+    control_char: char,
+    mut escapable: G,
+) -> impl Parser<I, <I as Stream>::Slice, Error>
+where
+    I: StreamIsPartial,
+    I: Stream + Offset,
+    <I as Stream>::Token: crate::stream::AsChar,
+    F: Parser<I, O1, Error>,
+    G: Parser<I, O2, Error>,
+    Error: ParseError<I>,
+{
+    trace("escaped", move |input: I| {
+        if input.is_partial() {
+            streaming_escaped_internal(input, &mut normal, control_char, &mut escapable)
+        } else {
+            complete_escaped_internal(input, &mut normal, control_char, &mut escapable)
+        }
+    })
+}
+
+pub(crate) fn streaming_escaped_internal<I, Error, F, G, O1, O2>(
+    input: I,
+    normal: &mut F,
+    control_char: char,
+    escapable: &mut G,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + Offset,
+    <I as Stream>::Token: crate::stream::AsChar,
+    F: Parser<I, O1, Error>,
+    G: Parser<I, O2, Error>,
+    Error: ParseError<I>,
+{
+    let mut i = input.clone();
+
+    while i.eof_offset() > 0 {
+        let current_len = i.eof_offset();
+
+        match normal.parse_next(i.clone()) {
+            Ok((i2, _)) => {
+                if i2.eof_offset() == 0 {
+                    return Err(ErrMode::Incomplete(Needed::Unknown));
+                } else if i2.eof_offset() == current_len {
+                    let offset = input.offset_to(&i2);
+                    return Ok(input.next_slice(offset));
+                } else {
+                    i = i2;
+                }
+            }
+            Err(ErrMode::Backtrack(_)) => {
+                if i.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                    let next = control_char.len_utf8();
+                    match escapable.parse_next(i.next_slice(next).0) {
+                        Ok((i2, _)) => {
+                            if i2.eof_offset() == 0 {
+                                return Err(ErrMode::Incomplete(Needed::Unknown));
+                            } else {
+                                i = i2;
+                            }
+                        }
+                        Err(e) => return Err(e),
+                    }
+                } else {
+                    let offset = input.offset_to(&i);
+                    return Ok(input.next_slice(offset));
+                }
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        }
+    }
+
+    Err(ErrMode::Incomplete(Needed::Unknown))
+}
+
+pub(crate) fn complete_escaped_internal<'a, I: 'a, Error, F, G, O1, O2>(
+    input: I,
+    normal: &mut F,
+    control_char: char,
+    escapable: &mut G,
+) -> IResult<I, <I as Stream>::Slice, Error>
+where
+    I: Stream + Offset,
+    <I as Stream>::Token: crate::stream::AsChar,
+    F: Parser<I, O1, Error>,
+    G: Parser<I, O2, Error>,
+    Error: ParseError<I>,
+{
+    let mut i = input.clone();
+
+    while i.eof_offset() > 0 {
+        let current_len = i.eof_offset();
+
+        match normal.parse_next(i.clone()) {
+            Ok((i2, _)) => {
+                // return if we consumed everything or if the normal parser
+                // does not consume anything
+                if i2.eof_offset() == 0 {
+                    return Ok(input.next_slice(input.eof_offset()));
+                } else if i2.eof_offset() == current_len {
+                    let offset = input.offset_to(&i2);
+                    return Ok(input.next_slice(offset));
+                } else {
+                    i = i2;
+                }
+            }
+            Err(ErrMode::Backtrack(_)) => {
+                if i.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                    let next = control_char.len_utf8();
+                    match escapable.parse_next(i.next_slice(next).0) {
+                        Ok((i2, _)) => {
+                            if i2.eof_offset() == 0 {
+                                return Ok(input.next_slice(input.eof_offset()));
+                            } else {
+                                i = i2;
+                            }
+                        }
+                        Err(e) => return Err(e),
+                    }
+                } else {
+                    let offset = input.offset_to(&i);
+                    return Ok(input.next_slice(offset));
+                }
+            }
+            Err(e) => {
+                return Err(e);
+            }
+        }
+    }
+
+    Ok(input.next_slice(input.eof_offset()))
+}
+
+/// Matches a byte string with escaped characters.
+///
+/// * The first argument matches the normal characters (it must not match the control character)
+/// * The second argument is the control character (like `\` in most languages)
+/// * The third argument matches the escaped characters and transforms them
+///
+/// As an example, the chain `abc\tdef` could be `abc    def` (it also consumes the control character)
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use std::str::from_utf8;
+/// use winnow::bytes::tag;
+/// use winnow::character::escaped_transform;
+/// use winnow::character::alpha1;
+/// use winnow::branch::alt;
+///
+/// fn parser(input: &str) -> IResult<&str, String> {
+///   escaped_transform(
+///     alpha1,
+///     '\\',
+///     alt((
+///       "\\".value("\\"),
+///       "\"".value("\""),
+///       "n".value("\n"),
+///     ))
+///   ).parse_next(input)
+/// }
+///
+/// assert_eq!(parser("ab\\\"cd"), Ok(("", String::from("ab\"cd"))));
+/// assert_eq!(parser("ab\\ncd"), Ok(("", String::from("ab\ncd"))));
+/// ```
+///
+/// ```
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use std::str::from_utf8;
+/// # use winnow::Partial;
+/// use winnow::bytes::tag;
+/// use winnow::character::escaped_transform;
+/// use winnow::character::alpha1;
+/// use winnow::branch::alt;
+///
+/// fn parser(input: Partial<&str>) -> IResult<Partial<&str>, String> {
+///   escaped_transform(
+///     alpha1,
+///     '\\',
+///     alt((
+///       "\\".value("\\"),
+///       "\"".value("\""),
+///       "n".value("\n"),
+///     ))
+///   ).parse_next(input)
+/// }
+///
+/// assert_eq!(parser(Partial::new("ab\\\"cd\"")), Ok((Partial::new("\""), String::from("ab\"cd"))));
+/// ```
+#[cfg(feature = "alloc")]
+#[inline(always)]
+pub fn escaped_transform<I, Error, F, G, Output>(
+    mut normal: F,
+    control_char: char,
+    mut transform: G,
+) -> impl Parser<I, Output, Error>
+where
+    I: StreamIsPartial,
+    I: Stream + Offset,
+    <I as Stream>::Token: crate::stream::AsChar,
+    Output: crate::stream::Accumulate<<I as Stream>::Slice>,
+    F: Parser<I, <I as Stream>::Slice, Error>,
+    G: Parser<I, <I as Stream>::Slice, Error>,
+    Error: ParseError<I>,
+{
+    trace("escaped_transform", move |input: I| {
+        if input.is_partial() {
+            streaming_escaped_transform_internal(input, &mut normal, control_char, &mut transform)
+        } else {
+            complete_escaped_transform_internal(input, &mut normal, control_char, &mut transform)
+        }
+    })
+}
+
+#[cfg(feature = "alloc")]
+pub(crate) fn streaming_escaped_transform_internal<I, Error, F, G, Output>(
+    input: I,
+    normal: &mut F,
+    control_char: char,
+    transform: &mut G,
+) -> IResult<I, Output, Error>
+where
+    I: Stream + Offset,
+    <I as Stream>::Token: crate::stream::AsChar,
+    Output: crate::stream::Accumulate<<I as Stream>::Slice>,
+    F: Parser<I, <I as Stream>::Slice, Error>,
+    G: Parser<I, <I as Stream>::Slice, Error>,
+    Error: ParseError<I>,
+{
+    let mut offset = 0;
+    let mut res = Output::initial(Some(input.eof_offset()));
+
+    let i = input.clone();
+
+    while offset < i.eof_offset() {
+        let current_len = i.eof_offset();
+        let remainder = i.next_slice(offset).0;
+        match normal.parse_next(remainder.clone()) {
+            Ok((i2, o)) => {
+                res.accumulate(o);
+                if i2.eof_offset() == 0 {
+                    return Err(ErrMode::Incomplete(Needed::Unknown));
+                } else if i2.eof_offset() == current_len {
+                    return Ok((remainder, res));
+                } else {
+                    offset = input.offset_to(&i2);
+                }
+            }
+            Err(ErrMode::Backtrack(_)) => {
+                if remainder.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                    let next = offset + control_char.len_utf8();
+                    match transform.parse_next(i.next_slice(next).0) {
+                        Ok((i2, o)) => {
+                            res.accumulate(o);
+                            if i2.eof_offset() == 0 {
+                                return Err(ErrMode::Incomplete(Needed::Unknown));
+                            } else {
+                                offset = input.offset_to(&i2);
+                            }
+                        }
+                        Err(e) => return Err(e),
+                    }
+                } else {
+                    return Ok((remainder, res));
+                }
+            }
+            Err(e) => return Err(e),
+        }
+    }
+    Err(ErrMode::Incomplete(Needed::Unknown))
+}
+
+#[cfg(feature = "alloc")]
+pub(crate) fn complete_escaped_transform_internal<I, Error, F, G, Output>(
+    input: I,
+    normal: &mut F,
+    control_char: char,
+    transform: &mut G,
+) -> IResult<I, Output, Error>
+where
+    I: Stream + Offset,
+    <I as Stream>::Token: crate::stream::AsChar,
+    Output: crate::stream::Accumulate<<I as Stream>::Slice>,
+    F: Parser<I, <I as Stream>::Slice, Error>,
+    G: Parser<I, <I as Stream>::Slice, Error>,
+    Error: ParseError<I>,
+{
+    let mut offset = 0;
+    let mut res = Output::initial(Some(input.eof_offset()));
+
+    let i = input.clone();
+
+    while offset < i.eof_offset() {
+        let current_len = i.eof_offset();
+        let (remainder, _) = i.next_slice(offset);
+        match normal.parse_next(remainder.clone()) {
+            Ok((i2, o)) => {
+                res.accumulate(o);
+                if i2.eof_offset() == 0 {
+                    return Ok((i.next_slice(i.eof_offset()).0, res));
+                } else if i2.eof_offset() == current_len {
+                    return Ok((remainder, res));
+                } else {
+                    offset = input.offset_to(&i2);
+                }
+            }
+            Err(ErrMode::Backtrack(_)) => {
+                if remainder.next_token().expect("eof_offset > 0").1.as_char() == control_char {
+                    let next = offset + control_char.len_utf8();
+                    match transform.parse_next(i.next_slice(next).0) {
+                        Ok((i2, o)) => {
+                            res.accumulate(o);
+                            if i2.eof_offset() == 0 {
+                                return Ok((i.next_slice(i.eof_offset()).0, res));
+                            } else {
+                                offset = input.offset_to(&i2);
+                            }
+                        }
+                        Err(e) => return Err(e),
+                    }
+                } else {
+                    return Ok((remainder, res));
+                }
+            }
+            Err(e) => return Err(e),
+        }
+    }
+    Ok((input.next_slice(offset).0, res))
+}
+
+mod sealed {
+    pub struct SealedMarker;
+}
diff --git a/vendor/winnow/src/character/tests.rs b/vendor/winnow/src/character/tests.rs
new file mode 100644
index 000000000..95a63c303
--- /dev/null
+++ b/vendor/winnow/src/character/tests.rs
@@ -0,0 +1,1496 @@
+use super::*;
+
+mod complete {
+    use super::*;
+    use crate::branch::alt;
+    use crate::bytes::none_of;
+    use crate::bytes::one_of;
+    use crate::combinator::opt;
+    use crate::error::ErrMode;
+    use crate::error::Error;
+    use crate::error::ErrorKind;
+    use crate::stream::ParseSlice;
+    #[cfg(feature = "alloc")]
+    use crate::{lib::std::string::String, lib::std::vec::Vec};
+    use proptest::prelude::*;
+
+    macro_rules! assert_parse(
+    ($left: expr, $right: expr) => {
+      let res: $crate::IResult<_, _, Error<_>> = $left;
+      assert_eq!(res, $right);
+    };
+  );
+
+    #[test]
+    fn character() {
+        let empty: &[u8] = b"";
+        let a: &[u8] = b"abcd";
+        let b: &[u8] = b"1234";
+        let c: &[u8] = b"a123";
+        let d: &[u8] = "azé12".as_bytes();
+        let e: &[u8] = b" ";
+        let f: &[u8] = b" ;";
+        //assert_eq!(alpha1::<_, Error>(a), Err(ErrMode::Incomplete(Needed::Size(1))));
+        assert_parse!(alpha1(a), Ok((empty, a)));
+        assert_eq!(
+            alpha1(b),
+            Err(ErrMode::Backtrack(Error::new(b, ErrorKind::Slice)))
+        );
+        assert_eq!(alpha1::<_, Error<_>>(c), Ok((&c[1..], &b"a"[..])));
+        assert_eq!(alpha1::<_, Error<_>>(d), Ok(("é12".as_bytes(), &b"az"[..])));
+        assert_eq!(
+            digit1(a),
+            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+        );
+        assert_eq!(digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(
+            digit1(c),
+            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+        );
+        assert_eq!(
+            digit1(d),
+            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+        );
+        assert_eq!(hex_digit1::<_, Error<_>>(a), Ok((empty, a)));
+        assert_eq!(hex_digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(hex_digit1::<_, Error<_>>(c), Ok((empty, c)));
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(d),
+            Ok(("zé12".as_bytes(), &b"a"[..]))
+        );
+        assert_eq!(
+            hex_digit1(e),
+            Err(ErrMode::Backtrack(Error::new(e, ErrorKind::Slice)))
+        );
+        assert_eq!(
+            oct_digit1(a),
+            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+        );
+        assert_eq!(oct_digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(
+            oct_digit1(c),
+            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+        );
+        assert_eq!(
+            oct_digit1(d),
+            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+        );
+        assert_eq!(alphanumeric1::<_, Error<_>>(a), Ok((empty, a)));
+        //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b)));
+        assert_eq!(alphanumeric1::<_, Error<_>>(c), Ok((empty, c)));
+        assert_eq!(
+            alphanumeric1::<_, Error<_>>(d),
+            Ok(("é12".as_bytes(), &b"az"[..]))
+        );
+        assert_eq!(space1::<_, Error<_>>(e), Ok((empty, e)));
+        assert_eq!(space1::<_, Error<_>>(f), Ok((&b";"[..], &b" "[..])));
+    }
+
+    #[cfg(feature = "alloc")]
+    #[test]
+    fn character_s() {
+        let empty = "";
+        let a = "abcd";
+        let b = "1234";
+        let c = "a123";
+        let d = "azé12";
+        let e = " ";
+        assert_eq!(alpha1::<_, Error<_>>(a), Ok((empty, a)));
+        assert_eq!(
+            alpha1(b),
+            Err(ErrMode::Backtrack(Error::new(b, ErrorKind::Slice)))
+        );
+        assert_eq!(alpha1::<_, Error<_>>(c), Ok((&c[1..], "a")));
+        assert_eq!(alpha1::<_, Error<_>>(d), Ok(("é12", "az")));
+        assert_eq!(
+            digit1(a),
+            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+        );
+        assert_eq!(digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(
+            digit1(c),
+            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+        );
+        assert_eq!(
+            digit1(d),
+            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+        );
+        assert_eq!(hex_digit1::<_, Error<_>>(a), Ok((empty, a)));
+        assert_eq!(hex_digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(hex_digit1::<_, Error<_>>(c), Ok((empty, c)));
+        assert_eq!(hex_digit1::<_, Error<_>>(d), Ok(("zé12", "a")));
+        assert_eq!(
+            hex_digit1(e),
+            Err(ErrMode::Backtrack(Error::new(e, ErrorKind::Slice)))
+        );
+        assert_eq!(
+            oct_digit1(a),
+            Err(ErrMode::Backtrack(Error::new(a, ErrorKind::Slice)))
+        );
+        assert_eq!(oct_digit1::<_, Error<_>>(b), Ok((empty, b)));
+        assert_eq!(
+            oct_digit1(c),
+            Err(ErrMode::Backtrack(Error::new(c, ErrorKind::Slice)))
+        );
+        assert_eq!(
+            oct_digit1(d),
+            Err(ErrMode::Backtrack(Error::new(d, ErrorKind::Slice)))
+        );
+        assert_eq!(alphanumeric1::<_, Error<_>>(a), Ok((empty, a)));
+        //assert_eq!(fix_error!(b,(), alphanumeric), Ok((empty, b)));
+        assert_eq!(alphanumeric1::<_, Error<_>>(c), Ok((empty, c)));
+        assert_eq!(alphanumeric1::<_, Error<_>>(d), Ok(("é12", "az")));
+        assert_eq!(space1::<_, Error<_>>(e), Ok((empty, e)));
+    }
+
+    use crate::stream::Offset;
+    #[test]
+    fn offset() {
+        let a = &b"abcd;"[..];
+        let b = &b"1234;"[..];
+        let c = &b"a123;"[..];
+        let d = &b" \t;"[..];
+        let e = &b" \t\r\n;"[..];
+        let f = &b"123abcDEF;"[..];
+
+        match alpha1::<_, Error<_>>(a) {
+            Ok((i, _)) => {
+                assert_eq!(a.offset_to(i) + i.len(), a.len());
+            }
+            _ => panic!("wrong return type in offset test for alpha"),
+        }
+        match digit1::<_, Error<_>>(b) {
+            Ok((i, _)) => {
+                assert_eq!(b.offset_to(i) + i.len(), b.len());
+            }
+            _ => panic!("wrong return type in offset test for digit"),
+        }
+        match alphanumeric1::<_, Error<_>>(c) {
+            Ok((i, _)) => {
+                assert_eq!(c.offset_to(i) + i.len(), c.len());
+            }
+            _ => panic!("wrong return type in offset test for alphanumeric"),
+        }
+        match space1::<_, Error<_>>(d) {
+            Ok((i, _)) => {
+                assert_eq!(d.offset_to(i) + i.len(), d.len());
+            }
+            _ => panic!("wrong return type in offset test for space"),
+        }
+        match multispace1::<_, Error<_>>(e) {
+            Ok((i, _)) => {
+                assert_eq!(e.offset_to(i) + i.len(), e.len());
+            }
+            _ => panic!("wrong return type in offset test for multispace"),
+        }
+        match hex_digit1::<_, Error<_>>(f) {
+            Ok((i, _)) => {
+                assert_eq!(f.offset_to(i) + i.len(), f.len());
+            }
+            _ => panic!("wrong return type in offset test for hex_digit"),
+        }
+        match oct_digit1::<_, Error<_>>(f) {
+            Ok((i, _)) => {
+                assert_eq!(f.offset_to(i) + i.len(), f.len());
+            }
+            _ => panic!("wrong return type in offset test for oct_digit"),
+        }
+    }
+
+    #[test]
+    fn is_not_line_ending_bytes() {
+        let a: &[u8] = b"ab12cd\nefgh";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(a),
+            Ok((&b"\nefgh"[..], &b"ab12cd"[..]))
+        );
+
+        let b: &[u8] = b"ab12cd\nefgh\nijkl";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(b),
+            Ok((&b"\nefgh\nijkl"[..], &b"ab12cd"[..]))
+        );
+
+        let c: &[u8] = b"ab12cd\r\nefgh\nijkl";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(c),
+            Ok((&b"\r\nefgh\nijkl"[..], &b"ab12cd"[..]))
+        );
+
+        let d: &[u8] = b"ab12cd";
+        assert_eq!(not_line_ending::<_, Error<_>>(d), Ok((&[][..], d)));
+    }
+
+    #[test]
+    fn is_not_line_ending_str() {
+        let f = "βèƒôřè\rÂßÇáƒƭèř";
+        assert_eq!(
+            not_line_ending(f),
+            Err(ErrMode::Backtrack(Error::new(f, ErrorKind::Tag)))
+        );
+
+        let g2: &str = "ab12cd";
+        assert_eq!(not_line_ending::<_, Error<_>>(g2), Ok(("", g2)));
+    }
+
+    #[test]
+    fn hex_digit_test() {
+        let i = &b"0123456789abcdefABCDEF;"[..];
+        assert_parse!(hex_digit1(i), Ok((&b";"[..], &i[..i.len() - 1])));
+
+        let i = &b"g"[..];
+        assert_parse!(
+            hex_digit1(i),
+            Err(ErrMode::Backtrack(error_position!(i, ErrorKind::Slice)))
+        );
+
+        let i = &b"G"[..];
+        assert_parse!(
+            hex_digit1(i),
+            Err(ErrMode::Backtrack(error_position!(i, ErrorKind::Slice)))
+        );
+
+        assert!(AsChar::is_hex_digit(b'0'));
+        assert!(AsChar::is_hex_digit(b'9'));
+        assert!(AsChar::is_hex_digit(b'a'));
+        assert!(AsChar::is_hex_digit(b'f'));
+        assert!(AsChar::is_hex_digit(b'A'));
+        assert!(AsChar::is_hex_digit(b'F'));
+        assert!(!AsChar::is_hex_digit(b'g'));
+        assert!(!AsChar::is_hex_digit(b'G'));
+        assert!(!AsChar::is_hex_digit(b'/'));
+        assert!(!AsChar::is_hex_digit(b':'));
+        assert!(!AsChar::is_hex_digit(b'@'));
+        assert!(!AsChar::is_hex_digit(b'\x60'));
+    }
+
+    #[test]
+    fn oct_digit_test() {
+        let i = &b"01234567;"[..];
+        assert_parse!(oct_digit1(i), Ok((&b";"[..], &i[..i.len() - 1])));
+
+        let i = &b"8"[..];
+        assert_parse!(
+            oct_digit1(i),
+            Err(ErrMode::Backtrack(error_position!(i, ErrorKind::Slice)))
+        );
+
+        assert!(AsChar::is_oct_digit(b'0'));
+        assert!(AsChar::is_oct_digit(b'7'));
+        assert!(!AsChar::is_oct_digit(b'8'));
+        assert!(!AsChar::is_oct_digit(b'9'));
+        assert!(!AsChar::is_oct_digit(b'a'));
+        assert!(!AsChar::is_oct_digit(b'A'));
+        assert!(!AsChar::is_oct_digit(b'/'));
+        assert!(!AsChar::is_oct_digit(b':'));
+        assert!(!AsChar::is_oct_digit(b'@'));
+        assert!(!AsChar::is_oct_digit(b'\x60'));
+    }
+
+    #[test]
+    fn full_line_windows() {
+        fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
+            (not_line_ending, line_ending).parse_next(i)
+        }
+        let input = b"abc\r\n";
+        let output = take_full_line(input);
+        assert_eq!(output, Ok((&b""[..], (&b"abc"[..], &b"\r\n"[..]))));
+    }
+
+    #[test]
+    fn full_line_unix() {
+        fn take_full_line(i: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
+            (not_line_ending, line_ending).parse_next(i)
+        }
+        let input = b"abc\n";
+        let output = take_full_line(input);
+        assert_eq!(output, Ok((&b""[..], (&b"abc"[..], &b"\n"[..]))));
+    }
+
+    #[test]
+    fn check_windows_lineending() {
+        let input = b"\r\n";
+        let output = line_ending(&input[..]);
+        assert_parse!(output, Ok((&b""[..], &b"\r\n"[..])));
+    }
+
+    #[test]
+    fn check_unix_lineending() {
+        let input = b"\n";
+        let output = line_ending(&input[..]);
+        assert_parse!(output, Ok((&b""[..], &b"\n"[..])));
+    }
+
+    #[test]
+    fn cr_lf() {
+        assert_parse!(crlf(&b"\r\na"[..]), Ok((&b"a"[..], &b"\r\n"[..])));
+        assert_parse!(
+            crlf(&b"\r"[..]),
+            Err(ErrMode::Backtrack(error_position!(
+                &b"\r"[..],
+                ErrorKind::Tag
+            )))
+        );
+        assert_parse!(
+            crlf(&b"\ra"[..]),
+            Err(ErrMode::Backtrack(error_position!(
+                &b"\ra"[..],
+                ErrorKind::Tag
+            )))
+        );
+
+        assert_parse!(crlf("\r\na"), Ok(("a", "\r\n")));
+        assert_parse!(
+            crlf("\r"),
+            Err(ErrMode::Backtrack(error_position!("\r", ErrorKind::Tag)))
+        );
+        assert_parse!(
+            crlf("\ra"),
+            Err(ErrMode::Backtrack(error_position!("\ra", ErrorKind::Tag)))
+        );
+    }
+
+    #[test]
+    fn end_of_line() {
+        assert_parse!(line_ending(&b"\na"[..]), Ok((&b"a"[..], &b"\n"[..])));
+        assert_parse!(line_ending(&b"\r\na"[..]), Ok((&b"a"[..], &b"\r\n"[..])));
+        assert_parse!(
+            line_ending(&b"\r"[..]),
+            Err(ErrMode::Backtrack(error_position!(
+                &b"\r"[..],
+                ErrorKind::Tag
+            )))
+        );
+        assert_parse!(
+            line_ending(&b"\ra"[..]),
+            Err(ErrMode::Backtrack(error_position!(
+                &b"\ra"[..],
+                ErrorKind::Tag
+            )))
+        );
+
+        assert_parse!(line_ending("\na"), Ok(("a", "\n")));
+        assert_parse!(line_ending("\r\na"), Ok(("a", "\r\n")));
+        assert_parse!(
+            line_ending("\r"),
+            Err(ErrMode::Backtrack(error_position!("\r", ErrorKind::Tag)))
+        );
+        assert_parse!(
+            line_ending("\ra"),
+            Err(ErrMode::Backtrack(error_position!("\ra", ErrorKind::Tag)))
+        );
+    }
+
+    fn digit_to_i16(input: &str) -> IResult<&str, i16> {
+        let i = input;
+        let (i, opt_sign) = opt(alt(('+', '-'))).parse_next(i)?;
+        let sign = match opt_sign {
+            Some('+') | None => true,
+            Some('-') => false,
+            _ => unreachable!(),
+        };
+
+        let (i, s) = digit1::<_, crate::error::Error<_>>(i)?;
+        match s.parse_slice() {
+            Some(n) => {
+                if sign {
+                    Ok((i, n))
+                } else {
+                    Ok((i, -n))
+                }
+            }
+            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+        }
+    }
+
+    fn digit_to_u32(i: &str) -> IResult<&str, u32> {
+        let (i, s) = digit1(i)?;
+        match s.parse_slice() {
+            Some(n) => Ok((i, n)),
+            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+        }
+    }
+
+    proptest! {
+      #[test]
+      #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+      fn ints(s in "\\PC*") {
+          let res1 = digit_to_i16(&s);
+          let res2 = dec_int(s.as_str());
+          assert_eq!(res1, res2);
+      }
+
+      #[test]
+      #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+      fn uints(s in "\\PC*") {
+          let res1 = digit_to_u32(&s);
+          let res2 = dec_uint(s.as_str());
+          assert_eq!(res1, res2);
+      }
+    }
+
+    #[test]
+    fn hex_uint_tests() {
+        fn hex_u32(input: &[u8]) -> IResult<&[u8], u32> {
+            hex_uint(input)
+        }
+
+        assert_parse!(
+            hex_u32(&b";"[..]),
+            Err(ErrMode::Backtrack(error_position!(
+                &b";"[..],
+                ErrorKind::Slice
+            )))
+        );
+        assert_parse!(hex_u32(&b"ff;"[..]), Ok((&b";"[..], 255)));
+        assert_parse!(hex_u32(&b"1be2;"[..]), Ok((&b";"[..], 7138)));
+        assert_parse!(hex_u32(&b"c5a31be2;"[..]), Ok((&b";"[..], 3_315_801_058)));
+        assert_parse!(hex_u32(&b"C5A31be2;"[..]), Ok((&b";"[..], 3_315_801_058)));
+        assert_parse!(
+            hex_u32(&b"00c5a31be2;"[..]), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                &b"00c5a31be2;"[..],
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(
+            hex_u32(&b"c5a31be201;"[..]), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                &b"c5a31be201;"[..],
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(hex_u32(&b"ffffffff;"[..]), Ok((&b";"[..], 4_294_967_295)));
+        assert_parse!(
+            hex_u32(&b"ffffffffffffffff;"[..]), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                &b"ffffffffffffffff;"[..],
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(
+            hex_u32(&b"ffffffffffffffff"[..]), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                &b"ffffffffffffffff"[..],
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(hex_u32(&b"0x1be2;"[..]), Ok((&b"x1be2;"[..], 0)));
+        assert_parse!(hex_u32(&b"12af"[..]), Ok((&b""[..], 0x12af)));
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn float_test() {
+        let mut test_cases = vec![
+            "+3.14",
+            "3.14",
+            "-3.14",
+            "0",
+            "0.0",
+            "1.",
+            ".789",
+            "-.5",
+            "1e7",
+            "-1E-7",
+            ".3e-2",
+            "1.e4",
+            "1.2e4",
+            "12.34",
+            "-1.234E-12",
+            "-1.234e-12",
+            "0.00000000000000000087",
+        ];
+
+        for test in test_cases.drain(..) {
+            let expected32 = str::parse::<f32>(test).unwrap();
+            let expected64 = str::parse::<f64>(test).unwrap();
+
+            println!("now parsing: {} -> {}", test, expected32);
+
+            let larger = test.to_string();
+
+            assert_parse!(float(larger.as_bytes()), Ok((&b""[..], expected32)));
+            assert_parse!(float(&larger[..]), Ok(("", expected32)));
+
+            assert_parse!(float(larger.as_bytes()), Ok((&b""[..], expected64)));
+            assert_parse!(float(&larger[..]), Ok(("", expected64)));
+        }
+
+        let remaining_exponent = "-1.234E-";
+        assert_parse!(
+            float::<_, f64, _>(remaining_exponent),
+            Err(ErrMode::Cut(Error {
+                input: "",
+                kind: ErrorKind::Slice
+            }))
+        );
+
+        let (_i, nan) = float::<_, f32, ()>("NaN").unwrap();
+        assert!(nan.is_nan());
+
+        let (_i, inf) = float::<_, f32, ()>("inf").unwrap();
+        assert!(inf.is_infinite());
+        let (_i, inf) = float::<_, f32, ()>("infinite").unwrap();
+        assert!(inf.is_infinite());
+    }
+
+    #[cfg(feature = "std")]
+    fn parse_f64(i: &str) -> IResult<&str, f64, ()> {
+        #[allow(deprecated)] // will just become `pub(crate)` later
+        match super::recognize_float_or_exceptions(i) {
+            Err(e) => Err(e),
+            Ok((i, s)) => {
+                if s.is_empty() {
+                    return Err(ErrMode::Backtrack(()));
+                }
+                match s.parse_slice() {
+                    Some(n) => Ok((i, n)),
+                    None => Err(ErrMode::Backtrack(())),
+                }
+            }
+        }
+    }
+
+    proptest! {
+      #[test]
+      #[cfg(feature = "std")]
+      #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+      fn floats(s in "\\PC*") {
+          println!("testing {}", s);
+          let res1 = parse_f64(&s);
+          let res2 = float::<_, f64, ()>(s.as_str());
+          assert_eq!(res1, res2);
+      }
+    }
+
+    // issue #1336 "escaped hangs if normal parser accepts empty"
+    #[test]
+    fn complete_escaped_hang() {
+        // issue #1336 "escaped hangs if normal parser accepts empty"
+        fn escaped_string(input: &str) -> IResult<&str, &str> {
+            use crate::bytes::one_of;
+            use crate::character::alpha0;
+            escaped(alpha0, '\\', one_of("n")).parse_next(input)
+        }
+
+        escaped_string("7").unwrap();
+        escaped_string("a7").unwrap();
+    }
+
+    #[test]
+    fn complete_escaped_hang_1118() {
+        // issue ##1118 escaped does not work with empty string
+        fn unquote(input: &str) -> IResult<&str, &str> {
+            use crate::bytes::one_of;
+            use crate::combinator::opt;
+            use crate::sequence::delimited;
+
+            delimited(
+                '"',
+                escaped(opt(none_of(r#"\""#)), '\\', one_of(r#"\"rnt"#)),
+                '"',
+            )
+            .parse_next(input)
+        }
+
+        assert_eq!(unquote(r#""""#), Ok(("", "")));
+    }
+
+    #[cfg(feature = "alloc")]
+    #[allow(unused_variables)]
+    #[test]
+    fn complete_escaping() {
+        use crate::bytes::one_of;
+        use crate::character::{alpha1 as alpha, digit1 as digit};
+
+        fn esc(i: &[u8]) -> IResult<&[u8], &[u8]> {
+            escaped(alpha, '\\', one_of("\"n\\")).parse_next(i)
+        }
+        assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], &b"abcd"[..])));
+        assert_eq!(esc(&b"ab\\\"cd;"[..]), Ok((&b";"[..], &b"ab\\\"cd"[..])));
+        assert_eq!(esc(&b"\\\"abcd;"[..]), Ok((&b";"[..], &b"\\\"abcd"[..])));
+        assert_eq!(esc(&b"\\n;"[..]), Ok((&b";"[..], &b"\\n"[..])));
+        assert_eq!(esc(&b"ab\\\"12"[..]), Ok((&b"12"[..], &b"ab\\\""[..])));
+        assert_eq!(
+            esc(&b"AB\\"[..]),
+            Err(ErrMode::Backtrack(error_position!(
+                &b""[..],
+                ErrorKind::Token
+            )))
+        );
+        assert_eq!(
+            esc(&b"AB\\A"[..]),
+            Err(ErrMode::Backtrack(error_node_position!(
+                &b"AB\\A"[..],
+                ErrorKind::Token,
+                error_position!(&b"A"[..], ErrorKind::Verify)
+            )))
+        );
+
+        fn esc2(i: &[u8]) -> IResult<&[u8], &[u8]> {
+            escaped(digit, '\\', one_of("\"n\\")).parse_next(i)
+        }
+        assert_eq!(esc2(&b"12\\nnn34"[..]), Ok((&b"nn34"[..], &b"12\\n"[..])));
+    }
+
+    #[cfg(feature = "alloc")]
+    #[test]
+    fn complete_escaping_str() {
+        use crate::bytes::one_of;
+        use crate::character::{alpha1 as alpha, digit1 as digit};
+
+        fn esc(i: &str) -> IResult<&str, &str> {
+            escaped(alpha, '\\', one_of("\"n\\")).parse_next(i)
+        }
+        assert_eq!(esc("abcd;"), Ok((";", "abcd")));
+        assert_eq!(esc("ab\\\"cd;"), Ok((";", "ab\\\"cd")));
+        assert_eq!(esc("\\\"abcd;"), Ok((";", "\\\"abcd")));
+        assert_eq!(esc("\\n;"), Ok((";", "\\n")));
+        assert_eq!(esc("ab\\\"12"), Ok(("12", "ab\\\"")));
+        assert_eq!(
+            esc("AB\\"),
+            Err(ErrMode::Backtrack(error_position!("", ErrorKind::Token)))
+        );
+        assert_eq!(
+            esc("AB\\A"),
+            Err(ErrMode::Backtrack(error_node_position!(
+                "AB\\A",
+                ErrorKind::Token,
+                error_position!("A", ErrorKind::Verify)
+            )))
+        );
+
+        fn esc2(i: &str) -> IResult<&str, &str> {
+            escaped(digit, '\\', one_of("\"n\\")).parse_next(i)
+        }
+        assert_eq!(esc2("12\\nnn34"), Ok(("nn34", "12\\n")));
+
+        fn esc3(i: &str) -> IResult<&str, &str> {
+            escaped(alpha, '\u{241b}', one_of("\"n")).parse_next(i)
+        }
+        assert_eq!(esc3("ab␛ncd;"), Ok((";", "ab␛ncd")));
+    }
+
+    #[test]
+    fn test_escaped_error() {
+        fn esc(s: &str) -> IResult<&str, &str> {
+            use crate::character::digit1;
+            escaped(digit1, '\\', one_of("\"n\\")).parse_next(s)
+        }
+
+        assert_eq!(esc("abcd"), Ok(("abcd", "")));
+    }
+
+    #[cfg(feature = "alloc")]
+    #[test]
+    fn complete_escape_transform() {
+        use crate::character::alpha1 as alpha;
+
+        #[cfg(feature = "alloc")]
+        fn to_s(i: Vec<u8>) -> String {
+            String::from_utf8_lossy(&i).into_owned()
+        }
+
+        fn esc(i: &[u8]) -> IResult<&[u8], String> {
+            escaped_transform(
+                alpha,
+                '\\',
+                alt((
+                    "\\".value(&b"\\"[..]),
+                    "\"".value(&b"\""[..]),
+                    "n".value(&b"\n"[..]),
+                )),
+            )
+            .map(to_s)
+            .parse_next(i)
+        }
+
+        assert_eq!(esc(&b"abcd;"[..]), Ok((&b";"[..], String::from("abcd"))));
+        assert_eq!(
+            esc(&b"ab\\\"cd;"[..]),
+            Ok((&b";"[..], String::from("ab\"cd")))
+        );
+        assert_eq!(
+            esc(&b"\\\"abcd;"[..]),
+            Ok((&b";"[..], String::from("\"abcd")))
+        );
+        assert_eq!(esc(&b"\\n;"[..]), Ok((&b";"[..], String::from("\n"))));
+        assert_eq!(
+            esc(&b"ab\\\"12"[..]),
+            Ok((&b"12"[..], String::from("ab\"")))
+        );
+        assert_eq!(
+            esc(&b"AB\\"[..]),
+            Err(ErrMode::Backtrack(error_position!(
+                &b""[..],
+                ErrorKind::Tag
+            )))
+        );
+        assert_eq!(
+            esc(&b"AB\\A"[..]),
+            Err(ErrMode::Backtrack(error_node_position!(
+                &b"AB\\A"[..],
+                ErrorKind::Eof,
+                error_position!(&b"A"[..], ErrorKind::Tag)
+            )))
+        );
+
+        fn esc2(i: &[u8]) -> IResult<&[u8], String> {
+            escaped_transform(
+                alpha,
+                '&',
+                alt((
+                    "egrave;".value("è".as_bytes()),
+                    "agrave;".value("à".as_bytes()),
+                )),
+            )
+            .map(to_s)
+            .parse_next(i)
+        }
+        assert_eq!(
+            esc2(&b"ab&egrave;DEF;"[..]),
+            Ok((&b";"[..], String::from("abèDEF")))
+        );
+        assert_eq!(
+            esc2(&b"ab&egrave;D&agrave;EF;"[..]),
+            Ok((&b";"[..], String::from("abèDàEF")))
+        );
+    }
+
+    #[cfg(feature = "std")]
+    #[test]
+    fn complete_escape_transform_str() {
+        use crate::character::alpha1 as alpha;
+
+        fn esc(i: &str) -> IResult<&str, String> {
+            escaped_transform(
+                alpha,
+                '\\',
+                alt(("\\".value("\\"), "\"".value("\""), "n".value("\n"))),
+            )
+            .parse_next(i)
+        }
+
+        assert_eq!(esc("abcd;"), Ok((";", String::from("abcd"))));
+        assert_eq!(esc("ab\\\"cd;"), Ok((";", String::from("ab\"cd"))));
+        assert_eq!(esc("\\\"abcd;"), Ok((";", String::from("\"abcd"))));
+        assert_eq!(esc("\\n;"), Ok((";", String::from("\n"))));
+        assert_eq!(esc("ab\\\"12"), Ok(("12", String::from("ab\""))));
+        assert_eq!(
+            esc("AB\\"),
+            Err(ErrMode::Backtrack(error_position!("", ErrorKind::Tag)))
+        );
+        assert_eq!(
+            esc("AB\\A"),
+            Err(ErrMode::Backtrack(error_node_position!(
+                "AB\\A",
+                ErrorKind::Eof,
+                error_position!("A", ErrorKind::Tag)
+            )))
+        );
+
+        fn esc2(i: &str) -> IResult<&str, String> {
+            escaped_transform(
+                alpha,
+                '&',
+                alt(("egrave;".value("è"), "agrave;".value("à"))),
+            )
+            .parse_next(i)
+        }
+        assert_eq!(esc2("ab&egrave;DEF;"), Ok((";", String::from("abèDEF"))));
+        assert_eq!(
+            esc2("ab&egrave;D&agrave;EF;"),
+            Ok((";", String::from("abèDàEF")))
+        );
+
+        fn esc3(i: &str) -> IResult<&str, String> {
+            escaped_transform(alpha, '␛', alt(("0".value("\0"), "n".value("\n")))).parse_next(i)
+        }
+        assert_eq!(esc3("a␛0bc␛n"), Ok(("", String::from("a\0bc\n"))));
+    }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn test_escaped_transform_error() {
+        fn esc_trans(s: &str) -> IResult<&str, String> {
+            use crate::character::digit1;
+            escaped_transform(digit1, '\\', "n").parse_next(s)
+        }
+
+        assert_eq!(esc_trans("abcd"), Ok(("abcd", String::new())));
+    }
+}
+
+mod partial {
+    use super::*;
+    use crate::combinator::opt;
+    use crate::error::Error;
+    use crate::error::ErrorKind;
+    use crate::error::{ErrMode, Needed};
+    use crate::stream::ParseSlice;
+    use crate::IResult;
+    use crate::Partial;
+    use proptest::prelude::*;
+
+    macro_rules! assert_parse(
+    ($left: expr, $right: expr) => {
+      let res: $crate::IResult<_, _, Error<_>> = $left;
+      assert_eq!(res, $right);
+    };
+  );
+
+    #[test]
+    fn character() {
+        let a: &[u8] = b"abcd";
+        let b: &[u8] = b"1234";
+        let c: &[u8] = b"a123";
+        let d: &[u8] = "azé12".as_bytes();
+        let e: &[u8] = b" ";
+        let f: &[u8] = b" ;";
+        //assert_eq!(alpha1::<_, Error<_>>(a), Err(ErrMode::Incomplete(Needed::new(1))));
+        assert_parse!(
+            alpha1(Partial::new(a)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            alpha1(Partial::new(b)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(b),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            alpha1::<_, Error<_>>(Partial::new(c)),
+            Ok((Partial::new(&c[1..]), &b"a"[..]))
+        );
+        assert_eq!(
+            alpha1::<_, Error<_>>(Partial::new(d)),
+            Ok((Partial::new("é12".as_bytes()), &b"az"[..]))
+        );
+        assert_eq!(
+            digit1(Partial::new(a)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(a),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            digit1::<_, Error<_>>(Partial::new(b)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            digit1(Partial::new(c)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(c),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            digit1(Partial::new(d)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(d),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(a)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(b)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(c)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(d)),
+            Ok((Partial::new("zé12".as_bytes()), &b"a"[..]))
+        );
+        assert_eq!(
+            hex_digit1(Partial::new(e)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(e),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            oct_digit1(Partial::new(a)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(a),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            oct_digit1::<_, Error<_>>(Partial::new(b)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            oct_digit1(Partial::new(c)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(c),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            oct_digit1(Partial::new(d)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(d),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            alphanumeric1::<_, Error<_>>(Partial::new(a)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b)));
+        assert_eq!(
+            alphanumeric1::<_, Error<_>>(Partial::new(c)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            alphanumeric1::<_, Error<_>>(Partial::new(d)),
+            Ok((Partial::new("é12".as_bytes()), &b"az"[..]))
+        );
+        assert_eq!(
+            space1::<_, Error<_>>(Partial::new(e)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            space1::<_, Error<_>>(Partial::new(f)),
+            Ok((Partial::new(&b";"[..]), &b" "[..]))
+        );
+    }
+
+    #[cfg(feature = "alloc")]
+    #[test]
+    fn character_s() {
+        let a = "abcd";
+        let b = "1234";
+        let c = "a123";
+        let d = "azé12";
+        let e = " ";
+        assert_eq!(
+            alpha1::<_, Error<_>>(Partial::new(a)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            alpha1(Partial::new(b)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(b),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            alpha1::<_, Error<_>>(Partial::new(c)),
+            Ok((Partial::new(&c[1..]), "a"))
+        );
+        assert_eq!(
+            alpha1::<_, Error<_>>(Partial::new(d)),
+            Ok((Partial::new("é12"), "az"))
+        );
+        assert_eq!(
+            digit1(Partial::new(a)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(a),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            digit1::<_, Error<_>>(Partial::new(b)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            digit1(Partial::new(c)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(c),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            digit1(Partial::new(d)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(d),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(a)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(b)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(c)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            hex_digit1::<_, Error<_>>(Partial::new(d)),
+            Ok((Partial::new("zé12"), "a"))
+        );
+        assert_eq!(
+            hex_digit1(Partial::new(e)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(e),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            oct_digit1(Partial::new(a)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(a),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            oct_digit1::<_, Error<_>>(Partial::new(b)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            oct_digit1(Partial::new(c)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(c),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            oct_digit1(Partial::new(d)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(d),
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            alphanumeric1::<_, Error<_>>(Partial::new(a)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b)));
+        assert_eq!(
+            alphanumeric1::<_, Error<_>>(Partial::new(c)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            alphanumeric1::<_, Error<_>>(Partial::new(d)),
+            Ok((Partial::new("é12"), "az"))
+        );
+        assert_eq!(
+            space1::<_, Error<_>>(Partial::new(e)),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    use crate::stream::Offset;
+    #[test]
+    fn offset() {
+        let a = &b"abcd;"[..];
+        let b = &b"1234;"[..];
+        let c = &b"a123;"[..];
+        let d = &b" \t;"[..];
+        let e = &b" \t\r\n;"[..];
+        let f = &b"123abcDEF;"[..];
+
+        match alpha1::<_, Error<_>>(Partial::new(a)) {
+            Ok((i, _)) => {
+                let i = i.into_inner();
+                assert_eq!(a.offset_to(i) + i.len(), a.len());
+            }
+            _ => panic!("wrong return type in offset test for alpha"),
+        }
+        match digit1::<_, Error<_>>(Partial::new(b)) {
+            Ok((i, _)) => {
+                let i = i.into_inner();
+                assert_eq!(b.offset_to(i) + i.len(), b.len());
+            }
+            _ => panic!("wrong return type in offset test for digit"),
+        }
+        match alphanumeric1::<_, Error<_>>(Partial::new(c)) {
+            Ok((i, _)) => {
+                let i = i.into_inner();
+                assert_eq!(c.offset_to(i) + i.len(), c.len());
+            }
+            _ => panic!("wrong return type in offset test for alphanumeric"),
+        }
+        match space1::<_, Error<_>>(Partial::new(d)) {
+            Ok((i, _)) => {
+                let i = i.into_inner();
+                assert_eq!(d.offset_to(i) + i.len(), d.len());
+            }
+            _ => panic!("wrong return type in offset test for space"),
+        }
+        match multispace1::<_, Error<_>>(Partial::new(e)) {
+            Ok((i, _)) => {
+                let i = i.into_inner();
+                assert_eq!(e.offset_to(i) + i.len(), e.len());
+            }
+            _ => panic!("wrong return type in offset test for multispace"),
+        }
+        match hex_digit1::<_, Error<_>>(Partial::new(f)) {
+            Ok((i, _)) => {
+                let i = i.into_inner();
+                assert_eq!(f.offset_to(i) + i.len(), f.len());
+            }
+            _ => panic!("wrong return type in offset test for hex_digit"),
+        }
+        match oct_digit1::<_, Error<_>>(Partial::new(f)) {
+            Ok((i, _)) => {
+                let i = i.into_inner();
+                assert_eq!(f.offset_to(i) + i.len(), f.len());
+            }
+            _ => panic!("wrong return type in offset test for oct_digit"),
+        }
+    }
+
+    #[test]
+    fn is_not_line_ending_bytes() {
+        let a: &[u8] = b"ab12cd\nefgh";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(Partial::new(a)),
+            Ok((Partial::new(&b"\nefgh"[..]), &b"ab12cd"[..]))
+        );
+
+        let b: &[u8] = b"ab12cd\nefgh\nijkl";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(Partial::new(b)),
+            Ok((Partial::new(&b"\nefgh\nijkl"[..]), &b"ab12cd"[..]))
+        );
+
+        let c: &[u8] = b"ab12cd\r\nefgh\nijkl";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(Partial::new(c)),
+            Ok((Partial::new(&b"\r\nefgh\nijkl"[..]), &b"ab12cd"[..]))
+        );
+
+        let d: &[u8] = b"ab12cd";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(Partial::new(d)),
+            Err(ErrMode::Incomplete(Needed::Unknown))
+        );
+    }
+
+    #[test]
+    fn is_not_line_ending_str() {
+        let f = "βèƒôřè\rÂßÇáƒƭèř";
+        assert_eq!(
+            not_line_ending(Partial::new(f)),
+            Err(ErrMode::Backtrack(Error::new(
+                Partial::new(f),
+                ErrorKind::Tag
+            )))
+        );
+
+        let g2: &str = "ab12cd";
+        assert_eq!(
+            not_line_ending::<_, Error<_>>(Partial::new(g2)),
+            Err(ErrMode::Incomplete(Needed::Unknown))
+        );
+    }
+
+    #[test]
+    fn hex_digit_test() {
+        let i = &b"0123456789abcdefABCDEF;"[..];
+        assert_parse!(
+            hex_digit1(Partial::new(i)),
+            Ok((Partial::new(&b";"[..]), &i[..i.len() - 1]))
+        );
+
+        let i = &b"g"[..];
+        assert_parse!(
+            hex_digit1(Partial::new(i)),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(i),
+                ErrorKind::Slice
+            )))
+        );
+
+        let i = &b"G"[..];
+        assert_parse!(
+            hex_digit1(Partial::new(i)),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(i),
+                ErrorKind::Slice
+            )))
+        );
+
+        assert!(AsChar::is_hex_digit(b'0'));
+        assert!(AsChar::is_hex_digit(b'9'));
+        assert!(AsChar::is_hex_digit(b'a'));
+        assert!(AsChar::is_hex_digit(b'f'));
+        assert!(AsChar::is_hex_digit(b'A'));
+        assert!(AsChar::is_hex_digit(b'F'));
+        assert!(!AsChar::is_hex_digit(b'g'));
+        assert!(!AsChar::is_hex_digit(b'G'));
+        assert!(!AsChar::is_hex_digit(b'/'));
+        assert!(!AsChar::is_hex_digit(b':'));
+        assert!(!AsChar::is_hex_digit(b'@'));
+        assert!(!AsChar::is_hex_digit(b'\x60'));
+    }
+
+    #[test]
+    fn oct_digit_test() {
+        let i = &b"01234567;"[..];
+        assert_parse!(
+            oct_digit1(Partial::new(i)),
+            Ok((Partial::new(&b";"[..]), &i[..i.len() - 1]))
+        );
+
+        let i = &b"8"[..];
+        assert_parse!(
+            oct_digit1(Partial::new(i)),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(i),
+                ErrorKind::Slice
+            )))
+        );
+
+        assert!(AsChar::is_oct_digit(b'0'));
+        assert!(AsChar::is_oct_digit(b'7'));
+        assert!(!AsChar::is_oct_digit(b'8'));
+        assert!(!AsChar::is_oct_digit(b'9'));
+        assert!(!AsChar::is_oct_digit(b'a'));
+        assert!(!AsChar::is_oct_digit(b'A'));
+        assert!(!AsChar::is_oct_digit(b'/'));
+        assert!(!AsChar::is_oct_digit(b':'));
+        assert!(!AsChar::is_oct_digit(b'@'));
+        assert!(!AsChar::is_oct_digit(b'\x60'));
+    }
+
+    #[test]
+    fn full_line_windows() {
+        #[allow(clippy::type_complexity)]
+        fn take_full_line(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> {
+            (not_line_ending, line_ending).parse_next(i)
+        }
+        let input = b"abc\r\n";
+        let output = take_full_line(Partial::new(input));
+        assert_eq!(
+            output,
+            Ok((Partial::new(&b""[..]), (&b"abc"[..], &b"\r\n"[..])))
+        );
+    }
+
+    #[test]
+    fn full_line_unix() {
+        #[allow(clippy::type_complexity)]
+        fn take_full_line(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> {
+            (not_line_ending, line_ending).parse_next(i)
+        }
+        let input = b"abc\n";
+        let output = take_full_line(Partial::new(input));
+        assert_eq!(
+            output,
+            Ok((Partial::new(&b""[..]), (&b"abc"[..], &b"\n"[..])))
+        );
+    }
+
+    #[test]
+    fn check_windows_lineending() {
+        let input = b"\r\n";
+        let output = line_ending(Partial::new(&input[..]));
+        assert_parse!(output, Ok((Partial::new(&b""[..]), &b"\r\n"[..])));
+    }
+
+    #[test]
+    fn check_unix_lineending() {
+        let input = b"\n";
+        let output = line_ending(Partial::new(&input[..]));
+        assert_parse!(output, Ok((Partial::new(&b""[..]), &b"\n"[..])));
+    }
+
+    #[test]
+    fn cr_lf() {
+        assert_parse!(
+            crlf(Partial::new(&b"\r\na"[..])),
+            Ok((Partial::new(&b"a"[..]), &b"\r\n"[..]))
+        );
+        assert_parse!(
+            crlf(Partial::new(&b"\r"[..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_parse!(
+            crlf(Partial::new(&b"\ra"[..])),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b"\ra"[..]),
+                ErrorKind::Tag
+            )))
+        );
+
+        assert_parse!(crlf(Partial::new("\r\na")), Ok((Partial::new("a"), "\r\n")));
+        assert_parse!(
+            crlf(Partial::new("\r")),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_parse!(
+            crlf(Partial::new("\ra")),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new("\ra"),
+                ErrorKind::Tag
+            )))
+        );
+    }
+
+    #[test]
+    fn end_of_line() {
+        assert_parse!(
+            line_ending(Partial::new(&b"\na"[..])),
+            Ok((Partial::new(&b"a"[..]), &b"\n"[..]))
+        );
+        assert_parse!(
+            line_ending(Partial::new(&b"\r\na"[..])),
+            Ok((Partial::new(&b"a"[..]), &b"\r\n"[..]))
+        );
+        assert_parse!(
+            line_ending(Partial::new(&b"\r"[..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_parse!(
+            line_ending(Partial::new(&b"\ra"[..])),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b"\ra"[..]),
+                ErrorKind::Tag
+            )))
+        );
+
+        assert_parse!(
+            line_ending(Partial::new("\na")),
+            Ok((Partial::new("a"), "\n"))
+        );
+        assert_parse!(
+            line_ending(Partial::new("\r\na")),
+            Ok((Partial::new("a"), "\r\n"))
+        );
+        assert_parse!(
+            line_ending(Partial::new("\r")),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_parse!(
+            line_ending(Partial::new("\ra")),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new("\ra"),
+                ErrorKind::Tag
+            )))
+        );
+    }
+
+    fn digit_to_i16(input: Partial<&str>) -> IResult<Partial<&str>, i16> {
+        let i = input;
+        let (i, opt_sign) = opt(one_of("+-")).parse_next(i)?;
+        let sign = match opt_sign {
+            Some('+') | None => true,
+            Some('-') => false,
+            _ => unreachable!(),
+        };
+
+        let (i, s) = digit1::<_, crate::error::Error<_>>(i)?;
+        match s.parse_slice() {
+            Some(n) => {
+                if sign {
+                    Ok((i, n))
+                } else {
+                    Ok((i, -n))
+                }
+            }
+            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+        }
+    }
+
+    fn digit_to_u32(i: Partial<&str>) -> IResult<Partial<&str>, u32> {
+        let (i, s) = digit1(i)?;
+        match s.parse_slice() {
+            Some(n) => Ok((i, n)),
+            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+        }
+    }
+
+    proptest! {
+      #[test]
+      #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+      fn ints(s in "\\PC*") {
+          let res1 = digit_to_i16(Partial::new(&s));
+          let res2 = dec_int(Partial::new(s.as_str()));
+          assert_eq!(res1, res2);
+      }
+
+      #[test]
+      #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+      fn uints(s in "\\PC*") {
+          let res1 = digit_to_u32(Partial::new(&s));
+          let res2 = dec_uint(Partial::new(s.as_str()));
+          assert_eq!(res1, res2);
+      }
+    }
+
+    #[test]
+    fn hex_uint_tests() {
+        fn hex_u32(input: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+            hex_uint(input)
+        }
+
+        assert_parse!(
+            hex_u32(Partial::new(&b";"[..])),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b";"[..]),
+                ErrorKind::Slice
+            )))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"ff;"[..])),
+            Ok((Partial::new(&b";"[..]), 255))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"1be2;"[..])),
+            Ok((Partial::new(&b";"[..]), 7138))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"c5a31be2;"[..])),
+            Ok((Partial::new(&b";"[..]), 3_315_801_058))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"C5A31be2;"[..])),
+            Ok((Partial::new(&b";"[..]), 3_315_801_058))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"00c5a31be2;"[..])), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b"00c5a31be2;"[..]),
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"c5a31be201;"[..])), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b"c5a31be201;"[..]),
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"ffffffff;"[..])),
+            Ok((Partial::new(&b";"[..]), 4_294_967_295))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"ffffffffffffffff;"[..])), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b"ffffffffffffffff;"[..]),
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"ffffffffffffffff"[..])), // overflow
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b"ffffffffffffffff"[..]),
+                ErrorKind::Verify
+            )))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"0x1be2;"[..])),
+            Ok((Partial::new(&b"x1be2;"[..]), 0))
+        );
+        assert_parse!(
+            hex_u32(Partial::new(&b"12af"[..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+}
diff --git a/vendor/winnow/src/combinator/mod.rs b/vendor/winnow/src/combinator/mod.rs
new file mode 100644
index 000000000..4276b06d3
--- /dev/null
+++ b/vendor/winnow/src/combinator/mod.rs
@@ -0,0 +1,1471 @@
+//! # List of parsers and combinators
+//!
+//! **Note**: this list is meant to provide a nicer way to find a parser than reading through the documentation on docs.rs. Function combinators are organized in module so they are a bit easier to find.
+//!
+//! ## Basic elements
+//!
+//! Those are used to recognize the lowest level elements of your grammar, like, "here is a dot", or "here is an big endian integer".
+//!
+//! | combinator | usage | input | output | comment |
+//! |---|---|---|---|---|
+//! | [`one_of`][crate::bytes::one_of] | `one_of("abc")` |  `"abc"` | `Ok(("bc", 'a'))` |Matches one of the provided characters (works with non ASCII characters too)|
+//! | [`none_of`][crate::bytes::none_of] | `none_of("abc")` |  `"xyab"` | `Ok(("yab", 'x'))` |Matches anything but the provided characters|
+//! | [`tag`][crate::bytes::tag] | `"hello"` |  `"hello world"` | `Ok((" world", "hello"))` |Recognizes a specific suite of characters or bytes|
+//! | [`tag_no_case`][crate::bytes::tag_no_case] | `tag_no_case("hello")` |  `"HeLLo World"` | `Ok((" World", "HeLLo"))` |Case insensitive comparison. Note that case insensitive comparison is not well defined for unicode, and that you might have bad surprises|
+//! | [`take`][crate::bytes::take] | `take(4)` |  `"hello"` | `Ok(("o", "hell"))` |Takes a specific number of bytes or characters|
+//! | [`take_while0`][crate::bytes::take_while0] | `take_while0(is_alphabetic)` |  `"abc123"` | `Ok(("123", "abc"))` |Returns the longest list of bytes for which the provided pattern matches. `take_while1` does the same, but must return at least one character|
+//! | [`take_till0`][crate::bytes::take_till0] | `take_till0(is_alphabetic)` |  `"123abc"` | `Ok(("abc", "123"))` |Returns the longest list of bytes or characters until the provided pattern matches. `take_till1` does the same, but must return at least one character. This is the reverse behaviour from `take_while0`: `take_till(f)` is equivalent to `take_while0(\|c\| !f(c))`|
+//! | [`take_until0`][crate::bytes::take_until0] | `take_until0("world")` |  `"Hello world"` | `Ok(("world", "Hello "))` |Returns the longest list of bytes or characters until the provided tag is found. `take_until1` does the same, but must return at least one character|
+//!
+//! ## Choice combinators
+//!
+//! | combinator | usage | input | output | comment |
+//! |---|---|---|---|---|
+//! | [`alt`][crate::branch::alt] | `alt(("ab", "cd"))` |  `"cdef"` | `Ok(("ef", "cd"))` |Try a list of parsers and return the result of the first successful one|
+//! | [`dispatch`][crate::branch::dispatch] | \- | \- | \- | `match` for parsers |
+//! | [`permutation`][crate::branch::permutation] | `permutation(("ab", "cd", "12"))` | `"cd12abc"` | `Ok(("c", ("ab", "cd", "12"))` |Succeeds when all its child parser have succeeded, whatever the order|
+//!
+//! ## Sequence combinators
+//!
+//! | combinator | usage | input | output | comment |
+//! |---|---|---|---|---|
+//! | [`(...)` (tuples)][crate::Parser] | `("ab", "XY", take(1))` | `"abXYZ!"` | `Ok(("!", ("ab", "XY", "Z")))` |Chains parsers and assemble the sub results in a tuple. You can use as many child parsers as you can put elements in a tuple|
+//! | [`delimited`][crate::sequence::delimited] | `delimited(char('('), take(2), char(')'))` | `"(ab)cd"` | `Ok(("cd", "ab"))` ||
+//! | [`preceded`][crate::sequence::preceded] | `preceded("ab", "XY")` | `"abXYZ"` | `Ok(("Z", "XY"))` ||
+//! | [`terminated`][crate::sequence::terminated] | `terminated("ab", "XY")` | `"abXYZ"` | `Ok(("Z", "ab"))` ||
+//! | [`separated_pair`][crate::sequence::separated_pair] | `separated_pair("hello", char(','), "world")` | `"hello,world!"` | `Ok(("!", ("hello", "world")))` ||
+//!
+//! ## Applying a parser multiple times
+//!
+//! | combinator | usage | input | output | comment |
+//! |---|---|---|---|---|
+//! | [`count`][crate::multi::count] | `count(take(2), 3)` | `"abcdefgh"` | `Ok(("gh", vec!["ab", "cd", "ef"]))` |Applies the child parser a specified number of times|
+//! | [`many0`][crate::multi::many0] | `many0("ab")` |  `"abababc"` | `Ok(("c", vec!["ab", "ab", "ab"]))` |Applies the parser 0 or more times and returns the list of results in a Vec. `many1` does the same operation but must return at least one element|
+//! | [`many_m_n`][crate::multi::many_m_n] | `many_m_n(1, 3, "ab")` | `"ababc"` | `Ok(("c", vec!["ab", "ab"]))` |Applies the parser between m and n times (n included) and returns the list of results in a Vec|
+//! | [`many_till0`][crate::multi::many_till0] | `many_till0(tag( "ab" ), tag( "ef" ))` | `"ababefg"` | `Ok(("g", (vec!["ab", "ab"], "ef")))` |Applies the first parser until the second applies. Returns a tuple containing the list of results from the first in a Vec and the result of the second|
+//! | [`separated0`][crate::multi::separated0] | `separated0("ab", ",")` | `"ab,ab,ab."` | `Ok((".", vec!["ab", "ab", "ab"]))` |`separated1` works like `separated0` but must returns at least one element|
+//! | [`fold_many0`][crate::multi::fold_many0] | `fold_many0(be_u8, \|\| 0, \|acc, item\| acc + item)` | `[1, 2, 3]` | `Ok(([], 6))` |Applies the parser 0 or more times and folds the list of return values. The `fold_many1` version must apply the child parser at least one time|
+//! | [`fold_many_m_n`][crate::multi::fold_many_m_n] | `fold_many_m_n(1, 2, be_u8, \|\| 0, \|acc, item\| acc + item)` | `[1, 2, 3]` | `Ok(([3], 3))` |Applies the parser between m and n times (n included) and folds the list of return value|
+//! | [`length_count`][crate::multi::length_count] | `length_count(number, "ab")` | `"2ababab"` | `Ok(("ab", vec!["ab", "ab"]))` |Gets a number from the first parser, then applies the second parser that many times|
+//!
+//! ## Partial related
+//!
+//! - [`eof`][eof]: Returns its input if it is at the end of input data
+//! - [`Parser::complete_err`]: Replaces an `Incomplete` returned by the child parser with an `Backtrack`
+//!
+//! ## Modifiers
+//!
+//! - [`cond`][cond]: Conditional combinator. Wraps another parser and calls it if the condition is met
+//! - [`Parser::flat_map`][crate::Parser::flat_map]: method to map a new parser from the output of the first parser, then apply that parser over the rest of the input
+//! - [`Parser::value`][crate::Parser::value]: method to replace the result of a parser
+//! - [`Parser::map`][crate::Parser::map]: method to map a function on the result of a parser
+//! - [`Parser::and_then`][crate::Parser::and_then]: Applies a second parser over the output of the first one
+//! - [`Parser::verify_map`][Parser::verify_map]: Maps a function returning an `Option` on the output of a parser
+//! - [`Parser::map_res`][Parser::map_res]: Maps a function returning a `Result` on the output of a parser
+//! - [`Parser::parse_to`][crate::Parser::parse_to]: Apply [`std::str::FromStr`] to the output of the parser
+//! - [`not`][not]: Returns a result only if the embedded parser returns `Backtrack` or `Incomplete`. Does not consume the input
+//! - [`opt`][opt]: Make the underlying parser optional
+//! - [`peek`][peek]: Returns a result without consuming the input
+//! - [`Parser::recognize`][Parser::recognize]: If the child parser was successful, return the consumed input as the produced value
+//! - [`Parser::with_recognized`][Parser::with_recognized]: If the child parser was successful, return a tuple of the consumed input and the produced output.
+//! - [`Parser::span`][Parser::span]: If the child parser was successful, return the location of the consumed input as the produced value
+//! - [`Parser::with_span`][Parser::with_span]: If the child parser was successful, return a tuple of the location of the consumed input and the produced output.
+//! - [`Parser::verify`]: Returns the result of the child parser if it satisfies a verification function
+//!
+//! ## Error management and debugging
+//!
+//! - [`cut_err`]: Commit the parse result, disallowing alternative parsers from being attempted
+//! - [`backtrack_err`]: Attemmpts a parse, allowing alternative parsers to be attempted despite
+//!   use of `cut_err`
+//! - [`Parser::context`]: Add context to the error if the parser fails
+//! - [`trace`][crate::trace::trace]: Print the parse state with the `debug` feature flag
+//! - [`todo()`]: Placeholder parser
+//!
+//! ## Remaining combinators
+//!
+//! - [`success`][success]: Returns a value without consuming any input, always succeeds
+//! - [`fail`][fail]: Inversion of `success`. Always fails.
+//! - [`Parser::by_ref`]: Allow moving `&mut impl Parser` into other parsers
+//!
+//! ## Text parsing
+//!
+//! - [`any`][crate::bytes::any]: Matches one token
+//! - [`tab`][crate::character::tab]: Matches a tab character `\t`
+//! - [`crlf`][crate::character::crlf]: Recognizes the string `\r\n`
+//! - [`line_ending`][crate::character::line_ending]: Recognizes an end of line (both `\n` and `\r\n`)
+//! - [`newline`][crate::character::newline]: Matches a newline character `\n`
+//! - [`not_line_ending`][crate::character::not_line_ending]: Recognizes a string of any char except `\r` or `\n`
+//! - [`rest`][rest]: Return the remaining input
+//!
+//! - [`alpha0`][crate::character::alpha0]: Recognizes zero or more lowercase and uppercase alphabetic characters: `[a-zA-Z]`. [`alpha1`][crate::character::alpha1] does the same but returns at least one character
+//! - [`alphanumeric0`][crate::character::alphanumeric0]: Recognizes zero or more numerical and alphabetic characters: `[0-9a-zA-Z]`. [`alphanumeric1`][crate::character::alphanumeric1] does the same but returns at least one character
+//! - [`space0`][crate::character::space0]: Recognizes zero or more spaces and tabs. [`space1`][crate::character::space1] does the same but returns at least one character
+//! - [`multispace0`][crate::character::multispace0]: Recognizes zero or more spaces, tabs, carriage returns and line feeds. [`multispace1`][crate::character::multispace1] does the same but returns at least one character
+//! - [`digit0`][crate::character::digit0]: Recognizes zero or more numerical characters: `[0-9]`. [`digit1`][crate::character::digit1] does the same but returns at least one character
+//! - [`hex_digit0`][crate::character::hex_digit0]: Recognizes zero or more hexadecimal numerical characters: `[0-9A-Fa-f]`. [`hex_digit1`][crate::character::hex_digit1] does the same but returns at least one character
+//! - [`oct_digit0`][crate::character::oct_digit0]: Recognizes zero or more octal characters: `[0-7]`. [`oct_digit1`][crate::character::oct_digit1] does the same but returns at least one character
+//!
+//! - [`float`][crate::character::float]: Parse a floating point number in a byte string
+//! - [`dec_int`][crate::character::dec_uint]: Decode a variable-width, decimal signed integer
+//! - [`dec_uint`][crate::character::dec_uint]: Decode a variable-width, decimal unsigned integer
+//! - [`hex_uint`][crate::character::hex_uint]: Decode a variable-width, hexadecimal integer
+//!
+//! - [`escaped`][crate::character::escaped]: Matches a byte string with escaped characters
+//! - [`escaped_transform`][crate::character::escaped_transform]: Matches a byte string with escaped characters, and returns a new string with the escaped characters replaced
+//!
+//! ### Character test functions
+//!
+//! Use these functions with a combinator like `take_while0`:
+//!
+//! - [`AsChar::is_alpha`][crate::stream::AsChar::is_alpha]: Tests if byte is ASCII alphabetic: `[A-Za-z]`
+//! - [`AsChar::is_alphanum`][crate::stream::AsChar::is_alphanum]: Tests if byte is ASCII alphanumeric: `[A-Za-z0-9]`
+//! - [`AsChar::is_dec_digit`][crate::stream::AsChar::is_dec_digit]: Tests if byte is ASCII digit: `[0-9]`
+//! - [`AsChar::is_hex_digit`][crate::stream::AsChar::is_hex_digit]: Tests if byte is ASCII hex digit: `[0-9A-Fa-f]`
+//! - [`AsChar::is_oct_digit`][crate::stream::AsChar::is_oct_digit]: Tests if byte is ASCII octal digit: `[0-7]`
+//! - [`AsChar::is_space`][crate::stream::AsChar::is_space]: Tests if byte is ASCII space or tab: `[ \t]`
+//! - [`AsChar::is_newline`][crate::stream::AsChar::is_newline]: Tests if byte is ASCII newline: `[\n]`
+//!
+//! ## Binary format parsing
+//!
+//! - [`length_data`][crate::multi::length_data]: Gets a number from the first parser, then takes a subslice of the input of that size, and returns that subslice
+//! - [`length_value`][crate::multi::length_value]: Gets a number from the first parser, takes a subslice of the input of that size, then applies the second parser on that subslice. If the second parser returns `Incomplete`, `length_value` will return an error
+//!
+//! ### Integers
+//!
+//! Parsing integers from binary formats can be done in two ways: With parser functions, or combinators with configurable endianness.
+//!
+//! - **configurable endianness:** [`i16`][crate::number::i16], [`i32`][crate::number::i32],
+//!   [`i64`][crate::number::i64], [`u16`][crate::number::u16], [`u32`][crate::number::u32],
+//!   [`u64`][crate::number::u64] are combinators that take as argument a
+//!   [`winnow::number::Endianness`][crate::number::Endianness], like this: `i16(endianness)`. If the
+//!   parameter is `winnow::number::Endianness::Big`, parse a big endian `i16` integer, otherwise a
+//!   little endian `i16` integer.
+//! - **fixed endianness**: The functions are prefixed by `be_` for big endian numbers, and by `le_` for little endian numbers, and the suffix is the type they parse to. As an example, `be_u32` parses a big endian unsigned integer stored in 32 bits.
+//!   - [`be_f32`][crate::number::be_f32], [`be_f64`][crate::number::be_f64]: Big endian floating point numbers
+//!   - [`le_f32`][crate::number::le_f32], [`le_f64`][crate::number::le_f64]: Little endian floating point numbers
+//!   - [`be_i8`][crate::number::be_i8], [`be_i16`][crate::number::be_i16], [`be_i24`][crate::number::be_i24], [`be_i32`][crate::number::be_i32], [`be_i64`][crate::number::be_i64], [`be_i128`][crate::number::be_i128]: Big endian signed integers
+//!   - [`be_u8`][crate::number::be_u8], [`be_u16`][crate::number::be_u16], [`be_u24`][crate::number::be_u24], [`be_u32`][crate::number::be_u32], [`be_u64`][crate::number::be_u64], [`be_u128`][crate::number::be_u128]: Big endian unsigned integers
+//!   - [`le_i8`][crate::number::le_i8], [`le_i16`][crate::number::le_i16], [`le_i24`][crate::number::le_i24], [`le_i32`][crate::number::le_i32], [`le_i64`][crate::number::le_i64], [`le_i128`][crate::number::le_i128]: Little endian signed integers
+//!   - [`le_u8`][crate::number::le_u8], [`le_u16`][crate::number::le_u16], [`le_u24`][crate::number::le_u24], [`le_u32`][crate::number::le_u32], [`le_u64`][crate::number::le_u64], [`le_u128`][crate::number::le_u128]: Little endian unsigned integers
+//!
+//! ### Bit stream parsing
+//!
+//! - [`bits`][crate::bits::bits]: Transforms the current input type (byte slice `&[u8]`) to a bit stream on which bit specific parsers and more general combinators can be applied
+//! - [`bytes`][crate::bits::bytes]: Transforms its bits stream input back into a byte slice for the underlying parser
+//! - [`take`][crate::bits::take]: Take a set number of its
+//! - [`tag`][crate::bits::tag]: Check if a set number of bis matches a pattern
+//! - [`bool`][crate::bits::bool]: Match any one bit
+
+use crate::error::{ContextError, ErrMode, ErrorKind, FromExternalError, Needed, ParseError};
+use crate::lib::std::borrow::Borrow;
+use crate::lib::std::ops::Range;
+use crate::stream::{Location, Stream};
+use crate::stream::{Offset, StreamIsPartial};
+use crate::trace::trace;
+use crate::trace::trace_result;
+use crate::*;
+
+#[cfg(test)]
+mod tests;
+
+/// Return the remaining input.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::error::ErrorKind;
+/// # use winnow::error::Error;
+/// use winnow::combinator::rest;
+/// assert_eq!(rest::<_,Error<_>>("abc"), Ok(("", "abc")));
+/// assert_eq!(rest::<_,Error<_>>(""), Ok(("", "")));
+/// ```
+#[inline]
+pub fn rest<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: Stream,
+{
+    trace("rest", move |input: I| {
+        Ok(input.next_slice(input.eof_offset()))
+    })
+    .parse_next(input)
+}
+
+/// Return the length of the remaining input.
+///
+/// Note: this does not advance the [`Stream`]
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::error::ErrorKind;
+/// # use winnow::error::Error;
+/// use winnow::combinator::rest_len;
+/// assert_eq!(rest_len::<_,Error<_>>("abc"), Ok(("abc", 3)));
+/// assert_eq!(rest_len::<_,Error<_>>(""), Ok(("", 0)));
+/// ```
+#[inline]
+pub fn rest_len<I, E: ParseError<I>>(input: I) -> IResult<I, usize, E>
+where
+    I: Stream,
+{
+    trace("rest_len", move |input: I| {
+        let len = input.eof_offset();
+        Ok((input, len))
+    })
+    .parse_next(input)
+}
+
+/// Implementation of [`Parser::by_ref`][Parser::by_ref]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct ByRef<'p, P> {
+    p: &'p mut P,
+}
+
+impl<'p, P> ByRef<'p, P> {
+    pub(crate) fn new(p: &'p mut P) -> Self {
+        Self { p }
+    }
+}
+
+impl<'p, I, O, E, P: Parser<I, O, E>> Parser<I, O, E> for ByRef<'p, P> {
+    fn parse_next(&mut self, i: I) -> IResult<I, O, E> {
+        self.p.parse_next(i)
+    }
+}
+
+/// Implementation of [`Parser::map`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct Map<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Fn(O) -> O2,
+{
+    parser: F,
+    map: G,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, G, I, O, O2, E> Map<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Fn(O) -> O2,
+{
+    pub(crate) fn new(parser: F, map: G) -> Self {
+        Self {
+            parser,
+            map,
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, G, I, O, O2, E> Parser<I, O2, E> for Map<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Fn(O) -> O2,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
+        match self.parser.parse_next(i) {
+            Err(e) => Err(e),
+            Ok((i, o)) => Ok((i, (self.map)(o))),
+        }
+    }
+}
+
+/// Implementation of [`Parser::map_res`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct MapRes<F, G, I, O, O2, E, E2>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> Result<O2, E2>,
+    I: Clone,
+    E: FromExternalError<I, E2>,
+{
+    parser: F,
+    map: G,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+    e2: core::marker::PhantomData<E2>,
+}
+
+impl<F, G, I, O, O2, E, E2> MapRes<F, G, I, O, O2, E, E2>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> Result<O2, E2>,
+    I: Clone,
+    E: FromExternalError<I, E2>,
+{
+    pub(crate) fn new(parser: F, map: G) -> Self {
+        Self {
+            parser,
+            map,
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+            e2: Default::default(),
+        }
+    }
+}
+
+impl<F, G, I, O, O2, E, E2> Parser<I, O2, E> for MapRes<F, G, I, O, O2, E, E2>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> Result<O2, E2>,
+    I: Clone,
+    E: FromExternalError<I, E2>,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, O2, E> {
+        let i = input.clone();
+        let (input, o) = self.parser.parse_next(input)?;
+        let res = match (self.map)(o) {
+            Ok(o2) => Ok((input, o2)),
+            Err(e) => Err(ErrMode::from_external_error(i, ErrorKind::Verify, e)),
+        };
+        trace_result("verify", &res);
+        res
+    }
+}
+
+/// Implementation of [`Parser::verify_map`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct VerifyMap<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> Option<O2>,
+    I: Clone,
+    E: ParseError<I>,
+{
+    parser: F,
+    map: G,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, G, I, O, O2, E> VerifyMap<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> Option<O2>,
+    I: Clone,
+    E: ParseError<I>,
+{
+    pub(crate) fn new(parser: F, map: G) -> Self {
+        Self {
+            parser,
+            map,
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, G, I, O, O2, E> Parser<I, O2, E> for VerifyMap<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> Option<O2>,
+    I: Clone,
+    E: ParseError<I>,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, O2, E> {
+        let i = input.clone();
+        let (input, o) = self.parser.parse_next(input)?;
+        let res = match (self.map)(o) {
+            Some(o2) => Ok((input, o2)),
+            None => Err(ErrMode::from_error_kind(i, ErrorKind::Verify)),
+        };
+        trace_result("verify", &res);
+        res
+    }
+}
+
+/// Implementation of [`Parser::and_then`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct AndThen<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Parser<O, O2, E>,
+    O: StreamIsPartial,
+{
+    outer: F,
+    inner: G,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, G, I, O, O2, E> AndThen<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Parser<O, O2, E>,
+    O: StreamIsPartial,
+{
+    pub(crate) fn new(outer: F, inner: G) -> Self {
+        Self {
+            outer,
+            inner,
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, G, I, O, O2, E> Parser<I, O2, E> for AndThen<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Parser<O, O2, E>,
+    O: StreamIsPartial,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
+        let (i, mut o) = self.outer.parse_next(i)?;
+        let _ = o.complete();
+        let (_, o2) = self.inner.parse_next(o)?;
+        Ok((i, o2))
+    }
+}
+
+/// Implementation of [`Parser::parse_to`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct ParseTo<P, I, O, O2, E>
+where
+    P: Parser<I, O, E>,
+    I: Stream,
+    O: crate::stream::ParseSlice<O2>,
+    E: ParseError<I>,
+{
+    p: P,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<P, I, O, O2, E> ParseTo<P, I, O, O2, E>
+where
+    P: Parser<I, O, E>,
+    I: Stream,
+    O: crate::stream::ParseSlice<O2>,
+    E: ParseError<I>,
+{
+    pub(crate) fn new(p: P) -> Self {
+        Self {
+            p,
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<P, I, O, O2, E> Parser<I, O2, E> for ParseTo<P, I, O, O2, E>
+where
+    P: Parser<I, O, E>,
+    I: Stream,
+    O: crate::stream::ParseSlice<O2>,
+    E: ParseError<I>,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
+        let input = i.clone();
+        let (i, o) = self.p.parse_next(i)?;
+
+        let res = o
+            .parse_slice()
+            .ok_or_else(|| ErrMode::from_error_kind(input, ErrorKind::Verify));
+        trace_result("verify", &res);
+        Ok((i, res?))
+    }
+}
+
+/// Implementation of [`Parser::flat_map`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct FlatMap<F, G, H, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> H,
+    H: Parser<I, O2, E>,
+{
+    f: F,
+    g: G,
+    h: core::marker::PhantomData<H>,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, G, H, I, O, O2, E> FlatMap<F, G, H, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> H,
+    H: Parser<I, O2, E>,
+{
+    pub(crate) fn new(f: F, g: G) -> Self {
+        Self {
+            f,
+            g,
+            h: Default::default(),
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, G, H, I, O, O2, E> Parser<I, O2, E> for FlatMap<F, G, H, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: FnMut(O) -> H,
+    H: Parser<I, O2, E>,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
+        let (i, o) = self.f.parse_next(i)?;
+        (self.g)(o).parse_next(i)
+    }
+}
+
+/// Apply a [`Parser`], producing `None` on [`ErrMode::Backtrack`].
+///
+/// To chain an error up, see [`cut_err`].
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::prelude::*;
+/// use winnow::combinator::opt;
+/// use winnow::character::alpha1;
+/// # fn main() {
+///
+/// fn parser(i: &str) -> IResult<&str, Option<&str>> {
+///   opt(alpha1).parse_next(i)
+/// }
+///
+/// assert_eq!(parser("abcd;"), Ok((";", Some("abcd"))));
+/// assert_eq!(parser("123;"), Ok(("123;", None)));
+/// # }
+/// ```
+pub fn opt<I: Stream, O, E: ParseError<I>, F>(mut f: F) -> impl Parser<I, Option<O>, E>
+where
+    F: Parser<I, O, E>,
+{
+    trace("opt", move |input: I| {
+        let i = input.clone();
+        match f.parse_next(input) {
+            Ok((i, o)) => Ok((i, Some(o))),
+            Err(ErrMode::Backtrack(_)) => Ok((i, None)),
+            Err(e) => Err(e),
+        }
+    })
+}
+
+/// Calls the parser if the condition is met.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, IResult};
+/// # use winnow::prelude::*;
+/// use winnow::combinator::cond;
+/// use winnow::character::alpha1;
+/// # fn main() {
+///
+/// fn parser(b: bool, i: &str) -> IResult<&str, Option<&str>> {
+///   cond(b, alpha1).parse_next(i)
+/// }
+///
+/// assert_eq!(parser(true, "abcd;"), Ok((";", Some("abcd"))));
+/// assert_eq!(parser(false, "abcd;"), Ok(("abcd;", None)));
+/// assert_eq!(parser(true, "123;"), Err(ErrMode::Backtrack(Error::new("123;", ErrorKind::Slice))));
+/// assert_eq!(parser(false, "123;"), Ok(("123;", None)));
+/// # }
+/// ```
+pub fn cond<I, O, E: ParseError<I>, F>(b: bool, mut f: F) -> impl Parser<I, Option<O>, E>
+where
+    I: Stream,
+    F: Parser<I, O, E>,
+{
+    trace("cond", move |input: I| {
+        if b {
+            match f.parse_next(input) {
+                Ok((i, o)) => Ok((i, Some(o))),
+                Err(e) => Err(e),
+            }
+        } else {
+            Ok((input, None))
+        }
+    })
+}
+
+/// Tries to apply its parser without consuming the input.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult};
+/// # use winnow::prelude::*;
+/// use winnow::combinator::peek;
+/// use winnow::character::alpha1;
+/// # fn main() {
+///
+/// let mut parser = peek(alpha1);
+///
+/// assert_eq!(parser.parse_next("abcd;"), Ok(("abcd;", "abcd")));
+/// assert_eq!(parser.parse_next("123;"), Err(ErrMode::Backtrack(Error::new("123;", ErrorKind::Slice))));
+/// # }
+/// ```
+#[doc(alias = "look_ahead")]
+#[doc(alias = "rewind")]
+pub fn peek<I: Stream, O, E: ParseError<I>, F>(mut f: F) -> impl Parser<I, O, E>
+where
+    F: Parser<I, O, E>,
+{
+    trace("peek", move |input: I| {
+        let i = input.clone();
+        match f.parse_next(input) {
+            Ok((_, o)) => Ok((i, o)),
+            Err(e) => Err(e),
+        }
+    })
+}
+
+/// Match the end of the [`Stream`]
+///
+/// Otherwise, it will error.
+///
+/// # Example
+///
+/// ```rust
+/// # use std::str;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::combinator::eof;
+/// # use winnow::prelude::*;
+///
+/// let mut parser = eof;
+/// assert_eq!(parser.parse_next("abc"), Err(ErrMode::Backtrack(Error::new("abc", ErrorKind::Eof))));
+/// assert_eq!(parser.parse_next(""), Ok(("", "")));
+/// ```
+#[doc(alias = "end")]
+#[doc(alias = "eoi")]
+pub fn eof<I, E: ParseError<I>>(input: I) -> IResult<I, <I as Stream>::Slice, E>
+where
+    I: Stream,
+{
+    trace("eof", move |input: I| {
+        if input.eof_offset() == 0 {
+            Ok(input.next_slice(0))
+        } else {
+            Err(ErrMode::from_error_kind(input, ErrorKind::Eof))
+        }
+    })
+    .parse_next(input)
+}
+
+/// Implementation of [`Parser::complete_err`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct CompleteErr<F> {
+    f: F,
+}
+
+impl<F> CompleteErr<F> {
+    pub(crate) fn new(f: F) -> Self {
+        Self { f }
+    }
+}
+
+impl<F, I, O, E> Parser<I, O, E> for CompleteErr<F>
+where
+    I: Stream,
+    F: Parser<I, O, E>,
+    E: ParseError<I>,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, O, E> {
+        trace("complete_err", |input: I| {
+            let i = input.clone();
+            match (self.f).parse_next(input) {
+                Err(ErrMode::Incomplete(_)) => {
+                    Err(ErrMode::from_error_kind(i, ErrorKind::Complete))
+                }
+                rest => rest,
+            }
+        })
+        .parse_next(input)
+    }
+}
+
+/// Implementation of [`Parser::verify`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct Verify<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Fn(&O2) -> bool,
+    I: Clone,
+    O: Borrow<O2>,
+    O2: ?Sized,
+    E: ParseError<I>,
+{
+    parser: F,
+    filter: G,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, G, I, O, O2, E> Verify<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Fn(&O2) -> bool,
+    I: Clone,
+    O: Borrow<O2>,
+    O2: ?Sized,
+    E: ParseError<I>,
+{
+    pub(crate) fn new(parser: F, filter: G) -> Self {
+        Self {
+            parser,
+            filter,
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, G, I, O, O2, E> Parser<I, O, E> for Verify<F, G, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    G: Fn(&O2) -> bool,
+    I: Clone,
+    O: Borrow<O2>,
+    O2: ?Sized,
+    E: ParseError<I>,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, O, E> {
+        let i = input.clone();
+        let (input, o) = self.parser.parse_next(input)?;
+
+        let res = if (self.filter)(o.borrow()) {
+            Ok((input, o))
+        } else {
+            Err(ErrMode::from_error_kind(i, ErrorKind::Verify))
+        };
+        trace_result("verify", &res);
+        res
+    }
+}
+
+/// Implementation of [`Parser::value`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct Value<F, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    O2: Clone,
+{
+    parser: F,
+    val: O2,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, O2, E> Value<F, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    O2: Clone,
+{
+    pub(crate) fn new(parser: F, val: O2) -> Self {
+        Self {
+            parser,
+            val,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, I, O, O2, E> Parser<I, O2, E> for Value<F, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    O2: Clone,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, O2, E> {
+        (self.parser)
+            .parse_next(input)
+            .map(|(i, _)| (i, self.val.clone()))
+    }
+}
+
+/// Implementation of [`Parser::void`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct Void<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+{
+    parser: F,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, E> Void<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+{
+    pub(crate) fn new(parser: F) -> Self {
+        Self {
+            parser,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, I, O, E> Parser<I, (), E> for Void<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, (), E> {
+        (self.parser).parse_next(input).map(|(i, _)| (i, ()))
+    }
+}
+
+/// Succeeds if the child parser returns an error.
+///
+/// **Note:** This does not advance the [`Stream`]
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult};
+/// # use winnow::prelude::*;
+/// use winnow::combinator::not;
+/// use winnow::character::alpha1;
+/// # fn main() {
+///
+/// let mut parser = not(alpha1);
+///
+/// assert_eq!(parser.parse_next("123"), Ok(("123", ())));
+/// assert_eq!(parser.parse_next("abcd"), Err(ErrMode::Backtrack(Error::new("abcd", ErrorKind::Not))));
+/// # }
+/// ```
+pub fn not<I: Stream, O, E: ParseError<I>, F>(mut parser: F) -> impl Parser<I, (), E>
+where
+    F: Parser<I, O, E>,
+{
+    trace("not", move |input: I| {
+        let i = input.clone();
+        match parser.parse_next(input) {
+            Ok(_) => Err(ErrMode::from_error_kind(i, ErrorKind::Not)),
+            Err(ErrMode::Backtrack(_)) => Ok((i, ())),
+            Err(e) => Err(e),
+        }
+    })
+}
+
+/// Implementation of [`Parser::recognize`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct Recognize<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream + Offset,
+{
+    parser: F,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, E> Recognize<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream + Offset,
+{
+    pub(crate) fn new(parser: F) -> Self {
+        Self {
+            parser,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<I, O, E, F> Parser<I, <I as Stream>::Slice, E> for Recognize<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream + Offset,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, <I as Stream>::Slice, E> {
+        let i = input.clone();
+        match (self.parser).parse_next(i) {
+            Ok((i, _)) => {
+                let offset = input.offset_to(&i);
+                Ok(input.next_slice(offset))
+            }
+            Err(e) => Err(e),
+        }
+    }
+}
+
+/// Implementation of [`Parser::with_recognized`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct WithRecognized<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream + Offset,
+{
+    parser: F,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, E> WithRecognized<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream + Offset,
+{
+    pub(crate) fn new(parser: F) -> Self {
+        Self {
+            parser,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, I, O, E> Parser<I, (O, <I as Stream>::Slice), E> for WithRecognized<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream + Offset,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, (O, <I as Stream>::Slice), E> {
+        let i = input.clone();
+        match (self.parser).parse_next(i) {
+            Ok((remaining, result)) => {
+                let offset = input.offset_to(&remaining);
+                let (remaining, recognized) = input.next_slice(offset);
+                Ok((remaining, (result, recognized)))
+            }
+            Err(e) => Err(e),
+        }
+    }
+}
+
+/// Implementation of [`Parser::span`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct Span<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Clone + Location,
+{
+    parser: F,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, E> Span<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Clone + Location,
+{
+    pub(crate) fn new(parser: F) -> Self {
+        Self {
+            parser,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<I, O, E, F> Parser<I, Range<usize>, E> for Span<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Clone + Location,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, Range<usize>, E> {
+        let start = input.location();
+        self.parser.parse_next(input).map(move |(remaining, _)| {
+            let end = remaining.location();
+            (remaining, (start..end))
+        })
+    }
+}
+
+/// Implementation of [`Parser::with_span`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct WithSpan<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Clone + Location,
+{
+    parser: F,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, E> WithSpan<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Clone + Location,
+{
+    pub(crate) fn new(parser: F) -> Self {
+        Self {
+            parser,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, I, O, E> Parser<I, (O, Range<usize>), E> for WithSpan<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Clone + Location,
+{
+    fn parse_next(&mut self, input: I) -> IResult<I, (O, Range<usize>), E> {
+        let start = input.location();
+        self.parser
+            .parse_next(input)
+            .map(move |(remaining, output)| {
+                let end = remaining.location();
+                (remaining, (output, (start..end)))
+            })
+    }
+}
+
+/// Transforms an [`ErrMode::Backtrack`] (recoverable) to [`ErrMode::Cut`] (unrecoverable)
+///
+/// This commits the parse result, preventing alternative branch paths like with
+/// [`winnow::branch::alt`][crate::branch::alt].
+///
+/// # Example
+///
+/// Without `cut_err`:
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::bytes::one_of;
+/// # use winnow::character::digit1;
+/// # use winnow::combinator::rest;
+/// # use winnow::branch::alt;
+/// # use winnow::sequence::preceded;
+/// # use winnow::prelude::*;
+/// # fn main() {
+///
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///   alt((
+///     preceded(one_of("+-"), digit1),
+///     rest
+///   )).parse_next(input)
+/// }
+///
+/// assert_eq!(parser("+10 ab"), Ok((" ab", "10")));
+/// assert_eq!(parser("ab"), Ok(("", "ab")));
+/// assert_eq!(parser("+"), Ok(("", "+")));
+/// # }
+/// ```
+///
+/// With `cut_err`:
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::prelude::*;
+/// # use winnow::bytes::one_of;
+/// # use winnow::character::digit1;
+/// # use winnow::combinator::rest;
+/// # use winnow::branch::alt;
+/// # use winnow::sequence::preceded;
+/// use winnow::combinator::cut_err;
+/// # fn main() {
+///
+/// fn parser(input: &str) -> IResult<&str, &str> {
+///   alt((
+///     preceded(one_of("+-"), cut_err(digit1)),
+///     rest
+///   )).parse_next(input)
+/// }
+///
+/// assert_eq!(parser("+10 ab"), Ok((" ab", "10")));
+/// assert_eq!(parser("ab"), Ok(("", "ab")));
+/// assert_eq!(parser("+"), Err(ErrMode::Cut(Error { input: "", kind: ErrorKind::Slice })));
+/// # }
+/// ```
+pub fn cut_err<I, O, E: ParseError<I>, F>(mut parser: F) -> impl Parser<I, O, E>
+where
+    I: Stream,
+    F: Parser<I, O, E>,
+{
+    trace("cut_err", move |input: I| {
+        parser.parse_next(input).map_err(|e| e.cut())
+    })
+}
+
+/// Transforms an [`ErrMode::Cut`] (unrecoverable) to [`ErrMode::Backtrack`] (recoverable)
+///
+/// This attempts the parse, allowing other parsers to be tried on failure, like with
+/// [`winnow::branch::alt`][crate::branch::alt].
+pub fn backtrack_err<I, O, E: ParseError<I>, F>(mut parser: F) -> impl Parser<I, O, E>
+where
+    I: Stream,
+    F: Parser<I, O, E>,
+{
+    trace("backtrack_err", move |input: I| {
+        parser.parse_next(input).map_err(|e| e.backtrack())
+    })
+}
+
+/// A placeholder for a not-yet-implemented [`Parser`]
+///
+/// This is analogous to the [`todo!`] macro and helps with prototyping.
+///
+/// # Panic
+///
+/// This will panic when parsing
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::combinator::todo;
+///
+/// fn parser(input: &str) -> IResult<&str, u64> {
+///     todo(input)
+/// }
+/// ```
+#[track_caller]
+pub fn todo<I, O, E>(input: I) -> IResult<I, O, E>
+where
+    I: Stream,
+{
+    #![allow(clippy::todo)]
+    trace("todo", move |_input: I| todo!("unimplemented parse")).parse_next(input)
+}
+
+/// Implementation of [`Parser::output_into`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct OutputInto<F, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    O: Into<O2>,
+{
+    parser: F,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    o2: core::marker::PhantomData<O2>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, O2, E> OutputInto<F, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    O: Into<O2>,
+{
+    pub(crate) fn new(parser: F) -> Self {
+        Self {
+            parser,
+            i: Default::default(),
+            o: Default::default(),
+            o2: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, I, O, O2, E> Parser<I, O2, E> for OutputInto<F, I, O, O2, E>
+where
+    F: Parser<I, O, E>,
+    O: Into<O2>,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O2, E> {
+        match self.parser.parse_next(i) {
+            Ok((i, o)) => Ok((i, o.into())),
+            Err(err) => Err(err),
+        }
+    }
+}
+
+/// Implementation of [`Parser::err_into`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct ErrInto<F, I, O, E, E2>
+where
+    F: Parser<I, O, E>,
+    E: Into<E2>,
+{
+    parser: F,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+    e2: core::marker::PhantomData<E2>,
+}
+
+impl<F, I, O, E, E2> ErrInto<F, I, O, E, E2>
+where
+    F: Parser<I, O, E>,
+    E: Into<E2>,
+{
+    pub(crate) fn new(parser: F) -> Self {
+        Self {
+            parser,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+            e2: Default::default(),
+        }
+    }
+}
+
+impl<F, I, O, E, E2> Parser<I, O, E2> for ErrInto<F, I, O, E, E2>
+where
+    F: Parser<I, O, E>,
+    E: Into<E2>,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O, E2> {
+        match self.parser.parse_next(i) {
+            Ok(ok) => Ok(ok),
+            Err(ErrMode::Backtrack(e)) => Err(ErrMode::Backtrack(e.into())),
+            Err(ErrMode::Cut(e)) => Err(ErrMode::Cut(e.into())),
+            Err(ErrMode::Incomplete(e)) => Err(ErrMode::Incomplete(e)),
+        }
+    }
+}
+
+/// Creates an iterator from input data and a parser.
+///
+/// Call the iterator's [`ParserIterator::finish`] method to get the remaining input if successful,
+/// or the error value if we encountered an error.
+///
+/// On [`ErrMode::Backtrack`], iteration will stop.  To instead chain an error up, see [`cut_err`].
+///
+/// # Example
+///
+/// ```rust
+/// use winnow::{combinator::iterator, IResult, bytes::tag, character::alpha1, sequence::terminated};
+/// use std::collections::HashMap;
+///
+/// let data = "abc|defg|hijkl|mnopqr|123";
+/// let mut it = iterator(data, terminated(alpha1, "|"));
+///
+/// let parsed = it.map(|v| (v, v.len())).collect::<HashMap<_,_>>();
+/// let res: IResult<_,_> = it.finish();
+///
+/// assert_eq!(parsed, [("abc", 3usize), ("defg", 4), ("hijkl", 5), ("mnopqr", 6)].iter().cloned().collect());
+/// assert_eq!(res, Ok(("123", ())));
+/// ```
+pub fn iterator<I, O, E, F>(input: I, parser: F) -> ParserIterator<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream,
+    E: ParseError<I>,
+{
+    ParserIterator {
+        parser,
+        input,
+        state: Some(State::Running),
+        o: Default::default(),
+    }
+}
+
+/// Main structure associated to [`iterator`].
+pub struct ParserIterator<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream,
+{
+    parser: F,
+    input: I,
+    state: Option<State<E>>,
+    o: core::marker::PhantomData<O>,
+}
+
+impl<F, I, O, E> ParserIterator<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream,
+{
+    /// Returns the remaining input if parsing was successful, or the error if we encountered an error.
+    pub fn finish(mut self) -> IResult<I, (), E> {
+        match self.state.take().unwrap() {
+            State::Running | State::Done => Ok((self.input, ())),
+            State::Failure(e) => Err(ErrMode::Cut(e)),
+            State::Incomplete(i) => Err(ErrMode::Incomplete(i)),
+        }
+    }
+}
+
+impl<'a, F, I, O, E> core::iter::Iterator for &'a mut ParserIterator<F, I, O, E>
+where
+    F: Parser<I, O, E>,
+    I: Stream,
+{
+    type Item = O;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let State::Running = self.state.take().unwrap() {
+            let input = self.input.clone();
+
+            match self.parser.parse_next(input) {
+                Ok((i, o)) => {
+                    self.input = i;
+                    self.state = Some(State::Running);
+                    Some(o)
+                }
+                Err(ErrMode::Backtrack(_)) => {
+                    self.state = Some(State::Done);
+                    None
+                }
+                Err(ErrMode::Cut(e)) => {
+                    self.state = Some(State::Failure(e));
+                    None
+                }
+                Err(ErrMode::Incomplete(i)) => {
+                    self.state = Some(State::Incomplete(i));
+                    None
+                }
+            }
+        } else {
+            None
+        }
+    }
+}
+
+enum State<E> {
+    Running,
+    Done,
+    Failure(E),
+    Incomplete(Needed),
+}
+
+/// Always succeeds with given value without consuming any input.
+///
+/// For example, it can be used as the last alternative in `alt` to
+/// specify the default case.
+///
+/// **Note:** This never advances the [`Stream`]
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::prelude::*;
+/// use winnow::branch::alt;
+/// use winnow::combinator::success;
+///
+/// let mut parser = success::<_,_,Error<_>>(10);
+/// assert_eq!(parser.parse_next("xyz"), Ok(("xyz", 10)));
+///
+/// fn sign(input: &str) -> IResult<&str, isize> {
+///     alt((
+///         '-'.value(-1),
+///         '+'.value(1),
+///         success::<_,_,Error<_>>(1)
+///     )).parse_next(input)
+/// }
+/// assert_eq!(sign("+10"), Ok(("10", 1)));
+/// assert_eq!(sign("-10"), Ok(("10", -1)));
+/// assert_eq!(sign("10"), Ok(("10", 1)));
+/// ```
+#[doc(alias = "value")]
+#[doc(alias = "empty")]
+pub fn success<I: Stream, O: Clone, E: ParseError<I>>(val: O) -> impl Parser<I, O, E> {
+    trace("success", move |input: I| Ok((input, val.clone())))
+}
+
+/// A parser which always fails.
+///
+/// For example, it can be used as the last alternative in `alt` to
+/// control the error message given.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult};
+/// use winnow::combinator::fail;
+///
+/// let s = "string";
+/// assert_eq!(fail::<_, &str, _>(s), Err(ErrMode::Backtrack(Error::new(s, ErrorKind::Fail))));
+/// ```
+#[doc(alias = "unexpected")]
+pub fn fail<I: Stream, O, E: ParseError<I>>(i: I) -> IResult<I, O, E> {
+    trace("fail", |i| {
+        Err(ErrMode::from_error_kind(i, ErrorKind::Fail))
+    })
+    .parse_next(i)
+}
+
+/// Implementation of [`Parser::context`]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub struct Context<F, I, O, E, C>
+where
+    F: Parser<I, O, E>,
+    I: Stream,
+    E: ContextError<I, C>,
+    C: Clone + crate::lib::std::fmt::Debug,
+{
+    parser: F,
+    context: C,
+    i: core::marker::PhantomData<I>,
+    o: core::marker::PhantomData<O>,
+    e: core::marker::PhantomData<E>,
+}
+
+impl<F, I, O, E, C> Context<F, I, O, E, C>
+where
+    F: Parser<I, O, E>,
+    I: Stream,
+    E: ContextError<I, C>,
+    C: Clone + crate::lib::std::fmt::Debug,
+{
+    pub(crate) fn new(parser: F, context: C) -> Self {
+        Self {
+            parser,
+            context,
+            i: Default::default(),
+            o: Default::default(),
+            e: Default::default(),
+        }
+    }
+}
+
+impl<F, I, O, E, C> Parser<I, O, E> for Context<F, I, O, E, C>
+where
+    F: Parser<I, O, E>,
+    I: Stream,
+    E: ContextError<I, C>,
+    C: Clone + crate::lib::std::fmt::Debug,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O, E> {
+        #[cfg(feature = "debug")]
+        let name = format!("context={:?}", self.context);
+        #[cfg(not(feature = "debug"))]
+        let name = "context";
+        trace(name, move |i: I| {
+            (self.parser)
+                .parse_next(i.clone())
+                .map_err(|err| err.map(|err| err.add_context(i, self.context.clone())))
+        })
+        .parse_next(i)
+    }
+}
diff --git a/vendor/winnow/src/combinator/tests.rs b/vendor/winnow/src/combinator/tests.rs
new file mode 100644
index 000000000..4286286ae
--- /dev/null
+++ b/vendor/winnow/src/combinator/tests.rs
@@ -0,0 +1,319 @@
+use super::*;
+
+use crate::bytes::take;
+use crate::error::ErrMode;
+use crate::error::Error;
+use crate::error::ErrorKind;
+use crate::error::Needed;
+use crate::error::ParseError;
+use crate::multi::count;
+use crate::number::u16;
+use crate::number::u8;
+use crate::number::Endianness;
+use crate::IResult;
+use crate::Parser;
+use crate::Partial;
+
+macro_rules! assert_parse(
+  ($left: expr, $right: expr) => {
+    let res: $crate::IResult<_, _, Error<_>> = $left;
+    assert_eq!(res, $right);
+  };
+);
+
+#[test]
+fn eof_on_slices() {
+    let not_over: &[u8] = &b"Hello, world!"[..];
+    let is_over: &[u8] = &b""[..];
+
+    let res_not_over = eof(not_over);
+    assert_parse!(
+        res_not_over,
+        Err(ErrMode::Backtrack(error_position!(
+            not_over,
+            ErrorKind::Eof
+        )))
+    );
+
+    let res_over = eof(is_over);
+    assert_parse!(res_over, Ok((is_over, is_over)));
+}
+
+#[test]
+fn eof_on_strs() {
+    let not_over: &str = "Hello, world!";
+    let is_over: &str = "";
+
+    let res_not_over = eof(not_over);
+    assert_parse!(
+        res_not_over,
+        Err(ErrMode::Backtrack(error_position!(
+            not_over,
+            ErrorKind::Eof
+        )))
+    );
+
+    let res_over = eof(is_over);
+    assert_parse!(res_over, Ok((is_over, is_over)));
+}
+
+#[test]
+fn rest_on_slices() {
+    let input: &[u8] = &b"Hello, world!"[..];
+    let empty: &[u8] = &b""[..];
+    assert_parse!(rest(input), Ok((empty, input)));
+}
+
+#[test]
+fn rest_on_strs() {
+    let input: &str = "Hello, world!";
+    let empty: &str = "";
+    assert_parse!(rest(input), Ok((empty, input)));
+}
+
+#[test]
+fn rest_len_on_slices() {
+    let input: &[u8] = &b"Hello, world!"[..];
+    assert_parse!(rest_len(input), Ok((input, input.len())));
+}
+
+use crate::lib::std::convert::From;
+impl From<u32> for CustomError {
+    fn from(_: u32) -> Self {
+        CustomError
+    }
+}
+
+impl<I> ParseError<I> for CustomError {
+    fn from_error_kind(_: I, _: ErrorKind) -> Self {
+        CustomError
+    }
+
+    fn append(self, _: I, _: ErrorKind) -> Self {
+        CustomError
+    }
+}
+
+struct CustomError;
+#[allow(dead_code)]
+fn custom_error(input: &[u8]) -> IResult<&[u8], &[u8], CustomError> {
+    //fix_error!(input, CustomError<_>, alphanumeric)
+    crate::character::alphanumeric1(input)
+}
+
+#[test]
+fn test_parser_flat_map() {
+    let input: &[u8] = &[3, 100, 101, 102, 103, 104][..];
+    assert_parse!(
+        u8.flat_map(take).parse_next(input),
+        Ok((&[103, 104][..], &[100, 101, 102][..]))
+    );
+}
+
+#[allow(dead_code)]
+fn test_closure_compiles_195(input: &[u8]) -> IResult<&[u8], ()> {
+    u8.flat_map(|num| count(u16(Endianness::Big), num as usize))
+        .parse_next(input)
+}
+
+#[test]
+fn test_parser_verify_map() {
+    let input: &[u8] = &[50][..];
+    assert_parse!(
+        u8.verify_map(|u| if u < 20 { Some(u) } else { None })
+            .parse_next(input),
+        Err(ErrMode::Backtrack(Error {
+            input: &[50][..],
+            kind: ErrorKind::Verify
+        }))
+    );
+    assert_parse!(
+        u8.verify_map(|u| if u > 20 { Some(u) } else { None })
+            .parse_next(input),
+        Ok((&[][..], 50))
+    );
+}
+
+#[test]
+fn test_parser_map_parser() {
+    let input: &[u8] = &[100, 101, 102, 103, 104][..];
+    assert_parse!(
+        take(4usize).and_then(take(2usize)).parse_next(input),
+        Ok((&[104][..], &[100, 101][..]))
+    );
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn test_parser_into() {
+    use crate::bytes::take;
+    use crate::error::Error;
+
+    let mut parser = take::<_, _, Error<_>>(3u8).output_into();
+    let result: IResult<&[u8], Vec<u8>> = parser.parse_next(&b"abcdefg"[..]);
+
+    assert_eq!(result, Ok((&b"defg"[..], vec![97, 98, 99])));
+}
+
+#[test]
+fn opt_test() {
+    fn opt_abcd(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Option<&[u8]>> {
+        opt("abcd").parse_next(i)
+    }
+
+    let a = &b"abcdef"[..];
+    let b = &b"bcdefg"[..];
+    let c = &b"ab"[..];
+    assert_eq!(
+        opt_abcd(Partial::new(a)),
+        Ok((Partial::new(&b"ef"[..]), Some(&b"abcd"[..])))
+    );
+    assert_eq!(
+        opt_abcd(Partial::new(b)),
+        Ok((Partial::new(&b"bcdefg"[..]), None))
+    );
+    assert_eq!(
+        opt_abcd(Partial::new(c)),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+}
+
+#[test]
+fn peek_test() {
+    fn peek_tag(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        peek("abcd").parse_next(i)
+    }
+
+    assert_eq!(
+        peek_tag(Partial::new(&b"abcdef"[..])),
+        Ok((Partial::new(&b"abcdef"[..]), &b"abcd"[..]))
+    );
+    assert_eq!(
+        peek_tag(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        peek_tag(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn not_test() {
+    fn not_aaa(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, ()> {
+        not("aaa").parse_next(i)
+    }
+
+    assert_eq!(
+        not_aaa(Partial::new(&b"aaa"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"aaa"[..]),
+            ErrorKind::Not
+        )))
+    );
+    assert_eq!(
+        not_aaa(Partial::new(&b"aa"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        not_aaa(Partial::new(&b"abcd"[..])),
+        Ok((Partial::new(&b"abcd"[..]), ()))
+    );
+}
+
+#[test]
+fn test_parser_verify() {
+    use crate::bytes::take;
+
+    fn test(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        take(5u8)
+            .verify(|slice: &[u8]| slice[0] == b'a')
+            .parse_next(i)
+    }
+    assert_eq!(
+        test(Partial::new(&b"bcd"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        test(Partial::new(&b"bcdefg"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"bcdefg"[..]),
+            ErrorKind::Verify
+        )))
+    );
+    assert_eq!(
+        test(Partial::new(&b"abcdefg"[..])),
+        Ok((Partial::new(&b"fg"[..]), &b"abcde"[..]))
+    );
+}
+
+#[test]
+#[allow(unused)]
+fn test_parser_verify_ref() {
+    use crate::bytes::take;
+
+    let mut parser1 = take(3u8).verify(|s: &[u8]| s == &b"abc"[..]);
+
+    assert_eq!(
+        parser1.parse_next(&b"abcd"[..]),
+        Ok((&b"d"[..], &b"abc"[..]))
+    );
+    assert_eq!(
+        parser1.parse_next(&b"defg"[..]),
+        Err(ErrMode::Backtrack(Error {
+            input: &b"defg"[..],
+            kind: ErrorKind::Verify
+        }))
+    );
+
+    fn parser2(i: &[u8]) -> IResult<&[u8], u32> {
+        crate::number::be_u32
+            .verify(|val: &u32| *val < 3)
+            .parse_next(i)
+    }
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn test_parser_verify_alloc() {
+    use crate::bytes::take;
+    let mut parser1 = take(3u8)
+        .map(|s: &[u8]| s.to_vec())
+        .verify(|s: &[u8]| s == &b"abc"[..]);
+
+    assert_eq!(
+        parser1.parse_next(&b"abcd"[..]),
+        Ok((&b"d"[..], b"abc".to_vec()))
+    );
+    assert_eq!(
+        parser1.parse_next(&b"defg"[..]),
+        Err(ErrMode::Backtrack(Error {
+            input: &b"defg"[..],
+            kind: ErrorKind::Verify
+        }))
+    );
+}
+
+#[test]
+fn fail_test() {
+    let a = "string";
+    let b = "another string";
+
+    assert_eq!(
+        fail::<_, &str, _>(a),
+        Err(ErrMode::Backtrack(Error {
+            input: a,
+            kind: ErrorKind::Fail
+        }))
+    );
+    assert_eq!(
+        fail::<_, &str, _>(b),
+        Err(ErrMode::Backtrack(Error {
+            input: b,
+            kind: ErrorKind::Fail
+        }))
+    );
+}
diff --git a/vendor/winnow/src/error.rs b/vendor/winnow/src/error.rs
new file mode 100644
index 000000000..b49b0560a
--- /dev/null
+++ b/vendor/winnow/src/error.rs
@@ -0,0 +1,721 @@
+//! # Error management
+//!
+//! Errors are designed with multiple needs in mind:
+//! - Accumulate more [context][Parser::context] as the error goes up the parser chain
+//! - Distinguish between [recoverable errors,
+//!   unrecoverable errors, and more data is needed][ErrMode]
+//! - Have a very low overhead, as errors are often discarded by the calling parser (examples: `many0`, `alt`)
+//! - Can be modified according to the user's needs, because some languages need a lot more information
+//! - Help thread-through the [stream][crate::stream]
+//!
+//! To abstract these needs away from the user, generally `winnow` parsers use the [`IResult`]
+//! alias, rather than [`Result`][std::result::Result].  [`finish`][FinishIResult::finish] is
+//! provided for top-level parsers to integrate with your application's error reporting.
+//!
+//! Error types include:
+//! - `()`
+//! - [`Error`]
+//! - [`VerboseError`]
+//! - [Custom errors][crate::_topic::error]
+
+#[cfg(feature = "alloc")]
+use crate::lib::std::borrow::ToOwned;
+use crate::lib::std::fmt;
+use core::num::NonZeroUsize;
+
+use crate::stream::Stream;
+use crate::stream::StreamIsPartial;
+#[allow(unused_imports)] // Here for intra-doc links
+use crate::Parser;
+
+/// Holds the result of [`Parser`]
+///
+/// - `Ok((I, O))` is the remaining [input][crate::stream] and the parsed value
+/// - [`Err(ErrMode<E>)`][ErrMode] is the error along with how to respond to it
+///
+/// By default, the error type (`E`) is [`Error`]
+///
+/// At the top-level of your parser, you can use the [`FinishIResult::finish`] method to convert
+/// it to a more common result type
+pub type IResult<I, O, E = Error<I>> = Result<(I, O), ErrMode<E>>;
+
+/// Extension trait to convert a parser's [`IResult`] to a more manageable type
+#[deprecated(since = "0.4.0", note = "Replaced with `Parser::parse`")]
+pub trait FinishIResult<I, O, E> {
+    /// Converts the parser's [`IResult`] to a type that is more consumable by callers.
+    ///
+    /// Errors if the parser is not at the [end of input][crate::combinator::eof].  See
+    /// [`FinishIResult::finish_err`] if the remaining input is needed.
+    ///
+    /// # Panic
+    ///
+    /// If the result is `Err(ErrMode::Incomplete(_))`, this method will panic.
+    /// - **Complete parsers:** It will not be an issue, `Incomplete` is never used
+    /// - **Partial parsers:** `Incomplete` will be returned if there's not enough data
+    /// for the parser to decide, and you should gather more data before parsing again.
+    /// Once the parser returns either `Ok(_)`, `Err(ErrMode::Backtrack(_))` or `Err(ErrMode::Cut(_))`,
+    /// you can get out of the parsing loop and call `finish_err()` on the parser's result
+    ///
+    /// # Example
+    ///
+    #[cfg_attr(not(feature = "std"), doc = "```ignore")]
+    #[cfg_attr(feature = "std", doc = "```")]
+    /// use winnow::prelude::*;
+    /// use winnow::character::hex_uint;
+    /// use winnow::error::Error;
+    ///
+    /// struct Hex(u64);
+    ///
+    /// fn parse(value: &str) -> Result<Hex, Error<String>> {
+    ///     hex_uint.map(Hex).parse_next(value).finish().map_err(Error::into_owned)
+    /// }
+    /// ```
+    #[deprecated(since = "0.4.0", note = "Replaced with `Parser::parse`")]
+    fn finish(self) -> Result<O, E>;
+
+    /// Converts the parser's [`IResult`] to a type that is more consumable by errors.
+    ///
+    ///  It keeps the same `Ok` branch, and merges `ErrMode::Backtrack` and `ErrMode::Cut` into the `Err`
+    ///  side.
+    ///
+    /// # Panic
+    ///
+    /// If the result is `Err(ErrMode::Incomplete(_))`, this method will panic as [`ErrMode::Incomplete`]
+    /// should only be set when the input is [`StreamIsPartial<false>`] which this isn't implemented
+    /// for.
+    #[deprecated(since = "0.4.0", note = "Replaced with `Parser::parse`")]
+    fn finish_err(self) -> Result<(I, O), E>;
+}
+
+#[allow(deprecated)]
+impl<I, O, E> FinishIResult<I, O, E> for IResult<I, O, E>
+where
+    I: Stream,
+    // Force users to deal with `Incomplete` when `StreamIsPartial<true>`
+    I: StreamIsPartial,
+    I: Clone,
+    E: ParseError<I>,
+{
+    fn finish(self) -> Result<O, E> {
+        debug_assert!(
+            !I::is_partial_supported(),
+            "partial streams need to handle `ErrMode::Incomplete`"
+        );
+
+        let (i, o) = self.finish_err()?;
+        crate::combinator::eof(i).finish_err()?;
+        Ok(o)
+    }
+
+    fn finish_err(self) -> Result<(I, O), E> {
+        debug_assert!(
+            !I::is_partial_supported(),
+            "partial streams need to handle `ErrMode::Incomplete`"
+        );
+
+        match self {
+            Ok(res) => Ok(res),
+            Err(ErrMode::Backtrack(e)) | Err(ErrMode::Cut(e)) => Err(e),
+            Err(ErrMode::Incomplete(_)) => {
+                panic!("complete parsers should not report `Err(ErrMode::Incomplete(_))`")
+            }
+        }
+    }
+}
+
+/// Contains information on needed data if a parser returned `Incomplete`
+///
+/// **Note:** This is only possible for `Stream` that are [partial][`StreamIsPartial`],
+/// like [`Partial`][crate::Partial].
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub enum Needed {
+    /// Needs more data, but we do not know how much
+    Unknown,
+    /// Contains the required data size in bytes
+    Size(NonZeroUsize),
+}
+
+impl Needed {
+    /// Creates `Needed` instance, returns `Needed::Unknown` if the argument is zero
+    pub fn new(s: usize) -> Self {
+        match NonZeroUsize::new(s) {
+            Some(sz) => Needed::Size(sz),
+            None => Needed::Unknown,
+        }
+    }
+
+    /// Indicates if we know how many bytes we need
+    pub fn is_known(&self) -> bool {
+        *self != Needed::Unknown
+    }
+
+    /// Maps a `Needed` to `Needed` by applying a function to a contained `Size` value.
+    #[inline]
+    pub fn map<F: Fn(NonZeroUsize) -> usize>(self, f: F) -> Needed {
+        match self {
+            Needed::Unknown => Needed::Unknown,
+            Needed::Size(n) => Needed::new(f(n)),
+        }
+    }
+}
+
+/// The `Err` enum indicates the parser was not successful
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+pub enum ErrMode<E> {
+    /// There was not enough data to determine the appropriate action
+    ///
+    /// More data needs to be buffered before retrying the parse.
+    ///
+    /// This must only be set when the [`Stream`] is [partial][`StreamIsPartial`], like with
+    /// [`Partial`][crate::Partial]
+    ///
+    /// Convert this into an `Backtrack` with [`Parser::complete_err`]
+    Incomplete(Needed),
+    /// The parser failed with a recoverable error (the default).
+    ///
+    /// For example, a parser for json values might include a
+    /// [`dec_uint`][crate::character::dec_uint] as one case in an [`alt`][crate::branch::alt]
+    /// combiantor.  If it fails, the next case should be tried.
+    Backtrack(E),
+    /// The parser had an unrecoverable error.
+    ///
+    /// The parser was on the right branch, so directly report it to the user rather than trying
+    /// other branches. You can use [`cut_err()`][crate::combinator::cut_err] combinator to switch
+    /// from `ErrMode::Backtrack` to `ErrMode::Cut`.
+    ///
+    /// For example, one case in an [`alt`][crate::branch::alt] combinator found a unique prefix
+    /// and you want any further errors parsing the case to be reported to the user.
+    Cut(E),
+}
+
+impl<E> ErrMode<E> {
+    /// Tests if the result is Incomplete
+    pub fn is_incomplete(&self) -> bool {
+        matches!(self, ErrMode::Incomplete(_))
+    }
+
+    /// Prevent backtracking, bubbling the error up to the top
+    pub fn cut(self) -> Self {
+        match self {
+            ErrMode::Backtrack(e) => ErrMode::Cut(e),
+            rest => rest,
+        }
+    }
+
+    /// Enable backtracking support
+    pub fn backtrack(self) -> Self {
+        match self {
+            ErrMode::Cut(e) => ErrMode::Backtrack(e),
+            rest => rest,
+        }
+    }
+
+    /// Applies the given function to the inner error
+    pub fn map<E2, F>(self, f: F) -> ErrMode<E2>
+    where
+        F: FnOnce(E) -> E2,
+    {
+        match self {
+            ErrMode::Incomplete(n) => ErrMode::Incomplete(n),
+            ErrMode::Cut(t) => ErrMode::Cut(f(t)),
+            ErrMode::Backtrack(t) => ErrMode::Backtrack(f(t)),
+        }
+    }
+
+    /// Automatically converts between errors if the underlying type supports it
+    pub fn convert<F>(self) -> ErrMode<F>
+    where
+        E: ErrorConvert<F>,
+    {
+        self.map(ErrorConvert::convert)
+    }
+}
+
+impl<I, E: ParseError<I>> ParseError<I> for ErrMode<E> {
+    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
+        ErrMode::Backtrack(E::from_error_kind(input, kind))
+    }
+
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn assert(input: I, message: &'static str) -> Self
+    where
+        I: crate::lib::std::fmt::Debug,
+    {
+        ErrMode::Backtrack(E::assert(input, message))
+    }
+
+    fn append(self, input: I, kind: ErrorKind) -> Self {
+        match self {
+            ErrMode::Backtrack(e) => ErrMode::Backtrack(e.append(input, kind)),
+            e => e,
+        }
+    }
+
+    fn or(self, other: Self) -> Self {
+        match (self, other) {
+            (ErrMode::Backtrack(e), ErrMode::Backtrack(o)) => ErrMode::Backtrack(e.or(o)),
+            (ErrMode::Incomplete(e), _) | (_, ErrMode::Incomplete(e)) => ErrMode::Incomplete(e),
+            (ErrMode::Cut(e), _) | (_, ErrMode::Cut(e)) => ErrMode::Cut(e),
+        }
+    }
+}
+
+impl<I, EXT, E> FromExternalError<I, EXT> for ErrMode<E>
+where
+    E: FromExternalError<I, EXT>,
+{
+    fn from_external_error(input: I, kind: ErrorKind, e: EXT) -> Self {
+        ErrMode::Backtrack(E::from_external_error(input, kind, e))
+    }
+}
+
+impl<T> ErrMode<Error<T>> {
+    /// Maps `ErrMode<Error<T>>` to `ErrMode<Error<U>>` with the given `F: T -> U`
+    pub fn map_input<U, F>(self, f: F) -> ErrMode<Error<U>>
+    where
+        F: FnOnce(T) -> U,
+    {
+        match self {
+            ErrMode::Incomplete(n) => ErrMode::Incomplete(n),
+            ErrMode::Cut(Error { input, kind }) => ErrMode::Cut(Error {
+                input: f(input),
+                kind,
+            }),
+            ErrMode::Backtrack(Error { input, kind }) => ErrMode::Backtrack(Error {
+                input: f(input),
+                kind,
+            }),
+        }
+    }
+}
+
+impl<E: Eq> Eq for ErrMode<E> {}
+
+impl<E> fmt::Display for ErrMode<E>
+where
+    E: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ErrMode::Incomplete(Needed::Size(u)) => write!(f, "Parsing requires {} bytes/chars", u),
+            ErrMode::Incomplete(Needed::Unknown) => write!(f, "Parsing requires more data"),
+            ErrMode::Cut(c) => write!(f, "Parsing Failure: {:?}", c),
+            ErrMode::Backtrack(c) => write!(f, "Parsing Error: {:?}", c),
+        }
+    }
+}
+
+/// The basic [`Parser`] trait for errors
+///
+/// It provides methods to create an error from some combinators,
+/// and combine existing errors in combinators like `alt`.
+pub trait ParseError<I>: Sized {
+    /// Creates an error from the input position and an [`ErrorKind`]
+    fn from_error_kind(input: I, kind: ErrorKind) -> Self;
+
+    /// Process a parser assertion
+    #[cfg_attr(debug_assertions, track_caller)]
+    fn assert(input: I, _message: &'static str) -> Self
+    where
+        I: crate::lib::std::fmt::Debug,
+    {
+        #[cfg(debug_assertions)]
+        panic!("assert `{}` failed at {:#?}", _message, input);
+        #[cfg(not(debug_assertions))]
+        Self::from_error_kind(input, ErrorKind::Assert)
+    }
+
+    /// Like [`ParseError::from_error_kind`] but merges it with the existing error.
+    ///
+    /// This is useful when backtracking through a parse tree, accumulating error context on the
+    /// way.
+    fn append(self, input: I, kind: ErrorKind) -> Self;
+
+    /// Combines errors from two different parse branches.
+    ///
+    /// For example, this would be used by [`alt`][crate::branch::alt] to report the error from
+    /// each case.
+    fn or(self, other: Self) -> Self {
+        other
+    }
+}
+
+/// Used by [`Parser::context`] to add custom data to error while backtracking
+///
+/// May be implemented multiple times for different kinds of context.
+pub trait ContextError<I, C = &'static str>: Sized {
+    /// Append to an existing error custom data
+    ///
+    /// This is used mainly by [`Parser::context`], to add user friendly information
+    /// to errors when backtracking through a parse tree
+    fn add_context(self, _input: I, _ctx: C) -> Self {
+        self
+    }
+}
+
+/// Create a new error with an external error, from [`std::str::FromStr`]
+///
+/// This trait is required by the [`Parser::map_res`] combinator.
+pub trait FromExternalError<I, E> {
+    /// Like [`ParseError::from_error_kind`] but also include an external error.
+    fn from_external_error(input: I, kind: ErrorKind, e: E) -> Self;
+}
+
+/// Equivalent of `From` implementation to avoid orphan rules in bits parsers
+pub trait ErrorConvert<E> {
+    /// Transform to another error type
+    fn convert(self) -> E;
+}
+
+/// Default error type, only contains the error' location and kind
+///
+/// This is a low-overhead error that only provides basic information.  For less overhead, see
+/// `()`.  Fore more information, see [`VerboseError`].
+///:w
+/// **Note:** [context][Parser::context] and inner errors (like from [`Parser::map_res`]) will be
+/// dropped.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Error<I> {
+    /// The input stream, pointing to the location where the error occurred
+    pub input: I,
+    /// A rudimentary error kind
+    pub kind: ErrorKind,
+}
+
+impl<I> Error<I> {
+    /// Creates a new basic error
+    pub fn new(input: I, kind: ErrorKind) -> Error<I> {
+        Error { input, kind }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'i, I: ToOwned + ?Sized> Error<&'i I> {
+    /// Obtaining ownership
+    pub fn into_owned(self) -> Error<<I as ToOwned>::Owned> {
+        Error {
+            input: self.input.to_owned(),
+            kind: self.kind,
+        }
+    }
+}
+
+impl<I> ParseError<I> for Error<I> {
+    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
+        Error { input, kind }
+    }
+
+    fn append(self, _: I, _: ErrorKind) -> Self {
+        self
+    }
+}
+
+impl<I, C> ContextError<I, C> for Error<I> {}
+
+impl<I, E> FromExternalError<I, E> for Error<I> {
+    /// Create a new error from an input position and an external error
+    fn from_external_error(input: I, kind: ErrorKind, _e: E) -> Self {
+        Error { input, kind }
+    }
+}
+
+impl<I> ErrorConvert<Error<(I, usize)>> for Error<I> {
+    fn convert(self) -> Error<(I, usize)> {
+        Error {
+            input: (self.input, 0),
+            kind: self.kind,
+        }
+    }
+}
+
+impl<I> ErrorConvert<Error<I>> for Error<(I, usize)> {
+    fn convert(self) -> Error<I> {
+        Error {
+            input: self.input.0,
+            kind: self.kind,
+        }
+    }
+}
+
+/// The Display implementation allows the `std::error::Error` implementation
+impl<I: fmt::Display> fmt::Display for Error<I> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "error {:?} at: {}", self.kind, self.input)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<I: fmt::Debug + fmt::Display + Sync + Send + 'static> std::error::Error for Error<I> {}
+
+impl<I> ParseError<I> for () {
+    fn from_error_kind(_: I, _: ErrorKind) -> Self {}
+
+    fn append(self, _: I, _: ErrorKind) -> Self {}
+}
+
+impl<I, C> ContextError<I, C> for () {}
+
+impl<I, E> FromExternalError<I, E> for () {
+    fn from_external_error(_input: I, _kind: ErrorKind, _e: E) -> Self {}
+}
+
+impl ErrorConvert<()> for () {
+    fn convert(self) {}
+}
+
+/// Accumulates error information while backtracking
+///
+/// For less overhead (and information), see [`Error`].
+///
+/// [`convert_error`] provides an example of how to render this for end-users.
+///
+/// **Note:** This will only capture the last failed branch for combinators like
+/// [`alt`][crate::branch::alt].
+#[cfg(feature = "alloc")]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct VerboseError<I> {
+    /// Accumulated error information
+    pub errors: crate::lib::std::vec::Vec<(I, VerboseErrorKind)>,
+}
+
+#[cfg(feature = "alloc")]
+impl<'i, I: ToOwned + ?Sized> VerboseError<&'i I> {
+    /// Obtaining ownership
+    pub fn into_owned(self) -> VerboseError<<I as ToOwned>::Owned> {
+        #[allow(clippy::redundant_clone)] // false positive
+        VerboseError {
+            errors: self
+                .errors
+                .into_iter()
+                .map(|(i, k)| (i.to_owned(), k))
+                .collect(),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[derive(Clone, Debug, Eq, PartialEq)]
+/// Error context for `VerboseError`
+pub enum VerboseErrorKind {
+    /// Static string added by the `context` function
+    Context(&'static str),
+    /// Error kind given by various parsers
+    Winnow(ErrorKind),
+}
+
+#[cfg(feature = "alloc")]
+impl<I> ParseError<I> for VerboseError<I> {
+    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
+        VerboseError {
+            errors: vec![(input, VerboseErrorKind::Winnow(kind))],
+        }
+    }
+
+    fn append(mut self, input: I, kind: ErrorKind) -> Self {
+        self.errors.push((input, VerboseErrorKind::Winnow(kind)));
+        self
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<I> ContextError<I, &'static str> for VerboseError<I> {
+    fn add_context(mut self, input: I, ctx: &'static str) -> Self {
+        self.errors.push((input, VerboseErrorKind::Context(ctx)));
+        self
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<I, E> FromExternalError<I, E> for VerboseError<I> {
+    /// Create a new error from an input position and an external error
+    fn from_external_error(input: I, kind: ErrorKind, _e: E) -> Self {
+        Self::from_error_kind(input, kind)
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<I> ErrorConvert<VerboseError<I>> for VerboseError<(I, usize)> {
+    fn convert(self) -> VerboseError<I> {
+        VerboseError {
+            errors: self.errors.into_iter().map(|(i, e)| (i.0, e)).collect(),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<I> ErrorConvert<VerboseError<(I, usize)>> for VerboseError<I> {
+    fn convert(self) -> VerboseError<(I, usize)> {
+        VerboseError {
+            errors: self.errors.into_iter().map(|(i, e)| ((i, 0), e)).collect(),
+        }
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<I: fmt::Display> fmt::Display for VerboseError<I> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "Parse error:")?;
+        for (input, error) in &self.errors {
+            match error {
+                VerboseErrorKind::Winnow(e) => writeln!(f, "{:?} at: {}", e, input)?,
+                VerboseErrorKind::Context(s) => writeln!(f, "in section '{}', at: {}", s, input)?,
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "std")]
+impl<I: fmt::Debug + fmt::Display + Sync + Send + 'static> std::error::Error for VerboseError<I> {}
+
+/// Transforms a `VerboseError` into a trace with input position information
+#[cfg(feature = "alloc")]
+pub fn convert_error<I: core::ops::Deref<Target = str>>(
+    input: I,
+    e: VerboseError<I>,
+) -> crate::lib::std::string::String {
+    use crate::lib::std::fmt::Write;
+    use crate::stream::Offset;
+
+    let mut result = crate::lib::std::string::String::new();
+
+    for (i, (substring, kind)) in e.errors.iter().enumerate() {
+        let offset = input.offset_to(substring);
+
+        if input.is_empty() {
+            match kind {
+                VerboseErrorKind::Context(s) => {
+                    write!(&mut result, "{}: in {}, got empty input\n\n", i, s)
+                }
+                VerboseErrorKind::Winnow(e) => {
+                    write!(&mut result, "{}: in {:?}, got empty input\n\n", i, e)
+                }
+            }
+        } else {
+            let prefix = &input.as_bytes()[..offset];
+
+            // Count the number of newlines in the first `offset` bytes of input
+            let line_number = prefix.iter().filter(|&&b| b == b'\n').count() + 1;
+
+            // Find the line that includes the subslice:
+            // Find the *last* newline before the substring starts
+            let line_begin = prefix
+                .iter()
+                .rev()
+                .position(|&b| b == b'\n')
+                .map(|pos| offset - pos)
+                .unwrap_or(0);
+
+            // Find the full line after that newline
+            let line = input[line_begin..]
+                .lines()
+                .next()
+                .unwrap_or(&input[line_begin..])
+                .trim_end();
+
+            // The (1-indexed) column number is the offset of our substring into that line
+            let column_number = line.offset_to(substring) + 1;
+
+            match kind {
+                VerboseErrorKind::Context(s) => write!(
+                    &mut result,
+                    "{i}: at line {line_number}, in {context}:\n\
+             {line}\n\
+             {caret:>column$}\n\n",
+                    i = i,
+                    line_number = line_number,
+                    context = s,
+                    line = line,
+                    caret = '^',
+                    column = column_number,
+                ),
+                VerboseErrorKind::Winnow(e) => write!(
+                    &mut result,
+                    "{i}: at line {line_number}, in {kind:?}:\n\
+             {line}\n\
+             {caret:>column$}\n\n",
+                    i = i,
+                    line_number = line_number,
+                    kind = e,
+                    line = line,
+                    caret = '^',
+                    column = column_number,
+                ),
+            }
+        }
+        // Because `write!` to a `String` is infallible, this `unwrap` is fine.
+        .unwrap();
+    }
+
+    result
+}
+
+/// Provide some minor debug context for errors
+#[rustfmt::skip]
+#[derive(Debug,PartialEq,Eq,Hash,Clone,Copy)]
+#[allow(missing_docs)]
+pub enum ErrorKind {
+  Assert,
+  Token,
+  Tag,
+  Alt,
+  Many,
+  Eof,
+  Slice,
+  Complete,
+  Not,
+  Verify,
+  Fail,
+}
+
+impl ErrorKind {
+    #[rustfmt::skip]
+    /// Converts an `ErrorKind` to a text description
+    pub fn description(&self) -> &str {
+    match *self {
+      ErrorKind::Assert                    => "assert",
+      ErrorKind::Token                     => "token",
+      ErrorKind::Tag                       => "tag",
+      ErrorKind::Alt                       => "alternative",
+      ErrorKind::Many                      => "many",
+      ErrorKind::Eof                       => "end of file",
+      ErrorKind::Slice                     => "slice",
+      ErrorKind::Complete                  => "complete",
+      ErrorKind::Not                       => "negation",
+      ErrorKind::Verify                    => "predicate verification",
+      ErrorKind::Fail                      => "fail",
+    }
+  }
+}
+
+/// Creates a parse error from a [`ErrorKind`]
+/// and the position in the input
+#[cfg(test)]
+macro_rules! error_position(
+  ($input:expr, $code:expr) => ({
+    $crate::error::ParseError::from_error_kind($input, $code)
+  });
+);
+
+#[cfg(test)]
+macro_rules! error_node_position(
+  ($input:expr, $code:expr, $next:expr) => ({
+    $crate::error::ParseError::append($next, $input, $code)
+  });
+);
+
+#[cfg(test)]
+#[cfg(feature = "alloc")]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn convert_error_panic() {
+        let input = "";
+
+        let _result: IResult<_, _, VerboseError<&str>> = 'x'.parse_next(input);
+    }
+}
diff --git a/vendor/winnow/src/lib.rs b/vendor/winnow/src/lib.rs
new file mode 100644
index 000000000..ddbc8f812
--- /dev/null
+++ b/vendor/winnow/src/lib.rs
@@ -0,0 +1,255 @@
+//! > winnow, making parsing a breeze
+//!
+//! `winnow` is a parser combinator library
+//!
+//! Quick links:
+//! - [List of combinators][crate::combinator]
+//! - [Tutorial][_tutorial::chapter_0]
+//! - [Special Topics][_topic]
+//! - [Discussions](https://github.com/winnow-rs/winnow/discussions)
+//!
+//! ## Aspirations
+//!
+//! `winnow` aims to be your "do everything" parser, much like people treat regular expressions.
+//!
+//! In roughly priority order:
+//! 1. Support writing parser declaratively while not getting in the way of imperative-style
+//!    parsing when needed, working as an open-ended toolbox rather than a close-ended framework.
+//! 2. Flexible enough to be used for any application, including parsing binary data, strings, or
+//!    separate lexing and parsing phases
+//! 3. Zero-cost abstractions, making it easy to write high performance parsers
+//! 4. Easy to use, making it trivial for one-off uses
+//!
+//! In addition:
+//! - Resilient maintainership, including
+//!   - Willing to break compatibility rather than batching up breaking changes in large releases
+//!   - Leverage feature flags to keep one active branch
+//! - We will support the last 6 months of rust releases (MSRV, currently 1.60)
+//!
+//! See also [Special Topic: Why winnow?][crate::_topic::why]
+//!
+//! ## Example
+//!
+//! Run
+//! ```console
+//! $ cargo add winnow
+//! ```
+//!
+//! Then use it to parse:
+//! ```rust
+//! # #[cfg(feature = "alloc")] {
+#![doc = include_str!("../examples/css/parser.rs")]
+//! # }
+//! ```
+//!
+//! See also the [Tutorial][_tutorial::chapter_0] and [Special Topics][_topic]
+
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(docsrs, feature(extended_key_value_attributes))]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![deny(missing_docs)]
+// BEGIN - Embark standard lints v6 for Rust 1.55+
+// do not change or add/remove here, but one can add exceptions after this section
+// for more info see: <https://github.com/EmbarkStudios/rust-ecosystem/issues/59>
+// "-Dunsafe_code",
+#![warn(clippy::all)]
+#![warn(clippy::await_holding_lock)]
+#![warn(clippy::char_lit_as_u8)]
+#![warn(clippy::checked_conversions)]
+#![warn(clippy::dbg_macro)]
+#![warn(clippy::debug_assert_with_mut_call)]
+#![warn(clippy::doc_markdown)]
+#![warn(clippy::empty_enum)]
+#![warn(clippy::enum_glob_use)]
+#![warn(clippy::exit)]
+#![warn(clippy::expl_impl_clone_on_copy)]
+#![warn(clippy::explicit_deref_methods)]
+#![warn(clippy::explicit_into_iter_loop)]
+#![warn(clippy::fallible_impl_from)]
+#![warn(clippy::filter_map_next)]
+#![warn(clippy::flat_map_option)]
+#![warn(clippy::float_cmp_const)]
+#![warn(clippy::fn_params_excessive_bools)]
+#![warn(clippy::from_iter_instead_of_collect)]
+#![warn(clippy::if_let_mutex)]
+#![warn(clippy::implicit_clone)]
+#![warn(clippy::imprecise_flops)]
+#![warn(clippy::inefficient_to_string)]
+#![warn(clippy::invalid_upcast_comparisons)]
+#![warn(clippy::large_digit_groups)]
+#![warn(clippy::large_stack_arrays)]
+#![warn(clippy::large_types_passed_by_value)]
+#![warn(clippy::let_unit_value)]
+#![warn(clippy::linkedlist)]
+#![warn(clippy::lossy_float_literal)]
+#![warn(clippy::macro_use_imports)]
+#![warn(clippy::manual_ok_or)]
+#![warn(clippy::map_err_ignore)]
+#![warn(clippy::map_flatten)]
+#![warn(clippy::map_unwrap_or)]
+#![warn(clippy::match_on_vec_items)]
+#![warn(clippy::match_same_arms)]
+#![warn(clippy::match_wild_err_arm)]
+#![warn(clippy::match_wildcard_for_single_variants)]
+#![warn(clippy::mem_forget)]
+#![warn(clippy::mismatched_target_os)]
+#![warn(clippy::missing_enforced_import_renames)]
+#![warn(clippy::mut_mut)]
+#![warn(clippy::mutex_integer)]
+#![warn(clippy::needless_borrow)]
+#![warn(clippy::needless_continue)]
+#![warn(clippy::needless_for_each)]
+#![warn(clippy::option_option)]
+#![warn(clippy::path_buf_push_overwrite)]
+#![warn(clippy::ptr_as_ptr)]
+#![warn(clippy::rc_mutex)]
+#![warn(clippy::ref_option_ref)]
+#![warn(clippy::rest_pat_in_fully_bound_structs)]
+#![warn(clippy::same_functions_in_if_condition)]
+#![warn(clippy::semicolon_if_nothing_returned)]
+#![warn(clippy::single_match_else)]
+#![warn(clippy::string_add_assign)]
+#![warn(clippy::string_add)]
+#![warn(clippy::string_lit_as_bytes)]
+#![warn(clippy::string_to_string)]
+#![warn(clippy::todo)]
+#![warn(clippy::trait_duplication_in_bounds)]
+#![warn(clippy::unimplemented)]
+#![warn(clippy::unnested_or_patterns)]
+#![warn(clippy::unused_self)]
+#![warn(clippy::useless_transmute)]
+#![warn(clippy::verbose_file_reads)]
+#![warn(clippy::zero_sized_map_values)]
+#![warn(future_incompatible)]
+#![warn(nonstandard_style)]
+#![warn(rust_2018_idioms)]
+// END - Embark standard lints v6 for Rust 1.55+
+#![allow(clippy::branches_sharing_code)]
+#![allow(clippy::collapsible_else_if)]
+#![allow(clippy::if_same_then_else)]
+#![allow(clippy::bool_assert_comparison)]
+#![allow(clippy::let_and_return)]
+#![allow(clippy::assertions_on_constants)]
+#![allow(clippy::map_unwrap_or)]
+#![allow(clippy::single_match_else)]
+#![allow(clippy::single_match)]
+#![allow(clippy::unnested_or_patterns)]
+#[cfg_attr(nightly, warn(rustdoc::missing_doc_code_examples))]
+#[cfg(feature = "alloc")]
+#[macro_use]
+extern crate alloc;
+#[cfg(doctest)]
+extern crate doc_comment;
+
+#[cfg(doctest)]
+doc_comment::doctest!("../README.md");
+
+/// Lib module to re-export everything needed from `std` or `core`/`alloc`. This is how `serde` does
+/// it, albeit there it is not public.
+#[doc(hidden)]
+pub(crate) mod lib {
+    /// `std` facade allowing `std`/`core` to be interchangeable. Reexports `alloc` crate optionally,
+    /// as well as `core` or `std`
+    #[cfg(not(feature = "std"))]
+    /// internal std exports for no_std compatibility
+    pub mod std {
+        #[doc(hidden)]
+        #[cfg(not(feature = "alloc"))]
+        pub use core::borrow;
+
+        #[cfg(feature = "alloc")]
+        #[doc(hidden)]
+        pub use alloc::{borrow, boxed, collections, string, vec};
+
+        #[doc(hidden)]
+        pub use core::{cmp, convert, fmt, hash, iter, mem, ops, option, result, slice, str};
+
+        /// internal reproduction of std prelude
+        #[doc(hidden)]
+        pub mod prelude {
+            pub use core::prelude as v1;
+        }
+    }
+
+    #[cfg(feature = "std")]
+    /// internal std exports for `no_std` compatibility
+    pub mod std {
+        #[doc(hidden)]
+        pub use std::{
+            alloc, borrow, boxed, cmp, collections, convert, fmt, hash, iter, mem, ops, option,
+            result, slice, str, string, vec,
+        };
+
+        /// internal reproduction of std prelude
+        #[doc(hidden)]
+        pub mod prelude {
+            pub use std::prelude as v1;
+        }
+    }
+}
+
+#[macro_use]
+mod macros;
+
+#[macro_use]
+pub mod error;
+
+mod parser;
+
+pub mod stream;
+
+pub mod bits;
+pub mod branch;
+pub mod bytes;
+pub mod character;
+pub mod combinator;
+pub mod multi;
+pub mod number;
+pub mod sequence;
+pub mod trace;
+
+#[cfg(feature = "unstable-doc")]
+pub mod _topic;
+#[cfg(feature = "unstable-doc")]
+pub mod _tutorial;
+
+/// Core concepts available for glob import
+///
+/// Including
+/// - [`FinishIResult`]
+/// - [`Parser`]
+///
+/// ## Example
+///
+/// ```rust
+/// use winnow::prelude::*;
+///
+/// fn parse_data(input: &str) -> IResult<&str, u64> {
+///     // ...
+/// #   winnow::character::dec_uint(input)
+/// }
+///
+/// fn main() {
+///   let result = parse_data.parse("100");
+///   assert_eq!(result, Ok(100));
+/// }
+/// ```
+pub mod prelude {
+    pub use crate::stream::StreamIsPartial as _;
+    #[allow(deprecated)]
+    pub use crate::FinishIResult as _;
+    pub use crate::IResult;
+    pub use crate::Parser;
+}
+
+#[allow(deprecated)]
+pub use error::FinishIResult;
+pub use error::IResult;
+pub use parser::*;
+pub use stream::BStr;
+pub use stream::Bytes;
+pub use stream::Located;
+pub use stream::Partial;
+pub use stream::Stateful;
+pub use stream::Str;
diff --git a/vendor/winnow/src/macros.rs b/vendor/winnow/src/macros.rs
new file mode 100644
index 000000000..bec67c1a3
--- /dev/null
+++ b/vendor/winnow/src/macros.rs
@@ -0,0 +1,78 @@
+/// `match` for parsers
+///
+/// When parsers have unique prefixes to test for, this offers better performance over
+/// [`alt`][crate::branch::alt] though it might be at the cost of duplicating parts of your grammar
+/// if you needed to [`peek`][crate::combinator::peek].
+///
+/// For tight control over the error in a catch-all case, use [`fail`][crate::combinator::fail].
+///
+/// # Example
+///
+/// ```rust
+/// use winnow::prelude::*;
+/// use winnow::branch::dispatch;
+/// # use winnow::bytes::any;
+/// # use winnow::combinator::peek;
+/// # use winnow::sequence::preceded;
+/// # use winnow::combinator::success;
+/// # use winnow::combinator::fail;
+///
+/// fn escaped(input: &str) -> IResult<&str, char> {
+///     preceded('\\', escape_seq_char).parse_next(input)
+/// }
+///
+/// fn escape_seq_char(input: &str) -> IResult<&str, char> {
+///     dispatch! {any;
+///         'b' => success('\u{8}'),
+///         'f' => success('\u{c}'),
+///         'n' => success('\n'),
+///         'r' => success('\r'),
+///         't' => success('\t'),
+///         '\\' => success('\\'),
+///         '"' => success('"'),
+///         _ => fail::<_, char, _>,
+///     }
+///     .parse_next(input)
+/// }
+///
+/// assert_eq!(escaped.parse_next("\\nHello"), Ok(("Hello", '\n')));
+/// ```
+#[macro_export]
+macro_rules! dispatch {
+    ($match_parser: expr; $( $pat:pat $(if $pred:expr)? => $expr: expr ),+ $(,)? ) => {
+        $crate::trace::trace("dispatch", move |i|
+        {
+            use $crate::Parser;
+            let (i, initial) = $match_parser.parse_next(i)?;
+            match initial {
+                $(
+                    $pat $(if $pred)? => $expr.parse_next(i),
+                )*
+            }
+        })
+    }
+}
+
+macro_rules! succ (
+  (0, $submac:ident ! ($($rest:tt)*)) => ($submac!(1, $($rest)*));
+  (1, $submac:ident ! ($($rest:tt)*)) => ($submac!(2, $($rest)*));
+  (2, $submac:ident ! ($($rest:tt)*)) => ($submac!(3, $($rest)*));
+  (3, $submac:ident ! ($($rest:tt)*)) => ($submac!(4, $($rest)*));
+  (4, $submac:ident ! ($($rest:tt)*)) => ($submac!(5, $($rest)*));
+  (5, $submac:ident ! ($($rest:tt)*)) => ($submac!(6, $($rest)*));
+  (6, $submac:ident ! ($($rest:tt)*)) => ($submac!(7, $($rest)*));
+  (7, $submac:ident ! ($($rest:tt)*)) => ($submac!(8, $($rest)*));
+  (8, $submac:ident ! ($($rest:tt)*)) => ($submac!(9, $($rest)*));
+  (9, $submac:ident ! ($($rest:tt)*)) => ($submac!(10, $($rest)*));
+  (10, $submac:ident ! ($($rest:tt)*)) => ($submac!(11, $($rest)*));
+  (11, $submac:ident ! ($($rest:tt)*)) => ($submac!(12, $($rest)*));
+  (12, $submac:ident ! ($($rest:tt)*)) => ($submac!(13, $($rest)*));
+  (13, $submac:ident ! ($($rest:tt)*)) => ($submac!(14, $($rest)*));
+  (14, $submac:ident ! ($($rest:tt)*)) => ($submac!(15, $($rest)*));
+  (15, $submac:ident ! ($($rest:tt)*)) => ($submac!(16, $($rest)*));
+  (16, $submac:ident ! ($($rest:tt)*)) => ($submac!(17, $($rest)*));
+  (17, $submac:ident ! ($($rest:tt)*)) => ($submac!(18, $($rest)*));
+  (18, $submac:ident ! ($($rest:tt)*)) => ($submac!(19, $($rest)*));
+  (19, $submac:ident ! ($($rest:tt)*)) => ($submac!(20, $($rest)*));
+  (20, $submac:ident ! ($($rest:tt)*)) => ($submac!(21, $($rest)*));
+);
diff --git a/vendor/winnow/src/multi/mod.rs b/vendor/winnow/src/multi/mod.rs
new file mode 100644
index 000000000..1c3aed7ba
--- /dev/null
+++ b/vendor/winnow/src/multi/mod.rs
@@ -0,0 +1,1065 @@
+//! Combinators applying their child parser multiple times
+
+#[cfg(test)]
+mod tests;
+
+use crate::error::ErrMode;
+use crate::error::ErrorKind;
+use crate::error::ParseError;
+use crate::stream::Accumulate;
+use crate::stream::{Stream, StreamIsPartial, ToUsize, UpdateSlice};
+use crate::trace::trace;
+use crate::Parser;
+
+/// [`Accumulate`] the output of a parser into a container, like `Vec`
+///
+/// This stops on [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// To recognize a series of tokens, [`Accumulate`] into a `()` and then [`Parser::recognize`].
+///
+/// **Warning:** if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
+/// return an error, to prevent going into an infinite loop
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::many0;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   many0("abc").parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// ```
+#[doc(alias = "skip_many")]
+#[doc(alias = "repeated")]
+#[doc(alias = "many0_count")]
+pub fn many0<I, O, C, E, F>(mut f: F) -> impl Parser<I, C, E>
+where
+    I: Stream,
+    C: Accumulate<O>,
+    F: Parser<I, O, E>,
+    E: ParseError<I>,
+{
+    trace("many0", move |mut i: I| {
+        let mut acc = C::initial(None);
+        loop {
+            let len = i.eof_offset();
+            match f.parse_next(i.clone()) {
+                Err(ErrMode::Backtrack(_)) => return Ok((i, acc)),
+                Err(e) => return Err(e),
+                Ok((i1, o)) => {
+                    // infinite loop check: the parser must always consume
+                    if i1.eof_offset() == len {
+                        return Err(ErrMode::assert(i, "many parsers must always consume"));
+                    }
+
+                    i = i1;
+                    acc.accumulate(o);
+                }
+            }
+        }
+    })
+}
+
+/// [`Accumulate`] the output of a parser into a container, like `Vec`
+///
+///
+/// This stops on [`ErrMode::Backtrack`] if there is at least one result.  To instead chain an error up,
+/// see [`cut_err`][crate::combinator::cut_err].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+///
+/// To recognize a series of tokens, [`Accumulate`] into a `()` and then [`Parser::recognize`].
+///
+/// **Warning:** If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::many1;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   many1("abc").parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// ```
+#[doc(alias = "skip_many1")]
+#[doc(alias = "repeated")]
+#[doc(alias = "many1_count")]
+pub fn many1<I, O, C, E, F>(mut f: F) -> impl Parser<I, C, E>
+where
+    I: Stream,
+    C: Accumulate<O>,
+    F: Parser<I, O, E>,
+    E: ParseError<I>,
+{
+    trace("many1", move |mut i: I| match f.parse_next(i.clone()) {
+        Err(e) => Err(e.append(i, ErrorKind::Many)),
+        Ok((i1, o)) => {
+            let mut acc = C::initial(None);
+            acc.accumulate(o);
+            i = i1;
+
+            loop {
+                let len = i.eof_offset();
+                match f.parse_next(i.clone()) {
+                    Err(ErrMode::Backtrack(_)) => return Ok((i, acc)),
+                    Err(e) => return Err(e),
+                    Ok((i1, o)) => {
+                        // infinite loop check: the parser must always consume
+                        if i1.eof_offset() == len {
+                            return Err(ErrMode::assert(i, "many parsers must always consume"));
+                        }
+
+                        i = i1;
+                        acc.accumulate(o);
+                    }
+                }
+            }
+        }
+    })
+}
+
+/// Applies the parser `f` until the parser `g` produces a result.
+///
+/// Returns a tuple of the results of `f` in a `Vec` and the result of `g`.
+///
+/// `f` keeps going so long as `g` produces [`ErrMode::Backtrack`]. To instead chain an error up, see [`cut_err`][crate::combinator::cut_err].
+///
+/// To recognize a series of tokens, [`Accumulate`] into a `()` and then [`Parser::recognize`].
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::many_till0;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, (Vec<&str>, &str)> {
+///   many_till0("abc", "end").parse_next(s)
+/// };
+///
+/// assert_eq!(parser("abcabcend"), Ok(("", (vec!["abc", "abc"], "end"))));
+/// assert_eq!(parser("abc123end"), Err(ErrMode::Backtrack(Error::new("123end", ErrorKind::Tag))));
+/// assert_eq!(parser("123123end"), Err(ErrMode::Backtrack(Error::new("123123end", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("abcendefg"), Ok(("efg", (vec!["abc"], "end"))));
+/// ```
+pub fn many_till0<I, O, C, P, E, F, G>(mut f: F, mut g: G) -> impl Parser<I, (C, P), E>
+where
+    I: Stream,
+    C: Accumulate<O>,
+    F: Parser<I, O, E>,
+    G: Parser<I, P, E>,
+    E: ParseError<I>,
+{
+    trace("many_till0", move |mut i: I| {
+        let mut res = C::initial(None);
+        loop {
+            let len = i.eof_offset();
+            match g.parse_next(i.clone()) {
+                Ok((i1, o)) => return Ok((i1, (res, o))),
+                Err(ErrMode::Backtrack(_)) => {
+                    match f.parse_next(i.clone()) {
+                        Err(e) => return Err(e.append(i, ErrorKind::Many)),
+                        Ok((i1, o)) => {
+                            // infinite loop check: the parser must always consume
+                            if i1.eof_offset() == len {
+                                return Err(ErrMode::assert(i, "many parsers must always consume"));
+                            }
+
+                            res.accumulate(o);
+                            i = i1;
+                        }
+                    }
+                }
+                Err(e) => return Err(e),
+            }
+        }
+    })
+}
+
+/// Alternates between two parsers to produce a list of elements.
+///
+/// This stops when either parser returns [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// # Arguments
+/// * `parser` Parses the elements of the list.
+/// * `sep` Parses the separator between list elements.
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::separated0;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   separated0("abc", "|").parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"])));
+/// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"])));
+/// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("def|abc"), Ok(("def|abc", vec![])));
+/// ```
+#[doc(alias = "sep_by")]
+#[doc(alias = "separated_list0")]
+pub fn separated0<I, O, C, O2, E, P, S>(mut parser: P, mut sep: S) -> impl Parser<I, C, E>
+where
+    I: Stream,
+    C: Accumulate<O>,
+    P: Parser<I, O, E>,
+    S: Parser<I, O2, E>,
+    E: ParseError<I>,
+{
+    trace("separated0", move |mut i: I| {
+        let mut res = C::initial(None);
+
+        match parser.parse_next(i.clone()) {
+            Err(ErrMode::Backtrack(_)) => return Ok((i, res)),
+            Err(e) => return Err(e),
+            Ok((i1, o)) => {
+                res.accumulate(o);
+                i = i1;
+            }
+        }
+
+        loop {
+            let len = i.eof_offset();
+            match sep.parse_next(i.clone()) {
+                Err(ErrMode::Backtrack(_)) => return Ok((i, res)),
+                Err(e) => return Err(e),
+                Ok((i1, _)) => {
+                    // infinite loop check: the parser must always consume
+                    if i1.eof_offset() == len {
+                        return Err(ErrMode::assert(i, "sep parsers must always consume"));
+                    }
+
+                    match parser.parse_next(i1.clone()) {
+                        Err(ErrMode::Backtrack(_)) => return Ok((i, res)),
+                        Err(e) => return Err(e),
+                        Ok((i2, o)) => {
+                            res.accumulate(o);
+                            i = i2;
+                        }
+                    }
+                }
+            }
+        }
+    })
+}
+
+/// Alternates between two parsers to produce a list of elements until [`ErrMode::Backtrack`].
+///
+/// Fails if the element parser does not produce at least one element.$
+///
+/// This stops when either parser returns [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// # Arguments
+/// * `sep` Parses the separator between list elements.
+/// * `f` Parses the elements of the list.
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::separated1;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   separated1("abc", "|").parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abc|abc|abc"), Ok(("", vec!["abc", "abc", "abc"])));
+/// assert_eq!(parser("abc123abc"), Ok(("123abc", vec!["abc"])));
+/// assert_eq!(parser("abc|def"), Ok(("|def", vec!["abc"])));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(Error::new("def|abc", ErrorKind::Tag))));
+/// ```
+#[doc(alias = "sep_by1")]
+#[doc(alias = "separated_list1")]
+pub fn separated1<I, O, C, O2, E, P, S>(mut parser: P, mut sep: S) -> impl Parser<I, C, E>
+where
+    I: Stream,
+    C: Accumulate<O>,
+    P: Parser<I, O, E>,
+    S: Parser<I, O2, E>,
+    E: ParseError<I>,
+{
+    trace("separated1", move |mut i: I| {
+        let mut res = C::initial(None);
+
+        // Parse the first element
+        match parser.parse_next(i.clone()) {
+            Err(e) => return Err(e),
+            Ok((i1, o)) => {
+                res.accumulate(o);
+                i = i1;
+            }
+        }
+
+        loop {
+            let len = i.eof_offset();
+            match sep.parse_next(i.clone()) {
+                Err(ErrMode::Backtrack(_)) => return Ok((i, res)),
+                Err(e) => return Err(e),
+                Ok((i1, _)) => {
+                    // infinite loop check: the parser must always consume
+                    if i1.eof_offset() == len {
+                        return Err(ErrMode::assert(i, "sep parsers must always consume"));
+                    }
+
+                    match parser.parse_next(i1.clone()) {
+                        Err(ErrMode::Backtrack(_)) => return Ok((i, res)),
+                        Err(e) => return Err(e),
+                        Ok((i2, o)) => {
+                            res.accumulate(o);
+                            i = i2;
+                        }
+                    }
+                }
+            }
+        }
+    })
+}
+
+/// Alternates between two parsers, merging the results (left associative)
+///
+/// This stops when either parser returns [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::separated_foldl1;
+/// use winnow::character::dec_int;
+///
+/// fn parser(s: &str) -> IResult<&str, i32> {
+///   separated_foldl1(dec_int, "-", |l, _, r| l - r).parse_next(s)
+/// }
+///
+/// assert_eq!(parser("9-3-5"), Ok(("", 1)));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(Error::new("def|abc", ErrorKind::Slice))));
+/// ```
+pub fn separated_foldl1<I, O, O2, E, P, S, Op>(
+    mut parser: P,
+    mut sep: S,
+    op: Op,
+) -> impl Parser<I, O, E>
+where
+    I: Stream,
+    P: Parser<I, O, E>,
+    S: Parser<I, O2, E>,
+    E: ParseError<I>,
+    Op: Fn(O, O2, O) -> O,
+{
+    trace("separated_foldl1", move |i: I| {
+        let (mut i, mut ol) = parser.parse_next(i)?;
+
+        loop {
+            let len = i.eof_offset();
+            match sep.parse_next(i.clone()) {
+                Err(ErrMode::Backtrack(_)) => return Ok((i, ol)),
+                Err(e) => return Err(e),
+                Ok((i1, s)) => {
+                    // infinite loop check: the parser must always consume
+                    if i1.eof_offset() == len {
+                        return Err(ErrMode::assert(i, "many parsers must always consume"));
+                    }
+
+                    match parser.parse_next(i1.clone()) {
+                        Err(ErrMode::Backtrack(_)) => return Ok((i, ol)),
+                        Err(e) => return Err(e),
+                        Ok((i2, or)) => {
+                            ol = op(ol, s, or);
+                            i = i2;
+                        }
+                    }
+                }
+            }
+        }
+    })
+}
+
+/// Alternates between two parsers, merging the results (right associative)
+///
+/// This stops when either parser returns [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// # Example
+///
+/// ```
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::separated_foldr1;
+/// use winnow::character::dec_uint;
+///
+/// fn parser(s: &str) -> IResult<&str, u32> {
+///   separated_foldr1(dec_uint, "^", |l: u32, _, r: u32| l.pow(r)).parse_next(s)
+/// }
+///
+/// assert_eq!(parser("2^3^2"), Ok(("", 512)));
+/// assert_eq!(parser("2"), Ok(("", 2)));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// assert_eq!(parser("def|abc"), Err(ErrMode::Backtrack(Error::new("def|abc", ErrorKind::Slice))));
+/// ```
+#[cfg(feature = "alloc")]
+pub fn separated_foldr1<I, O, O2, E, P, S, Op>(
+    mut parser: P,
+    mut sep: S,
+    op: Op,
+) -> impl Parser<I, O, E>
+where
+    I: Stream,
+    P: Parser<I, O, E>,
+    S: Parser<I, O2, E>,
+    E: ParseError<I>,
+    Op: Fn(O, O2, O) -> O,
+{
+    trace("separated_foldr1", move |i: I| {
+        let (i, ol) = parser.parse_next(i)?;
+        let (i, all): (_, crate::lib::std::vec::Vec<(O2, O)>) =
+            many0((sep.by_ref(), parser.by_ref())).parse_next(i)?;
+        if let Some((s, or)) = all
+            .into_iter()
+            .rev()
+            .reduce(|(sr, or), (sl, ol)| (sl, op(ol, sr, or)))
+        {
+            let merged = op(ol, s, or);
+            Ok((i, merged))
+        } else {
+            Ok((i, ol))
+        }
+    })
+}
+
+/// Repeats the embedded parser `m..=n` times
+///
+/// This stops before `n` when the parser returns [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// # Arguments
+/// * `m` The minimum number of iterations.
+/// * `n` The maximum number of iterations.
+/// * `f` The parser to apply.
+///
+/// To recognize a series of tokens, [`Accumulate`] into a `()` and then [`Parser::recognize`].
+///
+/// **Warning:** If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::many_m_n;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   many_m_n(0, 2, "abc").parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+#[doc(alias = "repeated")]
+pub fn many_m_n<I, O, C, E, F>(min: usize, max: usize, mut parse: F) -> impl Parser<I, C, E>
+where
+    I: Stream,
+    C: Accumulate<O>,
+    F: Parser<I, O, E>,
+    E: ParseError<I>,
+{
+    trace("many_m_n", move |mut input: I| {
+        if min > max {
+            return Err(ErrMode::Cut(E::from_error_kind(input, ErrorKind::Many)));
+        }
+
+        let mut res = C::initial(Some(min));
+        for count in 0..max {
+            let len = input.eof_offset();
+            match parse.parse_next(input.clone()) {
+                Ok((tail, value)) => {
+                    // infinite loop check: the parser must always consume
+                    if tail.eof_offset() == len {
+                        return Err(ErrMode::assert(input, "many parsers must always consume"));
+                    }
+
+                    res.accumulate(value);
+                    input = tail;
+                }
+                Err(ErrMode::Backtrack(e)) => {
+                    if count < min {
+                        return Err(ErrMode::Backtrack(e.append(input, ErrorKind::Many)));
+                    } else {
+                        return Ok((input, res));
+                    }
+                }
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+        }
+
+        Ok((input, res))
+    })
+}
+
+/// [`Accumulate`] the output of a parser into a container, like `Vec`
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `count` How often to apply the parser.
+///
+/// To recognize a series of tokens, [`Accumulate`] into a `()` and then [`Parser::recognize`].
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::count;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   count("abc", 2).parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag))));
+/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+#[doc(alias = "skip_counskip_count")]
+pub fn count<I, O, C, E, F>(mut f: F, count: usize) -> impl Parser<I, C, E>
+where
+    I: Stream,
+    C: Accumulate<O>,
+    F: Parser<I, O, E>,
+    E: ParseError<I>,
+{
+    trace("count", move |i: I| {
+        let mut input = i.clone();
+        let mut res = C::initial(Some(count));
+
+        for _ in 0..count {
+            let input_ = input.clone();
+            match f.parse_next(input_) {
+                Ok((i, o)) => {
+                    res.accumulate(o);
+                    input = i;
+                }
+                Err(e) => {
+                    return Err(e.append(i, ErrorKind::Many));
+                }
+            }
+        }
+
+        Ok((input, res))
+    })
+}
+
+/// Runs the embedded parser repeatedly, filling the given slice with results.
+///
+/// This parser fails if the input runs out before the given slice is full.
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `buf` The slice to fill
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::fill;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, [&str; 2]> {
+///   let mut buf = ["", ""];
+///   let (rest, ()) = fill("abc", &mut buf).parse_next(s)?;
+///   Ok((rest, buf))
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", ["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag))));
+/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Tag))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", ["abc", "abc"])));
+/// ```
+pub fn fill<'a, I, O, E, F>(mut f: F, buf: &'a mut [O]) -> impl Parser<I, (), E> + 'a
+where
+    I: Stream + 'a,
+    F: Parser<I, O, E> + 'a,
+    E: ParseError<I> + 'a,
+{
+    trace("fill", move |i: I| {
+        let mut input = i.clone();
+
+        for elem in buf.iter_mut() {
+            let input_ = input.clone();
+            match f.parse_next(input_) {
+                Ok((i, o)) => {
+                    *elem = o;
+                    input = i;
+                }
+                Err(e) => {
+                    return Err(e.append(i, ErrorKind::Many));
+                }
+            }
+        }
+
+        Ok((input, ()))
+    })
+}
+
+/// Repeats the embedded parser, calling `g` to gather the results.
+///
+/// This stops on [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `init` A function returning the initial value.
+/// * `g` The function that combines a result of `f` with
+///       the current accumulator.
+///
+/// **Warning:** if the parser passed in accepts empty inputs (like `alpha0` or `digit0`), `many0` will
+/// return an error, to prevent going into an infinite loop
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::fold_many0;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   fold_many0(
+///     "abc",
+///     Vec::new,
+///     |mut acc: Vec<_>, item| {
+///       acc.push(item);
+///       acc
+///     }
+///   ).parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// ```
+pub fn fold_many0<I, O, E, F, G, H, R>(mut f: F, mut init: H, mut g: G) -> impl Parser<I, R, E>
+where
+    I: Stream,
+    F: Parser<I, O, E>,
+    G: FnMut(R, O) -> R,
+    H: FnMut() -> R,
+    E: ParseError<I>,
+{
+    trace("fold_many0", move |i: I| {
+        let mut res = init();
+        let mut input = i;
+
+        loop {
+            let i_ = input.clone();
+            let len = input.eof_offset();
+            match f.parse_next(i_) {
+                Ok((i, o)) => {
+                    // infinite loop check: the parser must always consume
+                    if i.eof_offset() == len {
+                        return Err(ErrMode::assert(i, "many parsers must always consume"));
+                    }
+
+                    res = g(res, o);
+                    input = i;
+                }
+                Err(ErrMode::Backtrack(_)) => {
+                    return Ok((input, res));
+                }
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+        }
+    })
+}
+
+/// Repeats the embedded parser, calling `g` to gather the results.
+///
+/// This stops on [`ErrMode::Backtrack`] if there is at least one result.  To instead chain an error up,
+/// see [`cut_err`][crate::combinator::cut_err].
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `init` A function returning the initial value.
+/// * `g` The function that combines a result of `f` with
+///       the current accumulator.
+///
+/// **Warning:** If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::fold_many1;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   fold_many1(
+///     "abc",
+///     Vec::new,
+///     |mut acc: Vec<_>, item| {
+///       acc.push(item);
+///       acc
+///     }
+///   ).parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Err(ErrMode::Backtrack(Error::new("123123", ErrorKind::Many))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Many))));
+/// ```
+pub fn fold_many1<I, O, E, F, G, H, R>(mut f: F, mut init: H, mut g: G) -> impl Parser<I, R, E>
+where
+    I: Stream,
+    F: Parser<I, O, E>,
+    G: FnMut(R, O) -> R,
+    H: FnMut() -> R,
+    E: ParseError<I>,
+{
+    trace("fold_many1", move |i: I| {
+        let _i = i.clone();
+        let init = init();
+        match f.parse_next(_i) {
+            Err(ErrMode::Backtrack(_)) => Err(ErrMode::from_error_kind(i, ErrorKind::Many)),
+            Err(e) => Err(e),
+            Ok((i1, o1)) => {
+                let mut acc = g(init, o1);
+                let mut input = i1;
+
+                loop {
+                    let _input = input.clone();
+                    let len = input.eof_offset();
+                    match f.parse_next(_input) {
+                        Err(ErrMode::Backtrack(_)) => {
+                            break;
+                        }
+                        Err(e) => return Err(e),
+                        Ok((i, o)) => {
+                            // infinite loop check: the parser must always consume
+                            if i.eof_offset() == len {
+                                return Err(ErrMode::assert(i, "many parsers must always consume"));
+                            }
+
+                            acc = g(acc, o);
+                            input = i;
+                        }
+                    }
+                }
+
+                Ok((input, acc))
+            }
+        }
+    })
+}
+
+/// Repeats the embedded parser `m..=n` times, calling `g` to gather the results
+///
+/// This stops before `n` when the parser returns [`ErrMode::Backtrack`].  To instead chain an error up, see
+/// [`cut_err`][crate::combinator::cut_err].
+///
+/// # Arguments
+/// * `m` The minimum number of iterations.
+/// * `n` The maximum number of iterations.
+/// * `f` The parser to apply.
+/// * `init` A function returning the initial value.
+/// * `g` The function that combines a result of `f` with
+///       the current accumulator.
+///
+/// **Warning:** If the parser passed to `many1` accepts empty inputs
+/// (like `alpha0` or `digit0`), `many1` will return an error,
+/// to prevent going into an infinite loop.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::multi::fold_many_m_n;
+/// use winnow::bytes::tag;
+///
+/// fn parser(s: &str) -> IResult<&str, Vec<&str>> {
+///   fold_many_m_n(
+///     0,
+///     2,
+///     "abc",
+///     Vec::new,
+///     |mut acc: Vec<_>, item| {
+///       acc.push(item);
+///       acc
+///     }
+///   ).parse_next(s)
+/// }
+///
+/// assert_eq!(parser("abcabc"), Ok(("", vec!["abc", "abc"])));
+/// assert_eq!(parser("abc123"), Ok(("123", vec!["abc"])));
+/// assert_eq!(parser("123123"), Ok(("123123", vec![])));
+/// assert_eq!(parser(""), Ok(("", vec![])));
+/// assert_eq!(parser("abcabcabc"), Ok(("abc", vec!["abc", "abc"])));
+/// ```
+pub fn fold_many_m_n<I, O, E, F, G, H, R>(
+    min: usize,
+    max: usize,
+    mut parse: F,
+    mut init: H,
+    mut fold: G,
+) -> impl Parser<I, R, E>
+where
+    I: Stream,
+    F: Parser<I, O, E>,
+    G: FnMut(R, O) -> R,
+    H: FnMut() -> R,
+    E: ParseError<I>,
+{
+    trace("fold_many_m_n", move |mut input: I| {
+        if min > max {
+            return Err(ErrMode::Cut(E::from_error_kind(input, ErrorKind::Many)));
+        }
+
+        let mut acc = init();
+        for count in 0..max {
+            let len = input.eof_offset();
+            match parse.parse_next(input.clone()) {
+                Ok((tail, value)) => {
+                    // infinite loop check: the parser must always consume
+                    if tail.eof_offset() == len {
+                        return Err(ErrMode::assert(input, "many parsers must always consume"));
+                    }
+
+                    acc = fold(acc, value);
+                    input = tail;
+                }
+                //FInputXMError: handle failure properly
+                Err(ErrMode::Backtrack(err)) => {
+                    if count < min {
+                        return Err(ErrMode::Backtrack(err.append(input, ErrorKind::Many)));
+                    } else {
+                        break;
+                    }
+                }
+                Err(e) => return Err(e),
+            }
+        }
+
+        Ok((input, acc))
+    })
+}
+
+/// Gets a number from the parser and returns a
+/// subslice of the input of that size.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Arguments
+/// * `f` The parser to apply.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Needed, stream::Partial};
+/// # use winnow::prelude::*;
+/// use winnow::Bytes;
+/// use winnow::number::be_u16;
+/// use winnow::multi::length_data;
+/// use winnow::bytes::tag;
+///
+/// type Stream<'i> = Partial<&'i Bytes>;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Partial::new(Bytes::new(b))
+/// }
+///
+/// fn parser(s: Stream<'_>) -> IResult<Stream<'_>, &[u8]> {
+///   length_data(be_u16).parse_next(s)
+/// }
+///
+/// assert_eq!(parser(stream(b"\x00\x03abcefg")), Ok((stream(&b"efg"[..]), &b"abc"[..])));
+/// assert_eq!(parser(stream(b"\x00\x03a")), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+pub fn length_data<I, N, E, F>(mut f: F) -> impl Parser<I, <I as Stream>::Slice, E>
+where
+    I: StreamIsPartial,
+    I: Stream,
+    N: ToUsize,
+    F: Parser<I, N, E>,
+    E: ParseError<I>,
+{
+    trace("length_data", move |i: I| {
+        let (i, length) = f.parse_next(i)?;
+
+        crate::bytes::take(length).parse_next(i)
+    })
+}
+
+/// Gets a number from the first parser,
+/// takes a subslice of the input of that size,
+/// then applies the second parser on that subslice.
+/// If the second parser returns `Incomplete`,
+/// `length_value` will return an error.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Arguments
+/// * `f` The parser to apply.
+/// * `g` The parser to apply on the subslice.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed, stream::{Partial, StreamIsPartial}};
+/// # use winnow::prelude::*;
+/// use winnow::Bytes;
+/// use winnow::number::be_u16;
+/// use winnow::multi::length_value;
+/// use winnow::bytes::tag;
+///
+/// type Stream<'i> = Partial<&'i Bytes>;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Partial::new(Bytes::new(b))
+/// }
+///
+/// fn complete_stream(b: &[u8]) -> Stream<'_> {
+///     let mut p = Partial::new(Bytes::new(b));
+///     let _ = p.complete();
+///     p
+/// }
+///
+/// fn parser(s: Stream<'_>) -> IResult<Stream<'_>, &[u8]> {
+///   length_value(be_u16, "abc").parse_next(s)
+/// }
+///
+/// assert_eq!(parser(stream(b"\x00\x03abcefg")), Ok((stream(&b"efg"[..]), &b"abc"[..])));
+/// assert_eq!(parser(stream(b"\x00\x03123123")), Err(ErrMode::Backtrack(Error::new(complete_stream(&b"123"[..]), ErrorKind::Tag))));
+/// assert_eq!(parser(stream(b"\x00\x03a")), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+pub fn length_value<I, O, N, E, F, G>(mut f: F, mut g: G) -> impl Parser<I, O, E>
+where
+    I: StreamIsPartial,
+    I: Stream + UpdateSlice,
+    N: ToUsize,
+    F: Parser<I, N, E>,
+    G: Parser<I, O, E>,
+    E: ParseError<I>,
+{
+    trace("length_value", move |i: I| {
+        let (i, data) = length_data(f.by_ref()).parse_next(i)?;
+        let mut data = I::update_slice(i.clone(), data);
+        let _ = data.complete();
+        let (_, o) = g.by_ref().complete_err().parse_next(data)?;
+        Ok((i, o))
+    })
+}
+
+/// Gets a number from the first parser,
+/// then applies the second parser that many times.
+///
+/// # Arguments
+/// * `f` The parser to apply to obtain the count.
+/// * `g` The parser to apply repeatedly.
+///
+/// # Example
+///
+#[cfg_attr(not(feature = "std"), doc = "```ignore")]
+#[cfg_attr(feature = "std", doc = "```")]
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::prelude::*;
+/// use winnow::Bytes;
+/// use winnow::number::u8;
+/// use winnow::multi::length_count;
+/// use winnow::bytes::tag;
+///
+/// type Stream<'i> = &'i Bytes;
+///
+/// fn stream(b: &[u8]) -> Stream<'_> {
+///     Bytes::new(b)
+/// }
+///
+/// fn parser(s: Stream<'_>) -> IResult<Stream<'_>, Vec<&[u8]>> {
+///   length_count(u8.map(|i| {
+///      println!("got number: {}", i);
+///      i
+///   }), "abc").parse_next(s)
+/// }
+///
+/// assert_eq!(parser(stream(b"\x02abcabcabc")), Ok((stream(b"abc"), vec![&b"abc"[..], &b"abc"[..]])));
+/// assert_eq!(parser(stream(b"\x03123123123")), Err(ErrMode::Backtrack(Error::new(stream(b"123123123"), ErrorKind::Tag))));
+/// ```
+pub fn length_count<I, O, C, N, E, F, G>(mut f: F, mut g: G) -> impl Parser<I, C, E>
+where
+    I: Stream,
+    N: ToUsize,
+    C: Accumulate<O>,
+    F: Parser<I, N, E>,
+    G: Parser<I, O, E>,
+    E: ParseError<I>,
+{
+    trace("length_count", move |i: I| {
+        let (i, n) = f.parse_next(i)?;
+        let n = n.to_usize();
+        count(g.by_ref(), n).parse_next(i)
+    })
+}
diff --git a/vendor/winnow/src/multi/tests.rs b/vendor/winnow/src/multi/tests.rs
new file mode 100644
index 000000000..1977ff9c1
--- /dev/null
+++ b/vendor/winnow/src/multi/tests.rs
@@ -0,0 +1,743 @@
+use super::{length_data, length_value, many0, many1};
+use crate::Parser;
+use crate::Partial;
+use crate::{
+    character::digit1 as digit,
+    error::{ErrMode, ErrorKind, Needed, ParseError},
+    lib::std::str::{self, FromStr},
+    number::{be_u16, be_u8},
+    IResult,
+};
+#[cfg(feature = "alloc")]
+use crate::{
+    lib::std::vec::Vec,
+    multi::{
+        count, fold_many0, fold_many1, fold_many_m_n, length_count, many_m_n, many_till0,
+        separated0, separated1,
+    },
+};
+
+#[test]
+#[cfg(feature = "alloc")]
+fn separated0_test() {
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        separated0("abcd", ",").parse_next(i)
+    }
+    fn multi_empty(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        separated0("", ",").parse_next(i)
+    }
+    fn multi_longsep(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        separated0("abcd", "..").parse_next(i)
+    }
+
+    let a = &b"abcdef"[..];
+    let b = &b"abcd,abcdef"[..];
+    let c = &b"azerty"[..];
+    let d = &b",,abc"[..];
+    let e = &b"abcd,abcd,ef"[..];
+    let f = &b"abc"[..];
+    let g = &b"abcd."[..];
+    let h = &b"abcd,abc"[..];
+
+    let res1 = vec![&b"abcd"[..]];
+    assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
+    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+    assert_eq!(multi(Partial::new(b)), Ok((Partial::new(&b"ef"[..]), res2)));
+    assert_eq!(
+        multi(Partial::new(c)),
+        Ok((Partial::new(&b"azerty"[..]), Vec::new()))
+    );
+    let res3 = vec![&b""[..], &b""[..], &b""[..]];
+    assert_eq!(
+        multi_empty(Partial::new(d)),
+        Ok((Partial::new(&b"abc"[..]), res3))
+    );
+    let res4 = vec![&b"abcd"[..], &b"abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(e)),
+        Ok((Partial::new(&b",ef"[..]), res4))
+    );
+
+    assert_eq!(
+        multi(Partial::new(f)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        multi_longsep(Partial::new(g)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        multi(Partial::new(h)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+#[cfg_attr(debug_assertions, should_panic)]
+fn separated0_empty_sep_test() {
+    fn empty_sep(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        separated0("abc", "").parse_next(i)
+    }
+
+    let i = &b"abcabc"[..];
+
+    let i_err_pos = &i[3..];
+    assert_eq!(
+        empty_sep(Partial::new(i)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(i_err_pos),
+            ErrorKind::Assert
+        )))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn separated1_test() {
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        separated1("abcd", ",").parse_next(i)
+    }
+    fn multi_longsep(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        separated1("abcd", "..").parse_next(i)
+    }
+
+    let a = &b"abcdef"[..];
+    let b = &b"abcd,abcdef"[..];
+    let c = &b"azerty"[..];
+    let d = &b"abcd,abcd,ef"[..];
+
+    let f = &b"abc"[..];
+    let g = &b"abcd."[..];
+    let h = &b"abcd,abc"[..];
+
+    let res1 = vec![&b"abcd"[..]];
+    assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
+    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+    assert_eq!(multi(Partial::new(b)), Ok((Partial::new(&b"ef"[..]), res2)));
+    assert_eq!(
+        multi(Partial::new(c)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(c),
+            ErrorKind::Tag
+        )))
+    );
+    let res3 = vec![&b"abcd"[..], &b"abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(d)),
+        Ok((Partial::new(&b",ef"[..]), res3))
+    );
+
+    assert_eq!(
+        multi(Partial::new(f)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        multi_longsep(Partial::new(g)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        multi(Partial::new(h)),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many0_test() {
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        many0("abcd").parse_next(i)
+    }
+
+    assert_eq!(
+        multi(Partial::new(&b"abcdef"[..])),
+        Ok((Partial::new(&b"ef"[..]), vec![&b"abcd"[..]]))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"abcdabcdefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), vec![&b"abcd"[..], &b"abcd"[..]]))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"azerty"[..])),
+        Ok((Partial::new(&b"azerty"[..]), Vec::new()))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"abcdab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"abcd"[..])),
+        Err(ErrMode::Incomplete(Needed::new(4)))
+    );
+    assert_eq!(
+        multi(Partial::new(&b""[..])),
+        Err(ErrMode::Incomplete(Needed::new(4)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+#[cfg_attr(debug_assertions, should_panic)]
+fn many0_empty_test() {
+    fn multi_empty(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        many0("").parse_next(i)
+    }
+
+    assert_eq!(
+        multi_empty(Partial::new(&b"abcdef"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"abcdef"[..]),
+            ErrorKind::Assert
+        )))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many1_test() {
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        many1("abcd").parse_next(i)
+    }
+
+    let a = &b"abcdef"[..];
+    let b = &b"abcdabcdefgh"[..];
+    let c = &b"azerty"[..];
+    let d = &b"abcdab"[..];
+
+    let res1 = vec![&b"abcd"[..]];
+    assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
+    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(b)),
+        Ok((Partial::new(&b"efgh"[..]), res2))
+    );
+    assert_eq!(
+        multi(Partial::new(c)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(c),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        multi(Partial::new(d)),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many_till_test() {
+    #[allow(clippy::type_complexity)]
+    fn multi(i: &[u8]) -> IResult<&[u8], (Vec<&[u8]>, &[u8])> {
+        many_till0("abcd", "efgh").parse_next(i)
+    }
+
+    let a = b"abcdabcdefghabcd";
+    let b = b"efghabcd";
+    let c = b"azerty";
+
+    let res_a = (vec![&b"abcd"[..], &b"abcd"[..]], &b"efgh"[..]);
+    let res_b: (Vec<&[u8]>, &[u8]) = (Vec::new(), &b"efgh"[..]);
+    assert_eq!(multi(&a[..]), Ok((&b"abcd"[..], res_a)));
+    assert_eq!(multi(&b[..]), Ok((&b"abcd"[..], res_b)));
+    assert_eq!(
+        multi(&c[..]),
+        Err(ErrMode::Backtrack(error_node_position!(
+            &c[..],
+            ErrorKind::Many,
+            error_position!(&c[..], ErrorKind::Tag)
+        )))
+    );
+}
+
+#[test]
+#[cfg(feature = "std")]
+fn infinite_many() {
+    fn tst(input: &[u8]) -> IResult<&[u8], &[u8]> {
+        println!("input: {:?}", input);
+        Err(ErrMode::Backtrack(error_position!(input, ErrorKind::Tag)))
+    }
+
+    // should not go into an infinite loop
+    fn multi0(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+        many0(tst).parse_next(i)
+    }
+    let a = &b"abcdef"[..];
+    assert_eq!(multi0(a), Ok((a, Vec::new())));
+
+    fn multi1(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+        many1(tst).parse_next(i)
+    }
+    let a = &b"abcdef"[..];
+    assert_eq!(
+        multi1(a),
+        Err(ErrMode::Backtrack(error_position!(a, ErrorKind::Tag)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn many_m_n_test() {
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        many_m_n(2, 4, "Abcd").parse_next(i)
+    }
+
+    let a = &b"Abcdef"[..];
+    let b = &b"AbcdAbcdefgh"[..];
+    let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
+    let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
+    let e = &b"AbcdAb"[..];
+
+    assert_eq!(
+        multi(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"ef"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(b)),
+        Ok((Partial::new(&b"efgh"[..]), res1))
+    );
+    let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(c)),
+        Ok((Partial::new(&b"efgh"[..]), res2))
+    );
+    let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(d)),
+        Ok((Partial::new(&b"Abcdefgh"[..]), res3))
+    );
+    assert_eq!(
+        multi(Partial::new(e)),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn count_test() {
+    const TIMES: usize = 2;
+    fn cnt_2(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        count("abc", TIMES).parse_next(i)
+    }
+
+    assert_eq!(
+        cnt_2(Partial::new(&b"abcabcabcdef"[..])),
+        Ok((Partial::new(&b"abcdef"[..]), vec![&b"abc"[..], &b"abc"[..]]))
+    );
+    assert_eq!(
+        cnt_2(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        cnt_2(Partial::new(&b"abcab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        cnt_2(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        cnt_2(Partial::new(&b"xxxabcabcdef"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxxabcabcdef"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        cnt_2(Partial::new(&b"abcxxxabcdef"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxxabcdef"[..]),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn count_zero() {
+    const TIMES: usize = 0;
+    fn counter_2(i: &[u8]) -> IResult<&[u8], Vec<&[u8]>> {
+        count("abc", TIMES).parse_next(i)
+    }
+
+    let done = &b"abcabcabcdef"[..];
+    let parsed_done = Vec::new();
+    let rest = done;
+    let incomplete_1 = &b"ab"[..];
+    let parsed_incompl_1 = Vec::new();
+    let incomplete_2 = &b"abcab"[..];
+    let parsed_incompl_2 = Vec::new();
+    let error = &b"xxx"[..];
+    let error_remain = &b"xxx"[..];
+    let parsed_err = Vec::new();
+    let error_1 = &b"xxxabcabcdef"[..];
+    let parsed_err_1 = Vec::new();
+    let error_1_remain = &b"xxxabcabcdef"[..];
+    let error_2 = &b"abcxxxabcdef"[..];
+    let parsed_err_2 = Vec::new();
+    let error_2_remain = &b"abcxxxabcdef"[..];
+
+    assert_eq!(counter_2(done), Ok((rest, parsed_done)));
+    assert_eq!(
+        counter_2(incomplete_1),
+        Ok((incomplete_1, parsed_incompl_1))
+    );
+    assert_eq!(
+        counter_2(incomplete_2),
+        Ok((incomplete_2, parsed_incompl_2))
+    );
+    assert_eq!(counter_2(error), Ok((error_remain, parsed_err)));
+    assert_eq!(counter_2(error_1), Ok((error_1_remain, parsed_err_1)));
+    assert_eq!(counter_2(error_2), Ok((error_2_remain, parsed_err_2)));
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct NilError;
+
+impl<I> From<(I, ErrorKind)> for NilError {
+    fn from(_: (I, ErrorKind)) -> Self {
+        NilError
+    }
+}
+
+impl<I> ParseError<I> for NilError {
+    fn from_error_kind(_: I, _: ErrorKind) -> NilError {
+        NilError
+    }
+    fn append(self, _: I, _: ErrorKind) -> NilError {
+        NilError
+    }
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn length_count_test() {
+    fn number(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+        digit
+            .map_res(str::from_utf8)
+            .map_res(FromStr::from_str)
+            .parse_next(i)
+    }
+
+    fn cnt(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        length_count(number, "abc").parse_next(i)
+    }
+
+    assert_eq!(
+        cnt(Partial::new(&b"2abcabcabcdef"[..])),
+        Ok((Partial::new(&b"abcdef"[..]), vec![&b"abc"[..], &b"abc"[..]]))
+    );
+    assert_eq!(
+        cnt(Partial::new(&b"2ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        cnt(Partial::new(&b"3abcab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        cnt(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Slice
+        )))
+    );
+    assert_eq!(
+        cnt(Partial::new(&b"2abcxxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn length_data_test() {
+    fn number(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+        digit
+            .map_res(str::from_utf8)
+            .map_res(FromStr::from_str)
+            .parse_next(i)
+    }
+
+    fn take(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        length_data(number).parse_next(i)
+    }
+
+    assert_eq!(
+        take(Partial::new(&b"6abcabcabcdef"[..])),
+        Ok((Partial::new(&b"abcdef"[..]), &b"abcabc"[..]))
+    );
+    assert_eq!(
+        take(Partial::new(&b"3ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        take(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Slice
+        )))
+    );
+    assert_eq!(
+        take(Partial::new(&b"2abcxxx"[..])),
+        Ok((Partial::new(&b"cxxx"[..]), &b"ab"[..]))
+    );
+}
+
+#[test]
+fn length_value_test() {
+    use crate::stream::StreamIsPartial;
+
+    fn length_value_1(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u16> {
+        length_value(be_u8, be_u16).parse_next(i)
+    }
+    fn length_value_2(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (u8, u8)> {
+        length_value(be_u8, (be_u8, be_u8)).parse_next(i)
+    }
+
+    let mut empty_complete = Partial::new(&b""[..]);
+    let _ = empty_complete.complete();
+
+    let i1 = [0, 5, 6];
+    assert_eq!(
+        length_value_1(Partial::new(&i1)),
+        Err(ErrMode::Backtrack(error_position!(
+            empty_complete,
+            ErrorKind::Slice
+        )))
+    );
+    assert_eq!(
+        length_value_2(Partial::new(&i1)),
+        Err(ErrMode::Backtrack(error_position!(
+            empty_complete,
+            ErrorKind::Token
+        )))
+    );
+
+    let i2 = [1, 5, 6, 3];
+    {
+        let mut middle_complete = Partial::new(&i2[1..2]);
+        let _ = middle_complete.complete();
+        assert_eq!(
+            length_value_1(Partial::new(&i2)),
+            Err(ErrMode::Backtrack(error_position!(
+                middle_complete,
+                ErrorKind::Slice
+            )))
+        );
+        assert_eq!(
+            length_value_2(Partial::new(&i2)),
+            Err(ErrMode::Backtrack(error_position!(
+                empty_complete,
+                ErrorKind::Token
+            )))
+        );
+    }
+
+    let i3 = [2, 5, 6, 3, 4, 5, 7];
+    assert_eq!(
+        length_value_1(Partial::new(&i3)),
+        Ok((Partial::new(&i3[3..]), 1286))
+    );
+    assert_eq!(
+        length_value_2(Partial::new(&i3)),
+        Ok((Partial::new(&i3[3..]), (5, 6)))
+    );
+
+    let i4 = [3, 5, 6, 3, 4, 5];
+    assert_eq!(
+        length_value_1(Partial::new(&i4)),
+        Ok((Partial::new(&i4[4..]), 1286))
+    );
+    assert_eq!(
+        length_value_2(Partial::new(&i4)),
+        Ok((Partial::new(&i4[4..]), (5, 6)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn fold_many0_test() {
+    fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+        acc.push(item);
+        acc
+    }
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        fold_many0("abcd", Vec::new, fold_into_vec).parse_next(i)
+    }
+
+    assert_eq!(
+        multi(Partial::new(&b"abcdef"[..])),
+        Ok((Partial::new(&b"ef"[..]), vec![&b"abcd"[..]]))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"abcdabcdefgh"[..])),
+        Ok((Partial::new(&b"efgh"[..]), vec![&b"abcd"[..], &b"abcd"[..]]))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"azerty"[..])),
+        Ok((Partial::new(&b"azerty"[..]), Vec::new()))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"abcdab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        multi(Partial::new(&b"abcd"[..])),
+        Err(ErrMode::Incomplete(Needed::new(4)))
+    );
+    assert_eq!(
+        multi(Partial::new(&b""[..])),
+        Err(ErrMode::Incomplete(Needed::new(4)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+#[cfg_attr(debug_assertions, should_panic)]
+fn fold_many0_empty_test() {
+    fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+        acc.push(item);
+        acc
+    }
+    fn multi_empty(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        fold_many0("", Vec::new, fold_into_vec).parse_next(i)
+    }
+
+    assert_eq!(
+        multi_empty(Partial::new(&b"abcdef"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"abcdef"[..]),
+            ErrorKind::Assert
+        )))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn fold_many1_test() {
+    fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+        acc.push(item);
+        acc
+    }
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        fold_many1("abcd", Vec::new, fold_into_vec).parse_next(i)
+    }
+
+    let a = &b"abcdef"[..];
+    let b = &b"abcdabcdefgh"[..];
+    let c = &b"azerty"[..];
+    let d = &b"abcdab"[..];
+
+    let res1 = vec![&b"abcd"[..]];
+    assert_eq!(multi(Partial::new(a)), Ok((Partial::new(&b"ef"[..]), res1)));
+    let res2 = vec![&b"abcd"[..], &b"abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(b)),
+        Ok((Partial::new(&b"efgh"[..]), res2))
+    );
+    assert_eq!(
+        multi(Partial::new(c)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(c),
+            ErrorKind::Many
+        )))
+    );
+    assert_eq!(
+        multi(Partial::new(d)),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn fold_many_m_n_test() {
+    fn fold_into_vec<T>(mut acc: Vec<T>, item: T) -> Vec<T> {
+        acc.push(item);
+        acc
+    }
+    fn multi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, Vec<&[u8]>> {
+        fold_many_m_n(2, 4, "Abcd", Vec::new, fold_into_vec).parse_next(i)
+    }
+
+    let a = &b"Abcdef"[..];
+    let b = &b"AbcdAbcdefgh"[..];
+    let c = &b"AbcdAbcdAbcdAbcdefgh"[..];
+    let d = &b"AbcdAbcdAbcdAbcdAbcdefgh"[..];
+    let e = &b"AbcdAb"[..];
+
+    assert_eq!(
+        multi(Partial::new(a)),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"ef"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    let res1 = vec![&b"Abcd"[..], &b"Abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(b)),
+        Ok((Partial::new(&b"efgh"[..]), res1))
+    );
+    let res2 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(c)),
+        Ok((Partial::new(&b"efgh"[..]), res2))
+    );
+    let res3 = vec![&b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..], &b"Abcd"[..]];
+    assert_eq!(
+        multi(Partial::new(d)),
+        Ok((Partial::new(&b"Abcdefgh"[..]), res3))
+    );
+    assert_eq!(
+        multi(Partial::new(e)),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+}
+
+#[test]
+fn many0_count_test() {
+    fn count0_nums(i: &[u8]) -> IResult<&[u8], usize> {
+        many0((digit, ",")).parse_next(i)
+    }
+
+    assert_eq!(count0_nums(&b"123,junk"[..]), Ok((&b"junk"[..], 1)));
+
+    assert_eq!(count0_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
+
+    assert_eq!(
+        count0_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
+        Ok((&b"junk"[..], 10))
+    );
+
+    assert_eq!(count0_nums(&b"hello"[..]), Ok((&b"hello"[..], 0)));
+}
+
+#[test]
+fn many1_count_test() {
+    fn count1_nums(i: &[u8]) -> IResult<&[u8], usize> {
+        many1((digit, ",")).parse_next(i)
+    }
+
+    assert_eq!(count1_nums(&b"123,45,junk"[..]), Ok((&b"junk"[..], 2)));
+
+    assert_eq!(
+        count1_nums(&b"1,2,3,4,5,6,7,8,9,0,junk"[..]),
+        Ok((&b"junk"[..], 10))
+    );
+
+    assert_eq!(
+        count1_nums(&b"hello"[..]),
+        Err(ErrMode::Backtrack(error_position!(
+            &b"hello"[..],
+            ErrorKind::Slice
+        )))
+    );
+}
diff --git a/vendor/winnow/src/number/mod.rs b/vendor/winnow/src/number/mod.rs
new file mode 100644
index 000000000..1554ac729
--- /dev/null
+++ b/vendor/winnow/src/number/mod.rs
@@ -0,0 +1,2388 @@
+//! Parsers recognizing numbers
+
+#![allow(clippy::match_same_arms)]
+
+#[cfg(test)]
+mod tests;
+
+use crate::bytes::take;
+use crate::error::ErrMode;
+use crate::error::ErrorKind;
+use crate::error::Needed;
+use crate::error::ParseError;
+use crate::lib::std::ops::{Add, Shl};
+use crate::stream::{AsBytes, Stream, StreamIsPartial};
+use crate::trace::trace;
+use crate::IResult;
+use crate::Parser;
+
+/// Configurable endianness
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum Endianness {
+    /// Big endian
+    Big,
+    /// Little endian
+    Little,
+    /// Will match the host's endianness
+    Native,
+}
+
+/// Recognizes an unsigned 1 byte integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_u8;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u8> {
+///     be_u8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&[][..], ErrorKind::Token))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_u8;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+///     be_u8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"\x01abcd"[..]), 0x00)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn be_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+{
+    u8(input)
+}
+
+/// Recognizes a big endian unsigned 2 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_u16;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u16> {
+///     be_u16.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_u16;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u16> {
+///     be_u16.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0001)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn be_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_u16", move |input: I| be_uint(input, 2)).parse_next(input)
+}
+
+/// Recognizes a big endian unsigned 3 byte integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_u24;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u32> {
+///     be_u24.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_u24;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+///     be_u24.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x000102)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+#[inline(always)]
+pub fn be_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_u23", move |input: I| be_uint(input, 3)).parse_next(input)
+}
+
+/// Recognizes a big endian unsigned 4 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_u32;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u32> {
+///     be_u32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_u32;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+///     be_u32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x00010203)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn be_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_u32", move |input: I| be_uint(input, 4)).parse_next(input)
+}
+
+/// Recognizes a big endian unsigned 8 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_u64;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u64> {
+///     be_u64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_u64;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u64> {
+///     be_u64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0001020304050607)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn be_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_u64", move |input: I| be_uint(input, 8)).parse_next(input)
+}
+
+/// Recognizes a big endian unsigned 16 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_u128;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u128> {
+///     be_u128.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_u128;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u128> {
+///     be_u128.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x00010203040506070809101112131415)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+/// ```
+#[inline(always)]
+pub fn be_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_u128", move |input: I| be_uint(input, 16)).parse_next(input)
+}
+
+#[inline]
+fn be_uint<I, Uint, E: ParseError<I>>(input: I, bound: usize) -> IResult<I, Uint, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+    Uint: Default + Shl<u8, Output = Uint> + Add<Uint, Output = Uint> + From<u8>,
+{
+    debug_assert_ne!(bound, 1, "to_be_uint needs extra work to avoid overflow");
+    take(bound)
+        .map(|n: <I as Stream>::Slice| to_be_uint(n.as_bytes()))
+        .parse_next(input)
+}
+
+#[inline]
+fn to_be_uint<Uint>(number: &[u8]) -> Uint
+where
+    Uint: Default + Shl<u8, Output = Uint> + Add<Uint, Output = Uint> + From<u8>,
+{
+    let mut res = Uint::default();
+    for byte in number.iter().copied() {
+        res = (res << 8) + byte.into();
+    }
+
+    res
+}
+
+/// Recognizes a signed 1 byte integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_i8;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i8> {
+///     be_i8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&[][..], ErrorKind::Token))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_i8;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i8> {
+///       be_i8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"\x01abcd"[..]), 0x00)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn be_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+{
+    i8(input)
+}
+
+/// Recognizes a big endian signed 2 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_i16;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i16> {
+///     be_i16.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_i16;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i16> {
+///       be_i16.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0001)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+#[inline(always)]
+pub fn be_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_i16", move |input: I| {
+        be_uint::<_, u16, _>(input, 2).map(|(i, n)| (i, n as i16))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a big endian signed 3 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_i24;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i32> {
+///     be_i24.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_i24;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i32> {
+///       be_i24.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x000102)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn be_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_i24", move |input: I| {
+        be_uint::<_, u32, _>(input, 3).map(|(i, n)| {
+            // Same as the unsigned version but we need to sign-extend manually here
+            let n = if n & 0x80_00_00 != 0 {
+                (n | 0xff_00_00_00) as i32
+            } else {
+                n as i32
+            };
+            (i, n)
+        })
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a big endian signed 4 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_i32;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i32> {
+///       be_i32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_i32;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i32> {
+///       be_i32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x00010203)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(4))));
+/// ```
+#[inline(always)]
+pub fn be_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_i32", move |input: I| {
+        be_uint::<_, u32, _>(input, 4).map(|(i, n)| (i, n as i32))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a big endian signed 8 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_i64;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i64> {
+///       be_i64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_i64;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i64> {
+///       be_i64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0001020304050607)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn be_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_i64", move |input: I| {
+        be_uint::<_, u64, _>(input, 8).map(|(i, n)| (i, n as i64))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a big endian signed 16 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_i128;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i128> {
+///       be_i128.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_i128;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i128> {
+///       be_i128.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x00010203040506070809101112131415)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+/// ```
+#[inline(always)]
+pub fn be_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_i128", move |input: I| {
+        be_uint::<_, u128, _>(input, 16).map(|(i, n)| (i, n as i128))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes an unsigned 1 byte integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_u8;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u8> {
+///       le_u8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&[][..], ErrorKind::Token))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_u8;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+///       le_u8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"\x01abcd"[..]), 0x00)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn le_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+{
+    u8(input)
+}
+
+/// Recognizes a little endian unsigned 2 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_u16;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u16> {
+///       le_u16.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_u16;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u16> {
+///       le_u16::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn le_u16<I, E: ParseError<I>>(input: I) -> IResult<I, u16, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_u16", move |input: I| le_uint(input, 2)).parse_next(input)
+}
+
+/// Recognizes a little endian unsigned 3 byte integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_u24;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u32> {
+///       le_u24.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_u24;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+///       le_u24::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+#[inline(always)]
+pub fn le_u24<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_u24", move |input: I| le_uint(input, 3)).parse_next(input)
+}
+
+/// Recognizes a little endian unsigned 4 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_u32;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u32> {
+///       le_u32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_u32;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+///       le_u32::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x03020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn le_u32<I, E: ParseError<I>>(input: I) -> IResult<I, u32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_u32", move |input: I| le_uint(input, 4)).parse_next(input)
+}
+
+/// Recognizes a little endian unsigned 8 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_u64;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u64> {
+///       le_u64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_u64;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u64> {
+///       le_u64::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0706050403020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn le_u64<I, E: ParseError<I>>(input: I) -> IResult<I, u64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_u64", move |input: I| le_uint(input, 8)).parse_next(input)
+}
+
+/// Recognizes a little endian unsigned 16 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_u128;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u128> {
+///       le_u128.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_u128;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u128> {
+///       le_u128::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x15141312111009080706050403020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+/// ```
+#[inline(always)]
+pub fn le_u128<I, E: ParseError<I>>(input: I) -> IResult<I, u128, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_u128", move |input: I| le_uint(input, 16)).parse_next(input)
+}
+
+#[inline]
+fn le_uint<I, Uint, E: ParseError<I>>(input: I, bound: usize) -> IResult<I, Uint, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+    Uint: Default + Shl<u8, Output = Uint> + Add<Uint, Output = Uint> + From<u8>,
+{
+    take(bound)
+        .map(|n: <I as Stream>::Slice| to_le_uint(n.as_bytes()))
+        .parse_next(input)
+}
+
+#[inline]
+fn to_le_uint<Uint>(number: &[u8]) -> Uint
+where
+    Uint: Default + Shl<u8, Output = Uint> + Add<Uint, Output = Uint> + From<u8>,
+{
+    let mut res = Uint::default();
+    for (index, byte) in number.iter_offsets() {
+        res = res + (Uint::from(byte) << (8 * index as u8));
+    }
+
+    res
+}
+
+/// Recognizes a signed 1 byte integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_i8;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i8> {
+///       le_i8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&[][..], ErrorKind::Token))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_i8;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i8> {
+///       le_i8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"\x01abcd"[..]), 0x00)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn le_i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+{
+    i8(input)
+}
+
+/// Recognizes a little endian signed 2 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_i16;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i16> {
+///       le_i16.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_i16;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i16> {
+///       le_i16::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn le_i16<I, E: ParseError<I>>(input: I) -> IResult<I, i16, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_i16", move |input: I| {
+        le_uint::<_, u16, _>(input, 2).map(|(i, n)| (i, n as i16))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a little endian signed 3 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_i24;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i32> {
+///       le_i24.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_i24;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i32> {
+///       le_i24::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+#[inline(always)]
+pub fn le_i24<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_i24", move |input: I| {
+        le_uint::<_, u32, _>(input, 3).map(|(i, n)| {
+            // Same as the unsigned version but we need to sign-extend manually here
+            let n = if n & 0x80_00_00 != 0 {
+                (n | 0xff_00_00_00) as i32
+            } else {
+                n as i32
+            };
+            (i, n)
+        })
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a little endian signed 4 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_i32;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i32> {
+///       le_i32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_i32;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i32> {
+///       le_i32::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x03020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn le_i32<I, E: ParseError<I>>(input: I) -> IResult<I, i32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_i32", move |input: I| {
+        le_uint::<_, u32, _>(input, 4).map(|(i, n)| (i, n as i32))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a little endian signed 8 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_i64;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i64> {
+///       le_i64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_i64;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i64> {
+///       le_i64::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x0706050403020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn le_i64<I, E: ParseError<I>>(input: I) -> IResult<I, i64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_i64", move |input: I| {
+        le_uint::<_, u64, _>(input, 8).map(|(i, n)| (i, n as i64))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a little endian signed 16 bytes integer.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_i128;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i128> {
+///       le_i128.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
+/// assert_eq!(parser(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_i128;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i128> {
+///       le_i128::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Partial::new(&b"abcd"[..]), 0x15141312111009080706050403020100)));
+/// assert_eq!(parser(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+/// ```
+#[inline(always)]
+pub fn le_i128<I, E: ParseError<I>>(input: I) -> IResult<I, i128, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_i128", move |input: I| {
+        le_uint::<_, u128, _>(input, 16).map(|(i, n)| (i, n as i128))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes an unsigned 1 byte integer
+///
+/// **Note:** that endianness does not apply to 1 byte numbers.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::u8;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], u8> {
+///       u8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&[][..], ErrorKind::Token))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::u8;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u8> {
+///       u8::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"\x03abcefg"[..]), 0x00)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+{
+    trace("u8", move |input: I| {
+        if input.is_partial() {
+            streaming_u8(input)
+        } else {
+            complete_u8(input)
+        }
+    })
+    .parse_next(input)
+}
+
+#[inline]
+pub(crate) fn streaming_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
+where
+    I: Stream<Token = u8>,
+{
+    input
+        .next_token()
+        .ok_or_else(|| ErrMode::Incomplete(Needed::new(1)))
+}
+
+pub(crate) fn complete_u8<I, E: ParseError<I>>(input: I) -> IResult<I, u8, E>
+where
+    I: Stream<Token = u8>,
+{
+    input
+        .next_token()
+        .ok_or_else(|| ErrMode::Backtrack(E::from_error_kind(input, ErrorKind::Token)))
+}
+
+/// Recognizes an unsigned 2 bytes integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian u16 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian u16 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::u16;
+///
+/// let be_u16 = |s| {
+///     u16(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
+/// assert_eq!(be_u16(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_u16 = |s| {
+///     u16(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
+/// assert_eq!(le_u16(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::u16;
+///
+/// let be_u16 = |s| {
+///     u16::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0003)));
+/// assert_eq!(be_u16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+///
+/// let le_u16 = |s| {
+///     u16::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0300)));
+/// assert_eq!(le_u16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn u16<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, u16, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_u16,
+            crate::number::Endianness::Little => le_u16,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_u16,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_u16,
+        }
+    }(input)
+}
+
+/// Recognizes an unsigned 3 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian u24 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian u24 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::u24;
+///
+/// let be_u24 = |s| {
+///     u24(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
+/// assert_eq!(be_u24(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_u24 = |s| {
+///     u24(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
+/// assert_eq!(le_u24(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::u24;
+///
+/// let be_u24 = |s| {
+///     u24::<_,Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x000305)));
+/// assert_eq!(be_u24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+///
+/// let le_u24 = |s| {
+///     u24::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x050300)));
+/// assert_eq!(le_u24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+#[inline(always)]
+pub fn u24<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, u32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_u24,
+            crate::number::Endianness::Little => le_u24,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_u24,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_u24,
+        }
+    }(input)
+}
+
+/// Recognizes an unsigned 4 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian u32 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian u32 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::u32;
+///
+/// let be_u32 = |s| {
+///     u32(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
+/// assert_eq!(be_u32(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_u32 = |s| {
+///     u32(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
+/// assert_eq!(le_u32(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::u32;
+///
+/// let be_u32 = |s| {
+///     u32::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00030507)));
+/// assert_eq!(be_u32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+///
+/// let le_u32 = |s| {
+///     u32::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07050300)));
+/// assert_eq!(le_u32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn u32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, u32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_u32,
+            crate::number::Endianness::Little => le_u32,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_u32,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_u32,
+        }
+    }(input)
+}
+
+/// Recognizes an unsigned 8 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian u64 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian u64 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::u64;
+///
+/// let be_u64 = |s| {
+///     u64(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
+/// assert_eq!(be_u64(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_u64 = |s| {
+///     u64(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
+/// assert_eq!(le_u64(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::u64;
+///
+/// let be_u64 = |s| {
+///     u64::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0001020304050607)));
+/// assert_eq!(be_u64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+///
+/// let le_u64 = |s| {
+///     u64::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0706050403020100)));
+/// assert_eq!(le_u64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn u64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, u64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_u64,
+            crate::number::Endianness::Little => le_u64,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_u64,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_u64,
+        }
+    }(input)
+}
+
+/// Recognizes an unsigned 16 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian u128 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian u128 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::u128;
+///
+/// let be_u128 = |s| {
+///     u128(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
+/// assert_eq!(be_u128(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_u128 = |s| {
+///     u128(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
+/// assert_eq!(le_u128(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::u128;
+///
+/// let be_u128 = |s| {
+///     u128::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_u128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00010203040506070001020304050607)));
+/// assert_eq!(be_u128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+///
+/// let le_u128 = |s| {
+///     u128::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_u128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07060504030201000706050403020100)));
+/// assert_eq!(le_u128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+/// ```
+#[inline(always)]
+pub fn u128<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, u128, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_u128,
+            crate::number::Endianness::Little => le_u128,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_u128,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_u128,
+        }
+    }(input)
+}
+
+/// Recognizes a signed 1 byte integer
+///
+/// **Note:** that endianness does not apply to 1 byte numbers.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::i8;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], i8> {
+///       i8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&[][..], ErrorKind::Token))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::i8;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i8> {
+///       i8.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"\x03abcefg"[..]), 0x00)));
+/// assert_eq!(parser(Partial::new(&b""[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn i8<I, E: ParseError<I>>(input: I) -> IResult<I, i8, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+{
+    trace("i8", move |input: I| {
+        if input.is_partial() {
+            streaming_u8(input)
+        } else {
+            complete_u8(input)
+        }
+        .map(|(i, n)| (i, n as i8))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a signed 2 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian i16 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian i16 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::i16;
+///
+/// let be_i16 = |s| {
+///     i16(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
+/// assert_eq!(be_i16(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_i16 = |s| {
+///     i16(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
+/// assert_eq!(le_i16(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::i16;
+///
+/// let be_i16 = |s| {
+///     i16::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0003)));
+/// assert_eq!(be_i16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+///
+/// let le_i16 = |s| {
+///     i16::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i16(Partial::new(&b"\x00\x03abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0300)));
+/// assert_eq!(le_i16(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn i16<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, i16, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_i16,
+            crate::number::Endianness::Little => le_i16,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_i16,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_i16,
+        }
+    }(input)
+}
+
+/// Recognizes a signed 3 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian i24 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian i24 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::i24;
+///
+/// let be_i24 = |s| {
+///     i24(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
+/// assert_eq!(be_i24(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_i24 = |s| {
+///     i24(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
+/// assert_eq!(le_i24(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::i24;
+///
+/// let be_i24 = |s| {
+///     i24::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x000305)));
+/// assert_eq!(be_i24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+///
+/// let le_i24 = |s| {
+///     i24::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i24(Partial::new(&b"\x00\x03\x05abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x050300)));
+/// assert_eq!(le_i24(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(2))));
+/// ```
+#[inline(always)]
+pub fn i24<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, i32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_i24,
+            crate::number::Endianness::Little => le_i24,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_i24,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_i24,
+        }
+    }(input)
+}
+
+/// Recognizes a signed 4 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian i32 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian i32 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::i32;
+///
+/// let be_i32 = |s| {
+///     i32(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
+/// assert_eq!(be_i32(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_i32 = |s| {
+///     i32(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
+/// assert_eq!(le_i32(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::i32;
+///
+/// let be_i32 = |s| {
+///     i32::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00030507)));
+/// assert_eq!(be_i32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+///
+/// let le_i32 = |s| {
+///     i32::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i32(Partial::new(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07050300)));
+/// assert_eq!(le_i32(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn i32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, i32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_i32,
+            crate::number::Endianness::Little => le_i32,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_i32,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_i32,
+        }
+    }(input)
+}
+
+/// Recognizes a signed 8 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian i64 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian i64 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::i64;
+///
+/// let be_i64 = |s| {
+///     i64(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
+/// assert_eq!(be_i64(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_i64 = |s| {
+///     i64(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
+/// assert_eq!(le_i64(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::i64;
+///
+/// let be_i64 = |s| {
+///     i64::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0001020304050607)));
+/// assert_eq!(be_i64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+///
+/// let le_i64 = |s| {
+///     i64::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i64(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x0706050403020100)));
+/// assert_eq!(le_i64(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn i64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, i64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_i64,
+            crate::number::Endianness::Little => le_i64,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_i64,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_i64,
+        }
+    }(input)
+}
+
+/// Recognizes a signed 16 byte integer
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian i128 integer,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian i128 integer.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::i128;
+///
+/// let be_i128 = |s| {
+///     i128(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
+/// assert_eq!(be_i128(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+///
+/// let le_i128 = |s| {
+///     i128(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
+/// assert_eq!(le_i128(&b"\x01"[..]), Err(ErrMode::Backtrack(Error::new(&[0x01][..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::i128;
+///
+/// let be_i128 = |s| {
+///     i128::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_i128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x00010203040506070001020304050607)));
+/// assert_eq!(be_i128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+///
+/// let le_i128 = |s| {
+///     i128::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_i128(Partial::new(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Partial::new(&b"abcefg"[..]), 0x07060504030201000706050403020100)));
+/// assert_eq!(le_i128(Partial::new(&b"\x01"[..])), Err(ErrMode::Incomplete(Needed::new(15))));
+/// ```
+#[inline(always)]
+pub fn i128<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, i128, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_i128,
+            crate::number::Endianness::Little => le_i128,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_i128,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_i128,
+        }
+    }(input)
+}
+
+/// Recognizes a big endian 4 bytes floating point number.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_f32;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], f32> {
+///       be_f32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(parser(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_f32;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, f32> {
+///       be_f32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&[0x40, 0x29, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 2.640625)));
+/// assert_eq!(parser(Partial::new(&[0x01][..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn be_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_f32", move |input: I| {
+        be_uint::<_, u32, _>(input, 4).map(|(i, n)| (i, f32::from_bits(n)))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a big endian 8 bytes floating point number.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::be_f64;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], f64> {
+///       be_f64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(parser(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::be_f64;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, f64> {
+///       be_f64::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 12.5)));
+/// assert_eq!(parser(Partial::new(&[0x01][..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn be_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_f64", move |input: I| {
+        be_uint::<_, u64, _>(input, 8).map(|(i, n)| (i, f64::from_bits(n)))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a little endian 4 bytes floating point number.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_f32;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], f32> {
+///       le_f32.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(parser(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_f32;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, f32> {
+///       le_f32::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&[0x00, 0x00, 0x48, 0x41][..])), Ok((Partial::new(&b""[..]), 12.5)));
+/// assert_eq!(parser(Partial::new(&[0x01][..])), Err(ErrMode::Incomplete(Needed::new(3))));
+/// ```
+#[inline(always)]
+pub fn le_f32<I, E: ParseError<I>>(input: I) -> IResult<I, f32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("le_f32", move |input: I| {
+        le_uint::<_, u32, _>(input, 4).map(|(i, n)| (i, f32::from_bits(n)))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a little endian 8 bytes floating point number.
+///
+/// *Complete version*: Returns an error if there is not enough input data.
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::le_f64;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], f64> {
+///       le_f64.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(parser(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::Partial;
+/// use winnow::number::le_f64;
+///
+/// fn parser(s: Partial<&[u8]>) -> IResult<Partial<&[u8]>, f64> {
+///       le_f64::<_, Error<_>>.parse_next(s)
+/// }
+///
+/// assert_eq!(parser(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41][..])), Ok((Partial::new(&b""[..]), 3145728.0)));
+/// assert_eq!(parser(Partial::new(&[0x01][..])), Err(ErrMode::Incomplete(Needed::new(7))));
+/// ```
+#[inline(always)]
+pub fn le_f64<I, E: ParseError<I>>(input: I) -> IResult<I, f64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    trace("be_f64", move |input: I| {
+        le_uint::<_, u64, _>(input, 8).map(|(i, n)| (i, f64::from_bits(n)))
+    })
+    .parse_next(input)
+}
+
+/// Recognizes a 4 byte floating point number
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian f32 float,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian f32 float.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::f32;
+///
+/// let be_f32 = |s| {
+///     f32(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_f32(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(be_f32(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+///
+/// let le_f32 = |s| {
+///     f32(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_f32(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(le_f32(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::f32;
+///
+/// let be_f32 = |s| {
+///     f32::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_f32(Partial::new(&[0x41, 0x48, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 12.5)));
+/// assert_eq!(be_f32(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+///
+/// let le_f32 = |s| {
+///     f32::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_f32(Partial::new(&[0x00, 0x00, 0x48, 0x41][..])), Ok((Partial::new(&b""[..]), 12.5)));
+/// assert_eq!(le_f32(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+/// ```
+#[inline(always)]
+pub fn f32<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, f32, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_f32,
+            crate::number::Endianness::Little => le_f32,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_f32,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_f32,
+        }
+    }(input)
+}
+
+/// Recognizes an 8 byte floating point number
+///
+/// If the parameter is `winnow::number::Endianness::Big`, parse a big endian f64 float,
+/// otherwise if `winnow::number::Endianness::Little` parse a little endian f64 float.
+///
+/// *Complete version*: returns an error if there is not enough input data
+///
+/// *Partial version*: Will return `Err(winnow::error::ErrMode::Incomplete(_))` if there is not enough data.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::number::f64;
+///
+/// let be_f64 = |s| {
+///     f64(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_f64(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(be_f64(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+///
+/// let le_f64 = |s| {
+///     f64(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));
+/// assert_eq!(le_f64(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+/// ```
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// # use winnow::Partial;
+/// use winnow::number::f64;
+///
+/// let be_f64 = |s| {
+///     f64::<_, Error<_>>(winnow::number::Endianness::Big).parse_next(s)
+/// };
+///
+/// assert_eq!(be_f64(Partial::new(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])), Ok((Partial::new(&b""[..]), 12.5)));
+/// assert_eq!(be_f64(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(5))));
+///
+/// let le_f64 = |s| {
+///     f64::<_, Error<_>>(winnow::number::Endianness::Little).parse_next(s)
+/// };
+///
+/// assert_eq!(le_f64(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..])), Ok((Partial::new(&b""[..]), 12.5)));
+/// assert_eq!(le_f64(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(5))));
+/// ```
+#[inline(always)]
+pub fn f64<I, E: ParseError<I>>(endian: crate::number::Endianness) -> impl Parser<I, f64, E>
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    <I as Stream>::Slice: AsBytes,
+{
+    move |input: I| {
+        match endian {
+            crate::number::Endianness::Big => be_f64,
+            crate::number::Endianness::Little => le_f64,
+            #[cfg(target_endian = "big")]
+            crate::number::Endianness::Native => be_f64,
+            #[cfg(target_endian = "little")]
+            crate::number::Endianness::Native => le_f64,
+        }
+    }(input)
+}
diff --git a/vendor/winnow/src/number/tests.rs b/vendor/winnow/src/number/tests.rs
new file mode 100644
index 000000000..bbfeb239e
--- /dev/null
+++ b/vendor/winnow/src/number/tests.rs
@@ -0,0 +1,1058 @@
+use super::*;
+
+mod complete {
+    use super::*;
+    use crate::error::Error;
+
+    macro_rules! assert_parse(
+    ($left: expr, $right: expr) => {
+      let res: $crate::IResult<_, _, Error<_>> = $left;
+      assert_eq!(res, $right);
+    };
+  );
+
+    #[test]
+    fn i8_tests() {
+        assert_parse!(i8(&[0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(i8(&[0x7f][..]), Ok((&b""[..], 127)));
+        assert_parse!(i8(&[0xff][..]), Ok((&b""[..], -1)));
+        assert_parse!(i8(&[0x80][..]), Ok((&b""[..], -128)));
+    }
+
+    #[test]
+    fn be_i8_tests() {
+        assert_parse!(be_i8(&[0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(be_i8(&[0x7f][..]), Ok((&b""[..], 127)));
+        assert_parse!(be_i8(&[0xff][..]), Ok((&b""[..], -1)));
+        assert_parse!(be_i8(&[0x80][..]), Ok((&b""[..], -128)));
+    }
+
+    #[test]
+    fn be_i16_tests() {
+        assert_parse!(be_i16(&[0x00, 0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(be_i16(&[0x7f, 0xff][..]), Ok((&b""[..], 32_767_i16)));
+        assert_parse!(be_i16(&[0xff, 0xff][..]), Ok((&b""[..], -1)));
+        assert_parse!(be_i16(&[0x80, 0x00][..]), Ok((&b""[..], -32_768_i16)));
+    }
+
+    #[test]
+    fn be_u24_tests() {
+        assert_parse!(be_u24(&[0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(be_u24(&[0x00, 0xFF, 0xFF][..]), Ok((&b""[..], 65_535_u32)));
+        assert_parse!(
+            be_u24(&[0x12, 0x34, 0x56][..]),
+            Ok((&b""[..], 1_193_046_u32))
+        );
+    }
+
+    #[test]
+    fn be_i24_tests() {
+        assert_parse!(be_i24(&[0xFF, 0xFF, 0xFF][..]), Ok((&b""[..], -1_i32)));
+        assert_parse!(be_i24(&[0xFF, 0x00, 0x00][..]), Ok((&b""[..], -65_536_i32)));
+        assert_parse!(
+            be_i24(&[0xED, 0xCB, 0xAA][..]),
+            Ok((&b""[..], -1_193_046_i32))
+        );
+    }
+
+    #[test]
+    fn be_i32_tests() {
+        assert_parse!(be_i32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(
+            be_i32(&[0x7f, 0xff, 0xff, 0xff][..]),
+            Ok((&b""[..], 2_147_483_647_i32))
+        );
+        assert_parse!(be_i32(&[0xff, 0xff, 0xff, 0xff][..]), Ok((&b""[..], -1)));
+        assert_parse!(
+            be_i32(&[0x80, 0x00, 0x00, 0x00][..]),
+            Ok((&b""[..], -2_147_483_648_i32))
+        );
+    }
+
+    #[test]
+    fn be_i64_tests() {
+        assert_parse!(
+            be_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
+            Ok((&b""[..], 0))
+        );
+        assert_parse!(
+            be_i64(&[0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]),
+            Ok((&b""[..], 9_223_372_036_854_775_807_i64))
+        );
+        assert_parse!(
+            be_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]),
+            Ok((&b""[..], -1))
+        );
+        assert_parse!(
+            be_i64(&[0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
+            Ok((&b""[..], -9_223_372_036_854_775_808_i64))
+        );
+    }
+
+    #[test]
+    fn be_i128_tests() {
+        assert_parse!(
+            be_i128(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00
+                ][..]
+            ),
+            Ok((&b""[..], 0))
+        );
+        assert_parse!(
+            be_i128(
+                &[
+                    0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0xff
+                ][..]
+            ),
+            Ok((
+                &b""[..],
+                170_141_183_460_469_231_731_687_303_715_884_105_727_i128
+            ))
+        );
+        assert_parse!(
+            be_i128(
+                &[
+                    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0xff
+                ][..]
+            ),
+            Ok((&b""[..], -1))
+        );
+        assert_parse!(
+            be_i128(
+                &[
+                    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00
+                ][..]
+            ),
+            Ok((
+                &b""[..],
+                -170_141_183_460_469_231_731_687_303_715_884_105_728_i128
+            ))
+        );
+    }
+
+    #[test]
+    fn le_i8_tests() {
+        assert_parse!(le_i8(&[0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(le_i8(&[0x7f][..]), Ok((&b""[..], 127)));
+        assert_parse!(le_i8(&[0xff][..]), Ok((&b""[..], -1)));
+        assert_parse!(le_i8(&[0x80][..]), Ok((&b""[..], -128)));
+    }
+
+    #[test]
+    fn le_i16_tests() {
+        assert_parse!(le_i16(&[0x00, 0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(le_i16(&[0xff, 0x7f][..]), Ok((&b""[..], 32_767_i16)));
+        assert_parse!(le_i16(&[0xff, 0xff][..]), Ok((&b""[..], -1)));
+        assert_parse!(le_i16(&[0x00, 0x80][..]), Ok((&b""[..], -32_768_i16)));
+    }
+
+    #[test]
+    fn le_u24_tests() {
+        assert_parse!(le_u24(&[0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(le_u24(&[0xFF, 0xFF, 0x00][..]), Ok((&b""[..], 65_535_u32)));
+        assert_parse!(
+            le_u24(&[0x56, 0x34, 0x12][..]),
+            Ok((&b""[..], 1_193_046_u32))
+        );
+    }
+
+    #[test]
+    fn le_i24_tests() {
+        assert_parse!(le_i24(&[0xFF, 0xFF, 0xFF][..]), Ok((&b""[..], -1_i32)));
+        assert_parse!(le_i24(&[0x00, 0x00, 0xFF][..]), Ok((&b""[..], -65_536_i32)));
+        assert_parse!(
+            le_i24(&[0xAA, 0xCB, 0xED][..]),
+            Ok((&b""[..], -1_193_046_i32))
+        );
+    }
+
+    #[test]
+    fn le_i32_tests() {
+        assert_parse!(le_i32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0)));
+        assert_parse!(
+            le_i32(&[0xff, 0xff, 0xff, 0x7f][..]),
+            Ok((&b""[..], 2_147_483_647_i32))
+        );
+        assert_parse!(le_i32(&[0xff, 0xff, 0xff, 0xff][..]), Ok((&b""[..], -1)));
+        assert_parse!(
+            le_i32(&[0x00, 0x00, 0x00, 0x80][..]),
+            Ok((&b""[..], -2_147_483_648_i32))
+        );
+    }
+
+    #[test]
+    fn le_i64_tests() {
+        assert_parse!(
+            le_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
+            Ok((&b""[..], 0))
+        );
+        assert_parse!(
+            le_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f][..]),
+            Ok((&b""[..], 9_223_372_036_854_775_807_i64))
+        );
+        assert_parse!(
+            le_i64(&[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]),
+            Ok((&b""[..], -1))
+        );
+        assert_parse!(
+            le_i64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80][..]),
+            Ok((&b""[..], -9_223_372_036_854_775_808_i64))
+        );
+    }
+
+    #[test]
+    fn le_i128_tests() {
+        assert_parse!(
+            le_i128(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00
+                ][..]
+            ),
+            Ok((&b""[..], 0))
+        );
+        assert_parse!(
+            le_i128(
+                &[
+                    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0x7f
+                ][..]
+            ),
+            Ok((
+                &b""[..],
+                170_141_183_460_469_231_731_687_303_715_884_105_727_i128
+            ))
+        );
+        assert_parse!(
+            le_i128(
+                &[
+                    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0xff
+                ][..]
+            ),
+            Ok((&b""[..], -1))
+        );
+        assert_parse!(
+            le_i128(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x80
+                ][..]
+            ),
+            Ok((
+                &b""[..],
+                -170_141_183_460_469_231_731_687_303_715_884_105_728_i128
+            ))
+        );
+    }
+
+    #[test]
+    fn be_f32_tests() {
+        assert_parse!(be_f32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0_f32)));
+        assert_parse!(
+            be_f32(&[0x4d, 0x31, 0x1f, 0xd8][..]),
+            Ok((&b""[..], 185_728_380_f32))
+        );
+    }
+
+    #[test]
+    fn be_f64_tests() {
+        assert_parse!(
+            be_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
+            Ok((&b""[..], 0_f64))
+        );
+        assert_parse!(
+            be_f64(&[0x41, 0xa6, 0x23, 0xfb, 0x10, 0x00, 0x00, 0x00][..]),
+            Ok((&b""[..], 185_728_392_f64))
+        );
+    }
+
+    #[test]
+    fn le_f32_tests() {
+        assert_parse!(le_f32(&[0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 0_f32)));
+        assert_parse!(
+            le_f32(&[0xd8, 0x1f, 0x31, 0x4d][..]),
+            Ok((&b""[..], 185_728_380_f32))
+        );
+    }
+
+    #[test]
+    fn le_f64_tests() {
+        assert_parse!(
+            le_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]),
+            Ok((&b""[..], 0_f64))
+        );
+        assert_parse!(
+            le_f64(&[0x00, 0x00, 0x00, 0x10, 0xfb, 0x23, 0xa6, 0x41][..]),
+            Ok((&b""[..], 185_728_392_f64))
+        );
+    }
+
+    #[test]
+    fn configurable_endianness() {
+        use crate::number::Endianness;
+
+        fn be_tst16(i: &[u8]) -> IResult<&[u8], u16> {
+            u16(Endianness::Big).parse_next(i)
+        }
+        fn le_tst16(i: &[u8]) -> IResult<&[u8], u16> {
+            u16(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(be_tst16(&[0x80, 0x00]), Ok((&b""[..], 32_768_u16)));
+        assert_eq!(le_tst16(&[0x80, 0x00]), Ok((&b""[..], 128_u16)));
+
+        fn be_tst32(i: &[u8]) -> IResult<&[u8], u32> {
+            u32(Endianness::Big).parse_next(i)
+        }
+        fn le_tst32(i: &[u8]) -> IResult<&[u8], u32> {
+            u32(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tst32(&[0x12, 0x00, 0x60, 0x00]),
+            Ok((&b""[..], 302_014_464_u32))
+        );
+        assert_eq!(
+            le_tst32(&[0x12, 0x00, 0x60, 0x00]),
+            Ok((&b""[..], 6_291_474_u32))
+        );
+
+        fn be_tst64(i: &[u8]) -> IResult<&[u8], u64> {
+            u64(Endianness::Big).parse_next(i)
+        }
+        fn le_tst64(i: &[u8]) -> IResult<&[u8], u64> {
+            u64(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tst64(&[0x12, 0x00, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
+            Ok((&b""[..], 1_297_142_246_100_992_000_u64))
+        );
+        assert_eq!(
+            le_tst64(&[0x12, 0x00, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
+            Ok((&b""[..], 36_028_874_334_666_770_u64))
+        );
+
+        fn be_tsti16(i: &[u8]) -> IResult<&[u8], i16> {
+            i16(Endianness::Big).parse_next(i)
+        }
+        fn le_tsti16(i: &[u8]) -> IResult<&[u8], i16> {
+            i16(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(be_tsti16(&[0x00, 0x80]), Ok((&b""[..], 128_i16)));
+        assert_eq!(le_tsti16(&[0x00, 0x80]), Ok((&b""[..], -32_768_i16)));
+
+        fn be_tsti32(i: &[u8]) -> IResult<&[u8], i32> {
+            i32(Endianness::Big).parse_next(i)
+        }
+        fn le_tsti32(i: &[u8]) -> IResult<&[u8], i32> {
+            i32(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tsti32(&[0x00, 0x12, 0x60, 0x00]),
+            Ok((&b""[..], 1_204_224_i32))
+        );
+        assert_eq!(
+            le_tsti32(&[0x00, 0x12, 0x60, 0x00]),
+            Ok((&b""[..], 6_296_064_i32))
+        );
+
+        fn be_tsti64(i: &[u8]) -> IResult<&[u8], i64> {
+            i64(Endianness::Big).parse_next(i)
+        }
+        fn le_tsti64(i: &[u8]) -> IResult<&[u8], i64> {
+            i64(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tsti64(&[0x00, 0xFF, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
+            Ok((&b""[..], 71_881_672_479_506_432_i64))
+        );
+        assert_eq!(
+            le_tsti64(&[0x00, 0xFF, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00]),
+            Ok((&b""[..], 36_028_874_334_732_032_i64))
+        );
+    }
+}
+
+mod partial {
+    use super::*;
+    use crate::error::ErrMode;
+    use crate::error::Error;
+    use crate::error::Needed;
+    use crate::Partial;
+
+    macro_rules! assert_parse(
+    ($left: expr, $right: expr) => {
+      let res: $crate::IResult<_, _, Error<_>> = $left;
+      assert_eq!(res, $right);
+    };
+  );
+
+    #[test]
+    fn i8_tests() {
+        assert_parse!(
+            be_i8(Partial::new(&[0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            be_i8(Partial::new(&[0x7f][..])),
+            Ok((Partial::new(&b""[..]), 127))
+        );
+        assert_parse!(
+            be_i8(Partial::new(&[0xff][..])),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            be_i8(Partial::new(&[0x80][..])),
+            Ok((Partial::new(&b""[..]), -128))
+        );
+        assert_parse!(
+            be_i8(Partial::new(&[][..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    #[test]
+    fn i16_tests() {
+        assert_parse!(
+            be_i16(Partial::new(&[0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            be_i16(Partial::new(&[0x7f, 0xff][..])),
+            Ok((Partial::new(&b""[..]), 32_767_i16))
+        );
+        assert_parse!(
+            be_i16(Partial::new(&[0xff, 0xff][..])),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            be_i16(Partial::new(&[0x80, 0x00][..])),
+            Ok((Partial::new(&b""[..]), -32_768_i16))
+        );
+        assert_parse!(
+            be_i16(Partial::new(&[][..])),
+            Err(ErrMode::Incomplete(Needed::new(2)))
+        );
+        assert_parse!(
+            be_i16(Partial::new(&[0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    #[test]
+    fn u24_tests() {
+        assert_parse!(
+            be_u24(Partial::new(&[0x00, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            be_u24(Partial::new(&[0x00, 0xFF, 0xFF][..])),
+            Ok((Partial::new(&b""[..]), 65_535_u32))
+        );
+        assert_parse!(
+            be_u24(Partial::new(&[0x12, 0x34, 0x56][..])),
+            Ok((Partial::new(&b""[..]), 1_193_046_u32))
+        );
+        assert_parse!(
+            be_u24(Partial::new(&[][..])),
+            Err(ErrMode::Incomplete(Needed::new(3)))
+        );
+        assert_parse!(
+            be_u24(Partial::new(&[0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(2)))
+        );
+        assert_parse!(
+            be_u24(Partial::new(&[0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    #[test]
+    fn i24_tests() {
+        assert_parse!(
+            be_i24(Partial::new(&[0xFF, 0xFF, 0xFF][..])),
+            Ok((Partial::new(&b""[..]), -1_i32))
+        );
+        assert_parse!(
+            be_i24(Partial::new(&[0xFF, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), -65_536_i32))
+        );
+        assert_parse!(
+            be_i24(Partial::new(&[0xED, 0xCB, 0xAA][..])),
+            Ok((Partial::new(&b""[..]), -1_193_046_i32))
+        );
+        assert_parse!(
+            be_i24(Partial::new(&[][..])),
+            Err(ErrMode::Incomplete(Needed::new(3)))
+        );
+        assert_parse!(
+            be_i24(Partial::new(&[0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(2)))
+        );
+        assert_parse!(
+            be_i24(Partial::new(&[0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    #[test]
+    fn i32_tests() {
+        assert_parse!(
+            be_i32(Partial::new(&[0x00, 0x00, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            be_i32(Partial::new(&[0x7f, 0xff, 0xff, 0xff][..])),
+            Ok((Partial::new(&b""[..]), 2_147_483_647_i32))
+        );
+        assert_parse!(
+            be_i32(Partial::new(&[0xff, 0xff, 0xff, 0xff][..])),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            be_i32(Partial::new(&[0x80, 0x00, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), -2_147_483_648_i32))
+        );
+        assert_parse!(
+            be_i32(Partial::new(&[][..])),
+            Err(ErrMode::Incomplete(Needed::new(4)))
+        );
+        assert_parse!(
+            be_i32(Partial::new(&[0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(3)))
+        );
+        assert_parse!(
+            be_i32(Partial::new(&[0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(2)))
+        );
+        assert_parse!(
+            be_i32(Partial::new(&[0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    #[test]
+    fn i64_tests() {
+        assert_parse!(
+            be_i64(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            be_i64(Partial::new(
+                &[0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]
+            )),
+            Ok((Partial::new(&b""[..]), 9_223_372_036_854_775_807_i64))
+        );
+        assert_parse!(
+            be_i64(Partial::new(
+                &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]
+            )),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            be_i64(Partial::new(
+                &[0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Ok((Partial::new(&b""[..]), -9_223_372_036_854_775_808_i64))
+        );
+        assert_parse!(
+            be_i64(Partial::new(&[][..])),
+            Err(ErrMode::Incomplete(Needed::new(8)))
+        );
+        assert_parse!(
+            be_i64(Partial::new(&[0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(7)))
+        );
+        assert_parse!(
+            be_i64(Partial::new(&[0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(6)))
+        );
+        assert_parse!(
+            be_i64(Partial::new(&[0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(5)))
+        );
+        assert_parse!(
+            be_i64(Partial::new(&[0x00, 0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(4)))
+        );
+        assert_parse!(
+            be_i64(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(3)))
+        );
+        assert_parse!(
+            be_i64(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(2)))
+        );
+        assert_parse!(
+            be_i64(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    #[test]
+    fn i128_tests() {
+        assert_parse!(
+            be_i128(Partial::new(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00
+                ][..]
+            )),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[
+                    0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0xff
+                ][..]
+            )),
+            Ok((
+                Partial::new(&b""[..]),
+                170_141_183_460_469_231_731_687_303_715_884_105_727_i128
+            ))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[
+                    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0xff
+                ][..]
+            )),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[
+                    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00
+                ][..]
+            )),
+            Ok((
+                Partial::new(&b""[..]),
+                -170_141_183_460_469_231_731_687_303_715_884_105_728_i128
+            ))
+        );
+        assert_parse!(
+            be_i128(Partial::new(&[][..])),
+            Err(ErrMode::Incomplete(Needed::new(16)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(&[0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(15)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(&[0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(14)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(&[0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(13)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(&[0x00, 0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(12)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(11)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])),
+            Err(ErrMode::Incomplete(Needed::new(10)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(9)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(8)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(7)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(6)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(5)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(4)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(3)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00
+                ][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(2)))
+        );
+        assert_parse!(
+            be_i128(Partial::new(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00
+                ][..]
+            )),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+    }
+
+    #[test]
+    fn le_i8_tests() {
+        assert_parse!(
+            le_i8(Partial::new(&[0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            le_i8(Partial::new(&[0x7f][..])),
+            Ok((Partial::new(&b""[..]), 127))
+        );
+        assert_parse!(
+            le_i8(Partial::new(&[0xff][..])),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            le_i8(Partial::new(&[0x80][..])),
+            Ok((Partial::new(&b""[..]), -128))
+        );
+    }
+
+    #[test]
+    fn le_i16_tests() {
+        assert_parse!(
+            le_i16(Partial::new(&[0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            le_i16(Partial::new(&[0xff, 0x7f][..])),
+            Ok((Partial::new(&b""[..]), 32_767_i16))
+        );
+        assert_parse!(
+            le_i16(Partial::new(&[0xff, 0xff][..])),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            le_i16(Partial::new(&[0x00, 0x80][..])),
+            Ok((Partial::new(&b""[..]), -32_768_i16))
+        );
+    }
+
+    #[test]
+    fn le_u24_tests() {
+        assert_parse!(
+            le_u24(Partial::new(&[0x00, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            le_u24(Partial::new(&[0xFF, 0xFF, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 65_535_u32))
+        );
+        assert_parse!(
+            le_u24(Partial::new(&[0x56, 0x34, 0x12][..])),
+            Ok((Partial::new(&b""[..]), 1_193_046_u32))
+        );
+    }
+
+    #[test]
+    fn le_i24_tests() {
+        assert_parse!(
+            le_i24(Partial::new(&[0xFF, 0xFF, 0xFF][..])),
+            Ok((Partial::new(&b""[..]), -1_i32))
+        );
+        assert_parse!(
+            le_i24(Partial::new(&[0x00, 0x00, 0xFF][..])),
+            Ok((Partial::new(&b""[..]), -65_536_i32))
+        );
+        assert_parse!(
+            le_i24(Partial::new(&[0xAA, 0xCB, 0xED][..])),
+            Ok((Partial::new(&b""[..]), -1_193_046_i32))
+        );
+    }
+
+    #[test]
+    fn le_i32_tests() {
+        assert_parse!(
+            le_i32(Partial::new(&[0x00, 0x00, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            le_i32(Partial::new(&[0xff, 0xff, 0xff, 0x7f][..])),
+            Ok((Partial::new(&b""[..]), 2_147_483_647_i32))
+        );
+        assert_parse!(
+            le_i32(Partial::new(&[0xff, 0xff, 0xff, 0xff][..])),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            le_i32(Partial::new(&[0x00, 0x00, 0x00, 0x80][..])),
+            Ok((Partial::new(&b""[..]), -2_147_483_648_i32))
+        );
+    }
+
+    #[test]
+    fn le_i64_tests() {
+        assert_parse!(
+            le_i64(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            le_i64(Partial::new(
+                &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f][..]
+            )),
+            Ok((Partial::new(&b""[..]), 9_223_372_036_854_775_807_i64))
+        );
+        assert_parse!(
+            le_i64(Partial::new(
+                &[0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff][..]
+            )),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            le_i64(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80][..]
+            )),
+            Ok((Partial::new(&b""[..]), -9_223_372_036_854_775_808_i64))
+        );
+    }
+
+    #[test]
+    fn le_i128_tests() {
+        assert_parse!(
+            le_i128(Partial::new(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x00
+                ][..]
+            )),
+            Ok((Partial::new(&b""[..]), 0))
+        );
+        assert_parse!(
+            le_i128(Partial::new(
+                &[
+                    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0x7f
+                ][..]
+            )),
+            Ok((
+                Partial::new(&b""[..]),
+                170_141_183_460_469_231_731_687_303_715_884_105_727_i128
+            ))
+        );
+        assert_parse!(
+            le_i128(Partial::new(
+                &[
+                    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                    0xff, 0xff, 0xff
+                ][..]
+            )),
+            Ok((Partial::new(&b""[..]), -1))
+        );
+        assert_parse!(
+            le_i128(Partial::new(
+                &[
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x80
+                ][..]
+            )),
+            Ok((
+                Partial::new(&b""[..]),
+                -170_141_183_460_469_231_731_687_303_715_884_105_728_i128
+            ))
+        );
+    }
+
+    #[test]
+    fn be_f32_tests() {
+        assert_parse!(
+            be_f32(Partial::new(&[0x00, 0x00, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0_f32))
+        );
+        assert_parse!(
+            be_f32(Partial::new(&[0x4d, 0x31, 0x1f, 0xd8][..])),
+            Ok((Partial::new(&b""[..]), 185_728_380_f32))
+        );
+    }
+
+    #[test]
+    fn be_f64_tests() {
+        assert_parse!(
+            be_f64(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Ok((Partial::new(&b""[..]), 0_f64))
+        );
+        assert_parse!(
+            be_f64(Partial::new(
+                &[0x41, 0xa6, 0x23, 0xfb, 0x10, 0x00, 0x00, 0x00][..]
+            )),
+            Ok((Partial::new(&b""[..]), 185_728_392_f64))
+        );
+    }
+
+    #[test]
+    fn le_f32_tests() {
+        assert_parse!(
+            le_f32(Partial::new(&[0x00, 0x00, 0x00, 0x00][..])),
+            Ok((Partial::new(&b""[..]), 0_f32))
+        );
+        assert_parse!(
+            le_f32(Partial::new(&[0xd8, 0x1f, 0x31, 0x4d][..])),
+            Ok((Partial::new(&b""[..]), 185_728_380_f32))
+        );
+    }
+
+    #[test]
+    fn le_f64_tests() {
+        assert_parse!(
+            le_f64(Partial::new(
+                &[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]
+            )),
+            Ok((Partial::new(&b""[..]), 0_f64))
+        );
+        assert_parse!(
+            le_f64(Partial::new(
+                &[0x00, 0x00, 0x00, 0x10, 0xfb, 0x23, 0xa6, 0x41][..]
+            )),
+            Ok((Partial::new(&b""[..]), 185_728_392_f64))
+        );
+    }
+
+    #[test]
+    fn configurable_endianness() {
+        use crate::number::Endianness;
+
+        fn be_tst16(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u16> {
+            u16(Endianness::Big).parse_next(i)
+        }
+        fn le_tst16(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u16> {
+            u16(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tst16(Partial::new(&[0x80, 0x00])),
+            Ok((Partial::new(&b""[..]), 32_768_u16))
+        );
+        assert_eq!(
+            le_tst16(Partial::new(&[0x80, 0x00])),
+            Ok((Partial::new(&b""[..]), 128_u16))
+        );
+
+        fn be_tst32(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+            u32(Endianness::Big).parse_next(i)
+        }
+        fn le_tst32(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u32> {
+            u32(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tst32(Partial::new(&[0x12, 0x00, 0x60, 0x00])),
+            Ok((Partial::new(&b""[..]), 302_014_464_u32))
+        );
+        assert_eq!(
+            le_tst32(Partial::new(&[0x12, 0x00, 0x60, 0x00])),
+            Ok((Partial::new(&b""[..]), 6_291_474_u32))
+        );
+
+        fn be_tst64(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u64> {
+            u64(Endianness::Big).parse_next(i)
+        }
+        fn le_tst64(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, u64> {
+            u64(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tst64(Partial::new(&[
+                0x12, 0x00, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00
+            ])),
+            Ok((Partial::new(&b""[..]), 1_297_142_246_100_992_000_u64))
+        );
+        assert_eq!(
+            le_tst64(Partial::new(&[
+                0x12, 0x00, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00
+            ])),
+            Ok((Partial::new(&b""[..]), 36_028_874_334_666_770_u64))
+        );
+
+        fn be_tsti16(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i16> {
+            i16(Endianness::Big).parse_next(i)
+        }
+        fn le_tsti16(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i16> {
+            i16(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tsti16(Partial::new(&[0x00, 0x80])),
+            Ok((Partial::new(&b""[..]), 128_i16))
+        );
+        assert_eq!(
+            le_tsti16(Partial::new(&[0x00, 0x80])),
+            Ok((Partial::new(&b""[..]), -32_768_i16))
+        );
+
+        fn be_tsti32(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i32> {
+            i32(Endianness::Big).parse_next(i)
+        }
+        fn le_tsti32(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i32> {
+            i32(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tsti32(Partial::new(&[0x00, 0x12, 0x60, 0x00])),
+            Ok((Partial::new(&b""[..]), 1_204_224_i32))
+        );
+        assert_eq!(
+            le_tsti32(Partial::new(&[0x00, 0x12, 0x60, 0x00])),
+            Ok((Partial::new(&b""[..]), 6_296_064_i32))
+        );
+
+        fn be_tsti64(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i64> {
+            i64(Endianness::Big).parse_next(i)
+        }
+        fn le_tsti64(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, i64> {
+            i64(Endianness::Little).parse_next(i)
+        }
+        assert_eq!(
+            be_tsti64(Partial::new(&[
+                0x00, 0xFF, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00
+            ])),
+            Ok((Partial::new(&b""[..]), 71_881_672_479_506_432_i64))
+        );
+        assert_eq!(
+            le_tsti64(Partial::new(&[
+                0x00, 0xFF, 0x60, 0x00, 0x12, 0x00, 0x80, 0x00
+            ])),
+            Ok((Partial::new(&b""[..]), 36_028_874_334_732_032_i64))
+        );
+    }
+}
diff --git a/vendor/winnow/src/parser.rs b/vendor/winnow/src/parser.rs
new file mode 100644
index 000000000..264159094
--- /dev/null
+++ b/vendor/winnow/src/parser.rs
@@ -0,0 +1,909 @@
+//! Basic types to build the parsers
+
+use crate::combinator::*;
+use crate::error::{ContextError, FromExternalError, IResult, ParseError};
+use crate::stream::{AsChar, Compare, Location, Offset, ParseSlice, Stream, StreamIsPartial};
+
+/// Core trait for parsing
+///
+/// The simplest way to implement a `Parser` is with a function
+/// ```rust
+/// use winnow::prelude::*;
+///
+/// fn success(input: &str) -> IResult<&str, ()> {
+///     let output = ();
+///     Ok((input, output))
+/// }
+///
+/// let (input, output) = success.parse_next("Hello").unwrap();
+/// assert_eq!(input, "Hello");  // We didn't consume any input
+/// ```
+///
+/// which can be made stateful by returning a function
+/// ```rust
+/// use winnow::prelude::*;
+///
+/// fn success<O: Clone>(output: O) -> impl FnMut(&str) -> IResult<&str, O> {
+///     move |input: &str| {
+///         let output = output.clone();
+///         Ok((input, output))
+///     }
+/// }
+///
+/// let (input, output) = success("World").parse_next("Hello").unwrap();
+/// assert_eq!(input, "Hello");  // We didn't consume any input
+/// assert_eq!(output, "World");
+/// ```
+///
+/// Additionally, some basic types implement `Parser` as well, including
+/// - `u8` and `char`, see [`winnow::bytes::one_of`][crate::bytes::one_of]
+/// - `&[u8]` and `&str`, see [`winnow::bytes::tag`][crate::bytes::tag]
+pub trait Parser<I, O, E> {
+    /// Parse all of `input`, generating `O` from it
+    fn parse(&mut self, input: I) -> Result<O, E>
+    where
+        I: Stream,
+        // Force users to deal with `Incomplete` when `StreamIsPartial<true>`
+        I: StreamIsPartial,
+        I: Clone,
+        E: ParseError<I>,
+    {
+        #![allow(deprecated)]
+        use crate::error::FinishIResult;
+        self.parse_next(input).finish()
+    }
+
+    /// Take tokens from the [`Stream`], turning it into the output
+    ///
+    /// This includes advancing the [`Stream`] to the next location.
+    fn parse_next(&mut self, input: I) -> IResult<I, O, E>;
+
+    /// Treat `&mut Self` as a parser
+    ///
+    /// This helps when needing to move a `Parser` when all you have is a `&mut Parser`.
+    ///
+    /// # Example
+    ///
+    /// Because parsers are `FnMut`, they can be called multiple times.  This prevents moving `f`
+    /// into [`length_data`][crate::multi::length_data] and `g` into
+    /// [`Parser::complete_err`]:
+    /// ```rust,compile_fail
+    /// # use winnow::prelude::*;
+    /// # use winnow::IResult;
+    /// # use winnow::Parser;
+    /// # use winnow::error::ParseError;
+    /// # use winnow::multi::length_data;
+    /// pub fn length_value<'i, O, E: ParseError<&'i [u8]>>(
+    ///     mut f: impl Parser<&'i [u8], usize, E>,
+    ///     mut g: impl Parser<&'i [u8], O, E>
+    /// ) -> impl FnMut(&'i [u8]) -> IResult<&'i [u8], O, E> {
+    ///   move |i: &'i [u8]| {
+    ///     let (i, data) = length_data(f).parse_next(i)?;
+    ///     let (_, o) = g.complete().parse_next(data)?;
+    ///     Ok((i, o))
+    ///   }
+    /// }
+    /// ```
+    ///
+    /// By adding `by_ref`, we can make this work:
+    /// ```rust
+    /// # use winnow::prelude::*;
+    /// # use winnow::IResult;
+    /// # use winnow::Parser;
+    /// # use winnow::error::ParseError;
+    /// # use winnow::multi::length_data;
+    /// pub fn length_value<'i, O, E: ParseError<&'i [u8]>>(
+    ///     mut f: impl Parser<&'i [u8], usize, E>,
+    ///     mut g: impl Parser<&'i [u8], O, E>
+    /// ) -> impl FnMut(&'i [u8]) -> IResult<&'i [u8], O, E> {
+    ///   move |i: &'i [u8]| {
+    ///     let (i, data) = length_data(f.by_ref()).parse_next(i)?;
+    ///     let (_, o) = g.by_ref().complete_err().parse_next(data)?;
+    ///     Ok((i, o))
+    ///   }
+    /// }
+    /// ```
+    fn by_ref(&mut self) -> ByRef<'_, Self>
+    where
+        Self: core::marker::Sized,
+    {
+        ByRef::new(self)
+    }
+
+    /// Produce the provided value
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::character::alpha1;
+    /// # fn main() {
+    ///
+    /// let mut parser = alpha1.value(1234);
+    ///
+    /// assert_eq!(parser.parse_next("abcd"), Ok(("", 1234)));
+    /// assert_eq!(parser.parse_next("123abcd;"), Err(ErrMode::Backtrack(Error::new("123abcd;", ErrorKind::Slice))));
+    /// # }
+    /// ```
+    #[doc(alias = "to")]
+    fn value<O2>(self, val: O2) -> Value<Self, I, O, O2, E>
+    where
+        Self: core::marker::Sized,
+        O2: Clone,
+    {
+        Value::new(self, val)
+    }
+
+    /// Discards the output of the `Parser`
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::character::alpha1;
+    /// # fn main() {
+    ///
+    /// let mut parser = alpha1.void();
+    ///
+    /// assert_eq!(parser.parse_next("abcd"), Ok(("", ())));
+    /// assert_eq!(parser.parse_next("123abcd;"), Err(ErrMode::Backtrack(Error::new("123abcd;", ErrorKind::Slice))));
+    /// # }
+    /// ```
+    fn void(self) -> Void<Self, I, O, E>
+    where
+        Self: core::marker::Sized,
+    {
+        Void::new(self)
+    }
+
+    /// Convert the parser's output to another type using [`std::convert::From`]
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::IResult;
+    /// # use winnow::Parser;
+    /// use winnow::character::alpha1;
+    /// # fn main() {
+    ///
+    ///  fn parser1(i: &str) -> IResult<&str, &str> {
+    ///    alpha1(i)
+    ///  }
+    ///
+    ///  let mut parser2 = parser1.output_into();
+    ///
+    /// // the parser converts the &str output of the child parser into a Vec<u8>
+    /// let bytes: IResult<&str, Vec<u8>> = parser2.parse_next("abcd");
+    /// assert_eq!(bytes, Ok(("", vec![97, 98, 99, 100])));
+    /// # }
+    /// ```
+    fn output_into<O2>(self) -> OutputInto<Self, I, O, O2, E>
+    where
+        Self: core::marker::Sized,
+        O: Into<O2>,
+    {
+        OutputInto::new(self)
+    }
+
+    /// Produce the consumed input as produced value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::character::{alpha1};
+    /// use winnow::sequence::separated_pair;
+    /// # fn main() {
+    ///
+    /// let mut parser = separated_pair(alpha1, ',', alpha1).recognize();
+    ///
+    /// assert_eq!(parser.parse_next("abcd,efgh"), Ok(("", "abcd,efgh")));
+    /// assert_eq!(parser.parse_next("abcd;"),Err(ErrMode::Backtrack(Error::new(";", ErrorKind::Verify))));
+    /// # }
+    /// ```
+    #[doc(alias = "concat")]
+    fn recognize(self) -> Recognize<Self, I, O, E>
+    where
+        Self: core::marker::Sized,
+        I: Stream + Offset,
+    {
+        Recognize::new(self)
+    }
+
+    /// Produce the consumed input with the output
+    ///
+    /// Functions similarly to [recognize][Parser::recognize] except it
+    /// returns the parser output as well.
+    ///
+    /// This can be useful especially in cases where the output is not the same type
+    /// as the input, or the input is a user defined type.
+    ///
+    /// Returned tuple is of the format `(produced output, consumed input)`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::prelude::*;
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult};
+    /// use winnow::character::{alpha1};
+    /// use winnow::bytes::tag;
+    /// use winnow::sequence::separated_pair;
+    ///
+    /// fn inner_parser(input: &str) -> IResult<&str, bool> {
+    ///     "1234".value(true).parse_next(input)
+    /// }
+    ///
+    /// # fn main() {
+    ///
+    /// let mut consumed_parser = separated_pair(alpha1, ',', alpha1).value(true).with_recognized();
+    ///
+    /// assert_eq!(consumed_parser.parse_next("abcd,efgh1"), Ok(("1", (true, "abcd,efgh"))));
+    /// assert_eq!(consumed_parser.parse_next("abcd;"),Err(ErrMode::Backtrack(Error::new(";", ErrorKind::Verify))));
+    ///
+    /// // the second output (representing the consumed input)
+    /// // should be the same as that of the `recognize` parser.
+    /// let mut recognize_parser = inner_parser.recognize();
+    /// let mut consumed_parser = inner_parser.with_recognized().map(|(output, consumed)| consumed);
+    ///
+    /// assert_eq!(recognize_parser.parse_next("1234"), consumed_parser.parse_next("1234"));
+    /// assert_eq!(recognize_parser.parse_next("abcd"), consumed_parser.parse_next("abcd"));
+    /// # }
+    /// ```
+    #[doc(alias = "consumed")]
+    fn with_recognized(self) -> WithRecognized<Self, I, O, E>
+    where
+        Self: core::marker::Sized,
+        I: Stream + Offset,
+    {
+        WithRecognized::new(self)
+    }
+
+    /// Produce the location of the consumed input as produced value.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::prelude::*;
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, stream::Stream};
+    /// use winnow::stream::Located;
+    /// use winnow::character::alpha1;
+    /// use winnow::sequence::separated_pair;
+    ///
+    /// let mut parser = separated_pair(alpha1.span(), ',', alpha1.span());
+    ///
+    /// assert_eq!(parser.parse(Located::new("abcd,efgh")), Ok((0..4, 5..9)));
+    /// assert_eq!(parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").next_slice(4).0, ErrorKind::Verify))));
+    /// ```
+    fn span(self) -> Span<Self, I, O, E>
+    where
+        Self: core::marker::Sized,
+        I: Stream + Location,
+    {
+        Span::new(self)
+    }
+
+    /// Produce the location of consumed input with the output
+    ///
+    /// Functions similarly to [`Parser::span`] except it
+    /// returns the parser output as well.
+    ///
+    /// This can be useful especially in cases where the output is not the same type
+    /// as the input, or the input is a user defined type.
+    ///
+    /// Returned tuple is of the format `(produced output, consumed input)`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::prelude::*;
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, stream::Stream};
+    /// use winnow::stream::Located;
+    /// use winnow::character::alpha1;
+    /// use winnow::bytes::tag;
+    /// use winnow::sequence::separated_pair;
+    ///
+    /// fn inner_parser(input: Located<&str>) -> IResult<Located<&str>, bool> {
+    ///     "1234".value(true).parse_next(input)
+    /// }
+    ///
+    /// # fn main() {
+    ///
+    /// let mut consumed_parser = separated_pair(alpha1.value(1).with_span(), ',', alpha1.value(2).with_span());
+    ///
+    /// assert_eq!(consumed_parser.parse(Located::new("abcd,efgh")), Ok(((1, 0..4), (2, 5..9))));
+    /// assert_eq!(consumed_parser.parse_next(Located::new("abcd;")),Err(ErrMode::Backtrack(Error::new(Located::new("abcd;").next_slice(4).0, ErrorKind::Verify))));
+    ///
+    /// // the second output (representing the consumed input)
+    /// // should be the same as that of the `span` parser.
+    /// let mut recognize_parser = inner_parser.span();
+    /// let mut consumed_parser = inner_parser.with_span().map(|(output, consumed)| consumed);
+    ///
+    /// assert_eq!(recognize_parser.parse_next(Located::new("1234")), consumed_parser.parse_next(Located::new("1234")));
+    /// assert_eq!(recognize_parser.parse_next(Located::new("abcd")), consumed_parser.parse_next(Located::new("abcd")));
+    /// # }
+    /// ```
+    fn with_span(self) -> WithSpan<Self, I, O, E>
+    where
+        Self: core::marker::Sized,
+        I: Stream + Location,
+    {
+        WithSpan::new(self)
+    }
+
+    /// Maps a function over the output of a parser
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult,Parser};
+    /// use winnow::character::digit1;
+    /// # fn main() {
+    ///
+    /// let mut parser = digit1.map(|s: &str| s.len());
+    ///
+    /// // the parser will count how many characters were returned by digit1
+    /// assert_eq!(parser.parse_next("123456"), Ok(("", 6)));
+    ///
+    /// // this will fail if digit1 fails
+    /// assert_eq!(parser.parse_next("abc"), Err(ErrMode::Backtrack(Error::new("abc", ErrorKind::Slice))));
+    /// # }
+    /// ```
+    fn map<G, O2>(self, map: G) -> Map<Self, G, I, O, O2, E>
+    where
+        G: Fn(O) -> O2,
+        Self: core::marker::Sized,
+    {
+        Map::new(self, map)
+    }
+
+    /// Applies a function returning a `Result` over the output of a parser.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::character::digit1;
+    /// # fn main() {
+    ///
+    /// let mut parse = digit1.map_res(|s: &str| s.parse::<u8>());
+    ///
+    /// // the parser will convert the result of digit1 to a number
+    /// assert_eq!(parse.parse_next("123"), Ok(("", 123)));
+    ///
+    /// // this will fail if digit1 fails
+    /// assert_eq!(parse.parse_next("abc"), Err(ErrMode::Backtrack(Error::new("abc", ErrorKind::Slice))));
+    ///
+    /// // this will fail if the mapped function fails (a `u8` is too small to hold `123456`)
+    /// assert_eq!(parse.parse_next("123456"), Err(ErrMode::Backtrack(Error::new("123456", ErrorKind::Verify))));
+    /// # }
+    /// ```
+    fn map_res<G, O2, E2>(self, map: G) -> MapRes<Self, G, I, O, O2, E, E2>
+    where
+        Self: core::marker::Sized,
+        G: FnMut(O) -> Result<O2, E2>,
+        I: Clone,
+        E: FromExternalError<I, E2>,
+    {
+        MapRes::new(self, map)
+    }
+
+    /// Apply both [`Parser::verify`] and [`Parser::map`].
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::character::digit1;
+    /// # fn main() {
+    ///
+    /// let mut parse = digit1.verify_map(|s: &str| s.parse::<u8>().ok());
+    ///
+    /// // the parser will convert the result of digit1 to a number
+    /// assert_eq!(parse.parse_next("123"), Ok(("", 123)));
+    ///
+    /// // this will fail if digit1 fails
+    /// assert_eq!(parse.parse_next("abc"), Err(ErrMode::Backtrack(Error::new("abc", ErrorKind::Slice))));
+    ///
+    /// // this will fail if the mapped function fails (a `u8` is too small to hold `123456`)
+    /// assert_eq!(parse.parse_next("123456"), Err(ErrMode::Backtrack(Error::new("123456", ErrorKind::Verify))));
+    /// # }
+    /// ```
+    #[doc(alias = "satisfy_map")]
+    #[doc(alias = "filter_map")]
+    #[doc(alias = "map_opt")]
+    fn verify_map<G, O2>(self, map: G) -> VerifyMap<Self, G, I, O, O2, E>
+    where
+        Self: core::marker::Sized,
+        G: FnMut(O) -> Option<O2>,
+        I: Clone,
+        E: ParseError<I>,
+    {
+        VerifyMap::new(self, map)
+    }
+
+    /// Creates a parser from the output of this one
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::bytes::take;
+    /// use winnow::number::u8;
+    ///
+    /// fn length_data(input: &[u8]) -> IResult<&[u8], &[u8]> {
+    ///     u8.flat_map(take).parse_next(input)
+    /// }
+    ///
+    /// assert_eq!(length_data.parse_next(&[2, 0, 1, 2][..]), Ok((&[2][..], &[0, 1][..])));
+    /// assert_eq!(length_data.parse_next(&[4, 0, 1, 2][..]), Err(ErrMode::Backtrack(Error::new(&[0, 1, 2][..], ErrorKind::Slice))));
+    /// ```
+    ///
+    /// which is the same as
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::bytes::take;
+    /// use winnow::number::u8;
+    ///
+    /// fn length_data(input: &[u8]) -> IResult<&[u8], &[u8]> {
+    ///     let (input, length) = u8.parse_next(input)?;
+    ///     let (input, data) = take(length).parse_next(input)?;
+    ///     Ok((input, data))
+    /// }
+    ///
+    /// assert_eq!(length_data.parse_next(&[2, 0, 1, 2][..]), Ok((&[2][..], &[0, 1][..])));
+    /// assert_eq!(length_data.parse_next(&[4, 0, 1, 2][..]), Err(ErrMode::Backtrack(Error::new(&[0, 1, 2][..], ErrorKind::Slice))));
+    /// ```
+    fn flat_map<G, H, O2>(self, map: G) -> FlatMap<Self, G, H, I, O, O2, E>
+    where
+        Self: core::marker::Sized,
+        G: FnMut(O) -> H,
+        H: Parser<I, O2, E>,
+    {
+        FlatMap::new(self, map)
+    }
+
+    /// Applies a second parser over the output of the first one
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// use winnow::character::digit1;
+    /// use winnow::bytes::take;
+    /// # fn main() {
+    ///
+    /// let mut digits = take(5u8).and_then(digit1);
+    ///
+    /// assert_eq!(digits.parse_next("12345"), Ok(("", "12345")));
+    /// assert_eq!(digits.parse_next("123ab"), Ok(("", "123")));
+    /// assert_eq!(digits.parse_next("123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Slice))));
+    /// # }
+    /// ```
+    fn and_then<G, O2>(self, inner: G) -> AndThen<Self, G, I, O, O2, E>
+    where
+        Self: core::marker::Sized,
+        G: Parser<O, O2, E>,
+        O: StreamIsPartial,
+    {
+        AndThen::new(self, inner)
+    }
+
+    /// Apply [`std::str::FromStr`] to the output of the parser
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::prelude::*;
+    /// use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult,Parser};
+    /// use winnow::character::digit1;
+    ///
+    /// fn parser(input: &str) -> IResult<&str, u64> {
+    ///     digit1.parse_to().parse_next(input)
+    /// }
+    ///
+    /// // the parser will count how many characters were returned by digit1
+    /// assert_eq!(parser.parse_next("123456"), Ok(("", 123456)));
+    ///
+    /// // this will fail if digit1 fails
+    /// assert_eq!(parser.parse_next("abc"), Err(ErrMode::Backtrack(Error::new("abc", ErrorKind::Slice))));
+    /// ```
+    #[doc(alias = "from_str")]
+    fn parse_to<O2>(self) -> ParseTo<Self, I, O, O2, E>
+    where
+        Self: core::marker::Sized,
+        I: Stream,
+        O: ParseSlice<O2>,
+        E: ParseError<I>,
+    {
+        ParseTo::new(self)
+    }
+
+    /// Returns the output of the child parser if it satisfies a verification function.
+    ///
+    /// The verification function takes as argument a reference to the output of the
+    /// parser.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode,error::ErrorKind, error::Error, IResult, Parser};
+    /// # use winnow::character::alpha1;
+    /// # fn main() {
+    ///
+    /// let mut parser = alpha1.verify(|s: &str| s.len() == 4);
+    ///
+    /// assert_eq!(parser.parse_next("abcd"), Ok(("", "abcd")));
+    /// assert_eq!(parser.parse_next("abcde"), Err(ErrMode::Backtrack(Error::new("abcde", ErrorKind::Verify))));
+    /// assert_eq!(parser.parse_next("123abcd;"),Err(ErrMode::Backtrack(Error::new("123abcd;", ErrorKind::Slice))));
+    /// # }
+    /// ```
+    #[doc(alias = "satisfy")]
+    #[doc(alias = "filter")]
+    fn verify<G, O2>(self, filter: G) -> Verify<Self, G, I, O, O2, E>
+    where
+        Self: core::marker::Sized,
+        G: Fn(&O2) -> bool,
+        I: Clone,
+        O: crate::lib::std::borrow::Borrow<O2>,
+        O2: ?Sized,
+        E: ParseError<I>,
+    {
+        Verify::new(self, filter)
+    }
+
+    /// If parsing fails, add context to the error
+    ///
+    /// This is used mainly to add user friendly information
+    /// to errors when backtracking through a parse tree.
+    #[doc(alias = "labelled")]
+    fn context<C>(self, context: C) -> Context<Self, I, O, E, C>
+    where
+        Self: core::marker::Sized,
+        I: Stream,
+        E: ContextError<I, C>,
+        C: Clone + crate::lib::std::fmt::Debug,
+    {
+        Context::new(self, context)
+    }
+
+    /// Transforms [`Incomplete`][crate::error::ErrMode::Incomplete] into [`Backtrack`][crate::error::ErrMode::Backtrack]
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, IResult, stream::Partial, Parser};
+    /// # use winnow::bytes::take;
+    /// # fn main() {
+    ///
+    /// let mut parser = take(5u8).complete_err();
+    ///
+    /// assert_eq!(parser.parse_next(Partial::new("abcdefg")), Ok((Partial::new("fg"), "abcde")));
+    /// assert_eq!(parser.parse_next(Partial::new("abcd")), Err(ErrMode::Backtrack(Error::new(Partial::new("abcd"), ErrorKind::Complete))));
+    /// # }
+    /// ```
+    fn complete_err(self) -> CompleteErr<Self>
+    where
+        Self: core::marker::Sized,
+    {
+        CompleteErr::new(self)
+    }
+
+    /// Convert the parser's error to another type using [`std::convert::From`]
+    fn err_into<E2>(self) -> ErrInto<Self, I, O, E, E2>
+    where
+        Self: core::marker::Sized,
+        E: Into<E2>,
+    {
+        ErrInto::new(self)
+    }
+}
+
+impl<'a, I, O, E, F> Parser<I, O, E> for F
+where
+    F: FnMut(I) -> IResult<I, O, E> + 'a,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, O, E> {
+        self(i)
+    }
+}
+
+/// This is a shortcut for [`one_of`][crate::bytes::one_of].
+///
+/// # Example
+///
+/// ```
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{ErrorKind, Error}};
+/// fn parser(i: &[u8]) -> IResult<&[u8], u8> {
+///     b'a'.parse_next(i)
+/// }
+/// assert_eq!(parser(&b"abc"[..]), Ok((&b"bc"[..], b'a')));
+/// assert_eq!(parser(&b" abc"[..]), Err(ErrMode::Backtrack(Error::new(&b" abc"[..], ErrorKind::Verify))));
+/// assert_eq!(parser(&b"bc"[..]), Err(ErrMode::Backtrack(Error::new(&b"bc"[..], ErrorKind::Verify))));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&b""[..], ErrorKind::Token))));
+/// ```
+impl<I, E> Parser<I, u8, E> for u8
+where
+    I: StreamIsPartial,
+    I: Stream<Token = u8>,
+    E: ParseError<I>,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, u8, E> {
+        crate::bytes::one_of(*self).parse_next(i)
+    }
+}
+
+/// This is a shortcut for [`one_of`][crate::bytes::one_of].
+///
+/// # Example
+///
+/// ```
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{ErrorKind, Error}};
+/// fn parser(i: &str) -> IResult<&str, char> {
+///     'a'.parse_next(i)
+/// }
+/// assert_eq!(parser("abc"), Ok(("bc", 'a')));
+/// assert_eq!(parser(" abc"), Err(ErrMode::Backtrack(Error::new(" abc", ErrorKind::Verify))));
+/// assert_eq!(parser("bc"), Err(ErrMode::Backtrack(Error::new("bc", ErrorKind::Verify))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Token))));
+/// ```
+impl<I, E> Parser<I, <I as Stream>::Token, E> for char
+where
+    I: StreamIsPartial,
+    I: Stream,
+    <I as Stream>::Token: AsChar + Copy,
+    E: ParseError<I>,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, <I as Stream>::Token, E> {
+        crate::bytes::one_of(*self).parse_next(i)
+    }
+}
+
+/// This is a shortcut for [`tag`][crate::bytes::tag].
+///
+/// # Example
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::branch::alt;
+/// # use winnow::bytes::take;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   alt((&"Hello"[..], take(5usize))).parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"Hello, World!"[..]), Ok((&b", World!"[..], &b"Hello"[..])));
+/// assert_eq!(parser(&b"Something"[..]), Ok((&b"hing"[..], &b"Somet"[..])));
+/// assert_eq!(parser(&b"Some"[..]), Err(ErrMode::Backtrack(Error::new(&b"Some"[..], ErrorKind::Slice))));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&b""[..], ErrorKind::Slice))));
+/// ```
+impl<'s, I, E: ParseError<I>> Parser<I, <I as Stream>::Slice, E> for &'s [u8]
+where
+    I: Compare<&'s [u8]> + StreamIsPartial,
+    I: Stream,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, <I as Stream>::Slice, E> {
+        crate::bytes::tag(*self).parse_next(i)
+    }
+}
+
+/// This is a shortcut for [`tag`][crate::bytes::tag].
+///
+/// # Example
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed};
+/// # use winnow::branch::alt;
+/// # use winnow::bytes::take;
+///
+/// fn parser(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   alt((b"Hello", take(5usize))).parse_next(s)
+/// }
+///
+/// assert_eq!(parser(&b"Hello, World!"[..]), Ok((&b", World!"[..], &b"Hello"[..])));
+/// assert_eq!(parser(&b"Something"[..]), Ok((&b"hing"[..], &b"Somet"[..])));
+/// assert_eq!(parser(&b"Some"[..]), Err(ErrMode::Backtrack(Error::new(&b"Some"[..], ErrorKind::Slice))));
+/// assert_eq!(parser(&b""[..]), Err(ErrMode::Backtrack(Error::new(&b""[..], ErrorKind::Slice))));
+/// ```
+impl<'s, I, E: ParseError<I>, const N: usize> Parser<I, <I as Stream>::Slice, E> for &'s [u8; N]
+where
+    I: Compare<&'s [u8; N]> + StreamIsPartial,
+    I: Stream,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, <I as Stream>::Slice, E> {
+        crate::bytes::tag(*self).parse_next(i)
+    }
+}
+
+/// This is a shortcut for [`tag`][crate::bytes::tag].
+///
+/// # Example
+/// ```rust
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}};
+/// # use winnow::branch::alt;
+/// # use winnow::bytes::take;
+///
+/// fn parser(s: &str) -> IResult<&str, &str> {
+///   alt(("Hello", take(5usize))).parse_next(s)
+/// }
+///
+/// assert_eq!(parser("Hello, World!"), Ok((", World!", "Hello")));
+/// assert_eq!(parser("Something"), Ok(("hing", "Somet")));
+/// assert_eq!(parser("Some"), Err(ErrMode::Backtrack(Error::new("Some", ErrorKind::Slice))));
+/// assert_eq!(parser(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+impl<'s, I, E: ParseError<I>> Parser<I, <I as Stream>::Slice, E> for &'s str
+where
+    I: Compare<&'s str> + StreamIsPartial,
+    I: Stream,
+{
+    fn parse_next(&mut self, i: I) -> IResult<I, <I as Stream>::Slice, E> {
+        crate::bytes::tag(*self).parse_next(i)
+    }
+}
+
+impl<I, E: ParseError<I>> Parser<I, (), E> for () {
+    fn parse_next(&mut self, i: I) -> IResult<I, (), E> {
+        Ok((i, ()))
+    }
+}
+
+macro_rules! impl_parser_for_tuple {
+  ($($parser:ident $output:ident),+) => (
+    #[allow(non_snake_case)]
+    impl<I, $($output),+, E: ParseError<I>, $($parser),+> Parser<I, ($($output),+,), E> for ($($parser),+,)
+    where
+      $($parser: Parser<I, $output, E>),+
+    {
+      fn parse_next(&mut self, i: I) -> IResult<I, ($($output),+,), E> {
+        let ($(ref mut $parser),+,) = *self;
+
+        $(let(i, $output) = $parser.parse_next(i)?;)+
+
+        Ok((i, ($($output),+,)))
+      }
+    }
+  )
+}
+
+macro_rules! impl_parser_for_tuples {
+    ($parser1:ident $output1:ident, $($parser:ident $output:ident),+) => {
+        impl_parser_for_tuples!(__impl $parser1 $output1; $($parser $output),+);
+    };
+    (__impl $($parser:ident $output:ident),+; $parser1:ident $output1:ident $(,$parser2:ident $output2:ident)*) => {
+        impl_parser_for_tuple!($($parser $output),+);
+        impl_parser_for_tuples!(__impl $($parser $output),+, $parser1 $output1; $($parser2 $output2),*);
+    };
+    (__impl $($parser:ident $output:ident),+;) => {
+        impl_parser_for_tuple!($($parser $output),+);
+    }
+}
+
+impl_parser_for_tuples!(
+  P1 O1,
+  P2 O2,
+  P3 O3,
+  P4 O4,
+  P5 O5,
+  P6 O6,
+  P7 O7,
+  P8 O8,
+  P9 O9,
+  P10 O10,
+  P11 O11,
+  P12 O12,
+  P13 O13,
+  P14 O14,
+  P15 O15,
+  P16 O16,
+  P17 O17,
+  P18 O18,
+  P19 O19,
+  P20 O20,
+  P21 O21
+);
+
+#[cfg(feature = "alloc")]
+use alloc::boxed::Box;
+
+#[cfg(feature = "alloc")]
+impl<'a, I, O, E> Parser<I, O, E> for Box<dyn Parser<I, O, E> + 'a> {
+    fn parse_next(&mut self, input: I) -> IResult<I, O, E> {
+        (**self).parse_next(input)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::bytes::take;
+    use crate::error::ErrMode;
+    use crate::error::Error;
+    use crate::error::ErrorKind;
+    use crate::error::Needed;
+    use crate::number::be_u16;
+    use crate::Partial;
+
+    #[doc(hidden)]
+    #[macro_export]
+    macro_rules! assert_size (
+    ($t:ty, $sz:expr) => (
+      assert!($crate::lib::std::mem::size_of::<$t>() <= $sz, "{} <= {} failed", $crate::lib::std::mem::size_of::<$t>(), $sz);
+    );
+  );
+
+    #[test]
+    #[cfg(target_pointer_width = "64")]
+    fn size_test() {
+        assert_size!(IResult<&[u8], &[u8], (&[u8], u32)>, 40);
+        assert_size!(IResult<&str, &str, u32>, 40);
+        assert_size!(Needed, 8);
+        assert_size!(ErrMode<u32>, 16);
+        assert_size!(ErrorKind, 1);
+    }
+
+    #[test]
+    fn err_map_test() {
+        let e = ErrMode::Backtrack(1);
+        assert_eq!(e.map(|v| v + 1), ErrMode::Backtrack(2));
+    }
+
+    #[test]
+    fn single_element_tuples() {
+        use crate::character::alpha1;
+        use crate::error::ErrorKind;
+
+        let mut parser = (alpha1,);
+        assert_eq!(parser.parse_next("abc123def"), Ok(("123def", ("abc",))));
+        assert_eq!(
+            parser.parse_next("123def"),
+            Err(ErrMode::Backtrack(Error {
+                input: "123def",
+                kind: ErrorKind::Slice
+            }))
+        );
+    }
+
+    #[test]
+    fn tuple_test() {
+        #[allow(clippy::type_complexity)]
+        fn tuple_3(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (u16, &[u8], &[u8])> {
+            (be_u16, take(3u8), "fg").parse_next(i)
+        }
+
+        assert_eq!(
+            tuple_3(Partial::new(&b"abcdefgh"[..])),
+            Ok((
+                Partial::new(&b"h"[..]),
+                (0x6162u16, &b"cde"[..], &b"fg"[..])
+            ))
+        );
+        assert_eq!(
+            tuple_3(Partial::new(&b"abcd"[..])),
+            Err(ErrMode::Incomplete(Needed::new(1)))
+        );
+        assert_eq!(
+            tuple_3(Partial::new(&b"abcde"[..])),
+            Err(ErrMode::Incomplete(Needed::new(2)))
+        );
+        assert_eq!(
+            tuple_3(Partial::new(&b"abcdejk"[..])),
+            Err(ErrMode::Backtrack(error_position!(
+                Partial::new(&b"jk"[..]),
+                ErrorKind::Tag
+            )))
+        );
+    }
+
+    #[test]
+    fn unit_type() {
+        fn parser(i: &str) -> IResult<&str, ()> {
+            ().parse_next(i)
+        }
+        assert_eq!(parser.parse_next("abxsbsh"), Ok(("abxsbsh", ())));
+        assert_eq!(parser.parse_next("sdfjakdsas"), Ok(("sdfjakdsas", ())));
+        assert_eq!(parser.parse_next(""), Ok(("", ())));
+    }
+}
diff --git a/vendor/winnow/src/sequence/mod.rs b/vendor/winnow/src/sequence/mod.rs
new file mode 100644
index 000000000..68f772384
--- /dev/null
+++ b/vendor/winnow/src/sequence/mod.rs
@@ -0,0 +1,169 @@
+//! Combinators applying parsers in sequence
+
+#[cfg(test)]
+mod tests;
+
+use crate::error::ParseError;
+use crate::stream::Stream;
+use crate::trace::trace;
+use crate::Parser;
+
+/// Apply two parsers, only returning the output from the second.
+///
+/// # Arguments
+/// * `first` The opening parser.
+/// * `second` The second parser to get object.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::sequence::preceded;
+/// use winnow::bytes::tag;
+///
+/// let mut parser = preceded("abc", "efg");
+///
+/// assert_eq!(parser.parse_next("abcefg"), Ok(("", "efg")));
+/// assert_eq!(parser.parse_next("abcefghij"), Ok(("hij", "efg")));
+/// assert_eq!(parser.parse_next(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser.parse_next("123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag))));
+/// ```
+#[doc(alias = "ignore_then")]
+pub fn preceded<I, O1, O2, E: ParseError<I>, F, G>(
+    mut first: F,
+    mut second: G,
+) -> impl Parser<I, O2, E>
+where
+    I: Stream,
+    F: Parser<I, O1, E>,
+    G: Parser<I, O2, E>,
+{
+    trace("preceded", move |input: I| {
+        let (input, _) = first.parse_next(input)?;
+        second.parse_next(input)
+    })
+}
+
+/// Apply two parsers, only returning the output of the first.
+///
+/// # Arguments
+/// * `first` The first parser to apply.
+/// * `second` The second parser to match an object.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::prelude::*;
+/// # use winnow::error::Needed::Size;
+/// use winnow::sequence::terminated;
+/// use winnow::bytes::tag;
+///
+/// let mut parser = terminated("abc", "efg");
+///
+/// assert_eq!(parser.parse_next("abcefg"), Ok(("", "abc")));
+/// assert_eq!(parser.parse_next("abcefghij"), Ok(("hij", "abc")));
+/// assert_eq!(parser.parse_next(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser.parse_next("123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag))));
+/// ```
+#[doc(alias = "then_ignore")]
+pub fn terminated<I, O1, O2, E: ParseError<I>, F, G>(
+    mut first: F,
+    mut second: G,
+) -> impl Parser<I, O1, E>
+where
+    I: Stream,
+    F: Parser<I, O1, E>,
+    G: Parser<I, O2, E>,
+{
+    trace("terminated", move |input: I| {
+        let (input, o1) = first.parse_next(input)?;
+        second.parse_next(input).map(|(i, _)| (i, o1))
+    })
+}
+
+/// Apply three parsers, only returning the values of the first and third.
+///
+/// # Arguments
+/// * `first` The first parser to apply.
+/// * `sep` The separator parser to apply.
+/// * `second` The second parser to apply.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::error::Needed::Size;
+/// # use winnow::prelude::*;
+/// use winnow::sequence::separated_pair;
+/// use winnow::bytes::tag;
+///
+/// let mut parser = separated_pair("abc", "|", "efg");
+///
+/// assert_eq!(parser.parse_next("abc|efg"), Ok(("", ("abc", "efg"))));
+/// assert_eq!(parser.parse_next("abc|efghij"), Ok(("hij", ("abc", "efg"))));
+/// assert_eq!(parser.parse_next(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser.parse_next("123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag))));
+/// ```
+pub fn separated_pair<I, O1, O2, O3, E: ParseError<I>, F, G, H>(
+    mut first: F,
+    mut sep: G,
+    mut second: H,
+) -> impl Parser<I, (O1, O3), E>
+where
+    I: Stream,
+    F: Parser<I, O1, E>,
+    G: Parser<I, O2, E>,
+    H: Parser<I, O3, E>,
+{
+    trace("separated_pair", move |input: I| {
+        let (input, o1) = first.parse_next(input)?;
+        let (input, _) = sep.parse_next(input)?;
+        second.parse_next(input).map(|(i, o2)| (i, (o1, o2)))
+    })
+}
+
+/// Apply three parsers, only returning the output of the second.
+///
+/// # Arguments
+/// * `first` The first parser to apply and discard.
+/// * `second` The second parser to apply.
+/// * `third` The third parser to apply and discard.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error, error::Needed};
+/// # use winnow::error::Needed::Size;
+/// # use winnow::prelude::*;
+/// use winnow::sequence::delimited;
+/// use winnow::bytes::tag;
+///
+/// let mut parser = delimited("(", "abc", ")");
+///
+/// assert_eq!(parser.parse_next("(abc)"), Ok(("", "abc")));
+/// assert_eq!(parser.parse_next("(abc)def"), Ok(("def", "abc")));
+/// assert_eq!(parser.parse_next(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Tag))));
+/// assert_eq!(parser.parse_next("123"), Err(ErrMode::Backtrack(Error::new("123", ErrorKind::Tag))));
+/// ```
+#[doc(alias = "between")]
+#[doc(alias = "padded")]
+pub fn delimited<I, O1, O2, O3, E: ParseError<I>, F, G, H>(
+    mut first: F,
+    mut second: G,
+    mut third: H,
+) -> impl Parser<I, O2, E>
+where
+    I: Stream,
+    F: Parser<I, O1, E>,
+    G: Parser<I, O2, E>,
+    H: Parser<I, O3, E>,
+{
+    trace("delimited", move |input: I| {
+        let (input, _) = first.parse_next(input)?;
+        let (input, o2) = second.parse_next(input)?;
+        third.parse_next(input).map(|(i, _)| (i, o2))
+    })
+}
diff --git a/vendor/winnow/src/sequence/tests.rs b/vendor/winnow/src/sequence/tests.rs
new file mode 100644
index 000000000..77fa75df6
--- /dev/null
+++ b/vendor/winnow/src/sequence/tests.rs
@@ -0,0 +1,211 @@
+use super::*;
+
+use crate::error::{ErrMode, ErrorKind, Needed};
+use crate::IResult;
+use crate::Partial;
+
+#[derive(PartialEq, Eq, Debug)]
+struct B {
+    a: u8,
+    b: u8,
+}
+
+#[derive(PartialEq, Eq, Debug)]
+struct C {
+    a: u8,
+    b: Option<u8>,
+}
+
+#[test]
+fn complete() {
+    fn err_test(i: &[u8]) -> IResult<&[u8], &[u8]> {
+        let (i, _) = "ijkl".parse_next(i)?;
+        "mnop".parse_next(i)
+    }
+    let a = &b"ijklmn"[..];
+
+    let res_a = err_test(a);
+    assert_eq!(
+        res_a,
+        Err(ErrMode::Backtrack(error_position!(
+            &b"mn"[..],
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn separated_pair_test() {
+    #[allow(clippy::type_complexity)]
+    fn sep_pair_abc_def(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, (&[u8], &[u8])> {
+        separated_pair("abc", ",", "def").parse_next(i)
+    }
+
+    assert_eq!(
+        sep_pair_abc_def(Partial::new(&b"abc,defghijkl"[..])),
+        Ok((Partial::new(&b"ghijkl"[..]), (&b"abc"[..], &b"def"[..])))
+    );
+    assert_eq!(
+        sep_pair_abc_def(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        sep_pair_abc_def(Partial::new(&b"abc,d"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        sep_pair_abc_def(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        sep_pair_abc_def(Partial::new(&b"xxx,def"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx,def"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        sep_pair_abc_def(Partial::new(&b"abc,xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn preceded_test() {
+    fn preceded_abcd_efgh(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        preceded("abcd", "efgh").parse_next(i)
+    }
+
+    assert_eq!(
+        preceded_abcd_efgh(Partial::new(&b"abcdefghijkl"[..])),
+        Ok((Partial::new(&b"ijkl"[..]), &b"efgh"[..]))
+    );
+    assert_eq!(
+        preceded_abcd_efgh(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        preceded_abcd_efgh(Partial::new(&b"abcde"[..])),
+        Err(ErrMode::Incomplete(Needed::new(3)))
+    );
+    assert_eq!(
+        preceded_abcd_efgh(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        preceded_abcd_efgh(Partial::new(&b"xxxxdef"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxxxdef"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        preceded_abcd_efgh(Partial::new(&b"abcdxxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn terminated_test() {
+    fn terminated_abcd_efgh(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        terminated("abcd", "efgh").parse_next(i)
+    }
+
+    assert_eq!(
+        terminated_abcd_efgh(Partial::new(&b"abcdefghijkl"[..])),
+        Ok((Partial::new(&b"ijkl"[..]), &b"abcd"[..]))
+    );
+    assert_eq!(
+        terminated_abcd_efgh(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(2)))
+    );
+    assert_eq!(
+        terminated_abcd_efgh(Partial::new(&b"abcde"[..])),
+        Err(ErrMode::Incomplete(Needed::new(3)))
+    );
+    assert_eq!(
+        terminated_abcd_efgh(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        terminated_abcd_efgh(Partial::new(&b"xxxxdef"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxxxdef"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        terminated_abcd_efgh(Partial::new(&b"abcdxxxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+}
+
+#[test]
+fn delimited_test() {
+    fn delimited_abc_def_ghi(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+        delimited("abc", "def", "ghi").parse_next(i)
+    }
+
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"abcdefghijkl"[..])),
+        Ok((Partial::new(&b"jkl"[..]), &b"def"[..]))
+    );
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"ab"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"abcde"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"abcdefgh"[..])),
+        Err(ErrMode::Incomplete(Needed::new(1)))
+    );
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"xxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"xxxdefghi"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxxdefghi"[..]),
+            ErrorKind::Tag
+        ),))
+    );
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"abcxxxghi"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxxghi"[..]),
+            ErrorKind::Tag
+        )))
+    );
+    assert_eq!(
+        delimited_abc_def_ghi(Partial::new(&b"abcdefxxx"[..])),
+        Err(ErrMode::Backtrack(error_position!(
+            Partial::new(&b"xxx"[..]),
+            ErrorKind::Tag
+        )))
+    );
+}
diff --git a/vendor/winnow/src/stream/impls.rs b/vendor/winnow/src/stream/impls.rs
new file mode 100644
index 000000000..b277dd9a9
--- /dev/null
+++ b/vendor/winnow/src/stream/impls.rs
@@ -0,0 +1,537 @@
+macro_rules! impl_partial_eq {
+    ($lhs:ty, $rhs:ty) => {
+        impl<'a, 'b> PartialEq<$rhs> for $lhs {
+            #[inline]
+            fn eq(&self, other: &$rhs) -> bool {
+                let l = self.as_ref();
+                let r: &Self = other.as_ref();
+                PartialEq::eq(l, r)
+            }
+        }
+
+        impl<'a, 'b> PartialEq<$lhs> for $rhs {
+            #[inline]
+            fn eq(&self, other: &$lhs) -> bool {
+                PartialEq::eq(other, self)
+            }
+        }
+    };
+}
+
+macro_rules! impl_partial_ord {
+    ($lhs:ty, $rhs:ty) => {
+        impl<'a, 'b> PartialOrd<$rhs> for $lhs {
+            #[inline]
+            fn partial_cmp(&self, other: &$rhs) -> Option<Ordering> {
+                let l = self.as_ref();
+                let r: &Self = other.as_ref();
+                PartialOrd::partial_cmp(l, r)
+            }
+        }
+
+        impl<'a, 'b> PartialOrd<$lhs> for $rhs {
+            #[inline]
+            fn partial_cmp(&self, other: &$lhs) -> Option<Ordering> {
+                PartialOrd::partial_cmp(other, self)
+            }
+        }
+    };
+}
+
+mod bytes {
+    use crate::lib::std::{cmp::Ordering, fmt, ops};
+
+    use crate::stream::Bytes;
+
+    impl fmt::Display for Bytes {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            <Self as fmt::UpperHex>::fmt(self, f)
+        }
+    }
+
+    impl fmt::Debug for Bytes {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            <Self as fmt::UpperHex>::fmt(self, f)
+        }
+    }
+
+    impl fmt::LowerHex for Bytes {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            for byte in self.as_bytes() {
+                write!(f, "{:0>2x}", byte)?;
+            }
+            Ok(())
+        }
+    }
+
+    impl fmt::UpperHex for Bytes {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            for (i, byte) in self.as_bytes().iter().enumerate() {
+                if 0 < i {
+                    let absolute = (self.as_bytes().as_ptr() as usize) + i;
+                    if f.alternate() && absolute != 0 && absolute % 4 == 0 {
+                        write!(f, "_")?;
+                    }
+                }
+                write!(f, "{:0>2X}", byte)?;
+            }
+            Ok(())
+        }
+    }
+
+    impl ops::Deref for Bytes {
+        type Target = [u8];
+
+        #[inline]
+        fn deref(&self) -> &[u8] {
+            self.as_bytes()
+        }
+    }
+
+    impl ops::Index<usize> for Bytes {
+        type Output = u8;
+
+        #[inline]
+        fn index(&self, idx: usize) -> &u8 {
+            &self.as_bytes()[idx]
+        }
+    }
+
+    impl ops::Index<ops::RangeFull> for Bytes {
+        type Output = Bytes;
+
+        #[inline]
+        fn index(&self, _: ops::RangeFull) -> &Bytes {
+            self
+        }
+    }
+
+    impl ops::Index<ops::Range<usize>> for Bytes {
+        type Output = Bytes;
+
+        #[inline]
+        fn index(&self, r: ops::Range<usize>) -> &Bytes {
+            Bytes::new(&self.as_bytes()[r.start..r.end])
+        }
+    }
+
+    impl ops::Index<ops::RangeInclusive<usize>> for Bytes {
+        type Output = Bytes;
+
+        #[inline]
+        fn index(&self, r: ops::RangeInclusive<usize>) -> &Bytes {
+            Bytes::new(&self.as_bytes()[*r.start()..=*r.end()])
+        }
+    }
+
+    impl ops::Index<ops::RangeFrom<usize>> for Bytes {
+        type Output = Bytes;
+
+        #[inline]
+        fn index(&self, r: ops::RangeFrom<usize>) -> &Bytes {
+            Bytes::new(&self.as_bytes()[r.start..])
+        }
+    }
+
+    impl ops::Index<ops::RangeTo<usize>> for Bytes {
+        type Output = Bytes;
+
+        #[inline]
+        fn index(&self, r: ops::RangeTo<usize>) -> &Bytes {
+            Bytes::new(&self.as_bytes()[..r.end])
+        }
+    }
+
+    impl ops::Index<ops::RangeToInclusive<usize>> for Bytes {
+        type Output = Bytes;
+
+        #[inline]
+        fn index(&self, r: ops::RangeToInclusive<usize>) -> &Bytes {
+            Bytes::new(&self.as_bytes()[..=r.end])
+        }
+    }
+
+    impl AsRef<[u8]> for Bytes {
+        #[inline]
+        fn as_ref(&self) -> &[u8] {
+            self.as_bytes()
+        }
+    }
+
+    impl AsRef<Bytes> for [u8] {
+        #[inline]
+        fn as_ref(&self) -> &Bytes {
+            Bytes::new(self)
+        }
+    }
+
+    impl AsRef<Bytes> for str {
+        #[inline]
+        fn as_ref(&self) -> &Bytes {
+            Bytes::new(self)
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    impl crate::lib::std::borrow::ToOwned for Bytes {
+        type Owned = crate::lib::std::vec::Vec<u8>;
+
+        #[inline]
+        fn to_owned(&self) -> Self::Owned {
+            crate::lib::std::vec::Vec::from(self.as_bytes())
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    impl crate::lib::std::borrow::Borrow<Bytes> for crate::lib::std::vec::Vec<u8> {
+        #[inline]
+        fn borrow(&self) -> &Bytes {
+            Bytes::from_bytes(self.as_slice())
+        }
+    }
+
+    impl<'a> Default for &'a Bytes {
+        fn default() -> &'a Bytes {
+            Bytes::new(b"")
+        }
+    }
+
+    impl<'a> From<&'a [u8]> for &'a Bytes {
+        #[inline]
+        fn from(s: &'a [u8]) -> &'a Bytes {
+            Bytes::new(s)
+        }
+    }
+
+    impl<'a> From<&'a Bytes> for &'a [u8] {
+        #[inline]
+        fn from(s: &'a Bytes) -> &'a [u8] {
+            Bytes::as_bytes(s)
+        }
+    }
+
+    impl<'a> From<&'a str> for &'a Bytes {
+        #[inline]
+        fn from(s: &'a str) -> &'a Bytes {
+            Bytes::new(s.as_bytes())
+        }
+    }
+
+    impl Eq for Bytes {}
+
+    impl PartialEq<Bytes> for Bytes {
+        #[inline]
+        fn eq(&self, other: &Bytes) -> bool {
+            self.as_bytes() == other.as_bytes()
+        }
+    }
+
+    impl_partial_eq!(Bytes, [u8]);
+    impl_partial_eq!(Bytes, &'a [u8]);
+    impl_partial_eq!(Bytes, str);
+    impl_partial_eq!(Bytes, &'a str);
+
+    impl PartialOrd for Bytes {
+        #[inline]
+        fn partial_cmp(&self, other: &Bytes) -> Option<Ordering> {
+            PartialOrd::partial_cmp(self.as_bytes(), other.as_bytes())
+        }
+    }
+
+    impl Ord for Bytes {
+        #[inline]
+        fn cmp(&self, other: &Bytes) -> Ordering {
+            self.partial_cmp(other).unwrap()
+        }
+    }
+
+    impl_partial_ord!(Bytes, [u8]);
+    impl_partial_ord!(Bytes, &'a [u8]);
+    impl_partial_ord!(Bytes, str);
+    impl_partial_ord!(Bytes, &'a str);
+
+    #[cfg(all(test, feature = "std"))]
+    mod display {
+        use crate::stream::Bytes;
+
+        #[test]
+        fn clean() {
+            assert_eq!(&format!("{}", Bytes::new(b"abc")), "616263");
+            assert_eq!(&format!("{}", Bytes::new(b"\xf0\x28\x8c\xbc")), "F0288CBC");
+        }
+    }
+
+    #[cfg(all(test, feature = "std"))]
+    mod debug {
+        use crate::stream::Bytes;
+
+        #[test]
+        fn test_debug() {
+            assert_eq!(
+                "000000206674797069736F6D0000020069736F6D69736F32617663316D70",
+                format!(
+                    "{:?}",
+                    Bytes::new(b"\0\0\0 ftypisom\0\0\x02\0isomiso2avc1mp")
+                ),
+            );
+        }
+
+        #[test]
+        fn test_pretty_debug() {
+            // Output can change from run-to-run
+            format!(
+                "{:#?}",
+                Bytes::new(b"\0\0\0 ftypisom\0\0\x02\0isomiso2avc1mp")
+            );
+        }
+
+        #[test]
+        fn test_sliced() {
+            // Output can change from run-to-run
+            let total = Bytes::new(b"12345678901234567890");
+            format!("{:#?}", total);
+            format!("{:#?}", &total[1..]);
+            format!("{:#?}", &total[10..]);
+        }
+    }
+}
+
+mod bstr {
+    use crate::lib::std::{cmp::Ordering, fmt, ops};
+
+    use crate::stream::BStr;
+
+    #[cfg(feature = "alloc")]
+    impl fmt::Display for BStr {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            crate::lib::std::string::String::from_utf8_lossy(self.as_bytes()).fmt(f)
+        }
+    }
+
+    impl fmt::Debug for BStr {
+        #[inline]
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            if !f.alternate() {
+                write!(f, "\"")?;
+            }
+            for byte in self.as_bytes() {
+                let c = *byte as char;
+                write!(f, "{}", c.escape_debug())?;
+            }
+            if !f.alternate() {
+                write!(f, "\"")?;
+            }
+            Ok(())
+        }
+    }
+
+    impl ops::Deref for BStr {
+        type Target = [u8];
+
+        #[inline]
+        fn deref(&self) -> &[u8] {
+            self.as_bytes()
+        }
+    }
+
+    impl ops::Index<usize> for BStr {
+        type Output = u8;
+
+        #[inline]
+        fn index(&self, idx: usize) -> &u8 {
+            &self.as_bytes()[idx]
+        }
+    }
+
+    impl ops::Index<ops::RangeFull> for BStr {
+        type Output = BStr;
+
+        #[inline]
+        fn index(&self, _: ops::RangeFull) -> &BStr {
+            self
+        }
+    }
+
+    impl ops::Index<ops::Range<usize>> for BStr {
+        type Output = BStr;
+
+        #[inline]
+        fn index(&self, r: ops::Range<usize>) -> &BStr {
+            BStr::new(&self.as_bytes()[r.start..r.end])
+        }
+    }
+
+    impl ops::Index<ops::RangeInclusive<usize>> for BStr {
+        type Output = BStr;
+
+        #[inline]
+        fn index(&self, r: ops::RangeInclusive<usize>) -> &BStr {
+            BStr::new(&self.as_bytes()[*r.start()..=*r.end()])
+        }
+    }
+
+    impl ops::Index<ops::RangeFrom<usize>> for BStr {
+        type Output = BStr;
+
+        #[inline]
+        fn index(&self, r: ops::RangeFrom<usize>) -> &BStr {
+            BStr::new(&self.as_bytes()[r.start..])
+        }
+    }
+
+    impl ops::Index<ops::RangeTo<usize>> for BStr {
+        type Output = BStr;
+
+        #[inline]
+        fn index(&self, r: ops::RangeTo<usize>) -> &BStr {
+            BStr::new(&self.as_bytes()[..r.end])
+        }
+    }
+
+    impl ops::Index<ops::RangeToInclusive<usize>> for BStr {
+        type Output = BStr;
+
+        #[inline]
+        fn index(&self, r: ops::RangeToInclusive<usize>) -> &BStr {
+            BStr::new(&self.as_bytes()[..=r.end])
+        }
+    }
+
+    impl AsRef<[u8]> for BStr {
+        #[inline]
+        fn as_ref(&self) -> &[u8] {
+            self.as_bytes()
+        }
+    }
+
+    impl AsRef<BStr> for [u8] {
+        #[inline]
+        fn as_ref(&self) -> &BStr {
+            BStr::new(self)
+        }
+    }
+
+    impl AsRef<BStr> for str {
+        #[inline]
+        fn as_ref(&self) -> &BStr {
+            BStr::new(self)
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    impl crate::lib::std::borrow::ToOwned for BStr {
+        type Owned = crate::lib::std::vec::Vec<u8>;
+
+        #[inline]
+        fn to_owned(&self) -> Self::Owned {
+            crate::lib::std::vec::Vec::from(self.as_bytes())
+        }
+    }
+
+    #[cfg(feature = "alloc")]
+    impl crate::lib::std::borrow::Borrow<BStr> for crate::lib::std::vec::Vec<u8> {
+        #[inline]
+        fn borrow(&self) -> &BStr {
+            BStr::from_bytes(self.as_slice())
+        }
+    }
+
+    impl<'a> Default for &'a BStr {
+        fn default() -> &'a BStr {
+            BStr::new(b"")
+        }
+    }
+
+    impl<'a> From<&'a [u8]> for &'a BStr {
+        #[inline]
+        fn from(s: &'a [u8]) -> &'a BStr {
+            BStr::new(s)
+        }
+    }
+
+    impl<'a> From<&'a BStr> for &'a [u8] {
+        #[inline]
+        fn from(s: &'a BStr) -> &'a [u8] {
+            BStr::as_bytes(s)
+        }
+    }
+
+    impl<'a> From<&'a str> for &'a BStr {
+        #[inline]
+        fn from(s: &'a str) -> &'a BStr {
+            BStr::new(s.as_bytes())
+        }
+    }
+
+    impl Eq for BStr {}
+
+    impl PartialEq<BStr> for BStr {
+        #[inline]
+        fn eq(&self, other: &BStr) -> bool {
+            self.as_bytes() == other.as_bytes()
+        }
+    }
+
+    impl_partial_eq!(BStr, [u8]);
+    impl_partial_eq!(BStr, &'a [u8]);
+    impl_partial_eq!(BStr, str);
+    impl_partial_eq!(BStr, &'a str);
+
+    impl PartialOrd for BStr {
+        #[inline]
+        fn partial_cmp(&self, other: &BStr) -> Option<Ordering> {
+            PartialOrd::partial_cmp(self.as_bytes(), other.as_bytes())
+        }
+    }
+
+    impl Ord for BStr {
+        #[inline]
+        fn cmp(&self, other: &BStr) -> Ordering {
+            self.partial_cmp(other).unwrap()
+        }
+    }
+
+    impl_partial_ord!(BStr, [u8]);
+    impl_partial_ord!(BStr, &'a [u8]);
+    impl_partial_ord!(BStr, str);
+    impl_partial_ord!(BStr, &'a str);
+
+    #[cfg(all(test, feature = "std"))]
+    mod display {
+        use crate::stream::BStr;
+
+        #[test]
+        fn clean() {
+            assert_eq!(&format!("{}", BStr::new(b"abc")), "abc");
+            assert_eq!(&format!("{}", BStr::new(b"\xf0\x28\x8c\xbc")), "�(��");
+        }
+    }
+
+    #[cfg(all(test, feature = "std"))]
+    mod debug {
+        use crate::stream::BStr;
+
+        #[test]
+        fn test_debug() {
+            assert_eq!(&format!("{:?}", BStr::new(b"abc")), "\"abc\"");
+
+            assert_eq!(
+                "\"\\0\\0\\0 ftypisom\\0\\0\\u{2}\\0isomiso2avc1mp\"",
+                format!(
+                    "{:?}",
+                    BStr::new(b"\0\0\0 ftypisom\0\0\x02\0isomiso2avc1mp")
+                ),
+            );
+        }
+
+        #[test]
+        fn test_pretty_debug() {
+            assert_eq!(&format!("{:#?}", BStr::new(b"abc")), "abc");
+        }
+    }
+}
diff --git a/vendor/winnow/src/stream/mod.rs b/vendor/winnow/src/stream/mod.rs
new file mode 100644
index 000000000..019975a72
--- /dev/null
+++ b/vendor/winnow/src/stream/mod.rs
@@ -0,0 +1,2454 @@
+//! Stream capability for combinators to parse
+//!
+//! Stream types include:
+//! - `&[u8]` and [`Bytes`] for binary data
+//! - `&str` (aliased as [`Str`]) and [`BStr`] for UTF-8 data
+//! - [`Located`] can track the location within the original buffer to report
+//!   [spans][crate::Parser::with_span]
+//! - [`Stateful`] to thread global state through your parsers
+//! - [`Partial`] can mark an input as partial buffer that is being streamed into
+//! - [Custom stream types][crate::_topic::stream]
+
+use core::num::NonZeroUsize;
+
+use crate::error::{ErrMode, ErrorKind, Needed, ParseError};
+use crate::lib::std::iter::{Cloned, Enumerate};
+use crate::lib::std::ops::{
+    Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
+};
+use crate::lib::std::slice::Iter;
+use crate::lib::std::str::from_utf8;
+use crate::lib::std::str::CharIndices;
+use crate::lib::std::str::FromStr;
+use crate::IResult;
+
+#[cfg(feature = "alloc")]
+use crate::lib::std::collections::BTreeMap;
+#[cfg(feature = "std")]
+use crate::lib::std::collections::HashMap;
+#[cfg(feature = "alloc")]
+use crate::lib::std::string::String;
+#[cfg(feature = "alloc")]
+use crate::lib::std::vec::Vec;
+
+mod impls;
+#[cfg(test)]
+mod tests;
+
+/// UTF-8 Stream
+pub type Str<'i> = &'i str;
+
+/// Improved `Debug` experience for `&[u8]` byte streams
+#[allow(clippy::derive_hash_xor_eq)]
+#[derive(Hash)]
+#[repr(transparent)]
+pub struct Bytes([u8]);
+
+impl Bytes {
+    /// Make a stream out of a byte slice-like.
+    #[inline]
+    pub fn new<B: ?Sized + AsRef<[u8]>>(bytes: &B) -> &Self {
+        Self::from_bytes(bytes.as_ref())
+    }
+
+    #[inline]
+    fn from_bytes(slice: &[u8]) -> &Self {
+        unsafe { crate::lib::std::mem::transmute(slice) }
+    }
+
+    #[inline]
+    fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// Improved `Debug` experience for `&[u8]` UTF-8-ish streams
+#[allow(clippy::derive_hash_xor_eq)]
+#[derive(Hash)]
+#[repr(transparent)]
+pub struct BStr([u8]);
+
+impl BStr {
+    /// Make a stream out of a byte slice-like.
+    #[inline]
+    pub fn new<B: ?Sized + AsRef<[u8]>>(bytes: &B) -> &Self {
+        Self::from_bytes(bytes.as_ref())
+    }
+
+    #[inline]
+    fn from_bytes(slice: &[u8]) -> &Self {
+        unsafe { crate::lib::std::mem::transmute(slice) }
+    }
+
+    #[inline]
+    fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// Allow collecting the span of a parsed token
+///
+/// See [`Parser::span`][crate::Parser::span] and [`Parser::with_span`][crate::Parser::with_span] for more details
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Located<I> {
+    initial: I,
+    input: I,
+}
+
+impl<I> Located<I>
+where
+    I: Clone + Offset,
+{
+    /// Wrap another Stream with span tracking
+    pub fn new(input: I) -> Self {
+        let initial = input.clone();
+        Self { initial, input }
+    }
+
+    fn location(&self) -> usize {
+        self.initial.offset_to(&self.input)
+    }
+}
+
+impl<I> AsRef<I> for Located<I> {
+    #[inline(always)]
+    fn as_ref(&self) -> &I {
+        &self.input
+    }
+}
+
+impl<I> crate::lib::std::ops::Deref for Located<I> {
+    type Target = I;
+
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.input
+    }
+}
+
+impl<I: crate::lib::std::fmt::Display> crate::lib::std::fmt::Display for Located<I> {
+    fn fmt(&self, f: &mut crate::lib::std::fmt::Formatter<'_>) -> crate::lib::std::fmt::Result {
+        self.input.fmt(f)
+    }
+}
+
+/// Thread global state through your parsers
+///
+/// Use cases
+/// - Recursion checks
+/// - Error recovery
+/// - Debugging
+///
+/// # Example
+///
+/// ```
+/// # use std::cell::Cell;
+/// # use winnow::prelude::*;
+/// # use winnow::stream::Stateful;
+/// # use winnow::character::alpha1;
+/// # type Error = ();
+///
+/// #[derive(Clone, Debug)]
+/// struct State<'s>(&'s Cell<u32>);
+///
+/// impl<'s> State<'s> {
+///     fn count(&self) {
+///         self.0.set(self.0.get() + 1);
+///     }
+/// }
+///
+/// type Stream<'is> = Stateful<&'is str, State<'is>>;
+///
+/// fn word(i: Stream<'_>) -> IResult<Stream<'_>, &str> {
+///   i.state.count();
+///   alpha1(i)
+/// }
+///
+/// let data = "Hello";
+/// let state = Cell::new(0);
+/// let input = Stream { input: data, state: State(&state) };
+/// let output = word.parse(input).unwrap();
+/// assert_eq!(state.get(), 1);
+/// ```
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Stateful<I, S> {
+    /// Inner input being wrapped in state
+    pub input: I,
+    /// User-provided state
+    pub state: S,
+}
+
+impl<I, S> AsRef<I> for Stateful<I, S> {
+    #[inline(always)]
+    fn as_ref(&self) -> &I {
+        &self.input
+    }
+}
+
+impl<I, S> crate::lib::std::ops::Deref for Stateful<I, S> {
+    type Target = I;
+
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        self.as_ref()
+    }
+}
+
+impl<I: crate::lib::std::fmt::Display, S> crate::lib::std::fmt::Display for Stateful<I, S> {
+    fn fmt(&self, f: &mut crate::lib::std::fmt::Formatter<'_>) -> crate::lib::std::fmt::Result {
+        self.input.fmt(f)
+    }
+}
+
+/// Mark the input as a partial buffer for streaming input.
+///
+/// Complete input means that we already have all of the data.  This will be the common case with
+/// small files that can be read entirely to memory.
+///
+/// In contrast, streaming input assumes that we might not have all of the data.
+/// This can happen with some network protocol or large file parsers, where the
+/// input buffer can be full and need to be resized or refilled.
+/// - [`ErrMode::Incomplete`] will report how much more data is needed.
+/// - [`Parser::complete_err`][crate::Parser::complete_err] transform [`ErrMode::Incomplete`] to
+///   [`ErrMode::Backtrack`]
+///
+/// See also [`StreamIsPartial`] to tell whether the input supports complete or partial parsing.
+///
+/// See also [Special Topics: Parsing Partial Input][crate::_topic::partial].
+///
+/// # Example
+///
+/// Here is how it works in practice:
+///
+/// ```rust
+/// # use winnow::{IResult, error::ErrMode, error::Needed, error::{Error, ErrorKind}, bytes, character, stream::Partial};
+/// # use winnow::prelude::*;
+///
+/// fn take_partial(i: Partial<&[u8]>) -> IResult<Partial<&[u8]>, &[u8]> {
+///   bytes::take(4u8).parse_next(i)
+/// }
+///
+/// fn take_complete(i: &[u8]) -> IResult<&[u8], &[u8]> {
+///   bytes::take(4u8).parse_next(i)
+/// }
+///
+/// // both parsers will take 4 bytes as expected
+/// assert_eq!(take_partial(Partial::new(&b"abcde"[..])), Ok((Partial::new(&b"e"[..]), &b"abcd"[..])));
+/// assert_eq!(take_complete(&b"abcde"[..]), Ok((&b"e"[..], &b"abcd"[..])));
+///
+/// // if the input is smaller than 4 bytes, the partial parser
+/// // will return `Incomplete` to indicate that we need more data
+/// assert_eq!(take_partial(Partial::new(&b"abc"[..])), Err(ErrMode::Incomplete(Needed::new(1))));
+///
+/// // but the complete parser will return an error
+/// assert_eq!(take_complete(&b"abc"[..]), Err(ErrMode::Backtrack(Error::new(&b"abc"[..], ErrorKind::Slice))));
+///
+/// // the alpha0 function recognizes 0 or more alphabetic characters
+/// fn alpha0_partial(i: Partial<&str>) -> IResult<Partial<&str>, &str> {
+///   character::alpha0(i)
+/// }
+///
+/// fn alpha0_complete(i: &str) -> IResult<&str, &str> {
+///   character::alpha0(i)
+/// }
+///
+/// // if there's a clear limit to the recognized characters, both parsers work the same way
+/// assert_eq!(alpha0_partial(Partial::new("abcd;")), Ok((Partial::new(";"), "abcd")));
+/// assert_eq!(alpha0_complete("abcd;"), Ok((";", "abcd")));
+///
+/// // but when there's no limit, the partial version returns `Incomplete`, because it cannot
+/// // know if more input data should be recognized. The whole input could be "abcd;", or
+/// // "abcde;"
+/// assert_eq!(alpha0_partial(Partial::new("abcd")), Err(ErrMode::Incomplete(Needed::new(1))));
+///
+/// // while the complete version knows that all of the data is there
+/// assert_eq!(alpha0_complete("abcd"), Ok(("", "abcd")));
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Partial<I> {
+    input: I,
+    partial: bool,
+}
+
+impl<I> Partial<I>
+where
+    I: StreamIsPartial,
+{
+    /// Create a partial input
+    pub fn new(input: I) -> Self {
+        debug_assert!(
+            !I::is_partial_supported(),
+            "`Partial` can only wrap complete sources"
+        );
+        let partial = true;
+        Self { input, partial }
+    }
+
+    /// Extract the original [`Stream`]
+    #[inline(always)]
+    pub fn into_inner(self) -> I {
+        self.input
+    }
+}
+
+impl<I> Default for Partial<I>
+where
+    I: Default + StreamIsPartial,
+{
+    fn default() -> Self {
+        Self::new(I::default())
+    }
+}
+
+impl<I> crate::lib::std::ops::Deref for Partial<I> {
+    type Target = I;
+
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.input
+    }
+}
+
+impl<I: crate::lib::std::fmt::Display> crate::lib::std::fmt::Display for Partial<I> {
+    fn fmt(&self, f: &mut crate::lib::std::fmt::Formatter<'_>) -> crate::lib::std::fmt::Result {
+        self.input.fmt(f)
+    }
+}
+
+/// Abstract method to calculate the input length
+pub trait SliceLen {
+    /// Calculates the input length, as indicated by its name,
+    /// and the name of the trait itself
+    fn slice_len(&self) -> usize;
+}
+
+impl<'a, T> SliceLen for &'a [T] {
+    #[inline]
+    fn slice_len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T, const LEN: usize> SliceLen for [T; LEN] {
+    #[inline]
+    fn slice_len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<'a, T, const LEN: usize> SliceLen for &'a [T; LEN] {
+    #[inline]
+    fn slice_len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<'a> SliceLen for &'a str {
+    #[inline]
+    fn slice_len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<'a> SliceLen for &'a Bytes {
+    #[inline]
+    fn slice_len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<'a> SliceLen for &'a BStr {
+    #[inline]
+    fn slice_len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<I> SliceLen for (I, usize, usize)
+where
+    I: SliceLen,
+{
+    #[inline(always)]
+    fn slice_len(&self) -> usize {
+        self.0.slice_len() * 8 + self.2 - self.1
+    }
+}
+
+impl<I> SliceLen for Located<I>
+where
+    I: SliceLen,
+{
+    #[inline(always)]
+    fn slice_len(&self) -> usize {
+        self.input.slice_len()
+    }
+}
+
+impl<I, S> SliceLen for Stateful<I, S>
+where
+    I: SliceLen,
+{
+    #[inline(always)]
+    fn slice_len(&self) -> usize {
+        self.input.slice_len()
+    }
+}
+
+impl<I> SliceLen for Partial<I>
+where
+    I: SliceLen,
+{
+    #[inline(always)]
+    fn slice_len(&self) -> usize {
+        self.input.slice_len()
+    }
+}
+
+/// Core definition for parser input state
+pub trait Stream: Offset + Clone + crate::lib::std::fmt::Debug {
+    /// The smallest unit being parsed
+    ///
+    /// Example: `u8` for `&[u8]` or `char` for `&str`
+    type Token: crate::lib::std::fmt::Debug;
+    /// Sequence of `Token`s
+    ///
+    /// Example: `&[u8]` for `Located<&[u8]>` or `&str` for `Located<&str>`
+    type Slice: crate::lib::std::fmt::Debug;
+
+    /// Iterate with the offset from the current location
+    type IterOffsets: Iterator<Item = (usize, Self::Token)>;
+
+    /// Iterate with the offset from the current location
+    fn iter_offsets(&self) -> Self::IterOffsets;
+    /// Returns the offaet to the end of the input
+    fn eof_offset(&self) -> usize;
+
+    /// Split off the next token from the input
+    fn next_token(&self) -> Option<(Self, Self::Token)>;
+
+    /// Finds the offset of the next matching token
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool;
+    /// Get the offset for the number of `tokens` into the stream
+    ///
+    /// This means "0 tokens" will return `0` offset
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed>;
+    /// Split off a slice of tokens from the input
+    ///
+    /// **NOTE:** For inputs with variable width tokens, like `&str`'s `char`, `offset` might not correspond
+    /// with the number of tokens.  To get a valid offset, use:
+    /// - [`Stream::eof_offset`]
+    /// - [`Stream::iter_offsets`]
+    /// - [`Stream::offset_for`]
+    /// - [`Stream::offset_at`]
+    ///
+    /// # Panic
+    ///
+    /// This will panic if
+    ///
+    /// * Indexes must be within bounds of the original input;
+    /// * Indexes must uphold invariants of the stream, like for `str` they must lie on UTF-8
+    ///   sequence boundaries.
+    ///
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice);
+}
+
+impl<'i, T> Stream for &'i [T]
+where
+    T: Clone + crate::lib::std::fmt::Debug,
+{
+    type Token = T;
+    type Slice = &'i [T];
+
+    type IterOffsets = Enumerate<Cloned<Iter<'i, T>>>;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        self.iter().cloned().enumerate()
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        self.len()
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        self.split_first()
+            .map(|(token, next)| (next, token.clone()))
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        self.iter().position(|b| predicate(b.clone()))
+    }
+    #[inline(always)]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        if let Some(needed) = tokens.checked_sub(self.len()).and_then(NonZeroUsize::new) {
+            Err(Needed::Size(needed))
+        } else {
+            Ok(tokens)
+        }
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let (slice, next) = self.split_at(offset);
+        (next, slice)
+    }
+}
+
+impl<'i> Stream for &'i str {
+    type Token = char;
+    type Slice = &'i str;
+
+    type IterOffsets = CharIndices<'i>;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        self.char_indices()
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        self.len()
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        let c = self.chars().next()?;
+        let offset = c.len();
+        Some((&self[offset..], c))
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        for (o, c) in self.iter_offsets() {
+            if predicate(c) {
+                return Some(o);
+            }
+        }
+        None
+    }
+    #[inline]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        let mut cnt = 0;
+        for (offset, _) in self.iter_offsets() {
+            if cnt == tokens {
+                return Ok(offset);
+            }
+            cnt += 1;
+        }
+
+        if cnt == tokens {
+            Ok(self.eof_offset())
+        } else {
+            Err(Needed::Unknown)
+        }
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let (slice, next) = self.split_at(offset);
+        (next, slice)
+    }
+}
+
+impl<'i> Stream for &'i Bytes {
+    type Token = u8;
+    type Slice = &'i [u8];
+
+    type IterOffsets = Enumerate<Cloned<Iter<'i, u8>>>;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        self.iter().cloned().enumerate()
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        self.len()
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        if self.is_empty() {
+            None
+        } else {
+            Some((Bytes::from_bytes(&self[1..]), self[0]))
+        }
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        self.iter().position(|b| predicate(*b))
+    }
+    #[inline(always)]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        if let Some(needed) = tokens.checked_sub(self.len()).and_then(NonZeroUsize::new) {
+            Err(Needed::Size(needed))
+        } else {
+            Ok(tokens)
+        }
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let (next, slice) = (&self.0).next_slice(offset);
+        (Bytes::from_bytes(next), slice)
+    }
+}
+
+impl<'i> Stream for &'i BStr {
+    type Token = u8;
+    type Slice = &'i [u8];
+
+    type IterOffsets = Enumerate<Cloned<Iter<'i, u8>>>;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        self.iter().cloned().enumerate()
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        self.len()
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        if self.is_empty() {
+            None
+        } else {
+            Some((BStr::from_bytes(&self[1..]), self[0]))
+        }
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        self.iter().position(|b| predicate(*b))
+    }
+    #[inline(always)]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        if let Some(needed) = tokens.checked_sub(self.len()).and_then(NonZeroUsize::new) {
+            Err(Needed::Size(needed))
+        } else {
+            Ok(tokens)
+        }
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let (next, slice) = (&self.0).next_slice(offset);
+        (BStr::from_bytes(next), slice)
+    }
+}
+
+impl<I> Stream for (I, usize)
+where
+    I: Stream<Token = u8>,
+{
+    type Token = bool;
+    type Slice = (I::Slice, usize, usize);
+
+    type IterOffsets = BitOffsets<I>;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        BitOffsets {
+            i: self.clone(),
+            o: 0,
+        }
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        let offset = self.0.eof_offset() * 8;
+        if offset == 0 {
+            0
+        } else {
+            offset - self.1
+        }
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        next_bit(self)
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        self.iter_offsets()
+            .find_map(|(o, b)| predicate(b).then(|| o))
+    }
+    #[inline(always)]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        if let Some(needed) = tokens
+            .checked_sub(self.eof_offset())
+            .and_then(NonZeroUsize::new)
+        {
+            Err(Needed::Size(needed))
+        } else {
+            Ok(tokens)
+        }
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let byte_offset = (offset + self.1) / 8;
+        let end_offset = (offset + self.1) % 8;
+        let (i, s) = self.0.next_slice(byte_offset);
+        ((i, end_offset), (s, self.1, end_offset))
+    }
+}
+
+/// Iterator for [bit][crate::bits] stream (`(I, usize)`)
+pub struct BitOffsets<I> {
+    i: (I, usize),
+    o: usize,
+}
+
+impl<I> Iterator for BitOffsets<I>
+where
+    I: Stream<Token = u8>,
+{
+    type Item = (usize, bool);
+    fn next(&mut self) -> Option<Self::Item> {
+        let (next, b) = next_bit(&self.i)?;
+        let o = self.o;
+
+        self.i = next;
+        self.o += 1;
+
+        Some((o, b))
+    }
+}
+
+fn next_bit<I>(i: &(I, usize)) -> Option<((I, usize), bool)>
+where
+    I: Stream<Token = u8>,
+{
+    if i.eof_offset() == 0 {
+        return None;
+    }
+
+    let i = i.clone();
+    let (next_i, byte) = i.0.next_token()?;
+    let bit = (byte >> i.1) & 0x1 == 0x1;
+
+    let next_offset = i.1 + 1;
+    if next_offset == 8 {
+        Some(((next_i, 0), bit))
+    } else {
+        Some(((i.0, next_offset), bit))
+    }
+}
+
+impl<I: Stream> Stream for Located<I> {
+    type Token = <I as Stream>::Token;
+    type Slice = <I as Stream>::Slice;
+
+    type IterOffsets = <I as Stream>::IterOffsets;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        self.input.iter_offsets()
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        self.input.eof_offset()
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        let (next, token) = self.input.next_token()?;
+        Some((
+            Self {
+                initial: self.initial.clone(),
+                input: next,
+            },
+            token,
+        ))
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        self.input.offset_for(predicate)
+    }
+    #[inline(always)]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        self.input.offset_at(tokens)
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let (next, slice) = self.input.next_slice(offset);
+        (
+            Self {
+                initial: self.initial.clone(),
+                input: next,
+            },
+            slice,
+        )
+    }
+}
+
+impl<I: Stream, S: Clone + crate::lib::std::fmt::Debug> Stream for Stateful<I, S> {
+    type Token = <I as Stream>::Token;
+    type Slice = <I as Stream>::Slice;
+
+    type IterOffsets = <I as Stream>::IterOffsets;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        self.input.iter_offsets()
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        self.input.eof_offset()
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        let (next, token) = self.input.next_token()?;
+        Some((
+            Self {
+                input: next,
+                state: self.state.clone(),
+            },
+            token,
+        ))
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        self.input.offset_for(predicate)
+    }
+    #[inline(always)]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        self.input.offset_at(tokens)
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let (next, slice) = self.input.next_slice(offset);
+        (
+            Self {
+                input: next,
+                state: self.state.clone(),
+            },
+            slice,
+        )
+    }
+}
+
+impl<I: Stream> Stream for Partial<I> {
+    type Token = <I as Stream>::Token;
+    type Slice = <I as Stream>::Slice;
+
+    type IterOffsets = <I as Stream>::IterOffsets;
+
+    #[inline(always)]
+    fn iter_offsets(&self) -> Self::IterOffsets {
+        self.input.iter_offsets()
+    }
+    #[inline(always)]
+    fn eof_offset(&self) -> usize {
+        self.input.eof_offset()
+    }
+
+    #[inline(always)]
+    fn next_token(&self) -> Option<(Self, Self::Token)> {
+        let (next, token) = self.input.next_token()?;
+        Some((
+            Partial {
+                input: next,
+                partial: self.partial,
+            },
+            token,
+        ))
+    }
+
+    #[inline(always)]
+    fn offset_for<P>(&self, predicate: P) -> Option<usize>
+    where
+        P: Fn(Self::Token) -> bool,
+    {
+        self.input.offset_for(predicate)
+    }
+    #[inline(always)]
+    fn offset_at(&self, tokens: usize) -> Result<usize, Needed> {
+        self.input.offset_at(tokens)
+    }
+    #[inline(always)]
+    fn next_slice(&self, offset: usize) -> (Self, Self::Slice) {
+        let (next, slice) = self.input.next_slice(offset);
+        (
+            Partial {
+                input: next,
+                partial: self.partial,
+            },
+            slice,
+        )
+    }
+}
+
+/// Number of indices input has advanced since start of parsing
+pub trait Location {
+    /// Number of indices input has advanced since start of parsing
+    fn location(&self) -> usize;
+}
+
+impl<I> Location for Located<I>
+where
+    I: Clone + Offset,
+{
+    #[inline(always)]
+    fn location(&self) -> usize {
+        self.location()
+    }
+}
+
+impl<I, S> Location for Stateful<I, S>
+where
+    I: Location,
+{
+    #[inline(always)]
+    fn location(&self) -> usize {
+        self.input.location()
+    }
+}
+
+impl<I> Location for Partial<I>
+where
+    I: Location,
+{
+    #[inline(always)]
+    fn location(&self) -> usize {
+        self.input.location()
+    }
+}
+
+/// Marks the input as being the complete buffer or a partial buffer for streaming input
+///
+/// See [`Partial`] for marking a presumed complete buffer type as a streaming buffer.
+pub trait StreamIsPartial: Sized {
+    /// Whether the stream is currently partial or complete
+    type PartialState;
+
+    /// Mark the stream is complete
+    #[must_use]
+    fn complete(&mut self) -> Self::PartialState;
+
+    /// Restore the stream back to its previous state
+    fn restore_partial(&mut self, state: Self::PartialState);
+
+    /// Report whether the [`Stream`] is can ever be incomplete
+    fn is_partial_supported() -> bool;
+
+    /// Report whether the [`Stream`] is currently incomplete
+    #[inline(always)]
+    fn is_partial(&self) -> bool {
+        Self::is_partial_supported()
+    }
+}
+
+impl<'a, T> StreamIsPartial for &'a [T] {
+    type PartialState = ();
+
+    fn complete(&mut self) -> Self::PartialState {}
+
+    fn restore_partial(&mut self, _state: Self::PartialState) {}
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        false
+    }
+}
+
+impl<'a> StreamIsPartial for &'a str {
+    type PartialState = ();
+
+    fn complete(&mut self) -> Self::PartialState {
+        // Already complete
+    }
+
+    fn restore_partial(&mut self, _state: Self::PartialState) {}
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        false
+    }
+}
+
+impl<'a> StreamIsPartial for &'a Bytes {
+    type PartialState = ();
+
+    fn complete(&mut self) -> Self::PartialState {
+        // Already complete
+    }
+
+    fn restore_partial(&mut self, _state: Self::PartialState) {}
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        false
+    }
+}
+
+impl<'a> StreamIsPartial for &'a BStr {
+    type PartialState = ();
+
+    fn complete(&mut self) -> Self::PartialState {
+        // Already complete
+    }
+
+    fn restore_partial(&mut self, _state: Self::PartialState) {}
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        false
+    }
+}
+
+impl<I> StreamIsPartial for (I, usize)
+where
+    I: StreamIsPartial,
+{
+    type PartialState = I::PartialState;
+
+    fn complete(&mut self) -> Self::PartialState {
+        self.0.complete()
+    }
+
+    fn restore_partial(&mut self, state: Self::PartialState) {
+        self.0.restore_partial(state);
+    }
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        I::is_partial_supported()
+    }
+
+    #[inline(always)]
+    fn is_partial(&self) -> bool {
+        self.0.is_partial()
+    }
+}
+
+impl<I> StreamIsPartial for Located<I>
+where
+    I: StreamIsPartial,
+{
+    type PartialState = I::PartialState;
+
+    fn complete(&mut self) -> Self::PartialState {
+        self.input.complete()
+    }
+
+    fn restore_partial(&mut self, state: Self::PartialState) {
+        self.input.restore_partial(state);
+    }
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        I::is_partial_supported()
+    }
+
+    #[inline(always)]
+    fn is_partial(&self) -> bool {
+        self.input.is_partial()
+    }
+}
+
+impl<I, S> StreamIsPartial for Stateful<I, S>
+where
+    I: StreamIsPartial,
+{
+    type PartialState = I::PartialState;
+
+    fn complete(&mut self) -> Self::PartialState {
+        self.input.complete()
+    }
+
+    fn restore_partial(&mut self, state: Self::PartialState) {
+        self.input.restore_partial(state);
+    }
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        I::is_partial_supported()
+    }
+
+    #[inline(always)]
+    fn is_partial(&self) -> bool {
+        self.input.is_partial()
+    }
+}
+
+impl<I> StreamIsPartial for Partial<I>
+where
+    I: StreamIsPartial,
+{
+    type PartialState = bool;
+
+    fn complete(&mut self) -> Self::PartialState {
+        core::mem::replace(&mut self.partial, false)
+    }
+
+    fn restore_partial(&mut self, state: Self::PartialState) {
+        self.partial = state;
+    }
+
+    #[inline(always)]
+    fn is_partial_supported() -> bool {
+        true
+    }
+
+    #[inline(always)]
+    fn is_partial(&self) -> bool {
+        self.partial
+    }
+}
+
+/// Useful functions to calculate the offset between slices and show a hexdump of a slice
+pub trait Offset {
+    /// Offset between the first byte of self and the first byte of the argument
+    fn offset_to(&self, second: &Self) -> usize;
+}
+
+impl<'a, T> Offset for &'a [T] {
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        (*self).offset_to(*second)
+    }
+}
+
+/// Convenience implementation to accept `&[T]` instead of `&&[T]` as above
+impl<T> Offset for [T] {
+    #[inline]
+    fn offset_to(&self, second: &Self) -> usize {
+        let fst = self.as_ptr();
+        let snd = second.as_ptr();
+
+        debug_assert!(
+            fst <= snd,
+            "`Offset::offset_to` only accepts slices of `self`"
+        );
+        snd as usize - fst as usize
+    }
+}
+
+impl<'a> Offset for &'a str {
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        self.as_bytes().offset_to(second.as_bytes())
+    }
+}
+
+/// Convenience implementation to accept `&str` instead of `&&str` as above
+impl Offset for str {
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        self.as_bytes().offset_to(second.as_bytes())
+    }
+}
+
+impl Offset for Bytes {
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        self.as_bytes().offset_to(second.as_bytes())
+    }
+}
+
+impl<'a> Offset for &'a Bytes {
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        self.as_bytes().offset_to(second.as_bytes())
+    }
+}
+
+impl Offset for BStr {
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        self.as_bytes().offset_to(second.as_bytes())
+    }
+}
+
+impl<'a> Offset for &'a BStr {
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        self.as_bytes().offset_to(second.as_bytes())
+    }
+}
+
+impl<I> Offset for (I, usize)
+where
+    I: Offset,
+{
+    #[inline(always)]
+    fn offset_to(&self, other: &Self) -> usize {
+        self.0.offset_to(&other.0) * 8 + other.1 - self.1
+    }
+}
+
+impl<I> Offset for Located<I>
+where
+    I: Offset,
+{
+    #[inline(always)]
+    fn offset_to(&self, other: &Self) -> usize {
+        self.input.offset_to(&other.input)
+    }
+}
+
+impl<I, S> Offset for Stateful<I, S>
+where
+    I: Offset,
+{
+    #[inline(always)]
+    fn offset_to(&self, other: &Self) -> usize {
+        self.input.offset_to(&other.input)
+    }
+}
+
+impl<I> Offset for Partial<I>
+where
+    I: Offset,
+{
+    #[inline(always)]
+    fn offset_to(&self, second: &Self) -> usize {
+        self.input.offset_to(&second.input)
+    }
+}
+
+/// Helper trait for types that can be viewed as a byte slice
+pub trait AsBytes {
+    /// Casts the input type to a byte slice
+    fn as_bytes(&self) -> &[u8];
+}
+
+impl<'a> AsBytes for &'a [u8] {
+    #[inline(always)]
+    fn as_bytes(&self) -> &[u8] {
+        self
+    }
+}
+
+impl<'a> AsBytes for &'a Bytes {
+    #[inline(always)]
+    fn as_bytes(&self) -> &[u8] {
+        (*self).as_bytes()
+    }
+}
+
+impl<I> AsBytes for Located<I>
+where
+    I: AsBytes,
+{
+    #[inline(always)]
+    fn as_bytes(&self) -> &[u8] {
+        self.input.as_bytes()
+    }
+}
+
+impl<I, S> AsBytes for Stateful<I, S>
+where
+    I: AsBytes,
+{
+    #[inline(always)]
+    fn as_bytes(&self) -> &[u8] {
+        self.input.as_bytes()
+    }
+}
+
+impl<I> AsBytes for Partial<I>
+where
+    I: AsBytes,
+{
+    #[inline(always)]
+    fn as_bytes(&self) -> &[u8] {
+        self.input.as_bytes()
+    }
+}
+
+/// Helper trait for types that can be viewed as a byte slice
+pub trait AsBStr {
+    /// Casts the input type to a byte slice
+    fn as_bstr(&self) -> &[u8];
+}
+
+impl<'a> AsBStr for &'a [u8] {
+    #[inline(always)]
+    fn as_bstr(&self) -> &[u8] {
+        self
+    }
+}
+
+impl<'a> AsBStr for &'a BStr {
+    #[inline(always)]
+    fn as_bstr(&self) -> &[u8] {
+        (*self).as_bytes()
+    }
+}
+
+impl<'a> AsBStr for &'a str {
+    #[inline(always)]
+    fn as_bstr(&self) -> &[u8] {
+        (*self).as_bytes()
+    }
+}
+
+impl<I> AsBStr for Located<I>
+where
+    I: AsBStr,
+{
+    #[inline(always)]
+    fn as_bstr(&self) -> &[u8] {
+        self.input.as_bstr()
+    }
+}
+
+impl<I, S> AsBStr for Stateful<I, S>
+where
+    I: AsBStr,
+{
+    #[inline(always)]
+    fn as_bstr(&self) -> &[u8] {
+        self.input.as_bstr()
+    }
+}
+
+impl<I> AsBStr for Partial<I>
+where
+    I: AsBStr,
+{
+    #[inline(always)]
+    fn as_bstr(&self) -> &[u8] {
+        self.input.as_bstr()
+    }
+}
+
+/// Result of [`Compare::compare`]
+#[derive(Debug, Eq, PartialEq)]
+pub enum CompareResult {
+    /// Comparison was successful
+    Ok,
+    /// We need more data to be sure
+    Incomplete,
+    /// Comparison failed
+    Error,
+}
+
+/// Abstracts comparison operations
+pub trait Compare<T> {
+    /// Compares self to another value for equality
+    fn compare(&self, t: T) -> CompareResult;
+    /// Compares self to another value for equality
+    /// independently of the case.
+    ///
+    /// Warning: for `&str`, the comparison is done
+    /// by lowercasing both strings and comparing
+    /// the result. This is a temporary solution until
+    /// a better one appears
+    fn compare_no_case(&self, t: T) -> CompareResult;
+}
+
+fn lowercase_byte(c: u8) -> u8 {
+    match c {
+        b'A'..=b'Z' => c - b'A' + b'a',
+        _ => c,
+    }
+}
+
+impl<'a, 'b> Compare<&'b [u8]> for &'a [u8] {
+    #[inline]
+    fn compare(&self, t: &'b [u8]) -> CompareResult {
+        let pos = self.iter().zip(t.iter()).position(|(a, b)| a != b);
+
+        match pos {
+            Some(_) => CompareResult::Error,
+            None => {
+                if self.len() >= t.len() {
+                    CompareResult::Ok
+                } else {
+                    CompareResult::Incomplete
+                }
+            }
+        }
+    }
+
+    #[inline]
+    fn compare_no_case(&self, t: &'b [u8]) -> CompareResult {
+        if self
+            .iter()
+            .zip(t)
+            .any(|(a, b)| lowercase_byte(*a) != lowercase_byte(*b))
+        {
+            CompareResult::Error
+        } else if self.len() < t.len() {
+            CompareResult::Incomplete
+        } else {
+            CompareResult::Ok
+        }
+    }
+}
+
+impl<'a, const LEN: usize> Compare<[u8; LEN]> for &'a [u8] {
+    #[inline(always)]
+    fn compare(&self, t: [u8; LEN]) -> CompareResult {
+        self.compare(&t[..])
+    }
+
+    #[inline(always)]
+    fn compare_no_case(&self, t: [u8; LEN]) -> CompareResult {
+        self.compare_no_case(&t[..])
+    }
+}
+
+impl<'a, 'b, const LEN: usize> Compare<&'b [u8; LEN]> for &'a [u8] {
+    #[inline(always)]
+    fn compare(&self, t: &'b [u8; LEN]) -> CompareResult {
+        self.compare(&t[..])
+    }
+
+    #[inline(always)]
+    fn compare_no_case(&self, t: &'b [u8; LEN]) -> CompareResult {
+        self.compare_no_case(&t[..])
+    }
+}
+
+impl<'a, 'b> Compare<&'b str> for &'a [u8] {
+    #[inline(always)]
+    fn compare(&self, t: &'b str) -> CompareResult {
+        self.compare(t.as_bytes())
+    }
+    #[inline(always)]
+    fn compare_no_case(&self, t: &'b str) -> CompareResult {
+        self.compare_no_case(t.as_bytes())
+    }
+}
+
+impl<'a, 'b> Compare<&'b str> for &'a str {
+    #[inline(always)]
+    fn compare(&self, t: &'b str) -> CompareResult {
+        self.as_bytes().compare(t.as_bytes())
+    }
+
+    //FIXME: this version is too simple and does not use the current locale
+    #[inline]
+    fn compare_no_case(&self, t: &'b str) -> CompareResult {
+        let pos = self
+            .chars()
+            .zip(t.chars())
+            .position(|(a, b)| a.to_lowercase().ne(b.to_lowercase()));
+
+        match pos {
+            Some(_) => CompareResult::Error,
+            None => {
+                if self.len() >= t.len() {
+                    CompareResult::Ok
+                } else {
+                    CompareResult::Incomplete
+                }
+            }
+        }
+    }
+}
+
+impl<'a, 'b> Compare<&'b [u8]> for &'a str {
+    #[inline(always)]
+    fn compare(&self, t: &'b [u8]) -> CompareResult {
+        AsBStr::as_bstr(self).compare(t)
+    }
+    #[inline(always)]
+    fn compare_no_case(&self, t: &'b [u8]) -> CompareResult {
+        AsBStr::as_bstr(self).compare_no_case(t)
+    }
+}
+
+impl<'a, T> Compare<T> for &'a Bytes
+where
+    &'a [u8]: Compare<T>,
+{
+    #[inline(always)]
+    fn compare(&self, t: T) -> CompareResult {
+        let bytes = (*self).as_bytes();
+        bytes.compare(t)
+    }
+
+    #[inline(always)]
+    fn compare_no_case(&self, t: T) -> CompareResult {
+        let bytes = (*self).as_bytes();
+        bytes.compare_no_case(t)
+    }
+}
+
+impl<'a, T> Compare<T> for &'a BStr
+where
+    &'a [u8]: Compare<T>,
+{
+    #[inline(always)]
+    fn compare(&self, t: T) -> CompareResult {
+        let bytes = (*self).as_bytes();
+        bytes.compare(t)
+    }
+
+    #[inline(always)]
+    fn compare_no_case(&self, t: T) -> CompareResult {
+        let bytes = (*self).as_bytes();
+        bytes.compare_no_case(t)
+    }
+}
+
+impl<I, U> Compare<U> for Located<I>
+where
+    I: Compare<U>,
+{
+    #[inline(always)]
+    fn compare(&self, other: U) -> CompareResult {
+        self.input.compare(other)
+    }
+
+    #[inline(always)]
+    fn compare_no_case(&self, other: U) -> CompareResult {
+        self.input.compare_no_case(other)
+    }
+}
+
+impl<I, S, U> Compare<U> for Stateful<I, S>
+where
+    I: Compare<U>,
+{
+    #[inline(always)]
+    fn compare(&self, other: U) -> CompareResult {
+        self.input.compare(other)
+    }
+
+    #[inline(always)]
+    fn compare_no_case(&self, other: U) -> CompareResult {
+        self.input.compare_no_case(other)
+    }
+}
+
+impl<I, T> Compare<T> for Partial<I>
+where
+    I: Compare<T>,
+{
+    #[inline(always)]
+    fn compare(&self, t: T) -> CompareResult {
+        self.input.compare(t)
+    }
+
+    #[inline(always)]
+    fn compare_no_case(&self, t: T) -> CompareResult {
+        self.input.compare_no_case(t)
+    }
+}
+
+/// Look for a slice in self
+pub trait FindSlice<T> {
+    /// Returns the offset of the slice if it is found
+    fn find_slice(&self, substr: T) -> Option<usize>;
+}
+
+impl<'i, 's> FindSlice<&'s [u8]> for &'i [u8] {
+    #[inline(always)]
+    fn find_slice(&self, substr: &'s [u8]) -> Option<usize> {
+        memmem(self, substr)
+    }
+}
+
+impl<'i> FindSlice<u8> for &'i [u8] {
+    #[inline(always)]
+    fn find_slice(&self, substr: u8) -> Option<usize> {
+        memchr(substr, self)
+    }
+}
+
+impl<'i, 's> FindSlice<&'s str> for &'i [u8] {
+    #[inline(always)]
+    fn find_slice(&self, substr: &'s str) -> Option<usize> {
+        self.find_slice(substr.as_bytes())
+    }
+}
+
+impl<'i, 's> FindSlice<&'s str> for &'i str {
+    #[inline(always)]
+    fn find_slice(&self, substr: &'s str) -> Option<usize> {
+        self.find(substr)
+    }
+}
+
+impl<'i> FindSlice<char> for &'i str {
+    #[inline(always)]
+    fn find_slice(&self, substr: char) -> Option<usize> {
+        self.find(substr)
+    }
+}
+
+impl<'i, S> FindSlice<S> for &'i Bytes
+where
+    &'i [u8]: FindSlice<S>,
+{
+    #[inline(always)]
+    fn find_slice(&self, substr: S) -> Option<usize> {
+        let bytes = (*self).as_bytes();
+        let offset = bytes.find_slice(substr);
+        offset
+    }
+}
+
+impl<'i, S> FindSlice<S> for &'i BStr
+where
+    &'i [u8]: FindSlice<S>,
+{
+    #[inline(always)]
+    fn find_slice(&self, substr: S) -> Option<usize> {
+        let bytes = (*self).as_bytes();
+        let offset = bytes.find_slice(substr);
+        offset
+    }
+}
+
+impl<I, T> FindSlice<T> for Located<I>
+where
+    I: FindSlice<T>,
+{
+    #[inline(always)]
+    fn find_slice(&self, substr: T) -> Option<usize> {
+        self.input.find_slice(substr)
+    }
+}
+
+impl<I, S, T> FindSlice<T> for Stateful<I, S>
+where
+    I: FindSlice<T>,
+{
+    #[inline(always)]
+    fn find_slice(&self, substr: T) -> Option<usize> {
+        self.input.find_slice(substr)
+    }
+}
+
+impl<I, T> FindSlice<T> for Partial<I>
+where
+    I: FindSlice<T>,
+{
+    #[inline(always)]
+    fn find_slice(&self, substr: T) -> Option<usize> {
+        self.input.find_slice(substr)
+    }
+}
+
+/// Used to integrate `str`'s `parse()` method
+pub trait ParseSlice<R> {
+    /// Succeeds if `parse()` succeededThe
+    ///
+    /// The byte slice implementation will first convert it to a `&str`, then apply the `parse()`
+    /// function
+    fn parse_slice(&self) -> Option<R>;
+}
+
+impl<'a, R: FromStr> ParseSlice<R> for &'a [u8] {
+    #[inline(always)]
+    fn parse_slice(&self) -> Option<R> {
+        from_utf8(self).ok().and_then(|s| s.parse().ok())
+    }
+}
+
+impl<'a, R: FromStr> ParseSlice<R> for &'a str {
+    #[inline(always)]
+    fn parse_slice(&self) -> Option<R> {
+        self.parse().ok()
+    }
+}
+
+/// Convert a `Stream` into an appropriate `Output` type
+pub trait UpdateSlice: Stream {
+    /// Convert an `Output` type to be used as `Stream`
+    fn update_slice(self, inner: Self::Slice) -> Self;
+}
+
+impl<'a, T> UpdateSlice for &'a [T]
+where
+    T: Clone + crate::lib::std::fmt::Debug,
+{
+    #[inline(always)]
+    fn update_slice(self, inner: Self::Slice) -> Self {
+        inner
+    }
+}
+
+impl<'a> UpdateSlice for &'a str {
+    #[inline(always)]
+    fn update_slice(self, inner: Self::Slice) -> Self {
+        inner
+    }
+}
+
+impl<'a> UpdateSlice for &'a Bytes {
+    #[inline(always)]
+    fn update_slice(self, inner: Self::Slice) -> Self {
+        Bytes::new(inner)
+    }
+}
+
+impl<'a> UpdateSlice for &'a BStr {
+    #[inline(always)]
+    fn update_slice(self, inner: Self::Slice) -> Self {
+        BStr::new(inner)
+    }
+}
+
+impl<I> UpdateSlice for Located<I>
+where
+    I: UpdateSlice,
+{
+    #[inline(always)]
+    fn update_slice(mut self, inner: Self::Slice) -> Self {
+        self.input = I::update_slice(self.input, inner);
+        self
+    }
+}
+
+impl<I, S> UpdateSlice for Stateful<I, S>
+where
+    I: UpdateSlice,
+    S: Clone + crate::lib::std::fmt::Debug,
+{
+    #[inline(always)]
+    fn update_slice(mut self, inner: Self::Slice) -> Self {
+        self.input = I::update_slice(self.input, inner);
+        self
+    }
+}
+
+impl<I> UpdateSlice for Partial<I>
+where
+    I: UpdateSlice,
+{
+    #[inline(always)]
+    fn update_slice(self, inner: Self::Slice) -> Self {
+        Partial {
+            input: I::update_slice(self.input, inner),
+            partial: self.partial,
+        }
+    }
+}
+
+/// Abstracts something which can extend an `Extend`.
+/// Used to build modified input slices in `escaped_transform`
+pub trait Accumulate<T>: Sized {
+    /// Create a new `Extend` of the correct type
+    fn initial(capacity: Option<usize>) -> Self;
+    /// Accumulate the input into an accumulator
+    fn accumulate(&mut self, acc: T);
+}
+
+impl<T> Accumulate<T> for () {
+    #[inline(always)]
+    fn initial(_capacity: Option<usize>) -> Self {}
+    #[inline(always)]
+    fn accumulate(&mut self, _acc: T) {}
+}
+
+impl<T> Accumulate<T> for usize {
+    #[inline(always)]
+    fn initial(_capacity: Option<usize>) -> Self {
+        0
+    }
+    #[inline(always)]
+    fn accumulate(&mut self, _acc: T) {
+        *self += 1;
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<T> Accumulate<T> for Vec<T> {
+    #[inline(always)]
+    fn initial(capacity: Option<usize>) -> Self {
+        match capacity {
+            Some(capacity) => Vec::with_capacity(clamp_capacity::<T>(capacity)),
+            None => Vec::new(),
+        }
+    }
+    #[inline(always)]
+    fn accumulate(&mut self, acc: T) {
+        self.push(acc);
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'i, T: Clone> Accumulate<&'i [T]> for Vec<T> {
+    #[inline(always)]
+    fn initial(capacity: Option<usize>) -> Self {
+        match capacity {
+            Some(capacity) => Vec::with_capacity(clamp_capacity::<T>(capacity)),
+            None => Vec::new(),
+        }
+    }
+    #[inline(always)]
+    fn accumulate(&mut self, acc: &'i [T]) {
+        self.extend(acc.iter().cloned());
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl Accumulate<char> for String {
+    #[inline(always)]
+    fn initial(capacity: Option<usize>) -> Self {
+        match capacity {
+            Some(capacity) => String::with_capacity(clamp_capacity::<char>(capacity)),
+            None => String::new(),
+        }
+    }
+    #[inline(always)]
+    fn accumulate(&mut self, acc: char) {
+        self.push(acc);
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<'i> Accumulate<&'i str> for String {
+    #[inline(always)]
+    fn initial(capacity: Option<usize>) -> Self {
+        match capacity {
+            Some(capacity) => String::with_capacity(clamp_capacity::<char>(capacity)),
+            None => String::new(),
+        }
+    }
+    #[inline(always)]
+    fn accumulate(&mut self, acc: &'i str) {
+        self.push_str(acc);
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl<K, V> Accumulate<(K, V)> for BTreeMap<K, V>
+where
+    K: crate::lib::std::cmp::Ord,
+{
+    #[inline(always)]
+    fn initial(_capacity: Option<usize>) -> Self {
+        BTreeMap::new()
+    }
+    #[inline(always)]
+    fn accumulate(&mut self, (key, value): (K, V)) {
+        self.insert(key, value);
+    }
+}
+
+#[cfg(feature = "std")]
+impl<K, V> Accumulate<(K, V)> for HashMap<K, V>
+where
+    K: crate::lib::std::cmp::Eq + crate::lib::std::hash::Hash,
+{
+    #[inline(always)]
+    fn initial(capacity: Option<usize>) -> Self {
+        match capacity {
+            Some(capacity) => HashMap::with_capacity(clamp_capacity::<(K, V)>(capacity)),
+            None => HashMap::new(),
+        }
+    }
+    #[inline(always)]
+    fn accumulate(&mut self, (key, value): (K, V)) {
+        self.insert(key, value);
+    }
+}
+
+#[cfg(feature = "alloc")]
+#[inline]
+pub(crate) fn clamp_capacity<T>(capacity: usize) -> usize {
+    /// Don't pre-allocate more than 64KiB when calling `Vec::with_capacity`.
+    ///
+    /// Pre-allocating memory is a nice optimization but count fields can't
+    /// always be trusted. We should clamp initial capacities to some reasonable
+    /// amount. This reduces the risk of a bogus count value triggering a panic
+    /// due to an OOM error.
+    ///
+    /// This does not affect correctness. `winnow` will always read the full number
+    /// of elements regardless of the capacity cap.
+    const MAX_INITIAL_CAPACITY_BYTES: usize = 65536;
+
+    let max_initial_capacity =
+        MAX_INITIAL_CAPACITY_BYTES / crate::lib::std::mem::size_of::<T>().max(1);
+    capacity.min(max_initial_capacity)
+}
+
+/// Helper trait to convert numbers to usize.
+///
+/// By default, usize implements `From<u8>` and `From<u16>` but not
+/// `From<u32>` and `From<u64>` because that would be invalid on some
+/// platforms. This trait implements the conversion for platforms
+/// with 32 and 64 bits pointer platforms
+pub trait ToUsize {
+    /// converts self to usize
+    fn to_usize(&self) -> usize;
+}
+
+impl ToUsize for u8 {
+    #[inline(always)]
+    fn to_usize(&self) -> usize {
+        *self as usize
+    }
+}
+
+impl ToUsize for u16 {
+    #[inline(always)]
+    fn to_usize(&self) -> usize {
+        *self as usize
+    }
+}
+
+impl ToUsize for usize {
+    #[inline(always)]
+    fn to_usize(&self) -> usize {
+        *self
+    }
+}
+
+#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
+impl ToUsize for u32 {
+    #[inline(always)]
+    fn to_usize(&self) -> usize {
+        *self as usize
+    }
+}
+
+#[cfg(target_pointer_width = "64")]
+impl ToUsize for u64 {
+    #[inline(always)]
+    fn to_usize(&self) -> usize {
+        *self as usize
+    }
+}
+
+/// Transforms a token into a char for basic string parsing
+#[allow(clippy::len_without_is_empty)]
+#[allow(clippy::wrong_self_convention)]
+pub trait AsChar {
+    /// Makes a char from self
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use winnow::stream::AsChar as _;
+    ///
+    /// assert_eq!('a'.as_char(), 'a');
+    /// assert_eq!(u8::MAX.as_char(), std::char::from_u32(u8::MAX as u32).unwrap());
+    /// ```
+    fn as_char(self) -> char;
+
+    /// Tests that self is an alphabetic character
+    ///
+    /// **Warning:** for `&str` it recognizes alphabetic
+    /// characters outside of the 52 ASCII letters
+    fn is_alpha(self) -> bool;
+
+    /// Tests that self is an alphabetic character
+    /// or a decimal digit
+    fn is_alphanum(self) -> bool;
+    /// Tests that self is a decimal digit
+    fn is_dec_digit(self) -> bool;
+    /// Tests that self is an hex digit
+    fn is_hex_digit(self) -> bool;
+    /// Tests that self is an octal digit
+    fn is_oct_digit(self) -> bool;
+    /// Gets the len in bytes for self
+    fn len(self) -> usize;
+    /// Tests that self is ASCII space or tab
+    fn is_space(self) -> bool;
+    /// Tests if byte is ASCII newline: \n
+    fn is_newline(self) -> bool;
+}
+
+impl AsChar for u8 {
+    #[inline(always)]
+    fn as_char(self) -> char {
+        self as char
+    }
+    #[inline]
+    fn is_alpha(self) -> bool {
+        matches!(self, 0x41..=0x5A | 0x61..=0x7A)
+    }
+    #[inline]
+    fn is_alphanum(self) -> bool {
+        self.is_alpha() || self.is_dec_digit()
+    }
+    #[inline]
+    fn is_dec_digit(self) -> bool {
+        matches!(self, 0x30..=0x39)
+    }
+    #[inline]
+    fn is_hex_digit(self) -> bool {
+        matches!(self, 0x30..=0x39 | 0x41..=0x46 | 0x61..=0x66)
+    }
+    #[inline]
+    fn is_oct_digit(self) -> bool {
+        matches!(self, 0x30..=0x37)
+    }
+    #[inline]
+    fn len(self) -> usize {
+        1
+    }
+    #[inline]
+    fn is_space(self) -> bool {
+        self == b' ' || self == b'\t'
+    }
+    fn is_newline(self) -> bool {
+        self == b'\n'
+    }
+}
+impl<'a> AsChar for &'a u8 {
+    #[inline(always)]
+    fn as_char(self) -> char {
+        *self as char
+    }
+    #[inline]
+    fn is_alpha(self) -> bool {
+        matches!(*self, 0x41..=0x5A | 0x61..=0x7A)
+    }
+    #[inline]
+    fn is_alphanum(self) -> bool {
+        self.is_alpha() || self.is_dec_digit()
+    }
+    #[inline]
+    fn is_dec_digit(self) -> bool {
+        matches!(*self, 0x30..=0x39)
+    }
+    #[inline]
+    fn is_hex_digit(self) -> bool {
+        matches!(*self, 0x30..=0x39 | 0x41..=0x46 | 0x61..=0x66)
+    }
+    #[inline]
+    fn is_oct_digit(self) -> bool {
+        matches!(*self, 0x30..=0x37)
+    }
+    #[inline]
+    fn len(self) -> usize {
+        1
+    }
+    #[inline]
+    fn is_space(self) -> bool {
+        *self == b' ' || *self == b'\t'
+    }
+    fn is_newline(self) -> bool {
+        *self == b'\n'
+    }
+}
+
+impl AsChar for char {
+    #[inline(always)]
+    fn as_char(self) -> char {
+        self
+    }
+    #[inline]
+    fn is_alpha(self) -> bool {
+        self.is_ascii_alphabetic()
+    }
+    #[inline]
+    fn is_alphanum(self) -> bool {
+        self.is_alpha() || self.is_dec_digit()
+    }
+    #[inline]
+    fn is_dec_digit(self) -> bool {
+        self.is_ascii_digit()
+    }
+    #[inline]
+    fn is_hex_digit(self) -> bool {
+        self.is_ascii_hexdigit()
+    }
+    #[inline]
+    fn is_oct_digit(self) -> bool {
+        self.is_digit(8)
+    }
+    #[inline]
+    fn len(self) -> usize {
+        self.len_utf8()
+    }
+    #[inline]
+    fn is_space(self) -> bool {
+        self == ' ' || self == '\t'
+    }
+    fn is_newline(self) -> bool {
+        self == '\n'
+    }
+}
+
+impl<'a> AsChar for &'a char {
+    #[inline(always)]
+    fn as_char(self) -> char {
+        *self
+    }
+    #[inline]
+    fn is_alpha(self) -> bool {
+        self.is_ascii_alphabetic()
+    }
+    #[inline]
+    fn is_alphanum(self) -> bool {
+        self.is_alpha() || self.is_dec_digit()
+    }
+    #[inline]
+    fn is_dec_digit(self) -> bool {
+        self.is_ascii_digit()
+    }
+    #[inline]
+    fn is_hex_digit(self) -> bool {
+        self.is_ascii_hexdigit()
+    }
+    #[inline]
+    fn is_oct_digit(self) -> bool {
+        self.is_digit(8)
+    }
+    #[inline]
+    fn len(self) -> usize {
+        self.len_utf8()
+    }
+    #[inline]
+    fn is_space(self) -> bool {
+        *self == ' ' || *self == '\t'
+    }
+    fn is_newline(self) -> bool {
+        *self == '\n'
+    }
+}
+
+/// Check if a token in in a set of possible tokens
+///
+/// This is generally implemented on patterns that a token may match and supports `u8` and `char`
+/// tokens along with the following patterns
+/// - `b'c'` and `'c'`
+/// - `b""` and `""`
+/// - `|c| true`
+/// - `b'a'..=b'z'`, `'a'..='z'` (etc for each [range type][std::ops])
+/// - `(pattern1, pattern2, ...)`
+///
+/// # Example
+///
+/// For example, you could implement `hex_digit0` as:
+/// ```
+/// # use winnow::prelude::*;
+/// # use winnow::{error::ErrMode, error::ErrorKind, error::Error};
+/// # use winnow::bytes::take_while1;
+/// fn hex_digit1(input: &str) -> IResult<&str, &str> {
+///     take_while1(('a'..='f', 'A'..='F', '0'..='9')).parse_next(input)
+/// }
+///
+/// assert_eq!(hex_digit1("21cZ"), Ok(("Z", "21c")));
+/// assert_eq!(hex_digit1("H2"), Err(ErrMode::Backtrack(Error::new("H2", ErrorKind::Slice))));
+/// assert_eq!(hex_digit1(""), Err(ErrMode::Backtrack(Error::new("", ErrorKind::Slice))));
+/// ```
+pub trait ContainsToken<T> {
+    /// Returns true if self contains the token
+    fn contains_token(&self, token: T) -> bool;
+}
+
+impl ContainsToken<u8> for u8 {
+    #[inline(always)]
+    fn contains_token(&self, token: u8) -> bool {
+        *self == token
+    }
+}
+
+impl<'a> ContainsToken<&'a u8> for u8 {
+    #[inline(always)]
+    fn contains_token(&self, token: &u8) -> bool {
+        self.contains_token(*token)
+    }
+}
+
+impl ContainsToken<char> for u8 {
+    #[inline(always)]
+    fn contains_token(&self, token: char) -> bool {
+        self.as_char() == token
+    }
+}
+
+impl<'a> ContainsToken<&'a char> for u8 {
+    #[inline(always)]
+    fn contains_token(&self, token: &char) -> bool {
+        self.contains_token(*token)
+    }
+}
+
+impl<C: AsChar> ContainsToken<C> for char {
+    #[inline(always)]
+    fn contains_token(&self, token: C) -> bool {
+        *self == token.as_char()
+    }
+}
+
+impl<C: AsChar, F: Fn(C) -> bool> ContainsToken<C> for F {
+    #[inline(always)]
+    fn contains_token(&self, token: C) -> bool {
+        self(token)
+    }
+}
+
+impl<C1: AsChar, C2: AsChar + Clone> ContainsToken<C1> for Range<C2> {
+    #[inline(always)]
+    fn contains_token(&self, token: C1) -> bool {
+        let start = self.start.clone().as_char();
+        let end = self.end.clone().as_char();
+        (start..end).contains(&token.as_char())
+    }
+}
+
+impl<C1: AsChar, C2: AsChar + Clone> ContainsToken<C1> for RangeInclusive<C2> {
+    #[inline(always)]
+    fn contains_token(&self, token: C1) -> bool {
+        let start = self.start().clone().as_char();
+        let end = self.end().clone().as_char();
+        (start..=end).contains(&token.as_char())
+    }
+}
+
+impl<C1: AsChar, C2: AsChar + Clone> ContainsToken<C1> for RangeFrom<C2> {
+    #[inline(always)]
+    fn contains_token(&self, token: C1) -> bool {
+        let start = self.start.clone().as_char();
+        (start..).contains(&token.as_char())
+    }
+}
+
+impl<C1: AsChar, C2: AsChar + Clone> ContainsToken<C1> for RangeTo<C2> {
+    #[inline(always)]
+    fn contains_token(&self, token: C1) -> bool {
+        let end = self.end.clone().as_char();
+        (..end).contains(&token.as_char())
+    }
+}
+
+impl<C1: AsChar, C2: AsChar + Clone> ContainsToken<C1> for RangeToInclusive<C2> {
+    #[inline(always)]
+    fn contains_token(&self, token: C1) -> bool {
+        let end = self.end.clone().as_char();
+        (..=end).contains(&token.as_char())
+    }
+}
+
+impl<C1: AsChar> ContainsToken<C1> for RangeFull {
+    #[inline(always)]
+    fn contains_token(&self, _token: C1) -> bool {
+        true
+    }
+}
+
+impl<C: AsChar> ContainsToken<C> for &'_ [u8] {
+    #[inline]
+    fn contains_token(&self, token: C) -> bool {
+        let token = token.as_char();
+        self.iter().any(|t| t.as_char() == token)
+    }
+}
+
+impl<C: AsChar> ContainsToken<C> for &'_ [char] {
+    #[inline]
+    fn contains_token(&self, token: C) -> bool {
+        let token = token.as_char();
+        self.iter().any(|t| *t == token)
+    }
+}
+
+impl<const LEN: usize, C: AsChar> ContainsToken<C> for &'_ [u8; LEN] {
+    #[inline]
+    fn contains_token(&self, token: C) -> bool {
+        let token = token.as_char();
+        self.iter().any(|t| t.as_char() == token)
+    }
+}
+
+impl<const LEN: usize, C: AsChar> ContainsToken<C> for &'_ [char; LEN] {
+    #[inline]
+    fn contains_token(&self, token: C) -> bool {
+        let token = token.as_char();
+        self.iter().any(|t| *t == token)
+    }
+}
+
+impl<const LEN: usize, C: AsChar> ContainsToken<C> for [u8; LEN] {
+    #[inline]
+    fn contains_token(&self, token: C) -> bool {
+        let token = token.as_char();
+        self.iter().any(|t| t.as_char() == token)
+    }
+}
+
+impl<const LEN: usize, C: AsChar> ContainsToken<C> for [char; LEN] {
+    #[inline]
+    fn contains_token(&self, token: C) -> bool {
+        let token = token.as_char();
+        self.iter().any(|t| *t == token)
+    }
+}
+
+impl<C: AsChar> ContainsToken<C> for &'_ str {
+    #[inline(always)]
+    fn contains_token(&self, token: C) -> bool {
+        let token = token.as_char();
+        self.chars().any(|i| i == token)
+    }
+}
+
+impl<T> ContainsToken<T> for () {
+    #[inline(always)]
+    fn contains_token(&self, _token: T) -> bool {
+        false
+    }
+}
+
+macro_rules! impl_contains_token_for_tuple {
+  ($($haystack:ident),+) => (
+    #[allow(non_snake_case)]
+    impl<T, $($haystack),+> ContainsToken<T> for ($($haystack),+,)
+    where
+    T: Clone,
+      $($haystack: ContainsToken<T>),+
+    {
+    #[inline]
+      fn contains_token(&self, token: T) -> bool {
+        let ($(ref $haystack),+,) = *self;
+        $($haystack.contains_token(token.clone()) || )+ false
+      }
+    }
+  )
+}
+
+macro_rules! impl_contains_token_for_tuples {
+    ($haystack1:ident, $($haystack:ident),+) => {
+        impl_contains_token_for_tuples!(__impl $haystack1; $($haystack),+);
+    };
+    (__impl $($haystack:ident),+; $haystack1:ident $(,$haystack2:ident)*) => {
+        impl_contains_token_for_tuple!($($haystack),+);
+        impl_contains_token_for_tuples!(__impl $($haystack),+, $haystack1; $($haystack2),*);
+    };
+    (__impl $($haystack:ident),+;) => {
+        impl_contains_token_for_tuple!($($haystack),+);
+    }
+}
+
+impl_contains_token_for_tuples!(
+    F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21
+);
+
+/// Looks for the first element of the input type for which the condition returns true,
+/// and returns the input up to this position.
+///
+/// *Partial version*: If no element is found matching the condition, this will return `Incomplete`
+pub(crate) fn split_at_offset_partial<P, I: Stream, E: ParseError<I>>(
+    input: &I,
+    predicate: P,
+) -> IResult<I, <I as Stream>::Slice, E>
+where
+    P: Fn(I::Token) -> bool,
+{
+    let offset = input
+        .offset_for(predicate)
+        .ok_or_else(|| ErrMode::Incomplete(Needed::new(1)))?;
+    Ok(input.next_slice(offset))
+}
+
+/// Looks for the first element of the input type for which the condition returns true
+/// and returns the input up to this position.
+///
+/// Fails if the produced slice is empty.
+///
+/// *Partial version*: If no element is found matching the condition, this will return `Incomplete`
+pub(crate) fn split_at_offset1_partial<P, I: Stream, E: ParseError<I>>(
+    input: &I,
+    predicate: P,
+    e: ErrorKind,
+) -> IResult<I, <I as Stream>::Slice, E>
+where
+    P: Fn(I::Token) -> bool,
+{
+    let offset = input
+        .offset_for(predicate)
+        .ok_or_else(|| ErrMode::Incomplete(Needed::new(1)))?;
+    if offset == 0 {
+        Err(ErrMode::from_error_kind(input.clone(), e))
+    } else {
+        Ok(input.next_slice(offset))
+    }
+}
+
+/// Looks for the first element of the input type for which the condition returns true,
+/// and returns the input up to this position.
+///
+/// *Complete version*: If no element is found matching the condition, this will return the whole input
+pub(crate) fn split_at_offset_complete<P, I: Stream, E: ParseError<I>>(
+    input: &I,
+    predicate: P,
+) -> IResult<I, <I as Stream>::Slice, E>
+where
+    P: Fn(I::Token) -> bool,
+{
+    let offset = input
+        .offset_for(predicate)
+        .unwrap_or_else(|| input.eof_offset());
+    Ok(input.next_slice(offset))
+}
+
+/// Looks for the first element of the input type for which the condition returns true
+/// and returns the input up to this position.
+///
+/// Fails if the produced slice is empty.
+///
+/// *Complete version*: If no element is found matching the condition, this will return the whole input
+pub(crate) fn split_at_offset1_complete<P, I: Stream, E: ParseError<I>>(
+    input: &I,
+    predicate: P,
+    e: ErrorKind,
+) -> IResult<I, <I as Stream>::Slice, E>
+where
+    P: Fn(I::Token) -> bool,
+{
+    let offset = input
+        .offset_for(predicate)
+        .unwrap_or_else(|| input.eof_offset());
+    if offset == 0 {
+        Err(ErrMode::from_error_kind(input.clone(), e))
+    } else {
+        Ok(input.next_slice(offset))
+    }
+}
+
+#[cfg(feature = "simd")]
+#[inline(always)]
+fn memchr(token: u8, slice: &[u8]) -> Option<usize> {
+    memchr::memchr(token, slice)
+}
+
+#[cfg(not(feature = "simd"))]
+#[inline(always)]
+fn memchr(token: u8, slice: &[u8]) -> Option<usize> {
+    slice.iter().position(|t| *t == token)
+}
+
+#[cfg(feature = "simd")]
+#[inline(always)]
+fn memmem(slice: &[u8], tag: &[u8]) -> Option<usize> {
+    memchr::memmem::find(slice, tag)
+}
+
+#[cfg(not(feature = "simd"))]
+fn memmem(slice: &[u8], tag: &[u8]) -> Option<usize> {
+    for i in 0..slice.len() {
+        let subslice = &slice[i..];
+        if subslice.starts_with(tag) {
+            return Some(i);
+        }
+    }
+    None
+}
diff --git a/vendor/winnow/src/stream/tests.rs b/vendor/winnow/src/stream/tests.rs
new file mode 100644
index 000000000..de61df099
--- /dev/null
+++ b/vendor/winnow/src/stream/tests.rs
@@ -0,0 +1,116 @@
+#[cfg(feature = "std")]
+use proptest::prelude::*;
+
+use super::*;
+
+#[test]
+fn test_offset_u8() {
+    let s = b"abcd123";
+    let a = &s[..];
+    let b = &a[2..];
+    let c = &a[..4];
+    let d = &a[3..5];
+    assert_eq!(a.offset_to(b), 2);
+    assert_eq!(a.offset_to(c), 0);
+    assert_eq!(a.offset_to(d), 3);
+}
+
+#[test]
+fn test_offset_str() {
+    let a = "abcřèÂßÇd123";
+    let b = &a[7..];
+    let c = &a[..5];
+    let d = &a[5..9];
+    assert_eq!(a.offset_to(b), 7);
+    assert_eq!(a.offset_to(c), 0);
+    assert_eq!(a.offset_to(d), 5);
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn test_bit_stream_empty() {
+    let i = (&b""[..], 0);
+
+    let actual = i.iter_offsets().collect::<crate::lib::std::vec::Vec<_>>();
+    assert_eq!(actual, vec![]);
+
+    let actual = i.eof_offset();
+    assert_eq!(actual, 0);
+
+    let actual = i.next_token();
+    assert_eq!(actual, None);
+
+    let actual = i.offset_for(|b| b);
+    assert_eq!(actual, None);
+
+    let actual = i.offset_at(1);
+    assert_eq!(actual, Err(Needed::new(1)));
+
+    let (actual_input, actual_slice) = i.next_slice(0);
+    assert_eq!(actual_input, (&b""[..], 0));
+    assert_eq!(actual_slice, (&b""[..], 0, 0));
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn test_bit_offset_empty() {
+    let i = (&b""[..], 0);
+
+    let actual = i.offset_to(&i);
+    assert_eq!(actual, 0);
+}
+
+#[cfg(feature = "std")]
+proptest! {
+  #[test]
+  #[cfg_attr(miri, ignore)]  // See https://github.com/AltSysrq/proptest/issues/253
+  fn bit_stream(byte_len in 0..20usize, start in 0..160usize) {
+        bit_stream_inner(byte_len, start);
+  }
+}
+
+#[cfg(feature = "std")]
+fn bit_stream_inner(byte_len: usize, start: usize) {
+    let start = start.min(byte_len * 8);
+    let start_byte = start / 8;
+    let start_bit = start % 8;
+
+    let bytes = vec![0b1010_1010; byte_len];
+    let i = (&bytes[start_byte..], start_bit);
+
+    let mut curr_i = i;
+    let mut curr_offset = 0;
+    while let Some((next_i, _token)) = curr_i.next_token() {
+        let to_offset = i.offset_to(&curr_i);
+        assert_eq!(curr_offset, to_offset);
+
+        let (slice_i, _) = i.next_slice(curr_offset);
+        assert_eq!(curr_i, slice_i);
+
+        let at_offset = i.offset_at(curr_offset).unwrap();
+        assert_eq!(curr_offset, at_offset);
+
+        let eof_offset = curr_i.eof_offset();
+        let (next_eof_i, eof_slice) = curr_i.next_slice(eof_offset);
+        assert_eq!(next_eof_i, (&b""[..], 0));
+        let eof_slice_i = (eof_slice.0, eof_slice.1);
+        assert_eq!(eof_slice_i, curr_i);
+
+        curr_offset += 1;
+        curr_i = next_i;
+    }
+    assert_eq!(i.eof_offset(), curr_offset);
+}
+
+#[test]
+fn test_partial_complete() {
+    let mut i = Partial::new(&b""[..]);
+    assert!(Partial::<&[u8]>::is_partial_supported());
+
+    assert!(i.is_partial(), "incomplete by default");
+    let incomplete_state = i.complete();
+    assert!(!i.is_partial(), "the stream should be marked as complete");
+
+    i.restore_partial(incomplete_state);
+    assert!(i.is_partial(), "incomplete stream state should be restored");
+}
diff --git a/vendor/winnow/src/trace/internals.rs b/vendor/winnow/src/trace/internals.rs
new file mode 100644
index 000000000..2e91f69a8
--- /dev/null
+++ b/vendor/winnow/src/trace/internals.rs
@@ -0,0 +1,300 @@
+#![cfg(feature = "std")]
+
+use std::io::Write;
+
+use crate::error::ErrMode;
+use crate::stream::Stream;
+
+pub struct Depth {
+    depth: usize,
+    inc: bool,
+}
+
+impl Depth {
+    pub fn new() -> Self {
+        let depth = DEPTH.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        let inc = true;
+        Self { depth, inc }
+    }
+
+    pub fn existing() -> Self {
+        let depth = DEPTH.load(std::sync::atomic::Ordering::SeqCst);
+        let inc = false;
+        Self { depth, inc }
+    }
+}
+
+impl Drop for Depth {
+    fn drop(&mut self) {
+        if self.inc {
+            let _ = DEPTH.fetch_sub(1, std::sync::atomic::Ordering::SeqCst);
+        }
+    }
+}
+
+impl AsRef<usize> for Depth {
+    #[inline(always)]
+    fn as_ref(&self) -> &usize {
+        &self.depth
+    }
+}
+
+impl crate::lib::std::ops::Deref for Depth {
+    type Target = usize;
+
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        &self.depth
+    }
+}
+
+static DEPTH: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+
+pub enum Severity {
+    Success,
+    Backtrack,
+    Cut,
+    Incomplete,
+}
+
+impl Severity {
+    pub fn with_result<T, E>(result: &Result<T, ErrMode<E>>) -> Self {
+        match result {
+            Ok(_) => Self::Success,
+            Err(ErrMode::Backtrack(_)) => Self::Backtrack,
+            Err(ErrMode::Cut(_)) => Self::Cut,
+            Err(ErrMode::Incomplete(_)) => Self::Incomplete,
+        }
+    }
+}
+
+pub fn start<I: Stream>(
+    depth: usize,
+    name: &dyn crate::lib::std::fmt::Display,
+    count: usize,
+    input: &I,
+) {
+    let ansi_color = ansi_color();
+    let reset = if ansi_color {
+        anstyle::Reset.render().to_string()
+    } else {
+        "".to_owned()
+    };
+    let gutter_style = if ansi_color {
+        anstyle::Style::new().bold()
+    } else {
+        anstyle::Style::new()
+    }
+    .render();
+    let input_style = if ansi_color {
+        anstyle::Style::new().underline()
+    } else {
+        anstyle::Style::new()
+    }
+    .render();
+    let eof_style = if ansi_color {
+        anstyle::Style::new().fg_color(Some(anstyle::AnsiColor::Cyan.into()))
+    } else {
+        anstyle::Style::new()
+    }
+    .render();
+
+    let (call_width, input_width) = column_widths();
+
+    let count = if 0 < count {
+        format!(":{count}")
+    } else {
+        "".to_owned()
+    };
+    let call_column = format!("{:depth$}> {name}{count}", "");
+
+    let eof_offset = input.eof_offset();
+    let offset = input.offset_at(input_width).unwrap_or(eof_offset);
+    let (_, slice) = input.next_slice(offset);
+
+    // The debug version of `slice` might be wider, either due to rendering one byte as two nibbles or
+    // escaping in strings.
+    let mut debug_slice = format!("{:#?}", slice);
+    let (debug_slice, eof) = if let Some(debug_offset) = debug_slice
+        .char_indices()
+        .enumerate()
+        .find_map(|(pos, (offset, _))| (input_width <= pos).then(|| offset))
+    {
+        debug_slice.truncate(debug_offset);
+        let eof = "";
+        (debug_slice, eof)
+    } else {
+        let eof = if debug_slice.chars().count() < input_width {
+            "∅"
+        } else {
+            ""
+        };
+        (debug_slice, eof)
+    };
+
+    let writer = std::io::stderr();
+    let mut writer = writer.lock();
+    let _ = writeln!(writer, "{call_column:call_width$} {gutter_style}|{reset} {input_style}{debug_slice}{eof_style}{eof}{reset}");
+}
+
+pub fn end(
+    depth: usize,
+    name: &dyn crate::lib::std::fmt::Display,
+    count: usize,
+    consumed: Option<usize>,
+    severity: Severity,
+) {
+    let ansi_color = ansi_color();
+    let reset = if ansi_color {
+        anstyle::Reset.render().to_string()
+    } else {
+        "".to_owned()
+    };
+    let gutter_style = if ansi_color {
+        anstyle::Style::new().bold()
+    } else {
+        anstyle::Style::new()
+    }
+    .render();
+
+    let (call_width, _) = column_widths();
+
+    let count = if 0 < count {
+        format!(":{count}")
+    } else {
+        "".to_owned()
+    };
+    let call_column = format!("{:depth$}< {name}{count}", "");
+
+    let (mut status_style, status) = match severity {
+        Severity::Success => {
+            let style = anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Green.into()))
+                .render();
+            let status = format!("+{}", consumed.unwrap_or_default());
+            (style, status)
+        }
+        Severity::Backtrack => (
+            anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Yellow.into()))
+                .render(),
+            "backtrack".to_owned(),
+        ),
+        Severity::Cut => (
+            anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Red.into()))
+                .render(),
+            "cut".to_owned(),
+        ),
+        Severity::Incomplete => (
+            anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Red.into()))
+                .render(),
+            "incomplete".to_owned(),
+        ),
+    };
+    if !ansi_color {
+        status_style = anstyle::Style::new().render();
+    }
+
+    let writer = std::io::stderr();
+    let mut writer = writer.lock();
+    let _ = writeln!(
+        writer,
+        "{status_style}{call_column:call_width$}{reset} {gutter_style}|{reset} {status_style}{status}{reset}"
+    );
+}
+
+pub fn result(depth: usize, name: &dyn crate::lib::std::fmt::Display, severity: Severity) {
+    let ansi_color = ansi_color();
+    let reset = if ansi_color {
+        anstyle::Reset.render().to_string()
+    } else {
+        "".to_owned()
+    };
+    let gutter_style = if ansi_color {
+        anstyle::Style::new().bold()
+    } else {
+        anstyle::Style::new()
+    }
+    .render();
+
+    let (call_width, _) = column_widths();
+
+    let call_column = format!("{:depth$}| {name}", "");
+
+    let (mut status_style, status) = match severity {
+        Severity::Success => (
+            anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Green.into()))
+                .render(),
+            "",
+        ),
+        Severity::Backtrack => (
+            anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Yellow.into()))
+                .render(),
+            "backtrack",
+        ),
+        Severity::Cut => (
+            anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Red.into()))
+                .render(),
+            "cut",
+        ),
+        Severity::Incomplete => (
+            anstyle::Style::new()
+                .fg_color(Some(anstyle::AnsiColor::Red.into()))
+                .render(),
+            "incomplete",
+        ),
+    };
+    if !ansi_color {
+        status_style = anstyle::Style::new().render();
+    }
+
+    let writer = std::io::stderr();
+    let mut writer = writer.lock();
+    let _ = writeln!(
+        writer,
+        "{status_style}{call_column:call_width$}{reset} {gutter_style}|{reset} {status_style}{status}{reset}"
+    );
+}
+
+fn ansi_color() -> bool {
+    concolor::get(concolor::Stream::Stderr).ansi_color()
+}
+
+fn column_widths() -> (usize, usize) {
+    let term_width = term_width();
+
+    let min_call_width = 40;
+    let min_input_width = 20;
+    let decor_width = 3;
+    let extra_width = term_width
+        .checked_sub(min_call_width + min_input_width + decor_width)
+        .unwrap_or_default();
+    let call_width = min_call_width + 2 * extra_width / 3;
+    let input_width = min_input_width + extra_width / 3;
+
+    (call_width, input_width)
+}
+
+fn term_width() -> usize {
+    columns_env().or_else(query_width).unwrap_or(80)
+}
+
+fn query_width() -> Option<usize> {
+    use is_terminal::IsTerminal;
+    if std::io::stderr().is_terminal() {
+        terminal_size::terminal_size().map(|(w, _h)| w.0.into())
+    } else {
+        None
+    }
+}
+
+fn columns_env() -> Option<usize> {
+    std::env::var("COLUMNS")
+        .ok()
+        .and_then(|c| c.parse::<usize>().ok())
+}
diff --git a/vendor/winnow/src/trace/mod.rs b/vendor/winnow/src/trace/mod.rs
new file mode 100644
index 000000000..59dafba8e
--- /dev/null
+++ b/vendor/winnow/src/trace/mod.rs
@@ -0,0 +1,118 @@
+//! Parser execution tracing
+//!
+//! By default, nothing happens and tracing gets compiled away as a no-op.  To enable tracing, use
+//! `--features debug`.
+//!
+//! # Example
+//!
+//!![Trace output from string example](https://raw.githubusercontent.com/winnow-rs/winnow/main/assets/trace.svg "Example output")
+
+#[cfg(feature = "debug")]
+mod internals;
+
+use crate::error::ErrMode;
+use crate::stream::Stream;
+use crate::Parser;
+
+#[cfg(all(feature = "debug", not(feature = "std")))]
+compile_error!("`debug` requires `std`");
+
+/// Trace the execution of the parser
+///
+/// Note that [`Parser::context` also provides high level trace information.
+///
+/// See [`trace` module][self] for more details.
+///
+/// # Example
+///
+/// ```rust
+/// # use winnow::{error::ErrMode, error::{Error, ErrorKind}, error::Needed, IResult};
+/// # use winnow::bytes::take_while_m_n;
+/// # use winnow::stream::AsChar;
+/// # use winnow::prelude::*;
+/// use winnow::trace::trace;
+///
+/// fn short_alpha(s: &[u8]) -> IResult<&[u8], &[u8]> {
+///   trace("short_alpha",
+///     take_while_m_n(3, 6, AsChar::is_alpha)
+///   ).parse_next(s)
+/// }
+///
+/// assert_eq!(short_alpha(b"latin123"), Ok((&b"123"[..], &b"latin"[..])));
+/// assert_eq!(short_alpha(b"lengthy"), Ok((&b"y"[..], &b"length"[..])));
+/// assert_eq!(short_alpha(b"latin"), Ok((&b""[..], &b"latin"[..])));
+/// assert_eq!(short_alpha(b"ed"), Err(ErrMode::Backtrack(Error::new(&b"ed"[..], ErrorKind::Slice))));
+/// assert_eq!(short_alpha(b"12345"), Err(ErrMode::Backtrack(Error::new(&b"12345"[..], ErrorKind::Slice))));
+/// ```
+#[cfg_attr(not(feature = "debug"), allow(unused_variables))]
+#[cfg_attr(not(feature = "debug"), allow(unused_mut))]
+pub fn trace<I: Stream, O, E>(
+    name: impl crate::lib::std::fmt::Display,
+    mut parser: impl Parser<I, O, E>,
+) -> impl Parser<I, O, E> {
+    #[cfg(feature = "debug")]
+    {
+        let mut call_count = 0;
+        move |i: I| {
+            let depth = internals::Depth::new();
+            let original = i.clone();
+            internals::start(*depth, &name, call_count, &original);
+
+            let res = parser.parse_next(i);
+
+            let consumed = res.as_ref().ok().map(|(i, _)| {
+                if i.eof_offset() == 0 {
+                    // Sometimes, an unrelated empty string is returned which can break `offset_to`
+                    original.eof_offset()
+                } else {
+                    original.offset_to(i)
+                }
+            });
+            let severity = internals::Severity::with_result(&res);
+            internals::end(*depth, &name, call_count, consumed, severity);
+            call_count += 1;
+
+            res
+        }
+    }
+    #[cfg(not(feature = "debug"))]
+    {
+        parser
+    }
+}
+
+#[cfg_attr(not(feature = "debug"), allow(unused_variables))]
+pub(crate) fn trace_result<T, E>(
+    name: impl crate::lib::std::fmt::Display,
+    res: &Result<T, ErrMode<E>>,
+) {
+    #[cfg(feature = "debug")]
+    {
+        let depth = internals::Depth::existing();
+        let severity = internals::Severity::with_result(res);
+        internals::result(*depth, &name, severity);
+    }
+}
+
+#[test]
+#[cfg(feature = "std")]
+#[cfg_attr(miri, ignore)]
+#[cfg(unix)]
+#[cfg(feature = "debug")]
+fn example() {
+    use term_transcript::{test::TestConfig, ShellOptions};
+
+    let path = snapbox::cmd::compile_example("string", ["--features=debug"]).unwrap();
+
+    let current_dir = path.parent().unwrap();
+    let cmd = path.file_name().unwrap();
+    // HACK: term_transcript doesn't allow non-UTF8 paths
+    let cmd = format!("./{}", cmd.to_string_lossy());
+
+    TestConfig::new(
+        ShellOptions::default()
+            .with_current_dir(current_dir)
+            .with_env("CLICOLOR_FORCE", "1"),
+    )
+    .test("assets/trace.svg", [cmd.as_str()]);
+}