Deleted vendor folder

7 files changed, 0 insertions, 7399 deletions

diff --git a/vendor/serde/src/de/format.rs b/vendor/serde/src/de/format.rs
deleted file mode 100644
index 9053cc0..0000000
--- a/vendor/serde/src/de/format.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use crate::lib::fmt::{self, Write};
-use crate::lib::str;
-
-pub(super) struct Buf<'a> {
-    bytes: &'a mut [u8],
-    offset: usize,
-}
-
-impl<'a> Buf<'a> {
-    pub fn new(bytes: &'a mut [u8]) -> Self {
-        Buf { bytes, offset: 0 }
-    }
-
-    pub fn as_str(&self) -> &str {
-        let slice = &self.bytes[..self.offset];
-        unsafe { str::from_utf8_unchecked(slice) }
-    }
-}
-
-impl<'a> Write for Buf<'a> {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        if self.offset + s.len() > self.bytes.len() {
-            Err(fmt::Error)
-        } else {
-            self.bytes[self.offset..self.offset + s.len()].copy_from_slice(s.as_bytes());
-            self.offset += s.len();
-            Ok(())
-        }
-    }
-}
diff --git a/vendor/serde/src/de/ignored_any.rs b/vendor/serde/src/de/ignored_any.rs
deleted file mode 100644
index 2360a17..0000000
--- a/vendor/serde/src/de/ignored_any.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-use crate::lib::*;
-
-use crate::de::{
-    Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor,
-};
-
-/// An efficient way of discarding data from a deserializer.
-///
-/// Think of this like `serde_json::Value` in that it can be deserialized from
-/// any type, except that it does not store any information about the data that
-/// gets deserialized.
-///
-/// ```edition2021
-/// use serde::de::{
-///     self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,
-/// };
-/// use std::fmt;
-/// use std::marker::PhantomData;
-///
-/// /// A seed that can be used to deserialize only the `n`th element of a sequence
-/// /// while efficiently discarding elements of any type before or after index `n`.
-/// ///
-/// /// For example to deserialize only the element at index 3:
-/// ///
-/// /// ```
-/// /// NthElement::new(3).deserialize(deserializer)
-/// /// ```
-/// pub struct NthElement<T> {
-///     n: usize,
-///     marker: PhantomData<T>,
-/// }
-///
-/// impl<T> NthElement<T> {
-///     pub fn new(n: usize) -> Self {
-///         NthElement {
-///             n: n,
-///             marker: PhantomData,
-///         }
-///     }
-/// }
-///
-/// impl<'de, T> Visitor<'de> for NthElement<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     type Value = T;
-///
-///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(
-///             formatter,
-///             "a sequence in which we care about element {}",
-///             self.n
-///         )
-///     }
-///
-///     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-///     where
-///         A: SeqAccess<'de>,
-///     {
-///         // Skip over the first `n` elements.
-///         for i in 0..self.n {
-///             // It is an error if the sequence ends before we get to element `n`.
-///             if seq.next_element::<IgnoredAny>()?.is_none() {
-///                 return Err(de::Error::invalid_length(i, &self));
-///             }
-///         }
-///
-///         // Deserialize the one we care about.
-///         let nth = match seq.next_element()? {
-///             Some(nth) => nth,
-///             None => {
-///                 return Err(de::Error::invalid_length(self.n, &self));
-///             }
-///         };
-///
-///         // Skip over any remaining elements in the sequence after `n`.
-///         while let Some(IgnoredAny) = seq.next_element()? {
-///             // ignore
-///         }
-///
-///         Ok(nth)
-///     }
-/// }
-///
-/// impl<'de, T> DeserializeSeed<'de> for NthElement<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     type Value = T;
-///
-///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-///     where
-///         D: Deserializer<'de>,
-///     {
-///         deserializer.deserialize_seq(self)
-///     }
-/// }
-///
-/// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
-/// # where
-/// #     D: Deserializer<'de>,
-/// # {
-/// // Deserialize only the sequence element at index 3 from this deserializer.
-/// // The element at index 3 is required to be a string. Elements before and
-/// // after index 3 are allowed to be of any type.
-/// let s: String = NthElement::new(3).deserialize(deserializer)?;
-/// #     Ok(())
-/// # }
-/// ```
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct IgnoredAny;
-
-impl<'de> Visitor<'de> for IgnoredAny {
-    type Value = IgnoredAny;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("anything at all")
-    }
-
-    #[inline]
-    fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_i64<E>(self, x: i64) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
-        let _ = x;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let _ = s;
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_none<E>(self) -> Result<Self::Value, E> {
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        IgnoredAny::deserialize(deserializer)
-    }
-
-    #[inline]
-    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        IgnoredAny::deserialize(deserializer)
-    }
-
-    #[inline]
-    fn visit_unit<E>(self) -> Result<Self::Value, E> {
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        while let Some(IgnoredAny) = tri!(seq.next_element()) {
-            // Gobble
-        }
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-    where
-        A: MapAccess<'de>,
-    {
-        while let Some((IgnoredAny, IgnoredAny)) = tri!(map.next_entry()) {
-            // Gobble
-        }
-        Ok(IgnoredAny)
-    }
-
-    #[inline]
-    fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let _ = bytes;
-        Ok(IgnoredAny)
-    }
-
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        tri!(data.variant::<IgnoredAny>()).1.newtype_variant()
-    }
-}
-
-impl<'de> Deserialize<'de> for IgnoredAny {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_ignored_any(IgnoredAny)
-    }
-}
diff --git a/vendor/serde/src/de/impls.rs b/vendor/serde/src/de/impls.rs
deleted file mode 100644
index 413c997..0000000
--- a/vendor/serde/src/de/impls.rs
+++ /dev/null
@@ -1,3071 +0,0 @@
-use crate::lib::*;
-
-use crate::de::{
-    Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, Unexpected, VariantAccess,
-    Visitor,
-};
-
-use crate::seed::InPlaceSeed;
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-use crate::de::size_hint;
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct UnitVisitor;
-
-impl<'de> Visitor<'de> for UnitVisitor {
-    type Value = ();
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("unit")
-    }
-
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(())
-    }
-}
-
-impl<'de> Deserialize<'de> for () {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_unit(UnitVisitor)
-    }
-}
-
-#[cfg(feature = "unstable")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
-impl<'de> Deserialize<'de> for ! {
-    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Err(Error::custom("cannot deserialize `!`"))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct BoolVisitor;
-
-impl<'de> Visitor<'de> for BoolVisitor {
-    type Value = bool;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a boolean")
-    }
-
-    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-}
-
-impl<'de> Deserialize<'de> for bool {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_bool(BoolVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! impl_deserialize_num {
-    ($primitive:ident, $nonzero:ident $(cfg($($cfg:tt)*))*, $deserialize:ident $($method:ident!($($val:ident : $visit:ident)*);)*) => {
-        impl_deserialize_num!($primitive, $deserialize $($method!($($val : $visit)*);)*);
-
-        $(#[cfg($($cfg)*)])*
-        impl<'de> Deserialize<'de> for num::$nonzero {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct NonZeroVisitor;
-
-                impl<'de> Visitor<'de> for NonZeroVisitor {
-                    type Value = num::$nonzero;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str(concat!("a nonzero ", stringify!($primitive)))
-                    }
-
-                    $($($method!(nonzero $primitive $val : $visit);)*)*
-                }
-
-                deserializer.$deserialize(NonZeroVisitor)
-            }
-        }
-    };
-
-    ($primitive:ident, $deserialize:ident $($method:ident!($($val:ident : $visit:ident)*);)*) => {
-        impl<'de> Deserialize<'de> for $primitive {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct PrimitiveVisitor;
-
-                impl<'de> Visitor<'de> for PrimitiveVisitor {
-                    type Value = $primitive;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str(stringify!($primitive))
-                    }
-
-                    $($($method!($val : $visit);)*)*
-                }
-
-                deserializer.$deserialize(PrimitiveVisitor)
-            }
-        }
-    };
-}
-
-macro_rules! num_self {
-    ($ty:ident : $visit:ident) => {
-        #[inline]
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(v)
-        }
-    };
-
-    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if let Some(nonzero) = Self::Value::new(v) {
-                Ok(nonzero)
-            } else {
-                Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
-            }
-        }
-    };
-}
-
-macro_rules! num_as_self {
-    ($ty:ident : $visit:ident) => {
-        #[inline]
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            Ok(v as Self::Value)
-        }
-    };
-
-    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if let Some(nonzero) = Self::Value::new(v as $primitive) {
-                Ok(nonzero)
-            } else {
-                Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
-            }
-        }
-    };
-}
-
-macro_rules! num_as_copysign_self {
-    ($ty:ident : $visit:ident) => {
-        #[inline]
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            #[cfg(any(no_float_copysign, not(feature = "std")))]
-            {
-                Ok(v as Self::Value)
-            }
-
-            #[cfg(all(not(no_float_copysign), feature = "std"))]
-            {
-                // Preserve sign of NaN. The `as` produces a nondeterministic sign.
-                let sign = if v.is_sign_positive() { 1.0 } else { -1.0 };
-                Ok((v as Self::Value).copysign(sign))
-            }
-        }
-    };
-}
-
-macro_rules! int_to_int {
-    ($ty:ident : $visit:ident) => {
-        #[inline]
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if Self::Value::min_value() as i64 <= v as i64
-                && v as i64 <= Self::Value::max_value() as i64
-            {
-                Ok(v as Self::Value)
-            } else {
-                Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
-            }
-        }
-    };
-
-    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if $primitive::min_value() as i64 <= v as i64
-                && v as i64 <= $primitive::max_value() as i64
-            {
-                if let Some(nonzero) = Self::Value::new(v as $primitive) {
-                    return Ok(nonzero);
-                }
-            }
-            Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
-        }
-    };
-}
-
-macro_rules! int_to_uint {
-    ($ty:ident : $visit:ident) => {
-        #[inline]
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if 0 <= v && v as u64 <= Self::Value::max_value() as u64 {
-                Ok(v as Self::Value)
-            } else {
-                Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
-            }
-        }
-    };
-
-    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if 0 < v && v as u64 <= $primitive::max_value() as u64 {
-                if let Some(nonzero) = Self::Value::new(v as $primitive) {
-                    return Ok(nonzero);
-                }
-            }
-            Err(Error::invalid_value(Unexpected::Signed(v as i64), &self))
-        }
-    };
-}
-
-macro_rules! uint_to_self {
-    ($ty:ident : $visit:ident) => {
-        #[inline]
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if v as u64 <= Self::Value::max_value() as u64 {
-                Ok(v as Self::Value)
-            } else {
-                Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
-            }
-        }
-    };
-
-    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if v as u64 <= $primitive::max_value() as u64 {
-                if let Some(nonzero) = Self::Value::new(v as $primitive) {
-                    return Ok(nonzero);
-                }
-            }
-            Err(Error::invalid_value(Unexpected::Unsigned(v as u64), &self))
-        }
-    };
-}
-
-impl_deserialize_num! {
-    i8, NonZeroI8 cfg(not(no_num_nonzero_signed)), deserialize_i8
-    num_self!(i8:visit_i8);
-    int_to_int!(i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    i16, NonZeroI16 cfg(not(no_num_nonzero_signed)), deserialize_i16
-    num_self!(i16:visit_i16);
-    num_as_self!(i8:visit_i8);
-    int_to_int!(i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    i32, NonZeroI32 cfg(not(no_num_nonzero_signed)), deserialize_i32
-    num_self!(i32:visit_i32);
-    num_as_self!(i8:visit_i8 i16:visit_i16);
-    int_to_int!(i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    i64, NonZeroI64 cfg(not(no_num_nonzero_signed)), deserialize_i64
-    num_self!(i64:visit_i64);
-    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    isize, NonZeroIsize cfg(not(no_num_nonzero_signed)), deserialize_i64
-    num_as_self!(i8:visit_i8 i16:visit_i16);
-    int_to_int!(i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u8, NonZeroU8, deserialize_u8
-    num_self!(u8:visit_u8);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u16, NonZeroU16, deserialize_u16
-    num_self!(u16:visit_u16);
-    num_as_self!(u8:visit_u8);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u32, NonZeroU32, deserialize_u32
-    num_self!(u32:visit_u32);
-    num_as_self!(u8:visit_u8 u16:visit_u16);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    u64, NonZeroU64, deserialize_u64
-    num_self!(u64:visit_u64);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-}
-
-impl_deserialize_num! {
-    usize, NonZeroUsize, deserialize_u64
-    num_as_self!(u8:visit_u8 u16:visit_u16);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    uint_to_self!(u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    f32, deserialize_f32
-    num_self!(f32:visit_f32);
-    num_as_copysign_self!(f64:visit_f64);
-    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-impl_deserialize_num! {
-    f64, deserialize_f64
-    num_self!(f64:visit_f64);
-    num_as_copysign_self!(f32:visit_f32);
-    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-}
-
-macro_rules! num_128 {
-    ($ty:ident : $visit:ident) => {
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if v as i128 >= Self::Value::min_value() as i128
-                && v as u128 <= Self::Value::max_value() as u128
-            {
-                Ok(v as Self::Value)
-            } else {
-                Err(Error::invalid_value(
-                    Unexpected::Other(stringify!($ty)),
-                    &self,
-                ))
-            }
-        }
-    };
-
-    (nonzero $primitive:ident $ty:ident : $visit:ident) => {
-        fn $visit<E>(self, v: $ty) -> Result<Self::Value, E>
-        where
-            E: Error,
-        {
-            if v as i128 >= $primitive::min_value() as i128
-                && v as u128 <= $primitive::max_value() as u128
-            {
-                if let Some(nonzero) = Self::Value::new(v as $primitive) {
-                    Ok(nonzero)
-                } else {
-                    Err(Error::invalid_value(Unexpected::Unsigned(0), &self))
-                }
-            } else {
-                Err(Error::invalid_value(
-                    Unexpected::Other(stringify!($ty)),
-                    &self,
-                ))
-            }
-        }
-    };
-}
-
-impl_deserialize_num! {
-    i128, NonZeroI128 cfg(not(no_num_nonzero_signed)), deserialize_i128
-    num_self!(i128:visit_i128);
-    num_as_self!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-    num_128!(u128:visit_u128);
-}
-
-impl_deserialize_num! {
-    u128, NonZeroU128, deserialize_u128
-    num_self!(u128:visit_u128);
-    num_as_self!(u8:visit_u8 u16:visit_u16 u32:visit_u32 u64:visit_u64);
-    int_to_uint!(i8:visit_i8 i16:visit_i16 i32:visit_i32 i64:visit_i64);
-    num_128!(i128:visit_i128);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct CharVisitor;
-
-impl<'de> Visitor<'de> for CharVisitor {
-    type Value = char;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a character")
-    }
-
-    #[inline]
-    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-
-    #[inline]
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let mut iter = v.chars();
-        match (iter.next(), iter.next()) {
-            (Some(c), None) => Ok(c),
-            _ => Err(Error::invalid_value(Unexpected::Str(v), &self)),
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for char {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_char(CharVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-struct StringVisitor;
-#[cfg(any(feature = "std", feature = "alloc"))]
-struct StringInPlaceVisitor<'a>(&'a mut String);
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de> Visitor<'de> for StringVisitor {
-    type Value = String;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v.to_owned())
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match str::from_utf8(v) {
-            Ok(s) => Ok(s.to_owned()),
-            Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-        }
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match String::from_utf8(v) {
-            Ok(s) => Ok(s),
-            Err(e) => Err(Error::invalid_value(
-                Unexpected::Bytes(&e.into_bytes()),
-                &self,
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> {
-    type Value = ();
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.0.clear();
-        self.0.push_str(v);
-        Ok(())
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        *self.0 = v;
-        Ok(())
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match str::from_utf8(v) {
-            Ok(s) => {
-                self.0.clear();
-                self.0.push_str(s);
-                Ok(())
-            }
-            Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
-        }
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        match String::from_utf8(v) {
-            Ok(s) => {
-                *self.0 = s;
-                Ok(())
-            }
-            Err(e) => Err(Error::invalid_value(
-                Unexpected::Bytes(&e.into_bytes()),
-                &self,
-            )),
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de> Deserialize<'de> for String {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_string(StringVisitor)
-    }
-
-    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_string(StringInPlaceVisitor(place))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct StrVisitor;
-
-impl<'a> Visitor<'a> for StrVisitor {
-    type Value = &'a str;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a borrowed string")
-    }
-
-    fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v) // so easy
-    }
-
-    fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        str::from_utf8(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
-    }
-}
-
-impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_str(StrVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct BytesVisitor;
-
-impl<'a> Visitor<'a> for BytesVisitor {
-    type Value = &'a [u8];
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a borrowed byte array")
-    }
-
-    fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v)
-    }
-
-    fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v.as_bytes())
-    }
-}
-
-impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_bytes(BytesVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
-struct CStringVisitor;
-
-#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
-impl<'de> Visitor<'de> for CStringVisitor {
-    type Value = CString;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("byte array")
-    }
-
-    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        let capacity = size_hint::cautious::<u8>(seq.size_hint());
-        let mut values = Vec::<u8>::with_capacity(capacity);
-
-        while let Some(value) = tri!(seq.next_element()) {
-            values.push(value);
-        }
-
-        CString::new(values).map_err(Error::custom)
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        CString::new(v).map_err(Error::custom)
-    }
-}
-
-#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de> Deserialize<'de> for CString {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_byte_buf(CStringVisitor)
-    }
-}
-
-macro_rules! forwarded_impl {
-    (
-        $(#[$attr:meta])*
-        ($($id:ident),*), $ty:ty, $func:expr
-    ) => {
-        $(#[$attr])*
-        impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                Deserialize::deserialize(deserializer).map($func)
-            }
-        }
-    }
-}
-
-forwarded_impl! {
-    #[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    (), Box<CStr>, CString::into_boxed_c_str
-}
-
-forwarded_impl! {
-    (T), Reverse<T>, Reverse
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct OptionVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<'de, T> Visitor<'de> for OptionVisitor<T>
-where
-    T: Deserialize<'de>,
-{
-    type Value = Option<T>;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("option")
-    }
-
-    #[inline]
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(None)
-    }
-
-    #[inline]
-    fn visit_none<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(None)
-    }
-
-    #[inline]
-    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize(deserializer).map(Some)
-    }
-
-    fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()>
-    where
-        D: Deserializer<'de>,
-    {
-        Ok(T::deserialize(deserializer).ok())
-    }
-}
-
-impl<'de, T> Deserialize<'de> for Option<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_option(OptionVisitor {
-            marker: PhantomData,
-        })
-    }
-
-    // The Some variant's repr is opaque, so we can't play cute tricks with its
-    // tag to have deserialize_in_place build the content in place unconditionally.
-    //
-    // FIXME: investigate whether branching on the old value being Some to
-    // deserialize_in_place the value is profitable (probably data-dependent?)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct PhantomDataVisitor<T: ?Sized> {
-    marker: PhantomData<T>,
-}
-
-impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
-    type Value = PhantomData<T>;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("unit")
-    }
-
-    #[inline]
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(PhantomData)
-    }
-}
-
-impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let visitor = PhantomDataVisitor {
-            marker: PhantomData,
-        };
-        deserializer.deserialize_unit_struct("PhantomData", visitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! seq_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
-        $access:ident,
-        $clear:expr,
-        $with_capacity:expr,
-        $reserve:expr,
-        $insert:expr
-    ) => {
-        $(#[$attr])*
-        impl<'de, T $(, $typaram)*> Deserialize<'de> for $ty<T $(, $typaram)*>
-        where
-            T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
-            $($typaram: $bound1 $(+ $bound2)*,)*
-        {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct SeqVisitor<T $(, $typaram)*> {
-                    marker: PhantomData<$ty<T $(, $typaram)*>>,
-                }
-
-                impl<'de, T $(, $typaram)*> Visitor<'de> for SeqVisitor<T $(, $typaram)*>
-                where
-                    T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
-                    $($typaram: $bound1 $(+ $bound2)*,)*
-                {
-                    type Value = $ty<T $(, $typaram)*>;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("a sequence")
-                    }
-
-                    #[inline]
-                    fn visit_seq<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
-                    where
-                        A: SeqAccess<'de>,
-                    {
-                        let mut values = $with_capacity;
-
-                        while let Some(value) = tri!($access.next_element()) {
-                            $insert(&mut values, value);
-                        }
-
-                        Ok(values)
-                    }
-                }
-
-                let visitor = SeqVisitor { marker: PhantomData };
-                deserializer.deserialize_seq(visitor)
-            }
-
-            fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct SeqInPlaceVisitor<'a, T: 'a $(, $typaram: 'a)*>(&'a mut $ty<T $(, $typaram)*>);
-
-                impl<'a, 'de, T $(, $typaram)*> Visitor<'de> for SeqInPlaceVisitor<'a, T $(, $typaram)*>
-                where
-                    T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
-                    $($typaram: $bound1 $(+ $bound2)*,)*
-                {
-                    type Value = ();
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("a sequence")
-                    }
-
-                    #[inline]
-                    fn visit_seq<A>(mut self, mut $access: A) -> Result<Self::Value, A::Error>
-                    where
-                        A: SeqAccess<'de>,
-                    {
-                        $clear(&mut self.0);
-                        $reserve(&mut self.0, size_hint::cautious::<T>($access.size_hint()));
-
-                        // FIXME: try to overwrite old values here? (Vec, VecDeque, LinkedList)
-                        while let Some(value) = tri!($access.next_element()) {
-                            $insert(&mut self.0, value);
-                        }
-
-                        Ok(())
-                    }
-                }
-
-                deserializer.deserialize_seq(SeqInPlaceVisitor(place))
-            }
-        }
-    }
-}
-
-// Dummy impl of reserve
-#[cfg(any(feature = "std", feature = "alloc"))]
-fn nop_reserve<T>(_seq: T, _n: usize) {}
-
-seq_impl!(
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    BinaryHeap<T: Ord>,
-    seq,
-    BinaryHeap::clear,
-    BinaryHeap::with_capacity(size_hint::cautious::<T>(seq.size_hint())),
-    BinaryHeap::reserve,
-    BinaryHeap::push
-);
-
-seq_impl!(
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    BTreeSet<T: Eq + Ord>,
-    seq,
-    BTreeSet::clear,
-    BTreeSet::new(),
-    nop_reserve,
-    BTreeSet::insert
-);
-
-seq_impl!(
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    LinkedList<T>,
-    seq,
-    LinkedList::clear,
-    LinkedList::new(),
-    nop_reserve,
-    LinkedList::push_back
-);
-
-seq_impl!(
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    HashSet<T: Eq + Hash, S: BuildHasher + Default>,
-    seq,
-    HashSet::clear,
-    HashSet::with_capacity_and_hasher(size_hint::cautious::<T>(seq.size_hint()), S::default()),
-    HashSet::reserve,
-    HashSet::insert
-);
-
-seq_impl!(
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    VecDeque<T>,
-    seq,
-    VecDeque::clear,
-    VecDeque::with_capacity(size_hint::cautious::<T>(seq.size_hint())),
-    VecDeque::reserve,
-    VecDeque::push_back
-);
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, T> Deserialize<'de> for Vec<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct VecVisitor<T> {
-            marker: PhantomData<T>,
-        }
-
-        impl<'de, T> Visitor<'de> for VecVisitor<T>
-        where
-            T: Deserialize<'de>,
-        {
-            type Value = Vec<T>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a sequence")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let capacity = size_hint::cautious::<T>(seq.size_hint());
-                let mut values = Vec::<T>::with_capacity(capacity);
-
-                while let Some(value) = tri!(seq.next_element()) {
-                    values.push(value);
-                }
-
-                Ok(values)
-            }
-        }
-
-        let visitor = VecVisitor {
-            marker: PhantomData,
-        };
-        deserializer.deserialize_seq(visitor)
-    }
-
-    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec<T>);
-
-        impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
-        where
-            T: Deserialize<'de>,
-        {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("a sequence")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let hint = size_hint::cautious::<T>(seq.size_hint());
-                if let Some(additional) = hint.checked_sub(self.0.len()) {
-                    self.0.reserve(additional);
-                }
-
-                for i in 0..self.0.len() {
-                    let next = {
-                        let next_place = InPlaceSeed(&mut self.0[i]);
-                        tri!(seq.next_element_seed(next_place))
-                    };
-                    if next.is_none() {
-                        self.0.truncate(i);
-                        return Ok(());
-                    }
-                }
-
-                while let Some(value) = tri!(seq.next_element()) {
-                    self.0.push(value);
-                }
-
-                Ok(())
-            }
-        }
-
-        deserializer.deserialize_seq(VecInPlaceVisitor(place))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-struct ArrayVisitor<A> {
-    marker: PhantomData<A>,
-}
-struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
-
-impl<A> ArrayVisitor<A> {
-    fn new() -> Self {
-        ArrayVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
-    type Value = [T; 0];
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("an empty array")
-    }
-
-    #[inline]
-    fn visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        Ok([])
-    }
-}
-
-// Does not require T: Deserialize<'de>.
-impl<'de, T> Deserialize<'de> for [T; 0] {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_tuple(0, ArrayVisitor::<[T; 0]>::new())
-    }
-}
-
-macro_rules! array_impls {
-    ($($len:expr => ($($n:tt)+))+) => {
-        $(
-            impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
-            where
-                T: Deserialize<'de>,
-            {
-                type Value = [T; $len];
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str(concat!("an array of length ", $len))
-                }
-
-                #[inline]
-                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                where
-                    A: SeqAccess<'de>,
-                {
-                    Ok([$(
-                        match tri!(seq.next_element()) {
-                            Some(val) => val,
-                            None => return Err(Error::invalid_length($n, &self)),
-                        }
-                    ),+])
-                }
-            }
-
-            impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; $len]>
-            where
-                T: Deserialize<'de>,
-            {
-                type Value = ();
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str(concat!("an array of length ", $len))
-                }
-
-                #[inline]
-                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                where
-                    A: SeqAccess<'de>,
-                {
-                    let mut fail_idx = None;
-                    for (idx, dest) in self.0[..].iter_mut().enumerate() {
-                        if tri!(seq.next_element_seed(InPlaceSeed(dest))).is_none() {
-                            fail_idx = Some(idx);
-                            break;
-                        }
-                    }
-                    if let Some(idx) = fail_idx {
-                        return Err(Error::invalid_length(idx, &self));
-                    }
-                    Ok(())
-                }
-            }
-
-            impl<'de, T> Deserialize<'de> for [T; $len]
-            where
-                T: Deserialize<'de>,
-            {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    deserializer.deserialize_tuple($len, ArrayVisitor::<[T; $len]>::new())
-                }
-
-                fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    deserializer.deserialize_tuple($len, ArrayInPlaceVisitor(place))
-                }
-            }
-        )+
-    }
-}
-
-array_impls! {
-    1 => (0)
-    2 => (0 1)
-    3 => (0 1 2)
-    4 => (0 1 2 3)
-    5 => (0 1 2 3 4)
-    6 => (0 1 2 3 4 5)
-    7 => (0 1 2 3 4 5 6)
-    8 => (0 1 2 3 4 5 6 7)
-    9 => (0 1 2 3 4 5 6 7 8)
-    10 => (0 1 2 3 4 5 6 7 8 9)
-    11 => (0 1 2 3 4 5 6 7 8 9 10)
-    12 => (0 1 2 3 4 5 6 7 8 9 10 11)
-    13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
-    14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
-    15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
-    16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
-    17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
-    18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
-    19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
-    20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
-    21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
-    22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
-    23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
-    24 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23)
-    25 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
-    26 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25)
-    27 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)
-    28 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27)
-    29 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28)
-    30 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29)
-    31 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
-    32 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! tuple_impls {
-    ($($len:tt => ($($n:tt $name:ident)+))+) => {
-        $(
-            impl<'de, $($name: Deserialize<'de>),+> Deserialize<'de> for ($($name,)+) {
-                #[inline]
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    struct TupleVisitor<$($name,)+> {
-                        marker: PhantomData<($($name,)+)>,
-                    }
-
-                    impl<'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleVisitor<$($name,)+> {
-                        type Value = ($($name,)+);
-
-                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str(concat!("a tuple of size ", $len))
-                        }
-
-                        #[inline]
-                        #[allow(non_snake_case)]
-                        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                        where
-                            A: SeqAccess<'de>,
-                        {
-                            $(
-                                let $name = match tri!(seq.next_element()) {
-                                    Some(value) => value,
-                                    None => return Err(Error::invalid_length($n, &self)),
-                                };
-                            )+
-
-                            Ok(($($name,)+))
-                        }
-                    }
-
-                    deserializer.deserialize_tuple($len, TupleVisitor { marker: PhantomData })
-                }
-
-                #[inline]
-                fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    struct TupleInPlaceVisitor<'a, $($name: 'a,)+>(&'a mut ($($name,)+));
-
-                    impl<'a, 'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleInPlaceVisitor<'a, $($name,)+> {
-                        type Value = ();
-
-                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str(concat!("a tuple of size ", $len))
-                        }
-
-                        #[inline]
-                        #[allow(non_snake_case)]
-                        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-                        where
-                            A: SeqAccess<'de>,
-                        {
-                            $(
-                                if tri!(seq.next_element_seed(InPlaceSeed(&mut (self.0).$n))).is_none() {
-                                    return Err(Error::invalid_length($n, &self));
-                                }
-                            )+
-
-                            Ok(())
-                        }
-                    }
-
-                    deserializer.deserialize_tuple($len, TupleInPlaceVisitor(place))
-                }
-            }
-        )+
-    }
-}
-
-tuple_impls! {
-    1  => (0 T0)
-    2  => (0 T0 1 T1)
-    3  => (0 T0 1 T1 2 T2)
-    4  => (0 T0 1 T1 2 T2 3 T3)
-    5  => (0 T0 1 T1 2 T2 3 T3 4 T4)
-    6  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
-    7  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
-    8  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
-    9  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
-    10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
-    11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
-    12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
-    13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
-    14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
-    15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
-    16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! map_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)*>,
-        $access:ident,
-        $with_capacity:expr,
-    ) => {
-        $(#[$attr])*
-        impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty<K, V $(, $typaram)*>
-        where
-            K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
-            V: Deserialize<'de>,
-            $($typaram: $bound1 $(+ $bound2)*),*
-        {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct MapVisitor<K, V $(, $typaram)*> {
-                    marker: PhantomData<$ty<K, V $(, $typaram)*>>,
-                }
-
-                impl<'de, K, V $(, $typaram)*> Visitor<'de> for MapVisitor<K, V $(, $typaram)*>
-                where
-                    K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
-                    V: Deserialize<'de>,
-                    $($typaram: $bound1 $(+ $bound2)*),*
-                {
-                    type Value = $ty<K, V $(, $typaram)*>;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("a map")
-                    }
-
-                    #[inline]
-                    fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
-                    where
-                        A: MapAccess<'de>,
-                    {
-                        let mut values = $with_capacity;
-
-                        while let Some((key, value)) = tri!($access.next_entry()) {
-                            values.insert(key, value);
-                        }
-
-                        Ok(values)
-                    }
-                }
-
-                let visitor = MapVisitor { marker: PhantomData };
-                deserializer.deserialize_map(visitor)
-            }
-        }
-    }
-}
-
-map_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    BTreeMap<K: Ord, V>,
-    map,
-    BTreeMap::new(),
-}
-
-map_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
-    map,
-    HashMap::with_capacity_and_hasher(size_hint::cautious::<(K, V)>(map.size_hint()), S::default()),
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! parse_ip_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ty, $expecting:expr, $size:tt
-    ) => {
-        $(#[$attr])*
-        impl<'de> Deserialize<'de> for $ty {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                if deserializer.is_human_readable() {
-                    deserializer.deserialize_str(FromStrVisitor::new($expecting))
-                } else {
-                    <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
-                }
-            }
-        }
-    };
-}
-
-#[cfg(feature = "std")]
-macro_rules! variant_identifier {
-    (
-        $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*)
-        $expecting_message:expr,
-        $variants_name:ident
-    ) => {
-        enum $name_kind {
-            $($variant),*
-        }
-
-        static $variants_name: &[&str] = &[$(stringify!($variant)),*];
-
-        impl<'de> Deserialize<'de> for $name_kind {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct KindVisitor;
-
-                impl<'de> Visitor<'de> for KindVisitor {
-                    type Value = $name_kind;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str($expecting_message)
-                    }
-
-                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            $(
-                                $index => Ok($name_kind :: $variant),
-                            )*
-                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self),),
-                        }
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            $(
-                                stringify!($variant) => Ok($name_kind :: $variant),
-                            )*
-                            _ => Err(Error::unknown_variant(value, $variants_name)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            $(
-                                $bytes => Ok($name_kind :: $variant),
-                            )*
-                            _ => {
-                                match str::from_utf8(value) {
-                                    Ok(value) => Err(Error::unknown_variant(value, $variants_name)),
-                                    Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
-                                }
-                            }
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(KindVisitor)
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-macro_rules! deserialize_enum {
-    (
-        $name:ident $name_kind:ident ($($variant:ident; $bytes:expr; $index:expr),*)
-        $expecting_message:expr,
-        $deserializer:expr
-    ) => {
-        variant_identifier! {
-            $name_kind ($($variant; $bytes; $index),*)
-            $expecting_message,
-            VARIANTS
-        }
-
-        struct EnumVisitor;
-        impl<'de> Visitor<'de> for EnumVisitor {
-            type Value = $name;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str(concat!("a ", stringify!($name)))
-            }
-
-
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                match tri!(data.variant()) {
-                    $(
-                        ($name_kind :: $variant, v) => v.newtype_variant().map($name :: $variant),
-                    )*
-                }
-            }
-        }
-        $deserializer.deserialize_enum(stringify!($name), VARIANTS, EnumVisitor)
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de> Deserialize<'de> for net::IpAddr {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        if deserializer.is_human_readable() {
-            deserializer.deserialize_str(FromStrVisitor::new("IP address"))
-        } else {
-            use crate::lib::net::IpAddr;
-            deserialize_enum! {
-                IpAddr IpAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
-                "`V4` or `V6`",
-                deserializer
-            }
-        }
-    }
-}
-
-parse_ip_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    net::Ipv4Addr, "IPv4 address", 4
-}
-
-parse_ip_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    net::Ipv6Addr, "IPv6 address", 16
-}
-
-macro_rules! parse_socket_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ty, $expecting:tt,
-        $new:expr,
-    ) => {
-        $(#[$attr])*
-        impl<'de> Deserialize<'de> for $ty {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                if deserializer.is_human_readable() {
-                    deserializer.deserialize_str(FromStrVisitor::new($expecting))
-                } else {
-                    <(_, u16)>::deserialize(deserializer).map($new)
-                }
-            }
-        }
-    };
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de> Deserialize<'de> for net::SocketAddr {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        if deserializer.is_human_readable() {
-            deserializer.deserialize_str(FromStrVisitor::new("socket address"))
-        } else {
-            use crate::lib::net::SocketAddr;
-            deserialize_enum! {
-                SocketAddr SocketAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
-                "`V4` or `V6`",
-                deserializer
-            }
-        }
-    }
-}
-
-parse_socket_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    net::SocketAddrV4, "IPv4 socket address",
-    |(ip, port)| net::SocketAddrV4::new(ip, port),
-}
-
-parse_socket_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    net::SocketAddrV6, "IPv6 socket address",
-    |(ip, port)| net::SocketAddrV6::new(ip, port, 0, 0),
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-struct PathVisitor;
-
-#[cfg(feature = "std")]
-impl<'a> Visitor<'a> for PathVisitor {
-    type Value = &'a Path;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a borrowed path")
-    }
-
-    fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(v.as_ref())
-    }
-
-    fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        str::from_utf8(v)
-            .map(AsRef::as_ref)
-            .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_str(PathVisitor)
-    }
-}
-
-#[cfg(feature = "std")]
-struct PathBufVisitor;
-
-#[cfg(feature = "std")]
-impl<'de> Visitor<'de> for PathBufVisitor {
-    type Value = PathBuf;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("path string")
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(From::from(v))
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Ok(From::from(v))
-    }
-
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        str::from_utf8(v)
-            .map(From::from)
-            .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
-    }
-
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        String::from_utf8(v)
-            .map(From::from)
-            .map_err(|e| Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self))
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de> Deserialize<'de> for PathBuf {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_string(PathBufVisitor)
-    }
-}
-
-forwarded_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    (), Box<Path>, PathBuf::into_boxed_path
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// If this were outside of the serde crate, it would just use:
-//
-//    #[derive(Deserialize)]
-//    #[serde(variant_identifier)]
-#[cfg(all(feature = "std", any(unix, windows)))]
-variant_identifier! {
-    OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
-    "`Unix` or `Windows`",
-    OSSTR_VARIANTS
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-struct OsStringVisitor;
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-impl<'de> Visitor<'de> for OsStringVisitor {
-    type Value = OsString;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("os string")
-    }
-
-    #[cfg(unix)]
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        use std::os::unix::ffi::OsStringExt;
-
-        match tri!(data.variant()) {
-            (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec),
-            (OsStringKind::Windows, _) => Err(Error::custom(
-                "cannot deserialize Windows OS string on Unix",
-            )),
-        }
-    }
-
-    #[cfg(windows)]
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        use std::os::windows::ffi::OsStringExt;
-
-        match tri!(data.variant()) {
-            (OsStringKind::Windows, v) => v
-                .newtype_variant::<Vec<u16>>()
-                .map(|vec| OsString::from_wide(&vec)),
-            (OsStringKind::Unix, _) => Err(Error::custom(
-                "cannot deserialize Unix OS string on Windows",
-            )),
-        }
-    }
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
-impl<'de> Deserialize<'de> for OsString {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-forwarded_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    (T), Box<T>, Box::new
-}
-
-forwarded_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    (T), Box<[T]>, Vec::into_boxed_slice
-}
-
-forwarded_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    (), Box<str>, String::into_boxed_str
-}
-
-forwarded_impl! {
-    #[cfg(all(feature = "std", any(unix, windows)))]
-    #[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
-    (), Box<OsStr>, OsString::into_boxed_os_str
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
-where
-    T: ToOwned,
-    T::Owned: Deserialize<'de>,
-{
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::Owned::deserialize(deserializer).map(Cow::Owned)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
-/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
-///
-/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-#[cfg_attr(
-    doc_cfg,
-    doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
-)]
-impl<'de, T: ?Sized> Deserialize<'de> for RcWeak<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        tri!(Option::<T>::deserialize(deserializer));
-        Ok(RcWeak::new())
-    }
-}
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
-/// `Weak<T>` has a reference count of 0 and cannot be upgraded.
-///
-/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-#[cfg_attr(
-    doc_cfg,
-    doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
-)]
-impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        tri!(Option::<T>::deserialize(deserializer));
-        Ok(ArcWeak::new())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! box_forwarded_impl {
-    (
-        $(#[$attr:meta])*
-        $t:ident
-    ) => {
-        $(#[$attr])*
-        impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
-        where
-            Box<T>: Deserialize<'de>,
-        {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                Box::deserialize(deserializer).map(Into::into)
-            }
-        }
-    };
-}
-
-box_forwarded_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Deserializing a data structure containing `Rc` will not attempt to
-    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
-    /// will end up with a strong count of 1.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-    #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
-    Rc
-}
-
-box_forwarded_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Deserializing a data structure containing `Arc` will not attempt to
-    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
-    /// will end up with a strong count of 1.
-    ///
-    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
-    #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-    #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
-    Arc
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, T> Deserialize<'de> for Cell<T>
-where
-    T: Deserialize<'de> + Copy,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize(deserializer).map(Cell::new)
-    }
-}
-
-forwarded_impl! {
-    (T), RefCell<T>, RefCell::new
-}
-
-forwarded_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    (T), Mutex<T>, Mutex::new
-}
-
-forwarded_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    (T), RwLock<T>, RwLock::new
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// This is a cleaned-up version of the impl generated by:
-//
-//     #[derive(Deserialize)]
-//     #[serde(deny_unknown_fields)]
-//     struct Duration {
-//         secs: u64,
-//         nanos: u32,
-//     }
-impl<'de> Deserialize<'de> for Duration {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // If this were outside of the serde crate, it would just use:
-        //
-        //    #[derive(Deserialize)]
-        //    #[serde(field_identifier, rename_all = "lowercase")]
-        enum Field {
-            Secs,
-            Nanos,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`secs` or `nanos`")
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "secs" => Ok(Field::Secs),
-                            "nanos" => Ok(Field::Nanos),
-                            _ => Err(Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"secs" => Ok(Field::Secs),
-                            b"nanos" => Ok(Field::Nanos),
-                            _ => {
-                                let value = crate::__private::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&*value, FIELDS))
-                            }
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
-        where
-            E: Error,
-        {
-            static NANOS_PER_SEC: u32 = 1_000_000_000;
-            match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
-                Some(_) => Ok(()),
-                None => Err(E::custom("overflow deserializing Duration")),
-            }
-        }
-
-        struct DurationVisitor;
-
-        impl<'de> Visitor<'de> for DurationVisitor {
-            type Value = Duration;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("struct Duration")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let secs: u64 = match tri!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(0, &self));
-                    }
-                };
-                let nanos: u32 = match tri!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(1, &self));
-                    }
-                };
-                tri!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-
-            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-            where
-                A: MapAccess<'de>,
-            {
-                let mut secs: Option<u64> = None;
-                let mut nanos: Option<u32> = None;
-                while let Some(key) = tri!(map.next_key()) {
-                    match key {
-                        Field::Secs => {
-                            if secs.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("secs"));
-                            }
-                            secs = Some(tri!(map.next_value()));
-                        }
-                        Field::Nanos => {
-                            if nanos.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("nanos"));
-                            }
-                            nanos = Some(tri!(map.next_value()));
-                        }
-                    }
-                }
-                let secs = match secs {
-                    Some(secs) => secs,
-                    None => return Err(<A::Error as Error>::missing_field("secs")),
-                };
-                let nanos = match nanos {
-                    Some(nanos) => nanos,
-                    None => return Err(<A::Error as Error>::missing_field("nanos")),
-                };
-                tri!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-        }
-
-        const FIELDS: &[&str] = &["secs", "nanos"];
-        deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de> Deserialize<'de> for SystemTime {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // Reuse duration
-        enum Field {
-            Secs,
-            Nanos,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`")
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "secs_since_epoch" => Ok(Field::Secs),
-                            "nanos_since_epoch" => Ok(Field::Nanos),
-                            _ => Err(Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"secs_since_epoch" => Ok(Field::Secs),
-                            b"nanos_since_epoch" => Ok(Field::Nanos),
-                            _ => {
-                                let value = String::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&value, FIELDS))
-                            }
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
-        where
-            E: Error,
-        {
-            static NANOS_PER_SEC: u32 = 1_000_000_000;
-            match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
-                Some(_) => Ok(()),
-                None => Err(E::custom("overflow deserializing SystemTime epoch offset")),
-            }
-        }
-
-        struct DurationVisitor;
-
-        impl<'de> Visitor<'de> for DurationVisitor {
-            type Value = Duration;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("struct SystemTime")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let secs: u64 = match tri!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(0, &self));
-                    }
-                };
-                let nanos: u32 = match tri!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(1, &self));
-                    }
-                };
-                tri!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-
-            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-            where
-                A: MapAccess<'de>,
-            {
-                let mut secs: Option<u64> = None;
-                let mut nanos: Option<u32> = None;
-                while let Some(key) = tri!(map.next_key()) {
-                    match key {
-                        Field::Secs => {
-                            if secs.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field(
-                                    "secs_since_epoch",
-                                ));
-                            }
-                            secs = Some(tri!(map.next_value()));
-                        }
-                        Field::Nanos => {
-                            if nanos.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field(
-                                    "nanos_since_epoch",
-                                ));
-                            }
-                            nanos = Some(tri!(map.next_value()));
-                        }
-                    }
-                }
-                let secs = match secs {
-                    Some(secs) => secs,
-                    None => return Err(<A::Error as Error>::missing_field("secs_since_epoch")),
-                };
-                let nanos = match nanos {
-                    Some(nanos) => nanos,
-                    None => return Err(<A::Error as Error>::missing_field("nanos_since_epoch")),
-                };
-                tri!(check_overflow(secs, nanos));
-                Ok(Duration::new(secs, nanos))
-            }
-        }
-
-        const FIELDS: &[&str] = &["secs_since_epoch", "nanos_since_epoch"];
-        let duration = tri!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
-        #[cfg(not(no_systemtime_checked_add))]
-        let ret = UNIX_EPOCH
-            .checked_add(duration)
-            .ok_or_else(|| D::Error::custom("overflow deserializing SystemTime"));
-        #[cfg(no_systemtime_checked_add)]
-        let ret = Ok(UNIX_EPOCH + duration);
-        ret
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Similar to:
-//
-//     #[derive(Deserialize)]
-//     #[serde(deny_unknown_fields)]
-//     struct Range<Idx> {
-//         start: Idx,
-//         end: Idx,
-//     }
-impl<'de, Idx> Deserialize<'de> for Range<Idx>
-where
-    Idx: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let (start, end) = tri!(deserializer.deserialize_struct(
-            "Range",
-            range::FIELDS,
-            range::RangeVisitor {
-                expecting: "struct Range",
-                phantom: PhantomData,
-            },
-        ));
-        Ok(start..end)
-    }
-}
-
-impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
-where
-    Idx: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let (start, end) = tri!(deserializer.deserialize_struct(
-            "RangeInclusive",
-            range::FIELDS,
-            range::RangeVisitor {
-                expecting: "struct RangeInclusive",
-                phantom: PhantomData,
-            },
-        ));
-        Ok(RangeInclusive::new(start, end))
-    }
-}
-
-mod range {
-    use crate::lib::*;
-
-    use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
-
-    pub const FIELDS: &[&str] = &["start", "end"];
-
-    // If this were outside of the serde crate, it would just use:
-    //
-    //    #[derive(Deserialize)]
-    //    #[serde(field_identifier, rename_all = "lowercase")]
-    enum Field {
-        Start,
-        End,
-    }
-
-    impl<'de> Deserialize<'de> for Field {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct FieldVisitor;
-
-            impl<'de> Visitor<'de> for FieldVisitor {
-                type Value = Field;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("`start` or `end`")
-                }
-
-                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        "start" => Ok(Field::Start),
-                        "end" => Ok(Field::End),
-                        _ => Err(Error::unknown_field(value, FIELDS)),
-                    }
-                }
-
-                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        b"start" => Ok(Field::Start),
-                        b"end" => Ok(Field::End),
-                        _ => {
-                            let value = crate::__private::from_utf8_lossy(value);
-                            Err(Error::unknown_field(&*value, FIELDS))
-                        }
-                    }
-                }
-            }
-
-            deserializer.deserialize_identifier(FieldVisitor)
-        }
-    }
-
-    pub struct RangeVisitor<Idx> {
-        pub expecting: &'static str,
-        pub phantom: PhantomData<Idx>,
-    }
-
-    impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
-    where
-        Idx: Deserialize<'de>,
-    {
-        type Value = (Idx, Idx);
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str(self.expecting)
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-        where
-            A: SeqAccess<'de>,
-        {
-            let start: Idx = match tri!(seq.next_element()) {
-                Some(value) => value,
-                None => {
-                    return Err(Error::invalid_length(0, &self));
-                }
-            };
-            let end: Idx = match tri!(seq.next_element()) {
-                Some(value) => value,
-                None => {
-                    return Err(Error::invalid_length(1, &self));
-                }
-            };
-            Ok((start, end))
-        }
-
-        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-        where
-            A: MapAccess<'de>,
-        {
-            let mut start: Option<Idx> = None;
-            let mut end: Option<Idx> = None;
-            while let Some(key) = tri!(map.next_key()) {
-                match key {
-                    Field::Start => {
-                        if start.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("start"));
-                        }
-                        start = Some(tri!(map.next_value()));
-                    }
-                    Field::End => {
-                        if end.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("end"));
-                        }
-                        end = Some(tri!(map.next_value()));
-                    }
-                }
-            }
-            let start = match start {
-                Some(start) => start,
-                None => return Err(<A::Error as Error>::missing_field("start")),
-            };
-            let end = match end {
-                Some(end) => end,
-                None => return Err(<A::Error as Error>::missing_field("end")),
-            };
-            Ok((start, end))
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Similar to:
-//
-//     #[derive(Deserialize)]
-//     #[serde(deny_unknown_fields)]
-//     struct RangeFrom<Idx> {
-//         start: Idx,
-//     }
-impl<'de, Idx> Deserialize<'de> for RangeFrom<Idx>
-where
-    Idx: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let start = tri!(deserializer.deserialize_struct(
-            "RangeFrom",
-            range_from::FIELDS,
-            range_from::RangeFromVisitor {
-                expecting: "struct RangeFrom",
-                phantom: PhantomData,
-            },
-        ));
-        Ok(start..)
-    }
-}
-
-mod range_from {
-    use crate::lib::*;
-
-    use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
-
-    pub const FIELDS: &[&str] = &["start"];
-
-    // If this were outside of the serde crate, it would just use:
-    //
-    //    #[derive(Deserialize)]
-    //    #[serde(field_identifier, rename_all = "lowercase")]
-    enum Field {
-        Start,
-    }
-
-    impl<'de> Deserialize<'de> for Field {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct FieldVisitor;
-
-            impl<'de> Visitor<'de> for FieldVisitor {
-                type Value = Field;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("`start`")
-                }
-
-                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        "start" => Ok(Field::Start),
-                        _ => Err(Error::unknown_field(value, FIELDS)),
-                    }
-                }
-
-                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        b"start" => Ok(Field::Start),
-                        _ => {
-                            let value = crate::__private::from_utf8_lossy(value);
-                            Err(Error::unknown_field(&*value, FIELDS))
-                        }
-                    }
-                }
-            }
-
-            deserializer.deserialize_identifier(FieldVisitor)
-        }
-    }
-
-    pub struct RangeFromVisitor<Idx> {
-        pub expecting: &'static str,
-        pub phantom: PhantomData<Idx>,
-    }
-
-    impl<'de, Idx> Visitor<'de> for RangeFromVisitor<Idx>
-    where
-        Idx: Deserialize<'de>,
-    {
-        type Value = Idx;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str(self.expecting)
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-        where
-            A: SeqAccess<'de>,
-        {
-            let start: Idx = match tri!(seq.next_element()) {
-                Some(value) => value,
-                None => {
-                    return Err(Error::invalid_length(0, &self));
-                }
-            };
-            Ok(start)
-        }
-
-        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-        where
-            A: MapAccess<'de>,
-        {
-            let mut start: Option<Idx> = None;
-            while let Some(key) = tri!(map.next_key()) {
-                match key {
-                    Field::Start => {
-                        if start.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("start"));
-                        }
-                        start = Some(tri!(map.next_value()));
-                    }
-                }
-            }
-            let start = match start {
-                Some(start) => start,
-                None => return Err(<A::Error as Error>::missing_field("start")),
-            };
-            Ok(start)
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Similar to:
-//
-//     #[derive(Deserialize)]
-//     #[serde(deny_unknown_fields)]
-//     struct RangeTo<Idx> {
-//         end: Idx,
-//     }
-impl<'de, Idx> Deserialize<'de> for RangeTo<Idx>
-where
-    Idx: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let end = tri!(deserializer.deserialize_struct(
-            "RangeTo",
-            range_to::FIELDS,
-            range_to::RangeToVisitor {
-                expecting: "struct RangeTo",
-                phantom: PhantomData,
-            },
-        ));
-        Ok(..end)
-    }
-}
-
-mod range_to {
-    use crate::lib::*;
-
-    use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
-
-    pub const FIELDS: &[&str] = &["end"];
-
-    // If this were outside of the serde crate, it would just use:
-    //
-    //    #[derive(Deserialize)]
-    //    #[serde(field_identifier, rename_all = "lowercase")]
-    enum Field {
-        End,
-    }
-
-    impl<'de> Deserialize<'de> for Field {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            struct FieldVisitor;
-
-            impl<'de> Visitor<'de> for FieldVisitor {
-                type Value = Field;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("`end`")
-                }
-
-                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        "end" => Ok(Field::End),
-                        _ => Err(Error::unknown_field(value, FIELDS)),
-                    }
-                }
-
-                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    match value {
-                        b"end" => Ok(Field::End),
-                        _ => {
-                            let value = crate::__private::from_utf8_lossy(value);
-                            Err(Error::unknown_field(&*value, FIELDS))
-                        }
-                    }
-                }
-            }
-
-            deserializer.deserialize_identifier(FieldVisitor)
-        }
-    }
-
-    pub struct RangeToVisitor<Idx> {
-        pub expecting: &'static str,
-        pub phantom: PhantomData<Idx>,
-    }
-
-    impl<'de, Idx> Visitor<'de> for RangeToVisitor<Idx>
-    where
-        Idx: Deserialize<'de>,
-    {
-        type Value = Idx;
-
-        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-            formatter.write_str(self.expecting)
-        }
-
-        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-        where
-            A: SeqAccess<'de>,
-        {
-            let end: Idx = match tri!(seq.next_element()) {
-                Some(value) => value,
-                None => {
-                    return Err(Error::invalid_length(0, &self));
-                }
-            };
-            Ok(end)
-        }
-
-        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-        where
-            A: MapAccess<'de>,
-        {
-            let mut end: Option<Idx> = None;
-            while let Some(key) = tri!(map.next_key()) {
-                match key {
-                    Field::End => {
-                        if end.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("end"));
-                        }
-                        end = Some(tri!(map.next_value()));
-                    }
-                }
-            }
-            let end = match end {
-                Some(end) => end,
-                None => return Err(<A::Error as Error>::missing_field("end")),
-            };
-            Ok(end)
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, T> Deserialize<'de> for Bound<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        enum Field {
-            Unbounded,
-            Included,
-            Excluded,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`Unbounded`, `Included` or `Excluded`")
-                    }
-
-                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            0 => Ok(Field::Unbounded),
-                            1 => Ok(Field::Included),
-                            2 => Ok(Field::Excluded),
-                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)),
-                        }
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "Unbounded" => Ok(Field::Unbounded),
-                            "Included" => Ok(Field::Included),
-                            "Excluded" => Ok(Field::Excluded),
-                            _ => Err(Error::unknown_variant(value, VARIANTS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"Unbounded" => Ok(Field::Unbounded),
-                            b"Included" => Ok(Field::Included),
-                            b"Excluded" => Ok(Field::Excluded),
-                            _ => match str::from_utf8(value) {
-                                Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
-                                Err(_) => {
-                                    Err(Error::invalid_value(Unexpected::Bytes(value), &self))
-                                }
-                            },
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        struct BoundVisitor<T>(PhantomData<Bound<T>>);
-
-        impl<'de, T> Visitor<'de> for BoundVisitor<T>
-        where
-            T: Deserialize<'de>,
-        {
-            type Value = Bound<T>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("enum Bound")
-            }
-
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                match tri!(data.variant()) {
-                    (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded),
-                    (Field::Included, v) => v.newtype_variant().map(Bound::Included),
-                    (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded),
-                }
-            }
-        }
-
-        const VARIANTS: &[&str] = &["Unbounded", "Included", "Excluded"];
-
-        deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, T, E> Deserialize<'de> for Result<T, E>
-where
-    T: Deserialize<'de>,
-    E: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // If this were outside of the serde crate, it would just use:
-        //
-        //    #[derive(Deserialize)]
-        //    #[serde(variant_identifier)]
-        enum Field {
-            Ok,
-            Err,
-        }
-
-        impl<'de> Deserialize<'de> for Field {
-            #[inline]
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`Ok` or `Err`")
-                    }
-
-                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            0 => Ok(Field::Ok),
-                            1 => Ok(Field::Err),
-                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)),
-                        }
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "Ok" => Ok(Field::Ok),
-                            "Err" => Ok(Field::Err),
-                            _ => Err(Error::unknown_variant(value, VARIANTS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"Ok" => Ok(Field::Ok),
-                            b"Err" => Ok(Field::Err),
-                            _ => match str::from_utf8(value) {
-                                Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
-                                Err(_) => {
-                                    Err(Error::invalid_value(Unexpected::Bytes(value), &self))
-                                }
-                            },
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
-
-        impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E>
-        where
-            T: Deserialize<'de>,
-            E: Deserialize<'de>,
-        {
-            type Value = Result<T, E>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("enum Result")
-            }
-
-            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-            where
-                A: EnumAccess<'de>,
-            {
-                match tri!(data.variant()) {
-                    (Field::Ok, v) => v.newtype_variant().map(Ok),
-                    (Field::Err, v) => v.newtype_variant().map(Err),
-                }
-            }
-        }
-
-        const VARIANTS: &[&str] = &["Ok", "Err"];
-
-        deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, T> Deserialize<'de> for Wrapping<T>
-where
-    T: Deserialize<'de>,
-{
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        Deserialize::deserialize(deserializer).map(Wrapping)
-    }
-}
-
-#[cfg(all(feature = "std", not(no_std_atomic)))]
-macro_rules! atomic_impl {
-    ($($ty:ident $size:expr)*) => {
-        $(
-            #[cfg(any(no_target_has_atomic, target_has_atomic = $size))]
-            #[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", target_has_atomic = $size))))]
-            impl<'de> Deserialize<'de> for $ty {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                where
-                    D: Deserializer<'de>,
-                {
-                    Deserialize::deserialize(deserializer).map(Self::new)
-                }
-            }
-        )*
-    };
-}
-
-#[cfg(all(feature = "std", not(no_std_atomic)))]
-atomic_impl! {
-    AtomicBool "8"
-    AtomicI8 "8"
-    AtomicI16 "16"
-    AtomicI32 "32"
-    AtomicIsize "ptr"
-    AtomicU8 "8"
-    AtomicU16 "16"
-    AtomicU32 "32"
-    AtomicUsize "ptr"
-}
-
-#[cfg(all(feature = "std", not(no_std_atomic64)))]
-atomic_impl! {
-    AtomicI64 "64"
-    AtomicU64 "64"
-}
-
-#[cfg(feature = "std")]
-struct FromStrVisitor<T> {
-    expecting: &'static str,
-    ty: PhantomData<T>,
-}
-
-#[cfg(feature = "std")]
-impl<T> FromStrVisitor<T> {
-    fn new(expecting: &'static str) -> Self {
-        FromStrVisitor {
-            expecting,
-            ty: PhantomData,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-impl<'de, T> Visitor<'de> for FromStrVisitor<T>
-where
-    T: str::FromStr,
-    T::Err: fmt::Display,
-{
-    type Value = T;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(self.expecting)
-    }
-
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        s.parse().map_err(Error::custom)
-    }
-}
diff --git a/vendor/serde/src/de/mod.rs b/vendor/serde/src/de/mod.rs
deleted file mode 100644
index c9919d9..0000000
--- a/vendor/serde/src/de/mod.rs
+++ /dev/null
@@ -1,2292 +0,0 @@
-//! Generic data structure deserialization framework.
-//!
-//! The two most important traits in this module are [`Deserialize`] and
-//! [`Deserializer`].
-//!
-//!  - **A type that implements `Deserialize` is a data structure** that can be
-//!    deserialized from any data format supported by Serde, and conversely
-//!  - **A type that implements `Deserializer` is a data format** that can
-//!    deserialize any data structure supported by Serde.
-//!
-//! # The Deserialize trait
-//!
-//! Serde provides [`Deserialize`] implementations for many Rust primitive and
-//! standard library types. The complete list is below. All of these can be
-//! deserialized using Serde out of the box.
-//!
-//! Additionally, Serde provides a procedural macro called [`serde_derive`] to
-//! automatically generate [`Deserialize`] implementations for structs and enums
-//! in your program. See the [derive section of the manual] for how to use this.
-//!
-//! In rare cases it may be necessary to implement [`Deserialize`] manually for
-//! some type in your program. See the [Implementing `Deserialize`] section of
-//! the manual for more about this.
-//!
-//! Third-party crates may provide [`Deserialize`] implementations for types
-//! that they expose. For example the [`linked-hash-map`] crate provides a
-//! [`LinkedHashMap<K, V>`] type that is deserializable by Serde because the
-//! crate provides an implementation of [`Deserialize`] for it.
-//!
-//! # The Deserializer trait
-//!
-//! [`Deserializer`] implementations are provided by third-party crates, for
-//! example [`serde_json`], [`serde_yaml`] and [`postcard`].
-//!
-//! A partial list of well-maintained formats is given on the [Serde
-//! website][data formats].
-//!
-//! # Implementations of Deserialize provided by Serde
-//!
-//! This is a slightly different set of types than what is supported for
-//! serialization. Some types can be serialized by Serde but not deserialized.
-//! One example is `OsStr`.
-//!
-//!  - **Primitive types**:
-//!    - bool
-//!    - i8, i16, i32, i64, i128, isize
-//!    - u8, u16, u32, u64, u128, usize
-//!    - f32, f64
-//!    - char
-//!  - **Compound types**:
-//!    - \[T; 0\] through \[T; 32\]
-//!    - tuples up to size 16
-//!  - **Common standard library types**:
-//!    - String
-//!    - Option\<T\>
-//!    - Result\<T, E\>
-//!    - PhantomData\<T\>
-//!  - **Wrapper types**:
-//!    - Box\<T\>
-//!    - Box\<\[T\]\>
-//!    - Box\<str\>
-//!    - Cow\<'a, T\>
-//!    - Cell\<T\>
-//!    - RefCell\<T\>
-//!    - Mutex\<T\>
-//!    - RwLock\<T\>
-//!    - Rc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
-//!    - Arc\<T\>&emsp;*(if* features = \["rc"\] *is enabled)*
-//!  - **Collection types**:
-//!    - BTreeMap\<K, V\>
-//!    - BTreeSet\<T\>
-//!    - BinaryHeap\<T\>
-//!    - HashMap\<K, V, H\>
-//!    - HashSet\<T, H\>
-//!    - LinkedList\<T\>
-//!    - VecDeque\<T\>
-//!    - Vec\<T\>
-//!  - **Zero-copy types**:
-//!    - &str
-//!    - &\[u8\]
-//!  - **FFI types**:
-//!    - CString
-//!    - Box\<CStr\>
-//!    - OsString
-//!  - **Miscellaneous standard library types**:
-//!    - Duration
-//!    - SystemTime
-//!    - Path
-//!    - PathBuf
-//!    - Range\<T\>
-//!    - RangeInclusive\<T\>
-//!    - Bound\<T\>
-//!    - num::NonZero*
-//!    - `!` *(unstable)*
-//!  - **Net types**:
-//!    - IpAddr
-//!    - Ipv4Addr
-//!    - Ipv6Addr
-//!    - SocketAddr
-//!    - SocketAddrV4
-//!    - SocketAddrV6
-//!
-//! [Implementing `Deserialize`]: https://serde.rs/impl-deserialize.html
-//! [`Deserialize`]: ../trait.Deserialize.html
-//! [`Deserializer`]: ../trait.Deserializer.html
-//! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`postcard`]: https://github.com/jamesmunns/postcard
-//! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
-//! [`serde_derive`]: https://crates.io/crates/serde_derive
-//! [`serde_json`]: https://github.com/serde-rs/json
-//! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml
-//! [derive section of the manual]: https://serde.rs/derive.html
-//! [data formats]: https://serde.rs/#data-formats
-
-use crate::lib::*;
-
-////////////////////////////////////////////////////////////////////////////////
-
-pub mod value;
-
-mod format;
-mod ignored_any;
-mod impls;
-pub(crate) mod size_hint;
-
-pub use self::ignored_any::IgnoredAny;
-
-#[cfg(not(any(feature = "std", feature = "unstable")))]
-#[doc(no_inline)]
-pub use crate::std_error::Error as StdError;
-#[cfg(all(feature = "unstable", not(feature = "std")))]
-#[doc(no_inline)]
-pub use core::error::Error as StdError;
-#[cfg(feature = "std")]
-#[doc(no_inline)]
-pub use std::error::Error as StdError;
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! declare_error_trait {
-    (Error: Sized $(+ $($supertrait:ident)::+)*) => {
-        /// The `Error` trait allows `Deserialize` implementations to create descriptive
-        /// error messages belonging to the `Deserializer` against which they are
-        /// currently running.
-        ///
-        /// Every `Deserializer` declares an `Error` type that encompasses both
-        /// general-purpose deserialization errors as well as errors specific to the
-        /// particular deserialization format. For example the `Error` type of
-        /// `serde_json` can represent errors like an invalid JSON escape sequence or an
-        /// unterminated string literal, in addition to the error cases that are part of
-        /// this trait.
-        ///
-        /// Most deserializers should only need to provide the `Error::custom` method
-        /// and inherit the default behavior for the other methods.
-        ///
-        /// # Example implementation
-        ///
-        /// The [example data format] presented on the website shows an error
-        /// type appropriate for a basic JSON data format.
-        ///
-        /// [example data format]: https://serde.rs/data-format.html
-        pub trait Error: Sized $(+ $($supertrait)::+)* {
-            /// Raised when there is general error when deserializing a type.
-            ///
-            /// The message should not be capitalized and should not end with a period.
-            ///
-            /// ```edition2021
-            /// # use std::str::FromStr;
-            /// #
-            /// # struct IpAddr;
-            /// #
-            /// # impl FromStr for IpAddr {
-            /// #     type Err = String;
-            /// #
-            /// #     fn from_str(_: &str) -> Result<Self, String> {
-            /// #         unimplemented!()
-            /// #     }
-            /// # }
-            /// #
-            /// use serde::de::{self, Deserialize, Deserializer};
-            ///
-            /// impl<'de> Deserialize<'de> for IpAddr {
-            ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            ///     where
-            ///         D: Deserializer<'de>,
-            ///     {
-            ///         let s = String::deserialize(deserializer)?;
-            ///         s.parse().map_err(de::Error::custom)
-            ///     }
-            /// }
-            /// ```
-            fn custom<T>(msg: T) -> Self
-            where
-                T: Display;
-
-            /// Raised when a `Deserialize` receives a type different from what it was
-            /// expecting.
-            ///
-            /// The `unexp` argument provides information about what type was received.
-            /// This is the type that was present in the input file or other source data
-            /// of the Deserializer.
-            ///
-            /// The `exp` argument provides information about what type was being
-            /// expected. This is the type that is written in the program.
-            ///
-            /// For example if we try to deserialize a String out of a JSON file
-            /// containing an integer, the unexpected type is the integer and the
-            /// expected type is the string.
-            #[cold]
-            fn invalid_type(unexp: Unexpected, exp: &Expected) -> Self {
-                Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp))
-            }
-
-            /// Raised when a `Deserialize` receives a value of the right type but that
-            /// is wrong for some other reason.
-            ///
-            /// The `unexp` argument provides information about what value was received.
-            /// This is the value that was present in the input file or other source
-            /// data of the Deserializer.
-            ///
-            /// The `exp` argument provides information about what value was being
-            /// expected. This is the type that is written in the program.
-            ///
-            /// For example if we try to deserialize a String out of some binary data
-            /// that is not valid UTF-8, the unexpected value is the bytes and the
-            /// expected value is a string.
-            #[cold]
-            fn invalid_value(unexp: Unexpected, exp: &Expected) -> Self {
-                Error::custom(format_args!("invalid value: {}, expected {}", unexp, exp))
-            }
-
-            /// Raised when deserializing a sequence or map and the input data contains
-            /// too many or too few elements.
-            ///
-            /// The `len` argument is the number of elements encountered. The sequence
-            /// or map may have expected more arguments or fewer arguments.
-            ///
-            /// The `exp` argument provides information about what data was being
-            /// expected. For example `exp` might say that a tuple of size 6 was
-            /// expected.
-            #[cold]
-            fn invalid_length(len: usize, exp: &Expected) -> Self {
-                Error::custom(format_args!("invalid length {}, expected {}", len, exp))
-            }
-
-            /// Raised when a `Deserialize` enum type received a variant with an
-            /// unrecognized name.
-            #[cold]
-            fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self {
-                if expected.is_empty() {
-                    Error::custom(format_args!(
-                        "unknown variant `{}`, there are no variants",
-                        variant
-                    ))
-                } else {
-                    Error::custom(format_args!(
-                        "unknown variant `{}`, expected {}",
-                        variant,
-                        OneOf { names: expected }
-                    ))
-                }
-            }
-
-            /// Raised when a `Deserialize` struct type received a field with an
-            /// unrecognized name.
-            #[cold]
-            fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
-                if expected.is_empty() {
-                    Error::custom(format_args!(
-                        "unknown field `{}`, there are no fields",
-                        field
-                    ))
-                } else {
-                    Error::custom(format_args!(
-                        "unknown field `{}`, expected {}",
-                        field,
-                        OneOf { names: expected }
-                    ))
-                }
-            }
-
-            /// Raised when a `Deserialize` struct type expected to receive a required
-            /// field with a particular name but that field was not present in the
-            /// input.
-            #[cold]
-            fn missing_field(field: &'static str) -> Self {
-                Error::custom(format_args!("missing field `{}`", field))
-            }
-
-            /// Raised when a `Deserialize` struct type received more than one of the
-            /// same field.
-            #[cold]
-            fn duplicate_field(field: &'static str) -> Self {
-                Error::custom(format_args!("duplicate field `{}`", field))
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-declare_error_trait!(Error: Sized + StdError);
-
-#[cfg(not(feature = "std"))]
-declare_error_trait!(Error: Sized + Debug + Display);
-
-/// `Unexpected` represents an unexpected invocation of any one of the `Visitor`
-/// trait methods.
-///
-/// This is used as an argument to the `invalid_type`, `invalid_value`, and
-/// `invalid_length` methods of the `Error` trait to build error messages.
-///
-/// ```edition2021
-/// # use std::fmt;
-/// #
-/// # use serde::de::{self, Unexpected, Visitor};
-/// #
-/// # struct Example;
-/// #
-/// # impl<'de> Visitor<'de> for Example {
-/// #     type Value = ();
-/// #
-/// #     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-/// #         write!(formatter, "definitely not a boolean")
-/// #     }
-/// #
-/// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-/// where
-///     E: de::Error,
-/// {
-///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
-/// }
-/// # }
-/// ```
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum Unexpected<'a> {
-    /// The input contained a boolean value that was not expected.
-    Bool(bool),
-
-    /// The input contained an unsigned integer `u8`, `u16`, `u32` or `u64` that
-    /// was not expected.
-    Unsigned(u64),
-
-    /// The input contained a signed integer `i8`, `i16`, `i32` or `i64` that
-    /// was not expected.
-    Signed(i64),
-
-    /// The input contained a floating point `f32` or `f64` that was not
-    /// expected.
-    Float(f64),
-
-    /// The input contained a `char` that was not expected.
-    Char(char),
-
-    /// The input contained a `&str` or `String` that was not expected.
-    Str(&'a str),
-
-    /// The input contained a `&[u8]` or `Vec<u8>` that was not expected.
-    Bytes(&'a [u8]),
-
-    /// The input contained a unit `()` that was not expected.
-    Unit,
-
-    /// The input contained an `Option<T>` that was not expected.
-    Option,
-
-    /// The input contained a newtype struct that was not expected.
-    NewtypeStruct,
-
-    /// The input contained a sequence that was not expected.
-    Seq,
-
-    /// The input contained a map that was not expected.
-    Map,
-
-    /// The input contained an enum that was not expected.
-    Enum,
-
-    /// The input contained a unit variant that was not expected.
-    UnitVariant,
-
-    /// The input contained a newtype variant that was not expected.
-    NewtypeVariant,
-
-    /// The input contained a tuple variant that was not expected.
-    TupleVariant,
-
-    /// The input contained a struct variant that was not expected.
-    StructVariant,
-
-    /// A message stating what uncategorized thing the input contained that was
-    /// not expected.
-    ///
-    /// The message should be a noun or noun phrase, not capitalized and without
-    /// a period. An example message is "unoriginal superhero".
-    Other(&'a str),
-}
-
-impl<'a> fmt::Display for Unexpected<'a> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        use self::Unexpected::*;
-        match *self {
-            Bool(b) => write!(formatter, "boolean `{}`", b),
-            Unsigned(i) => write!(formatter, "integer `{}`", i),
-            Signed(i) => write!(formatter, "integer `{}`", i),
-            Float(f) => write!(formatter, "floating point `{}`", f),
-            Char(c) => write!(formatter, "character `{}`", c),
-            Str(s) => write!(formatter, "string {:?}", s),
-            Bytes(_) => write!(formatter, "byte array"),
-            Unit => write!(formatter, "unit value"),
-            Option => write!(formatter, "Option value"),
-            NewtypeStruct => write!(formatter, "newtype struct"),
-            Seq => write!(formatter, "sequence"),
-            Map => write!(formatter, "map"),
-            Enum => write!(formatter, "enum"),
-            UnitVariant => write!(formatter, "unit variant"),
-            NewtypeVariant => write!(formatter, "newtype variant"),
-            TupleVariant => write!(formatter, "tuple variant"),
-            StructVariant => write!(formatter, "struct variant"),
-            Other(other) => formatter.write_str(other),
-        }
-    }
-}
-
-/// `Expected` represents an explanation of what data a `Visitor` was expecting
-/// to receive.
-///
-/// This is used as an argument to the `invalid_type`, `invalid_value`, and
-/// `invalid_length` methods of the `Error` trait to build error messages. The
-/// message should be a noun or noun phrase that completes the sentence "This
-/// Visitor expects to receive ...", for example the message could be "an
-/// integer between 0 and 64". The message should not be capitalized and should
-/// not end with a period.
-///
-/// Within the context of a `Visitor` implementation, the `Visitor` itself
-/// (`&self`) is an implementation of this trait.
-///
-/// ```edition2021
-/// # use serde::de::{self, Unexpected, Visitor};
-/// # use std::fmt;
-/// #
-/// # struct Example;
-/// #
-/// # impl<'de> Visitor<'de> for Example {
-/// #     type Value = ();
-/// #
-/// #     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-/// #         write!(formatter, "definitely not a boolean")
-/// #     }
-/// #
-/// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-/// where
-///     E: de::Error,
-/// {
-///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
-/// }
-/// # }
-/// ```
-///
-/// Outside of a `Visitor`, `&"..."` can be used.
-///
-/// ```edition2021
-/// # use serde::de::{self, Unexpected};
-/// #
-/// # fn example<E>() -> Result<(), E>
-/// # where
-/// #     E: de::Error,
-/// # {
-/// #     let v = true;
-/// return Err(de::Error::invalid_type(
-///     Unexpected::Bool(v),
-///     &"a negative integer",
-/// ));
-/// # }
-/// ```
-pub trait Expected {
-    /// Format an explanation of what data was being expected. Same signature as
-    /// the `Display` and `Debug` traits.
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
-}
-
-impl<'de, T> Expected for T
-where
-    T: Visitor<'de>,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        self.expecting(formatter)
-    }
-}
-
-impl<'a> Expected for &'a str {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(self)
-    }
-}
-
-impl<'a> Display for Expected + 'a {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Expected::fmt(self, formatter)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data structure** that can be deserialized from any data format supported
-/// by Serde.
-///
-/// Serde provides `Deserialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][crate::de]. All of these
-/// can be deserialized using Serde out of the box.
-///
-/// Additionally, Serde provides a procedural macro called `serde_derive` to
-/// automatically generate `Deserialize` implementations for structs and enums
-/// in your program. See the [derive section of the manual][derive] for how to
-/// use this.
-///
-/// In rare cases it may be necessary to implement `Deserialize` manually for
-/// some type in your program. See the [Implementing
-/// `Deserialize`][impl-deserialize] section of the manual for more about this.
-///
-/// Third-party crates may provide `Deserialize` implementations for types that
-/// they expose. For example the `linked-hash-map` crate provides a
-/// `LinkedHashMap<K, V>` type that is deserializable by Serde because the crate
-/// provides an implementation of `Deserialize` for it.
-///
-/// [derive]: https://serde.rs/derive.html
-/// [impl-deserialize]: https://serde.rs/impl-deserialize.html
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by `Self` when deserialized. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-pub trait Deserialize<'de>: Sized {
-    /// Deserialize this value from the given Serde deserializer.
-    ///
-    /// See the [Implementing `Deserialize`][impl-deserialize] section of the
-    /// manual for more information about how to implement this method.
-    ///
-    /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>;
-
-    /// Deserializes a value into `self` from the given Deserializer.
-    ///
-    /// The purpose of this method is to allow the deserializer to reuse
-    /// resources and avoid copies. As such, if this method returns an error,
-    /// `self` will be in an indeterminate state where some parts of the struct
-    /// have been overwritten. Although whatever state that is will be
-    /// memory-safe.
-    ///
-    /// This is generally useful when repeatedly deserializing values that
-    /// are processed one at a time, where the value of `self` doesn't matter
-    /// when the next deserialization occurs.
-    ///
-    /// If you manually implement this, your recursive deserializations should
-    /// use `deserialize_in_place`.
-    ///
-    /// This method is stable and an official public API, but hidden from the
-    /// documentation because it is almost never what newbies are looking for.
-    /// Showing it in rustdoc would cause it to be featured more prominently
-    /// than it deserves.
-    #[doc(hidden)]
-    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // Default implementation just delegates to `deserialize` impl.
-        *place = tri!(Deserialize::deserialize(deserializer));
-        Ok(())
-    }
-}
-
-/// A data structure that can be deserialized without borrowing any data from
-/// the deserializer.
-///
-/// This is primarily useful for trait bounds on functions. For example a
-/// `from_str` function may be able to deserialize a data structure that borrows
-/// from the input string, but a `from_reader` function may only deserialize
-/// owned data.
-///
-/// ```edition2021
-/// # use serde::de::{Deserialize, DeserializeOwned};
-/// # use std::io::{Read, Result};
-/// #
-/// # trait Ignore {
-/// fn from_str<'a, T>(s: &'a str) -> Result<T>
-/// where
-///     T: Deserialize<'a>;
-///
-/// fn from_reader<R, T>(rdr: R) -> Result<T>
-/// where
-///     R: Read,
-///     T: DeserializeOwned;
-/// # }
-/// ```
-///
-/// # Lifetime
-///
-/// The relationship between `Deserialize` and `DeserializeOwned` in trait
-/// bounds is explained in more detail on the page [Understanding deserializer
-/// lifetimes].
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-pub trait DeserializeOwned: for<'de> Deserialize<'de> {}
-impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
-
-/// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you
-/// ever find yourself looking for a way to pass data into a `Deserialize` impl,
-/// this trait is the way to do it.
-///
-/// As one example of stateful deserialization consider deserializing a JSON
-/// array into an existing buffer. Using the `Deserialize` trait we could
-/// deserialize a JSON array into a `Vec<T>` but it would be a freshly allocated
-/// `Vec<T>`; there is no way for `Deserialize` to reuse a previously allocated
-/// buffer. Using `DeserializeSeed` instead makes this possible as in the
-/// example code below.
-///
-/// The canonical API for stateless deserialization looks like this:
-///
-/// ```edition2021
-/// # use serde::Deserialize;
-/// #
-/// # enum Error {}
-/// #
-/// fn func<'de, T: Deserialize<'de>>() -> Result<T, Error>
-/// # {
-/// #     unimplemented!()
-/// # }
-/// ```
-///
-/// Adjusting an API like this to support stateful deserialization is a matter
-/// of accepting a seed as input:
-///
-/// ```edition2021
-/// # use serde::de::DeserializeSeed;
-/// #
-/// # enum Error {}
-/// #
-/// fn func_seed<'de, T: DeserializeSeed<'de>>(seed: T) -> Result<T::Value, Error>
-/// # {
-/// #     let _ = seed;
-/// #     unimplemented!()
-/// # }
-/// ```
-///
-/// In practice the majority of deserialization is stateless. An API expecting a
-/// seed can be appeased by passing `std::marker::PhantomData` as a seed in the
-/// case of stateless deserialization.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by `Self::Value` when deserialized. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example
-///
-/// Suppose we have JSON that looks like `[[1, 2], [3, 4, 5], [6]]` and we need
-/// to deserialize it into a flat representation like `vec![1, 2, 3, 4, 5, 6]`.
-/// Allocating a brand new `Vec<T>` for each subarray would be slow. Instead we
-/// would like to allocate a single `Vec<T>` and then deserialize each subarray
-/// into it. This requires stateful deserialization using the `DeserializeSeed`
-/// trait.
-///
-/// ```edition2021
-/// use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor};
-/// use std::fmt;
-/// use std::marker::PhantomData;
-///
-/// // A DeserializeSeed implementation that uses stateful deserialization to
-/// // append array elements onto the end of an existing vector. The preexisting
-/// // state ("seed") in this case is the Vec<T>. The `deserialize` method of
-/// // `ExtendVec` will be traversing the inner arrays of the JSON input and
-/// // appending each integer into the existing Vec.
-/// struct ExtendVec<'a, T: 'a>(&'a mut Vec<T>);
-///
-/// impl<'de, 'a, T> DeserializeSeed<'de> for ExtendVec<'a, T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     // The return type of the `deserialize` method. This implementation
-///     // appends onto an existing vector but does not create any new data
-///     // structure, so the return type is ().
-///     type Value = ();
-///
-///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-///     where
-///         D: Deserializer<'de>,
-///     {
-///         // Visitor implementation that will walk an inner array of the JSON
-///         // input.
-///         struct ExtendVecVisitor<'a, T: 'a>(&'a mut Vec<T>);
-///
-///         impl<'de, 'a, T> Visitor<'de> for ExtendVecVisitor<'a, T>
-///         where
-///             T: Deserialize<'de>,
-///         {
-///             type Value = ();
-///
-///             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///                 write!(formatter, "an array of integers")
-///             }
-///
-///             fn visit_seq<A>(self, mut seq: A) -> Result<(), A::Error>
-///             where
-///                 A: SeqAccess<'de>,
-///             {
-///                 // Decrease the number of reallocations if there are many elements
-///                 if let Some(size_hint) = seq.size_hint() {
-///                     self.0.reserve(size_hint);
-///                 }
-///
-///                 // Visit each element in the inner array and push it onto
-///                 // the existing vector.
-///                 while let Some(elem) = seq.next_element()? {
-///                     self.0.push(elem);
-///                 }
-///                 Ok(())
-///             }
-///         }
-///
-///         deserializer.deserialize_seq(ExtendVecVisitor(self.0))
-///     }
-/// }
-///
-/// // Visitor implementation that will walk the outer array of the JSON input.
-/// struct FlattenedVecVisitor<T>(PhantomData<T>);
-///
-/// impl<'de, T> Visitor<'de> for FlattenedVecVisitor<T>
-/// where
-///     T: Deserialize<'de>,
-/// {
-///     // This Visitor constructs a single Vec<T> to hold the flattened
-///     // contents of the inner arrays.
-///     type Value = Vec<T>;
-///
-///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(formatter, "an array of arrays")
-///     }
-///
-///     fn visit_seq<A>(self, mut seq: A) -> Result<Vec<T>, A::Error>
-///     where
-///         A: SeqAccess<'de>,
-///     {
-///         // Create a single Vec to hold the flattened contents.
-///         let mut vec = Vec::new();
-///
-///         // Each iteration through this loop is one inner array.
-///         while let Some(()) = seq.next_element_seed(ExtendVec(&mut vec))? {
-///             // Nothing to do; inner array has been appended into `vec`.
-///         }
-///
-///         // Return the finished vec.
-///         Ok(vec)
-///     }
-/// }
-///
-/// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
-/// # where
-/// #     D: Deserializer<'de>,
-/// # {
-/// let visitor = FlattenedVecVisitor(PhantomData);
-/// let flattened: Vec<u64> = deserializer.deserialize_seq(visitor)?;
-/// #     Ok(())
-/// # }
-/// ```
-pub trait DeserializeSeed<'de>: Sized {
-    /// The type produced by using this seed.
-    type Value;
-
-    /// Equivalent to the more common `Deserialize::deserialize` method, except
-    /// with some initial piece of data (the seed) passed in.
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>;
-}
-
-impl<'de, T> DeserializeSeed<'de> for PhantomData<T>
-where
-    T: Deserialize<'de>,
-{
-    type Value = T;
-
-    #[inline]
-    fn deserialize<D>(self, deserializer: D) -> Result<T, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize(deserializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data format** that can deserialize any data structure supported by
-/// Serde.
-///
-/// The role of this trait is to define the deserialization half of the [Serde
-/// data model], which is a way to categorize every Rust data type into one of
-/// 29 possible types. Each method of the `Deserializer` trait corresponds to one
-/// of the types of the data model.
-///
-/// Implementations of `Deserialize` map themselves into this data model by
-/// passing to the `Deserializer` a `Visitor` implementation that can receive
-/// these various types.
-///
-/// The types that make up the Serde data model are:
-///
-///  - **14 primitive types**
-///    - bool
-///    - i8, i16, i32, i64, i128
-///    - u8, u16, u32, u64, u128
-///    - f32, f64
-///    - char
-///  - **string**
-///    - UTF-8 bytes with a length and no null terminator.
-///    - When serializing, all strings are handled equally. When deserializing,
-///      there are three flavors of strings: transient, owned, and borrowed.
-///  - **byte array** - \[u8\]
-///    - Similar to strings, during deserialization byte arrays can be
-///      transient, owned, or borrowed.
-///  - **option**
-///    - Either none or some value.
-///  - **unit**
-///    - The type of `()` in Rust. It represents an anonymous value containing
-///      no data.
-///  - **unit_struct**
-///    - For example `struct Unit` or `PhantomData<T>`. It represents a named
-///      value containing no data.
-///  - **unit_variant**
-///    - For example the `E::A` and `E::B` in `enum E { A, B }`.
-///  - **newtype_struct**
-///    - For example `struct Millimeters(u8)`.
-///  - **newtype_variant**
-///    - For example the `E::N` in `enum E { N(u8) }`.
-///  - **seq**
-///    - A variably sized heterogeneous sequence of values, for example `Vec<T>`
-///      or `HashSet<T>`. When serializing, the length may or may not be known
-///      before iterating through all the data. When deserializing, the length
-///      is determined by looking at the serialized data.
-///  - **tuple**
-///    - A statically sized heterogeneous sequence of values for which the
-///      length will be known at deserialization time without looking at the
-///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or
-///      `[u64; 10]`.
-///  - **tuple_struct**
-///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.
-///  - **tuple_variant**
-///    - For example the `E::T` in `enum E { T(u8, u8) }`.
-///  - **map**
-///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
-///  - **struct**
-///    - A heterogeneous key-value pairing in which the keys are strings and
-///      will be known at deserialization time without looking at the serialized
-///      data, for example `struct S { r: u8, g: u8, b: u8 }`.
-///  - **struct_variant**
-///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
-///
-/// The `Deserializer` trait supports two entry point styles which enables
-/// different kinds of deserialization.
-///
-/// 1. The `deserialize_any` method. Self-describing data formats like JSON are
-///    able to look at the serialized data and tell what it represents. For
-///    example the JSON deserializer may see an opening curly brace (`{`) and
-///    know that it is seeing a map. If the data format supports
-///    `Deserializer::deserialize_any`, it will drive the Visitor using whatever
-///    type it sees in the input. JSON uses this approach when deserializing
-///    `serde_json::Value` which is an enum that can represent any JSON
-///    document. Without knowing what is in a JSON document, we can deserialize
-///    it to `serde_json::Value` by going through
-///    `Deserializer::deserialize_any`.
-///
-/// 2. The various `deserialize_*` methods. Non-self-describing formats like
-///    Postcard need to be told what is in the input in order to deserialize it.
-///    The `deserialize_*` methods are hints to the deserializer for how to
-///    interpret the next piece of input. Non-self-describing formats are not
-///    able to deserialize something like `serde_json::Value` which relies on
-///    `Deserializer::deserialize_any`.
-///
-/// When implementing `Deserialize`, you should avoid relying on
-/// `Deserializer::deserialize_any` unless you need to be told by the
-/// Deserializer what type is in the input. Know that relying on
-/// `Deserializer::deserialize_any` means your data type will be able to
-/// deserialize from self-describing formats only, ruling out Postcard and many
-/// others.
-///
-/// [Serde data model]: https://serde.rs/data-model.html
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed from the input when deserializing. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website contains example code for
-/// a basic JSON `Deserializer`.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait Deserializer<'de>: Sized {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-
-    /// Require the `Deserializer` to figure out how to drive the visitor based
-    /// on what data type is in the input.
-    ///
-    /// When implementing `Deserialize`, you should avoid relying on
-    /// `Deserializer::deserialize_any` unless you need to be told by the
-    /// Deserializer what type is in the input. Know that relying on
-    /// `Deserializer::deserialize_any` means your data type will be able to
-    /// deserialize from self-describing formats only, ruling out Postcard and
-    /// many others.
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `bool` value.
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i8` value.
-    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i16` value.
-    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i32` value.
-    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i64` value.
-    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `i128` value.
-    ///
-    /// The default behavior unconditionally returns an error.
-    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        let _ = visitor;
-        Err(Error::custom("i128 is not supported"))
-    }
-
-    /// Hint that the `Deserialize` type is expecting a `u8` value.
-    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `u16` value.
-    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `u32` value.
-    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `u64` value.
-    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an `u128` value.
-    ///
-    /// The default behavior unconditionally returns an error.
-    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        let _ = visitor;
-        Err(Error::custom("u128 is not supported"))
-    }
-
-    /// Hint that the `Deserialize` type is expecting a `f32` value.
-    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `f64` value.
-    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a `char` value.
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a string value and does
-    /// not benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would benefit from taking ownership of `String` data,
-    /// indicate this to the `Deserializer` by using `deserialize_string`
-    /// instead.
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a string value and would
-    /// benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would not benefit from taking ownership of `String`
-    /// data, indicate that to the `Deserializer` by using `deserialize_str`
-    /// instead.
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a byte array and does not
-    /// benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would benefit from taking ownership of `Vec<u8>` data,
-    /// indicate this to the `Deserializer` by using `deserialize_byte_buf`
-    /// instead.
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a byte array and would
-    /// benefit from taking ownership of buffered data owned by the
-    /// `Deserializer`.
-    ///
-    /// If the `Visitor` would not benefit from taking ownership of `Vec<u8>`
-    /// data, indicate that to the `Deserializer` by using `deserialize_bytes`
-    /// instead.
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an optional value.
-    ///
-    /// This allows deserializers that encode an optional value as a nullable
-    /// value to convert the null value into `None` and a regular value into
-    /// `Some(value)`.
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a unit value.
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a unit struct with a
-    /// particular name.
-    fn deserialize_unit_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a newtype struct with a
-    /// particular name.
-    fn deserialize_newtype_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a sequence of values.
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a sequence of values and
-    /// knows how many values there are without looking at the serialized data.
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a tuple struct with a
-    /// particular name and number of fields.
-    fn deserialize_tuple_struct<V>(
-        self,
-        name: &'static str,
-        len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a map of key-value pairs.
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting a struct with a particular
-    /// name and fields.
-    fn deserialize_struct<V>(
-        self,
-        name: &'static str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting an enum value with a
-    /// particular name and possible variants.
-    fn deserialize_enum<V>(
-        self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type is expecting the name of a struct
-    /// field or the discriminant of an enum variant.
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Hint that the `Deserialize` type needs to deserialize a value whose type
-    /// doesn't matter because it is ignored.
-    ///
-    /// Deserializers for non-self-describing formats may not support this mode.
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Determine whether `Deserialize` implementations should expect to
-    /// deserialize their human-readable form.
-    ///
-    /// Some types have a human-readable form that may be somewhat expensive to
-    /// construct, as well as a binary form that is compact and efficient.
-    /// Generally text-based formats like JSON and YAML will prefer to use the
-    /// human-readable one and binary formats like Postcard will prefer the
-    /// compact one.
-    ///
-    /// ```edition2021
-    /// # use std::ops::Add;
-    /// # use std::str::FromStr;
-    /// #
-    /// # struct Timestamp;
-    /// #
-    /// # impl Timestamp {
-    /// #     const EPOCH: Timestamp = Timestamp;
-    /// # }
-    /// #
-    /// # impl FromStr for Timestamp {
-    /// #     type Err = String;
-    /// #     fn from_str(_: &str) -> Result<Self, Self::Err> {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// # struct Duration;
-    /// #
-    /// # impl Duration {
-    /// #     fn seconds(_: u64) -> Self { unimplemented!() }
-    /// # }
-    /// #
-    /// # impl Add<Duration> for Timestamp {
-    /// #     type Output = Timestamp;
-    /// #     fn add(self, _: Duration) -> Self::Output {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::de::{self, Deserialize, Deserializer};
-    ///
-    /// impl<'de> Deserialize<'de> for Timestamp {
-    ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    ///     where
-    ///         D: Deserializer<'de>,
-    ///     {
-    ///         if deserializer.is_human_readable() {
-    ///             // Deserialize from a human-readable string like "2015-05-15T17:01:00Z".
-    ///             let s = String::deserialize(deserializer)?;
-    ///             Timestamp::from_str(&s).map_err(de::Error::custom)
-    ///         } else {
-    ///             // Deserialize from a compact binary representation, seconds since
-    ///             // the Unix epoch.
-    ///             let n = u64::deserialize(deserializer)?;
-    ///             Ok(Timestamp::EPOCH + Duration::seconds(n))
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// The default implementation of this method returns `true`. Data formats
-    /// may override this to `false` to request a compact form for types that
-    /// support one. Note that modifying this method to change a format from
-    /// human-readable to compact or vice versa should be regarded as a breaking
-    /// change, as a value serialized in human-readable mode is not required to
-    /// deserialize from the same data in compact mode.
-    #[inline]
-    fn is_human_readable(&self) -> bool {
-        true
-    }
-
-    // Not public API.
-    #[cfg(all(not(no_serde_derive), any(feature = "std", feature = "alloc")))]
-    #[doc(hidden)]
-    fn __deserialize_content<V>(
-        self,
-        _: crate::actually_private::T,
-        visitor: V,
-    ) -> Result<crate::__private::de::Content<'de>, Self::Error>
-    where
-        V: Visitor<'de, Value = crate::__private::de::Content<'de>>,
-    {
-        self.deserialize_any(visitor)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// This trait represents a visitor that walks through a deserializer.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the requirement for lifetime of data
-/// that may be borrowed by `Self::Value`. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example
-///
-/// ```edition2021
-/// # use serde::de::{self, Unexpected, Visitor};
-/// # use std::fmt;
-/// #
-/// /// A visitor that deserializes a long string - a string containing at least
-/// /// some minimum number of bytes.
-/// struct LongString {
-///     min: usize,
-/// }
-///
-/// impl<'de> Visitor<'de> for LongString {
-///     type Value = String;
-///
-///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(formatter, "a string containing at least {} bytes", self.min)
-///     }
-///
-///     fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-///     where
-///         E: de::Error,
-///     {
-///         if s.len() >= self.min {
-///             Ok(s.to_owned())
-///         } else {
-///             Err(de::Error::invalid_value(Unexpected::Str(s), &self))
-///         }
-///     }
-/// }
-/// ```
-pub trait Visitor<'de>: Sized {
-    /// The value produced by this visitor.
-    type Value;
-
-    /// Format a message stating what data this Visitor expects to receive.
-    ///
-    /// This is used in error messages. The message should complete the sentence
-    /// "This Visitor expects to receive ...", for example the message could be
-    /// "an integer between 0 and 64". The message should not be capitalized and
-    /// should not end with a period.
-    ///
-    /// ```edition2021
-    /// # use std::fmt;
-    /// #
-    /// # struct S {
-    /// #     max: usize,
-    /// # }
-    /// #
-    /// # impl<'de> serde::de::Visitor<'de> for S {
-    /// #     type Value = ();
-    /// #
-    /// fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-    ///     write!(formatter, "an integer between 0 and {}", self.max)
-    /// }
-    /// # }
-    /// ```
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result;
-
-    /// The input contains a boolean.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Bool(v), &self))
-    }
-
-    /// The input contains an `i8`.
-    ///
-    /// The default implementation forwards to [`visit_i64`].
-    ///
-    /// [`visit_i64`]: #method.visit_i64
-    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    /// The input contains an `i16`.
-    ///
-    /// The default implementation forwards to [`visit_i64`].
-    ///
-    /// [`visit_i64`]: #method.visit_i64
-    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    /// The input contains an `i32`.
-    ///
-    /// The default implementation forwards to [`visit_i64`].
-    ///
-    /// [`visit_i64`]: #method.visit_i64
-    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    /// The input contains an `i64`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Signed(v), &self))
-    }
-
-    /// The input contains a `i128`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let mut buf = [0u8; 58];
-        let mut writer = format::Buf::new(&mut buf);
-        fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
-        Err(Error::invalid_type(
-            Unexpected::Other(writer.as_str()),
-            &self,
-        ))
-    }
-
-    /// The input contains a `u8`.
-    ///
-    /// The default implementation forwards to [`visit_u64`].
-    ///
-    /// [`visit_u64`]: #method.visit_u64
-    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    /// The input contains a `u16`.
-    ///
-    /// The default implementation forwards to [`visit_u64`].
-    ///
-    /// [`visit_u64`]: #method.visit_u64
-    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    /// The input contains a `u32`.
-    ///
-    /// The default implementation forwards to [`visit_u64`].
-    ///
-    /// [`visit_u64`]: #method.visit_u64
-    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    /// The input contains a `u64`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
-    }
-
-    /// The input contains a `u128`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        let mut buf = [0u8; 57];
-        let mut writer = format::Buf::new(&mut buf);
-        fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
-        Err(Error::invalid_type(
-            Unexpected::Other(writer.as_str()),
-            &self,
-        ))
-    }
-
-    /// The input contains an `f32`.
-    ///
-    /// The default implementation forwards to [`visit_f64`].
-    ///
-    /// [`visit_f64`]: #method.visit_f64
-    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_f64(v as f64)
-    }
-
-    /// The input contains an `f64`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Float(v), &self))
-    }
-
-    /// The input contains a `char`.
-    ///
-    /// The default implementation forwards to [`visit_str`] as a one-character
-    /// string.
-    ///
-    /// [`visit_str`]: #method.visit_str
-    #[inline]
-    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_str(v.encode_utf8(&mut [0u8; 4]))
-    }
-
-    /// The input contains a string. The lifetime of the string is ephemeral and
-    /// it may be destroyed after this method returns.
-    ///
-    /// This method allows the `Deserializer` to avoid a copy by retaining
-    /// ownership of any buffered data. `Deserialize` implementations that do
-    /// not benefit from taking ownership of `String` data should indicate that
-    /// to the deserializer by using `Deserializer::deserialize_str` rather than
-    /// `Deserializer::deserialize_string`.
-    ///
-    /// It is never correct to implement `visit_string` without implementing
-    /// `visit_str`. Implement neither, both, or just `visit_str`.
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Str(v), &self))
-    }
-
-    /// The input contains a string that lives at least as long as the
-    /// `Deserializer`.
-    ///
-    /// This enables zero-copy deserialization of strings in some formats. For
-    /// example JSON input containing the JSON string `"borrowed"` can be
-    /// deserialized with zero copying into a `&'a str` as long as the input
-    /// data outlives `'a`.
-    ///
-    /// The default implementation forwards to `visit_str`.
-    #[inline]
-    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_str(v)
-    }
-
-    /// The input contains a string and ownership of the string is being given
-    /// to the `Visitor`.
-    ///
-    /// This method allows the `Visitor` to avoid a copy by taking ownership of
-    /// a string created by the `Deserializer`. `Deserialize` implementations
-    /// that benefit from taking ownership of `String` data should indicate that
-    /// to the deserializer by using `Deserializer::deserialize_string` rather
-    /// than `Deserializer::deserialize_str`, although not every deserializer
-    /// will honor such a request.
-    ///
-    /// It is never correct to implement `visit_string` without implementing
-    /// `visit_str`. Implement neither, both, or just `visit_str`.
-    ///
-    /// The default implementation forwards to `visit_str` and then drops the
-    /// `String`.
-    #[inline]
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_str(&v)
-    }
-
-    /// The input contains a byte array. The lifetime of the byte array is
-    /// ephemeral and it may be destroyed after this method returns.
-    ///
-    /// This method allows the `Deserializer` to avoid a copy by retaining
-    /// ownership of any buffered data. `Deserialize` implementations that do
-    /// not benefit from taking ownership of `Vec<u8>` data should indicate that
-    /// to the deserializer by using `Deserializer::deserialize_bytes` rather
-    /// than `Deserializer::deserialize_byte_buf`.
-    ///
-    /// It is never correct to implement `visit_byte_buf` without implementing
-    /// `visit_bytes`. Implement neither, both, or just `visit_bytes`.
-    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Bytes(v), &self))
-    }
-
-    /// The input contains a byte array that lives at least as long as the
-    /// `Deserializer`.
-    ///
-    /// This enables zero-copy deserialization of bytes in some formats. For
-    /// example Postcard data containing bytes can be deserialized with zero
-    /// copying into a `&'a [u8]` as long as the input data outlives `'a`.
-    ///
-    /// The default implementation forwards to `visit_bytes`.
-    #[inline]
-    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_bytes(v)
-    }
-
-    /// The input contains a byte array and ownership of the byte array is being
-    /// given to the `Visitor`.
-    ///
-    /// This method allows the `Visitor` to avoid a copy by taking ownership of
-    /// a byte buffer created by the `Deserializer`. `Deserialize`
-    /// implementations that benefit from taking ownership of `Vec<u8>` data
-    /// should indicate that to the deserializer by using
-    /// `Deserializer::deserialize_byte_buf` rather than
-    /// `Deserializer::deserialize_bytes`, although not every deserializer will
-    /// honor such a request.
-    ///
-    /// It is never correct to implement `visit_byte_buf` without implementing
-    /// `visit_bytes`. Implement neither, both, or just `visit_bytes`.
-    ///
-    /// The default implementation forwards to `visit_bytes` and then drops the
-    /// `Vec<u8>`.
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        self.visit_bytes(&v)
-    }
-
-    /// The input contains an optional that is absent.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_none<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Option, &self))
-    }
-
-    /// The input contains an optional that is present.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let _ = deserializer;
-        Err(Error::invalid_type(Unexpected::Option, &self))
-    }
-
-    /// The input contains a unit `()`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_unit<E>(self) -> Result<Self::Value, E>
-    where
-        E: Error,
-    {
-        Err(Error::invalid_type(Unexpected::Unit, &self))
-    }
-
-    /// The input contains a newtype struct.
-    ///
-    /// The content of the newtype struct may be read from the given
-    /// `Deserializer`.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let _ = deserializer;
-        Err(Error::invalid_type(Unexpected::NewtypeStruct, &self))
-    }
-
-    /// The input contains a sequence of elements.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
-    where
-        A: SeqAccess<'de>,
-    {
-        let _ = seq;
-        Err(Error::invalid_type(Unexpected::Seq, &self))
-    }
-
-    /// The input contains a key-value map.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
-    where
-        A: MapAccess<'de>,
-    {
-        let _ = map;
-        Err(Error::invalid_type(Unexpected::Map, &self))
-    }
-
-    /// The input contains an enum.
-    ///
-    /// The default implementation fails with a type error.
-    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
-    where
-        A: EnumAccess<'de>,
-    {
-        let _ = data;
-        Err(Error::invalid_type(Unexpected::Enum, &self))
-    }
-
-    // Used when deserializing a flattened Option field. Not public API.
-    #[doc(hidden)]
-    fn __private_visit_untagged_option<D>(self, _: D) -> Result<Self::Value, ()>
-    where
-        D: Deserializer<'de>,
-    {
-        Err(())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Provides a `Visitor` access to each element of a sequence in the input.
-///
-/// This is a trait that a `Deserializer` passes to a `Visitor` implementation,
-/// which deserializes each item in a sequence.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by deserialized sequence elements. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SeqAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SeqAccess<'de> {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-
-    /// This returns `Ok(Some(value))` for the next value in the sequence, or
-    /// `Ok(None)` if there are no more remaining items.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `SeqAccess::next_element` instead.
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>;
-
-    /// This returns `Ok(Some(value))` for the next value in the sequence, or
-    /// `Ok(None)` if there are no more remaining items.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `SeqAccess` implementations should not override the default behavior.
-    #[inline]
-    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
-    where
-        T: Deserialize<'de>,
-    {
-        self.next_element_seed(PhantomData)
-    }
-
-    /// Returns the number of elements remaining in the sequence, if known.
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        None
-    }
-}
-
-impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A
-where
-    A: SeqAccess<'de>,
-{
-    type Error = A::Error;
-
-    #[inline]
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        (**self).next_element_seed(seed)
-    }
-
-    #[inline]
-    fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>
-    where
-        T: Deserialize<'de>,
-    {
-        (**self).next_element()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        (**self).size_hint()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Provides a `Visitor` access to each entry of a map in the input.
-///
-/// This is a trait that a `Deserializer` passes to a `Visitor` implementation.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by deserialized map entries. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `MapAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait MapAccess<'de> {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-
-    /// This returns `Ok(Some(key))` for the next key in the map, or `Ok(None)`
-    /// if there are no more remaining entries.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `MapAccess::next_key` or `MapAccess::next_entry` instead.
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
-    where
-        K: DeserializeSeed<'de>;
-
-    /// This returns a `Ok(value)` for the next value in the map.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `MapAccess::next_value` instead.
-    ///
-    /// # Panics
-    ///
-    /// Calling `next_value_seed` before `next_key_seed` is incorrect and is
-    /// allowed to panic or return bogus results.
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
-    where
-        V: DeserializeSeed<'de>;
-
-    /// This returns `Ok(Some((key, value)))` for the next (key-value) pair in
-    /// the map, or `Ok(None)` if there are no more remaining items.
-    ///
-    /// `MapAccess` implementations should override the default behavior if a
-    /// more efficient implementation is possible.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `MapAccess::next_entry` instead.
-    #[inline]
-    fn next_entry_seed<K, V>(
-        &mut self,
-        kseed: K,
-        vseed: V,
-    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
-    where
-        K: DeserializeSeed<'de>,
-        V: DeserializeSeed<'de>,
-    {
-        match tri!(self.next_key_seed(kseed)) {
-            Some(key) => {
-                let value = tri!(self.next_value_seed(vseed));
-                Ok(Some((key, value)))
-            }
-            None => Ok(None),
-        }
-    }
-
-    /// This returns `Ok(Some(key))` for the next key in the map, or `Ok(None)`
-    /// if there are no more remaining entries.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `MapAccess` implementations should not override the default behavior.
-    #[inline]
-    fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
-    where
-        K: Deserialize<'de>,
-    {
-        self.next_key_seed(PhantomData)
-    }
-
-    /// This returns a `Ok(value)` for the next value in the map.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `MapAccess` implementations should not override the default behavior.
-    ///
-    /// # Panics
-    ///
-    /// Calling `next_value` before `next_key` is incorrect and is allowed to
-    /// panic or return bogus results.
-    #[inline]
-    fn next_value<V>(&mut self) -> Result<V, Self::Error>
-    where
-        V: Deserialize<'de>,
-    {
-        self.next_value_seed(PhantomData)
-    }
-
-    /// This returns `Ok(Some((key, value)))` for the next (key-value) pair in
-    /// the map, or `Ok(None)` if there are no more remaining items.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `MapAccess` implementations should not override the default behavior.
-    #[inline]
-    fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
-    where
-        K: Deserialize<'de>,
-        V: Deserialize<'de>,
-    {
-        self.next_entry_seed(PhantomData, PhantomData)
-    }
-
-    /// Returns the number of entries remaining in the map, if known.
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        None
-    }
-}
-
-impl<'de, 'a, A: ?Sized> MapAccess<'de> for &'a mut A
-where
-    A: MapAccess<'de>,
-{
-    type Error = A::Error;
-
-    #[inline]
-    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
-    where
-        K: DeserializeSeed<'de>,
-    {
-        (**self).next_key_seed(seed)
-    }
-
-    #[inline]
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        (**self).next_value_seed(seed)
-    }
-
-    #[inline]
-    fn next_entry_seed<K, V>(
-        &mut self,
-        kseed: K,
-        vseed: V,
-    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
-    where
-        K: DeserializeSeed<'de>,
-        V: DeserializeSeed<'de>,
-    {
-        (**self).next_entry_seed(kseed, vseed)
-    }
-
-    #[inline]
-    fn next_entry<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
-    where
-        K: Deserialize<'de>,
-        V: Deserialize<'de>,
-    {
-        (**self).next_entry()
-    }
-
-    #[inline]
-    fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error>
-    where
-        K: Deserialize<'de>,
-    {
-        (**self).next_key()
-    }
-
-    #[inline]
-    fn next_value<V>(&mut self) -> Result<V, Self::Error>
-    where
-        V: Deserialize<'de>,
-    {
-        (**self).next_value()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> Option<usize> {
-        (**self).size_hint()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Provides a `Visitor` access to the data of an enum in the input.
-///
-/// `EnumAccess` is created by the `Deserializer` and passed to the
-/// `Visitor` in order to identify which variant of an enum to deserialize.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by the deserialized enum variant. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `EnumAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait EnumAccess<'de>: Sized {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization.
-    type Error: Error;
-    /// The `Visitor` that will be used to deserialize the content of the enum
-    /// variant.
-    type Variant: VariantAccess<'de, Error = Self::Error>;
-
-    /// `variant` is called to identify which variant to deserialize.
-    ///
-    /// `Deserialize` implementations should typically use `EnumAccess::variant`
-    /// instead.
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
-    where
-        V: DeserializeSeed<'de>;
-
-    /// `variant` is called to identify which variant to deserialize.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `EnumAccess` implementations should not override the default behavior.
-    #[inline]
-    fn variant<V>(self) -> Result<(V, Self::Variant), Self::Error>
-    where
-        V: Deserialize<'de>,
-    {
-        self.variant_seed(PhantomData)
-    }
-}
-
-/// `VariantAccess` is a visitor that is created by the `Deserializer` and
-/// passed to the `Deserialize` to deserialize the content of a particular enum
-/// variant.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed by the deserialized enum variant. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `VariantAccess` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait VariantAccess<'de>: Sized {
-    /// The error type that can be returned if some error occurs during
-    /// deserialization. Must match the error type of our `EnumAccess`.
-    type Error: Error;
-
-    /// Called when deserializing a variant with no values.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2021
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// fn unit_variant(self) -> Result<(), Self::Error> {
-    ///     // What the data actually contained; suppose it is a tuple variant.
-    ///     let unexp = Unexpected::TupleVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"unit variant"))
-    /// }
-    /// #
-    /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #     where
-    /// #         T: DeserializeSeed<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// # }
-    /// ```
-    fn unit_variant(self) -> Result<(), Self::Error>;
-
-    /// Called when deserializing a variant with a single value.
-    ///
-    /// `Deserialize` implementations should typically use
-    /// `VariantAccess::newtype_variant` instead.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2021
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// #     fn unit_variant(self) -> Result<(), Self::Error> {
-    /// #         unimplemented!()
-    /// #     }
-    /// #
-    /// fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
-    /// where
-    ///     T: DeserializeSeed<'de>,
-    /// {
-    ///     // What the data actually contained; suppose it is a unit variant.
-    ///     let unexp = Unexpected::UnitVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"newtype variant"))
-    /// }
-    /// #
-    /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// # }
-    /// ```
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: DeserializeSeed<'de>;
-
-    /// Called when deserializing a variant with a single value.
-    ///
-    /// This method exists as a convenience for `Deserialize` implementations.
-    /// `VariantAccess` implementations should not override the default
-    /// behavior.
-    #[inline]
-    fn newtype_variant<T>(self) -> Result<T, Self::Error>
-    where
-        T: Deserialize<'de>,
-    {
-        self.newtype_variant_seed(PhantomData)
-    }
-
-    /// Called when deserializing a tuple-like variant.
-    ///
-    /// The `len` is the number of fields expected in the tuple variant.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2021
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// #     fn unit_variant(self) -> Result<(), Self::Error> {
-    /// #         unimplemented!()
-    /// #     }
-    /// #
-    /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #     where
-    /// #         T: DeserializeSeed<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
-    /// where
-    ///     V: Visitor<'de>,
-    /// {
-    ///     // What the data actually contained; suppose it is a unit variant.
-    ///     let unexp = Unexpected::UnitVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"tuple variant"))
-    /// }
-    /// #
-    /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// # }
-    /// ```
-    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-
-    /// Called when deserializing a struct-like variant.
-    ///
-    /// The `fields` are the names of the fields of the struct variant.
-    ///
-    /// If the data contains a different type of variant, the following
-    /// `invalid_type` error should be constructed:
-    ///
-    /// ```edition2021
-    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
-    /// #
-    /// # struct X;
-    /// #
-    /// # impl<'de> VariantAccess<'de> for X {
-    /// #     type Error = value::Error;
-    /// #
-    /// #     fn unit_variant(self) -> Result<(), Self::Error> {
-    /// #         unimplemented!()
-    /// #     }
-    /// #
-    /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #     where
-    /// #         T: DeserializeSeed<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #     where
-    /// #         V: Visitor<'de>,
-    /// #     { unimplemented!() }
-    /// #
-    /// fn struct_variant<V>(
-    ///     self,
-    ///     _fields: &'static [&'static str],
-    ///     _visitor: V,
-    /// ) -> Result<V::Value, Self::Error>
-    /// where
-    ///     V: Visitor<'de>,
-    /// {
-    ///     // What the data actually contained; suppose it is a unit variant.
-    ///     let unexp = Unexpected::UnitVariant;
-    ///     Err(de::Error::invalid_type(unexp, &"struct variant"))
-    /// }
-    /// # }
-    /// ```
-    fn struct_variant<V>(
-        self,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Converts an existing value into a `Deserializer` from which other values can
-/// be deserialized.
-///
-/// # Lifetime
-///
-/// The `'de` lifetime of this trait is the lifetime of data that may be
-/// borrowed from the resulting `Deserializer`. See the page [Understanding
-/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
-///
-/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
-///
-/// # Example
-///
-/// ```edition2021
-/// use serde::de::{value, Deserialize, IntoDeserializer};
-/// use serde_derive::Deserialize;
-/// use std::str::FromStr;
-///
-/// #[derive(Deserialize)]
-/// enum Setting {
-///     On,
-///     Off,
-/// }
-///
-/// impl FromStr for Setting {
-///     type Err = value::Error;
-///
-///     fn from_str(s: &str) -> Result<Self, Self::Err> {
-///         Self::deserialize(s.into_deserializer())
-///     }
-/// }
-/// ```
-pub trait IntoDeserializer<'de, E: Error = value::Error> {
-    /// The type of the deserializer being converted into.
-    type Deserializer: Deserializer<'de, Error = E>;
-
-    /// Convert this value into a deserializer.
-    fn into_deserializer(self) -> Self::Deserializer;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Used in error messages.
-///
-/// - expected `a`
-/// - expected `a` or `b`
-/// - expected one of `a`, `b`, `c`
-///
-/// The slice of names must not be empty.
-struct OneOf {
-    names: &'static [&'static str],
-}
-
-impl Display for OneOf {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self.names.len() {
-            0 => panic!(), // special case elsewhere
-            1 => write!(formatter, "`{}`", self.names[0]),
-            2 => write!(formatter, "`{}` or `{}`", self.names[0], self.names[1]),
-            _ => {
-                tri!(write!(formatter, "one of "));
-                for (i, alt) in self.names.iter().enumerate() {
-                    if i > 0 {
-                        tri!(write!(formatter, ", "));
-                    }
-                    tri!(write!(formatter, "`{}`", alt));
-                }
-                Ok(())
-            }
-        }
-    }
-}
diff --git a/vendor/serde/src/de/seed.rs b/vendor/serde/src/de/seed.rs
deleted file mode 100644
index 52fb89d..0000000
--- a/vendor/serde/src/de/seed.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use crate::de::{Deserialize, DeserializeSeed, Deserializer};
-
-/// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
-///
-/// Wraps a mutable reference and calls deserialize_in_place on it.
-pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T);
-
-impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T>
-where
-    T: Deserialize<'de>,
-{
-    type Value = ();
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        T::deserialize_in_place(deserializer, self.0)
-    }
-}
diff --git a/vendor/serde/src/de/size_hint.rs b/vendor/serde/src/de/size_hint.rs
deleted file mode 100644
index 4a4fe25..0000000
--- a/vendor/serde/src/de/size_hint.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use crate::lib::*;
-
-pub fn from_bounds<I>(iter: &I) -> Option<usize>
-where
-    I: Iterator,
-{
-    helper(iter.size_hint())
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-pub fn cautious<Element>(hint: Option<usize>) -> usize {
-    const MAX_PREALLOC_BYTES: usize = 1024 * 1024;
-
-    if mem::size_of::<Element>() == 0 {
-        0
-    } else {
-        cmp::min(
-            hint.unwrap_or(0),
-            MAX_PREALLOC_BYTES / mem::size_of::<Element>(),
-        )
-    }
-}
-
-fn helper(bounds: (usize, Option<usize>)) -> Option<usize> {
-    match bounds {
-        (lower, Some(upper)) if lower == upper => Some(upper),
-        _ => None,
-    }
-}
diff --git a/vendor/serde/src/de/value.rs b/vendor/serde/src/de/value.rs
deleted file mode 100644
index b229eba..0000000
--- a/vendor/serde/src/de/value.rs
+++ /dev/null
@@ -1,1720 +0,0 @@
-//! Building blocks for deserializing basic values using the `IntoDeserializer`
-//! trait.
-//!
-//! ```edition2021
-//! use serde::de::{value, Deserialize, IntoDeserializer};
-//! use serde_derive::Deserialize;
-//! use std::str::FromStr;
-//!
-//! #[derive(Deserialize)]
-//! enum Setting {
-//!     On,
-//!     Off,
-//! }
-//!
-//! impl FromStr for Setting {
-//!     type Err = value::Error;
-//!
-//!     fn from_str(s: &str) -> Result<Self, Self::Err> {
-//!         Self::deserialize(s.into_deserializer())
-//!     }
-//! }
-//! ```
-
-use crate::lib::*;
-
-use self::private::{First, Second};
-use crate::de::{self, size_hint, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor};
-use crate::ser;
-
-////////////////////////////////////////////////////////////////////////////////
-
-// For structs that contain a PhantomData. We do not want the trait
-// bound `E: Clone` inferred by derive(Clone).
-macro_rules! impl_copy_clone {
-    ($ty:ident $(<$lifetime:tt>)*) => {
-        impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
-
-        impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> {
-            fn clone(&self) -> Self {
-                *self
-            }
-        }
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A minimal representation of all possible errors that can occur using the
-/// `IntoDeserializer` trait.
-#[derive(Clone, PartialEq)]
-pub struct Error {
-    err: ErrorImpl,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-type ErrorImpl = Box<str>;
-#[cfg(not(any(feature = "std", feature = "alloc")))]
-type ErrorImpl = ();
-
-impl de::Error for Error {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cold]
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        Error {
-            err: msg.to_string().into_boxed_str(),
-        }
-    }
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    #[cold]
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        let _ = msg;
-        Error { err: () }
-    }
-}
-
-impl ser::Error for Error {
-    #[cold]
-    fn custom<T>(msg: T) -> Self
-    where
-        T: Display,
-    {
-        de::Error::custom(msg)
-    }
-}
-
-impl Display for Error {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str(&self.err)
-    }
-
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("Serde deserialization error")
-    }
-}
-
-impl Debug for Error {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        let mut debug = formatter.debug_tuple("Error");
-        #[cfg(any(feature = "std", feature = "alloc"))]
-        debug.field(&self.err);
-        debug.finish()
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        &self.err
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<'de, E> IntoDeserializer<'de, E> for ()
-where
-    E: de::Error,
-{
-    type Deserializer = UnitDeserializer<E>;
-
-    fn into_deserializer(self) -> UnitDeserializer<E> {
-        UnitDeserializer::new()
-    }
-}
-
-/// A deserializer holding a `()`.
-pub struct UnitDeserializer<E> {
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(UnitDeserializer);
-
-impl<E> UnitDeserializer<E> {
-    #[allow(missing_docs)]
-    pub fn new() -> Self {
-        UnitDeserializer {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct enum identifier ignored_any
-    }
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_unit()
-    }
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_none()
-    }
-}
-
-impl<E> Debug for UnitDeserializer<E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.debug_struct("UnitDeserializer").finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that cannot be instantiated.
-#[cfg(feature = "unstable")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
-pub struct NeverDeserializer<E> {
-    never: !,
-    marker: PhantomData<E>,
-}
-
-#[cfg(feature = "unstable")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
-impl<'de, E> IntoDeserializer<'de, E> for !
-where
-    E: de::Error,
-{
-    type Deserializer = NeverDeserializer<E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.never
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! primitive_deserializer {
-    ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
-        #[doc = "A deserializer holding"]
-        #[doc = $doc]
-        pub struct $name<E> {
-            value: $ty,
-            marker: PhantomData<E>
-        }
-
-        impl_copy_clone!($name);
-
-        impl<'de, E> IntoDeserializer<'de, E> for $ty
-        where
-            E: de::Error,
-        {
-            type Deserializer = $name<E>;
-
-            fn into_deserializer(self) -> $name<E> {
-                $name::new(self)
-            }
-        }
-
-        impl<E> $name<E> {
-            #[allow(missing_docs)]
-            pub fn new(value: $ty) -> Self {
-                $name {
-                    value,
-                    marker: PhantomData,
-                }
-            }
-        }
-
-        impl<'de, E> de::Deserializer<'de> for $name<E>
-        where
-            E: de::Error,
-        {
-            type Error = E;
-
-            forward_to_deserialize_any! {
-                bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str
-                string bytes byte_buf option unit unit_struct newtype_struct seq
-                tuple tuple_struct map struct enum identifier ignored_any
-            }
-
-            fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-            where
-                V: de::Visitor<'de>,
-            {
-                visitor.$method(self.value $($cast)*)
-            }
-        }
-
-        impl<E> Debug for $name<E> {
-            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter
-                    .debug_struct(stringify!($name))
-                    .field("value", &self.value)
-                    .finish()
-            }
-        }
-    }
-}
-
-primitive_deserializer!(bool, "a `bool`.", BoolDeserializer, visit_bool);
-primitive_deserializer!(i8, "an `i8`.", I8Deserializer, visit_i8);
-primitive_deserializer!(i16, "an `i16`.", I16Deserializer, visit_i16);
-primitive_deserializer!(i32, "an `i32`.", I32Deserializer, visit_i32);
-primitive_deserializer!(i64, "an `i64`.", I64Deserializer, visit_i64);
-primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
-primitive_deserializer!(isize, "an `isize`.", IsizeDeserializer, visit_i64 as i64);
-primitive_deserializer!(u8, "a `u8`.", U8Deserializer, visit_u8);
-primitive_deserializer!(u16, "a `u16`.", U16Deserializer, visit_u16);
-primitive_deserializer!(u64, "a `u64`.", U64Deserializer, visit_u64);
-primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
-primitive_deserializer!(usize, "a `usize`.", UsizeDeserializer, visit_u64 as u64);
-primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
-primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
-primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
-
-/// A deserializer holding a `u32`.
-pub struct U32Deserializer<E> {
-    value: u32,
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(U32Deserializer);
-
-impl<'de, E> IntoDeserializer<'de, E> for u32
-where
-    E: de::Error,
-{
-    type Deserializer = U32Deserializer<E>;
-
-    fn into_deserializer(self) -> U32Deserializer<E> {
-        U32Deserializer::new(self)
-    }
-}
-
-impl<E> U32Deserializer<E> {
-    #[allow(missing_docs)]
-    pub fn new(value: u32) -> Self {
-        U32Deserializer {
-            value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, E> de::Deserializer<'de> for U32Deserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_u32(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-}
-
-impl<'de, E> de::EnumAccess<'de> for U32Deserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-impl<E> Debug for U32Deserializer<E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("U32Deserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&str`.
-pub struct StrDeserializer<'a, E> {
-    value: &'a str,
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(StrDeserializer<'de>);
-
-impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
-where
-    E: de::Error,
-{
-    type Deserializer = StrDeserializer<'a, E>;
-
-    fn into_deserializer(self) -> StrDeserializer<'a, E> {
-        StrDeserializer::new(self)
-    }
-}
-
-impl<'a, E> StrDeserializer<'a, E> {
-    #[allow(missing_docs)]
-    pub fn new(value: &'a str) -> Self {
-        StrDeserializer {
-            value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, 'a, E> de::Deserializer<'de> for StrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_str(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de, 'a, E> de::EnumAccess<'de> for StrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-impl<'a, E> Debug for StrDeserializer<'a, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("StrDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&str` with a lifetime tied to another
-/// deserializer.
-pub struct BorrowedStrDeserializer<'de, E> {
-    value: &'de str,
-    marker: PhantomData<E>,
-}
-
-impl_copy_clone!(BorrowedStrDeserializer<'de>);
-
-impl<'de, E> BorrowedStrDeserializer<'de, E> {
-    /// Create a new borrowed deserializer from the given string.
-    pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
-        BorrowedStrDeserializer {
-            value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_borrowed_str(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-impl<'de, E> Debug for BorrowedStrDeserializer<'de, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("BorrowedStrDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `String`.
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-pub struct StringDeserializer<E> {
-    value: String,
-    marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> Clone for StringDeserializer<E> {
-    fn clone(&self) -> Self {
-        StringDeserializer {
-            value: self.value.clone(),
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, E> IntoDeserializer<'de, E> for String
-where
-    E: de::Error,
-{
-    type Deserializer = StringDeserializer<E>;
-
-    fn into_deserializer(self) -> StringDeserializer<E> {
-        StringDeserializer::new(self)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> StringDeserializer<E> {
-    #[allow(missing_docs)]
-    pub fn new(value: String) -> Self {
-        StringDeserializer {
-            value,
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, E> de::Deserializer<'de> for StringDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_string(self.value)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, E> de::EnumAccess<'de> for StringDeserializer<E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<E> Debug for StringDeserializer<E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("StringDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `Cow<str>`.
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-pub struct CowStrDeserializer<'a, E> {
-    value: Cow<'a, str>,
-    marker: PhantomData<E>,
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> Clone for CowStrDeserializer<'a, E> {
-    fn clone(&self) -> Self {
-        CowStrDeserializer {
-            value: self.value.clone(),
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
-where
-    E: de::Error,
-{
-    type Deserializer = CowStrDeserializer<'a, E>;
-
-    fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
-        CowStrDeserializer::new(self)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> CowStrDeserializer<'a, E> {
-    #[allow(missing_docs)]
-    pub fn new(value: Cow<'a, str>) -> Self {
-        CowStrDeserializer {
-            value,
-            marker: PhantomData,
-        }
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self.value {
-            Cow::Borrowed(string) => visitor.visit_str(string),
-            Cow::Owned(string) => visitor.visit_string(string),
-        }
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = name;
-        let _ = variants;
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-    type Variant = private::UnitOnly<E>;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        seed.deserialize(self).map(private::unit_only)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-impl<'a, E> Debug for CowStrDeserializer<'a, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("CowStrDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`].
-pub struct BytesDeserializer<'a, E> {
-    value: &'a [u8],
-    marker: PhantomData<E>,
-}
-
-impl<'a, E> BytesDeserializer<'a, E> {
-    /// Create a new deserializer from the given bytes.
-    pub fn new(value: &'a [u8]) -> Self {
-        BytesDeserializer {
-            value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl_copy_clone!(BytesDeserializer<'a>);
-
-impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a [u8]
-where
-    E: de::Error,
-{
-    type Deserializer = BytesDeserializer<'a, E>;
-
-    fn into_deserializer(self) -> BytesDeserializer<'a, E> {
-        BytesDeserializer::new(self)
-    }
-}
-
-impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_bytes(self.value)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-impl<'a, E> Debug for BytesDeserializer<'a, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("BytesDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-/// A deserializer holding a `&[u8]` with a lifetime tied to another
-/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`].
-pub struct BorrowedBytesDeserializer<'de, E> {
-    value: &'de [u8],
-    marker: PhantomData<E>,
-}
-
-impl<'de, E> BorrowedBytesDeserializer<'de, E> {
-    /// Create a new borrowed deserializer from the given borrowed bytes.
-    pub fn new(value: &'de [u8]) -> Self {
-        BorrowedBytesDeserializer {
-            value,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl_copy_clone!(BorrowedBytesDeserializer<'de>);
-
-impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
-where
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_borrowed_bytes(self.value)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-impl<'de, E> Debug for BorrowedBytesDeserializer<'de, E> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("BorrowedBytesDeserializer")
-            .field("value", &self.value)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that iterates over a sequence.
-#[derive(Clone)]
-pub struct SeqDeserializer<I, E> {
-    iter: iter::Fuse<I>,
-    count: usize,
-    marker: PhantomData<E>,
-}
-
-impl<I, E> SeqDeserializer<I, E>
-where
-    I: Iterator,
-{
-    /// Construct a new `SeqDeserializer<I, E>`.
-    pub fn new(iter: I) -> Self {
-        SeqDeserializer {
-            iter: iter.fuse(),
-            count: 0,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<I, E> SeqDeserializer<I, E>
-where
-    I: Iterator,
-    E: de::Error,
-{
-    /// Check for remaining elements after passing a `SeqDeserializer` to
-    /// `Visitor::visit_seq`.
-    pub fn end(self) -> Result<(), E> {
-        let remaining = self.iter.count();
-        if remaining == 0 {
-            Ok(())
-        } else {
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(
-                self.count + remaining,
-                &ExpectedInSeq(self.count),
-            ))
-        }
-    }
-}
-
-impl<'de, I, T, E> de::Deserializer<'de> for SeqDeserializer<I, E>
-where
-    I: Iterator<Item = T>,
-    T: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let v = tri!(visitor.visit_seq(&mut self));
-        tri!(self.end());
-        Ok(v)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-impl<'de, I, T, E> de::SeqAccess<'de> for SeqDeserializer<I, E>
-where
-    I: Iterator<Item = T>,
-    T: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_element_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error>
-    where
-        V: de::DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(value) => {
-                self.count += 1;
-                seed.deserialize(value.into_deserializer()).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        size_hint::from_bounds(&self.iter)
-    }
-}
-
-struct ExpectedInSeq(usize);
-
-impl Expected for ExpectedInSeq {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        if self.0 == 1 {
-            write!(formatter, "1 element in sequence")
-        } else {
-            write!(formatter, "{} elements in sequence", self.0)
-        }
-    }
-}
-
-impl<I, E> Debug for SeqDeserializer<I, E>
-where
-    I: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("SeqDeserializer")
-            .field("iter", &self.iter)
-            .field("count", &self.count)
-            .finish()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
-where
-    T: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        SeqDeserializer::new(self.into_iter())
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
-where
-    T: IntoDeserializer<'de, E> + Eq + Ord,
-    E: de::Error,
-{
-    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        SeqDeserializer::new(self.into_iter())
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
-where
-    T: IntoDeserializer<'de, E> + Eq + Hash,
-    S: BuildHasher,
-    E: de::Error,
-{
-    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        SeqDeserializer::new(self.into_iter())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `SeqAccess`.
-#[derive(Clone, Debug)]
-pub struct SeqAccessDeserializer<A> {
-    seq: A,
-}
-
-impl<A> SeqAccessDeserializer<A> {
-    /// Construct a new `SeqAccessDeserializer<A>`.
-    pub fn new(seq: A) -> Self {
-        SeqAccessDeserializer { seq }
-    }
-}
-
-impl<'de, A> de::Deserializer<'de> for SeqAccessDeserializer<A>
-where
-    A: de::SeqAccess<'de>,
-{
-    type Error = A::Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_seq(self.seq)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer that iterates over a map.
-pub struct MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-{
-    iter: iter::Fuse<I>,
-    value: Option<Second<I::Item>>,
-    count: usize,
-    lifetime: PhantomData<&'de ()>,
-    error: PhantomData<E>,
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-{
-    /// Construct a new `MapDeserializer<I, E>`.
-    pub fn new(iter: I) -> Self {
-        MapDeserializer {
-            iter: iter.fuse(),
-            value: None,
-            count: 0,
-            lifetime: PhantomData,
-            error: PhantomData,
-        }
-    }
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    E: de::Error,
-{
-    /// Check for remaining elements after passing a `MapDeserializer` to
-    /// `Visitor::visit_map`.
-    pub fn end(self) -> Result<(), E> {
-        let remaining = self.iter.count();
-        if remaining == 0 {
-            Ok(())
-        } else {
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(
-                self.count + remaining,
-                &ExpectedInMap(self.count),
-            ))
-        }
-    }
-}
-
-impl<'de, I, E> MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-{
-    fn next_pair(&mut self) -> Option<(First<I::Item>, Second<I::Item>)> {
-        match self.iter.next() {
-            Some(kv) => {
-                self.count += 1;
-                Some(private::Pair::split(kv))
-            }
-            None => None,
-        }
-    }
-}
-
-impl<'de, I, E> de::Deserializer<'de> for MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    First<I::Item>: IntoDeserializer<'de, E>,
-    Second<I::Item>: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let value = tri!(visitor.visit_map(&mut self));
-        tri!(self.end());
-        Ok(value)
-    }
-
-    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let value = tri!(visitor.visit_seq(&mut self));
-        tri!(self.end());
-        Ok(value)
-    }
-
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let _ = len;
-        self.deserialize_seq(visitor)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
-        struct enum identifier ignored_any
-    }
-}
-
-impl<'de, I, E> de::MapAccess<'de> for MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    First<I::Item>: IntoDeserializer<'de, E>,
-    Second<I::Item>: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match self.next_pair() {
-            Some((key, value)) => {
-                self.value = Some(value);
-                seed.deserialize(key.into_deserializer()).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        let value = self.value.take();
-        // Panic because this indicates a bug in the program rather than an
-        // expected failure.
-        let value = value.expect("MapAccess::next_value called before next_key");
-        seed.deserialize(value.into_deserializer())
-    }
-
-    fn next_entry_seed<TK, TV>(
-        &mut self,
-        kseed: TK,
-        vseed: TV,
-    ) -> Result<Option<(TK::Value, TV::Value)>, Self::Error>
-    where
-        TK: de::DeserializeSeed<'de>,
-        TV: de::DeserializeSeed<'de>,
-    {
-        match self.next_pair() {
-            Some((key, value)) => {
-                let key = tri!(kseed.deserialize(key.into_deserializer()));
-                let value = tri!(vseed.deserialize(value.into_deserializer()));
-                Ok(Some((key, value)))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        size_hint::from_bounds(&self.iter)
-    }
-}
-
-impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E>
-where
-    I: Iterator,
-    I::Item: private::Pair,
-    First<I::Item>: IntoDeserializer<'de, E>,
-    Second<I::Item>: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match self.next_pair() {
-            Some((k, v)) => {
-                let de = PairDeserializer(k, v, PhantomData);
-                seed.deserialize(de).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        size_hint::from_bounds(&self.iter)
-    }
-}
-
-// Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`.
-impl<'de, I, E> Clone for MapDeserializer<'de, I, E>
-where
-    I: Iterator + Clone,
-    I::Item: private::Pair,
-    Second<I::Item>: Clone,
-{
-    fn clone(&self) -> Self {
-        MapDeserializer {
-            iter: self.iter.clone(),
-            value: self.value.clone(),
-            count: self.count,
-            lifetime: self.lifetime,
-            error: self.error,
-        }
-    }
-}
-
-impl<'de, I, E> Debug for MapDeserializer<'de, I, E>
-where
-    I: Iterator + Debug,
-    I::Item: private::Pair,
-    Second<I::Item>: Debug,
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter
-            .debug_struct("MapDeserializer")
-            .field("iter", &self.iter)
-            .field("value", &self.value)
-            .field("count", &self.count)
-            .finish()
-    }
-}
-
-// Used in the `impl SeqAccess for MapDeserializer` to visit the map as a
-// sequence of pairs.
-struct PairDeserializer<A, B, E>(A, B, PhantomData<E>);
-
-impl<'de, A, B, E> de::Deserializer<'de> for PairDeserializer<A, B, E>
-where
-    A: IntoDeserializer<'de, E>,
-    B: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct tuple_struct map
-        struct enum identifier ignored_any
-    }
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        let mut pair_visitor = PairVisitor(Some(self.0), Some(self.1), PhantomData);
-        let pair = tri!(visitor.visit_seq(&mut pair_visitor));
-        if pair_visitor.1.is_none() {
-            Ok(pair)
-        } else {
-            let remaining = pair_visitor.size_hint().unwrap();
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(2, &ExpectedInSeq(2 - remaining)))
-        }
-    }
-
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        if len == 2 {
-            self.deserialize_seq(visitor)
-        } else {
-            // First argument is the number of elements in the data, second
-            // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(2, &ExpectedInSeq(len)))
-        }
-    }
-}
-
-struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
-
-impl<'de, A, B, E> de::SeqAccess<'de> for PairVisitor<A, B, E>
-where
-    A: IntoDeserializer<'de, E>,
-    B: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Error = E;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        if let Some(k) = self.0.take() {
-            seed.deserialize(k.into_deserializer()).map(Some)
-        } else if let Some(v) = self.1.take() {
-            seed.deserialize(v.into_deserializer()).map(Some)
-        } else {
-            Ok(None)
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        if self.0.is_some() {
-            Some(2)
-        } else if self.1.is_some() {
-            Some(1)
-        } else {
-            Some(0)
-        }
-    }
-}
-
-struct ExpectedInMap(usize);
-
-impl Expected for ExpectedInMap {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        if self.0 == 1 {
-            write!(formatter, "1 element in map")
-        } else {
-            write!(formatter, "{} elements in map", self.0)
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
-where
-    K: IntoDeserializer<'de, E> + Eq + Ord,
-    V: IntoDeserializer<'de, E>,
-    E: de::Error,
-{
-    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        MapDeserializer::new(self.into_iter())
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
-where
-    K: IntoDeserializer<'de, E> + Eq + Hash,
-    V: IntoDeserializer<'de, E>,
-    S: BuildHasher,
-    E: de::Error,
-{
-    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        MapDeserializer::new(self.into_iter())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding a `MapAccess`.
-#[derive(Clone, Debug)]
-pub struct MapAccessDeserializer<A> {
-    map: A,
-}
-
-impl<A> MapAccessDeserializer<A> {
-    /// Construct a new `MapAccessDeserializer<A>`.
-    pub fn new(map: A) -> Self {
-        MapAccessDeserializer { map }
-    }
-}
-
-impl<'de, A> de::Deserializer<'de> for MapAccessDeserializer<A>
-where
-    A: de::MapAccess<'de>,
-{
-    type Error = A::Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_map(self.map)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A>
-where
-    A: de::MapAccess<'de>,
-{
-    type Error = A::Error;
-    type Variant = private::MapAsEnum<A>;
-
-    fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        match tri!(self.map.next_key_seed(seed)) {
-            Some(key) => Ok((key, private::map_as_enum(self.map))),
-            None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A deserializer holding an `EnumAccess`.
-#[derive(Clone, Debug)]
-pub struct EnumAccessDeserializer<A> {
-    access: A,
-}
-
-impl<A> EnumAccessDeserializer<A> {
-    /// Construct a new `EnumAccessDeserializer<A>`.
-    pub fn new(access: A) -> Self {
-        EnumAccessDeserializer { access }
-    }
-}
-
-impl<'de, A> de::Deserializer<'de> for EnumAccessDeserializer<A>
-where
-    A: de::EnumAccess<'de>,
-{
-    type Error = A::Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_enum(self.access)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct enum identifier ignored_any
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-mod private {
-    use crate::lib::*;
-
-    use crate::de::{
-        self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor,
-    };
-
-    pub struct UnitOnly<E> {
-        marker: PhantomData<E>,
-    }
-
-    pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
-        (
-            t,
-            UnitOnly {
-                marker: PhantomData,
-            },
-        )
-    }
-
-    impl<'de, E> de::VariantAccess<'de> for UnitOnly<E>
-    where
-        E: de::Error,
-    {
-        type Error = E;
-
-        fn unit_variant(self) -> Result<(), Self::Error> {
-            Ok(())
-        }
-
-        fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
-        where
-            T: de::DeserializeSeed<'de>,
-        {
-            Err(de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"newtype variant",
-            ))
-        }
-
-        fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            Err(de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"tuple variant",
-            ))
-        }
-
-        fn struct_variant<V>(
-            self,
-            _fields: &'static [&'static str],
-            _visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: de::Visitor<'de>,
-        {
-            Err(de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"struct variant",
-            ))
-        }
-    }
-
-    pub struct MapAsEnum<A> {
-        map: A,
-    }
-
-    pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
-        MapAsEnum { map }
-    }
-
-    impl<'de, A> VariantAccess<'de> for MapAsEnum<A>
-    where
-        A: MapAccess<'de>,
-    {
-        type Error = A::Error;
-
-        fn unit_variant(mut self) -> Result<(), Self::Error> {
-            self.map.next_value()
-        }
-
-        fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
-        where
-            T: DeserializeSeed<'de>,
-        {
-            self.map.next_value_seed(seed)
-        }
-
-        fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.map.next_value_seed(SeedTupleVariant { len, visitor })
-        }
-
-        fn struct_variant<V>(
-            mut self,
-            _fields: &'static [&'static str],
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
-        where
-            V: Visitor<'de>,
-        {
-            self.map.next_value_seed(SeedStructVariant { visitor })
-        }
-    }
-
-    struct SeedTupleVariant<V> {
-        len: usize,
-        visitor: V,
-    }
-
-    impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V>
-    where
-        V: Visitor<'de>,
-    {
-        type Value = V::Value;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            deserializer.deserialize_tuple(self.len, self.visitor)
-        }
-    }
-
-    struct SeedStructVariant<V> {
-        visitor: V,
-    }
-
-    impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V>
-    where
-        V: Visitor<'de>,
-    {
-        type Value = V::Value;
-
-        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            deserializer.deserialize_map(self.visitor)
-        }
-    }
-
-    /// Avoid having to restate the generic types on `MapDeserializer`. The
-    /// `Iterator::Item` contains enough information to figure out K and V.
-    pub trait Pair {
-        type First;
-        type Second;
-        fn split(self) -> (Self::First, Self::Second);
-    }
-
-    impl<A, B> Pair for (A, B) {
-        type First = A;
-        type Second = B;
-        fn split(self) -> (A, B) {
-            self
-        }
-    }
-
-    pub type First<T> = <T as Pair>::First;
-    pub type Second<T> = <T as Pair>::Second;
-}