Deleted vendor folder

4 files changed, 0 insertions, 3415 deletions

diff --git a/vendor/serde/src/ser/fmt.rs b/vendor/serde/src/ser/fmt.rs
deleted file mode 100644
index 0650ab6..0000000
--- a/vendor/serde/src/ser/fmt.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use crate::lib::*;
-use crate::ser::{Error, Impossible, Serialize, Serializer};
-
-impl Error for fmt::Error {
-    fn custom<T: Display>(_msg: T) -> Self {
-        fmt::Error
-    }
-}
-
-macro_rules! fmt_primitives {
-    ($($f:ident: $t:ty,)*) => {
-        $(
-            fn $f(self, v: $t) -> fmt::Result {
-                Display::fmt(&v, self)
-            }
-        )*
-    };
-}
-
-/// ```edition2021
-/// use serde::ser::Serialize;
-/// use serde_derive::Serialize;
-/// use std::fmt::{self, Display};
-///
-/// #[derive(Serialize)]
-/// #[serde(rename_all = "kebab-case")]
-/// pub enum MessageType {
-///     StartRequest,
-///     EndRequest,
-/// }
-///
-/// impl Display for MessageType {
-///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-///         self.serialize(f)
-///     }
-/// }
-/// ```
-impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
-    type Ok = ();
-    type Error = fmt::Error;
-    type SerializeSeq = Impossible<(), fmt::Error>;
-    type SerializeTuple = Impossible<(), fmt::Error>;
-    type SerializeTupleStruct = Impossible<(), fmt::Error>;
-    type SerializeTupleVariant = Impossible<(), fmt::Error>;
-    type SerializeMap = Impossible<(), fmt::Error>;
-    type SerializeStruct = Impossible<(), fmt::Error>;
-    type SerializeStructVariant = Impossible<(), fmt::Error>;
-
-    fmt_primitives! {
-        serialize_bool: bool,
-        serialize_i8: i8,
-        serialize_i16: i16,
-        serialize_i32: i32,
-        serialize_i64: i64,
-        serialize_i128: i128,
-        serialize_u8: u8,
-        serialize_u16: u16,
-        serialize_u32: u32,
-        serialize_u64: u64,
-        serialize_u128: u128,
-        serialize_f32: f32,
-        serialize_f64: f64,
-        serialize_char: char,
-        serialize_str: &str,
-        serialize_unit_struct: &'static str,
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> fmt::Result {
-        Display::fmt(variant, self)
-    }
-
-    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result
-    where
-        T: Serialize,
-    {
-        Serialize::serialize(value, self)
-    }
-
-    fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_none(self) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result
-    where
-        T: Serialize,
-    {
-        Err(fmt::Error)
-    }
-
-    fn serialize_unit(self) -> fmt::Result {
-        Err(fmt::Error)
-    }
-
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> fmt::Result
-    where
-        T: Serialize,
-    {
-        Err(fmt::Error)
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStruct, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant, fmt::Error> {
-        Err(fmt::Error)
-    }
-
-    fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result
-    where
-        T: Display,
-    {
-        Display::fmt(value, self)
-    }
-}
diff --git a/vendor/serde/src/ser/impls.rs b/vendor/serde/src/ser/impls.rs
deleted file mode 100644
index 8c70634..0000000
--- a/vendor/serde/src/ser/impls.rs
+++ /dev/null
@@ -1,1077 +0,0 @@
-use crate::lib::*;
-
-use crate::ser::{Error, Serialize, SerializeTuple, Serializer};
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! primitive_impl {
-    ($ty:ident, $method:ident $($cast:tt)*) => {
-        impl Serialize for $ty {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.$method(*self $($cast)*)
-            }
-        }
-    }
-}
-
-primitive_impl!(bool, serialize_bool);
-primitive_impl!(isize, serialize_i64 as i64);
-primitive_impl!(i8, serialize_i8);
-primitive_impl!(i16, serialize_i16);
-primitive_impl!(i32, serialize_i32);
-primitive_impl!(i64, serialize_i64);
-primitive_impl!(i128, serialize_i128);
-primitive_impl!(usize, serialize_u64 as u64);
-primitive_impl!(u8, serialize_u8);
-primitive_impl!(u16, serialize_u16);
-primitive_impl!(u32, serialize_u32);
-primitive_impl!(u64, serialize_u64);
-primitive_impl!(u128, serialize_u128);
-primitive_impl!(f32, serialize_f32);
-primitive_impl!(f64, serialize_f64);
-primitive_impl!(char, serialize_char);
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl Serialize for str {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self)
-    }
-}
-
-#[cfg(any(feature = "std", feature = "alloc"))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl Serialize for String {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(self)
-    }
-}
-
-impl<'a> Serialize for fmt::Arguments<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.collect_str(self)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(any(feature = "std", not(no_core_cstr)))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for CStr {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(self.to_bytes())
-    }
-}
-
-#[cfg(any(feature = "std", all(not(no_core_cstr), feature = "alloc")))]
-#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-impl Serialize for CString {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_bytes(self.to_bytes())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for Option<T>
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Some(ref value) => serializer.serialize_some(value),
-            None => serializer.serialize_none(),
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T: ?Sized> Serialize for PhantomData<T> {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_unit_struct("PhantomData")
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-// Does not require T: Serialize.
-impl<T> Serialize for [T; 0] {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        tri!(serializer.serialize_tuple(0)).end()
-    }
-}
-
-macro_rules! array_impls {
-    ($($len:tt)+) => {
-        $(
-            impl<T> Serialize for [T; $len]
-            where
-                T: Serialize,
-            {
-                #[inline]
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    let mut seq = tri!(serializer.serialize_tuple($len));
-                    for e in self {
-                        tri!(seq.serialize_element(e));
-                    }
-                    seq.end()
-                }
-            }
-        )+
-    }
-}
-
-array_impls! {
-    01 02 03 04 05 06 07 08 09 10
-    11 12 13 14 15 16 17 18 19 20
-    21 22 23 24 25 26 27 28 29 30
-    31 32
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for [T]
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.collect_seq(self)
-    }
-}
-
-#[cfg(not(no_relaxed_trait_bounds))]
-macro_rules! seq_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
-    ) => {
-        $(#[$attr])*
-        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
-        where
-            T: Serialize,
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_seq(self)
-            }
-        }
-    }
-}
-
-#[cfg(no_relaxed_trait_bounds)]
-macro_rules! seq_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ident <T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)*>
-    ) => {
-        $(#[$attr])*
-        impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
-        where
-            T: Serialize $(+ $tbound1 $(+ $tbound2)*)*,
-            $($typaram: $bound,)*
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_seq(self)
-            }
-        }
-    }
-}
-
-seq_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    BinaryHeap<T: Ord>
-}
-
-seq_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    BTreeSet<T: Ord>
-}
-
-seq_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    HashSet<T: Eq + Hash, H: BuildHasher>
-}
-
-seq_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    LinkedList<T>
-}
-
-seq_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    Vec<T>
-}
-
-seq_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    VecDeque<T>
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<Idx> Serialize for Range<Idx>
-where
-    Idx: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = tri!(serializer.serialize_struct("Range", 2));
-        tri!(state.serialize_field("start", &self.start));
-        tri!(state.serialize_field("end", &self.end));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<Idx> Serialize for RangeFrom<Idx>
-where
-    Idx: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = tri!(serializer.serialize_struct("RangeFrom", 1));
-        tri!(state.serialize_field("start", &self.start));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<Idx> Serialize for RangeInclusive<Idx>
-where
-    Idx: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = tri!(serializer.serialize_struct("RangeInclusive", 2));
-        tri!(state.serialize_field("start", &self.start()));
-        tri!(state.serialize_field("end", &self.end()));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<Idx> Serialize for RangeTo<Idx>
-where
-    Idx: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = tri!(serializer.serialize_struct("RangeTo", 1));
-        tri!(state.serialize_field("end", &self.end));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for Bound<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Bound::Unbounded => serializer.serialize_unit_variant("Bound", 0, "Unbounded"),
-            Bound::Included(ref value) => {
-                serializer.serialize_newtype_variant("Bound", 1, "Included", value)
-            }
-            Bound::Excluded(ref value) => {
-                serializer.serialize_newtype_variant("Bound", 2, "Excluded", value)
-            }
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl Serialize for () {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_unit()
-    }
-}
-
-#[cfg(feature = "unstable")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "unstable")))]
-impl Serialize for ! {
-    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        *self
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! tuple_impls {
-    ($($len:expr => ($($n:tt $name:ident)+))+) => {
-        $(
-            impl<$($name),+> Serialize for ($($name,)+)
-            where
-                $($name: Serialize,)+
-            {
-                #[inline]
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    let mut tuple = tri!(serializer.serialize_tuple($len));
-                    $(
-                        tri!(tuple.serialize_element(&self.$n));
-                    )+
-                    tuple.end()
-                }
-            }
-        )+
-    }
-}
-
-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)
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(not(no_relaxed_trait_bounds))]
-macro_rules! map_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
-    ) => {
-        $(#[$attr])*
-        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
-        where
-            K: Serialize,
-            V: Serialize,
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_map(self)
-            }
-        }
-    }
-}
-
-#[cfg(no_relaxed_trait_bounds)]
-macro_rules! map_impl {
-    (
-        $(#[$attr:meta])*
-        $ty:ident <K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)*>
-    ) => {
-        $(#[$attr])*
-        impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
-        where
-            K: Serialize $(+ $kbound1 $(+ $kbound2)*)*,
-            V: Serialize,
-            $($typaram: $bound,)*
-        {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.collect_map(self)
-            }
-        }
-    }
-}
-
-map_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    BTreeMap<K: Ord, V>
-}
-
-map_impl! {
-    #[cfg(feature = "std")]
-    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-    HashMap<K: Eq + Hash, V, H: BuildHasher>
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! deref_impl {
-    (
-        $(#[$attr:meta])*
-        <$($desc:tt)+
-    ) => {
-        $(#[$attr])*
-        impl <$($desc)+ {
-            #[inline]
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                (**self).serialize(serializer)
-            }
-        }
-    };
-}
-
-deref_impl! {
-    <'a, T: ?Sized> Serialize for &'a T where T: Serialize
-}
-
-deref_impl! {
-    <'a, T: ?Sized> Serialize for &'a mut T where T: Serialize
-}
-
-deref_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    <T: ?Sized> Serialize for Box<T> where T: Serialize
-}
-
-deref_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Serializing a data structure containing `Rc` will serialize a copy of
-    /// the contents of the `Rc` each time the `Rc` is referenced within the
-    /// data structure. Serialization will not attempt to deduplicate these
-    /// repeated data.
-    ///
-    /// [`"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")))))]
-    <T: ?Sized> Serialize for Rc<T> where T: Serialize
-}
-
-deref_impl! {
-    /// This impl requires the [`"rc"`] Cargo feature of Serde.
-    ///
-    /// Serializing a data structure containing `Arc` will serialize a copy of
-    /// the contents of the `Arc` each time the `Arc` is referenced within the
-    /// data structure. Serialization will not attempt to deduplicate these
-    /// repeated data.
-    ///
-    /// [`"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")))))]
-    <T: ?Sized> Serialize for Arc<T> where T: Serialize
-}
-
-deref_impl! {
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
-    <'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde.
-///
-/// [`"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<T: ?Sized> Serialize for RcWeak<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.upgrade().serialize(serializer)
-    }
-}
-
-/// This impl requires the [`"rc"`] Cargo feature of Serde.
-///
-/// [`"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<T: ?Sized> Serialize for ArcWeak<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.upgrade().serialize(serializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-macro_rules! nonzero_integers {
-    ($($T:ident,)+) => {
-        $(
-            impl Serialize for num::$T {
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    self.get().serialize(serializer)
-                }
-            }
-        )+
-    }
-}
-
-nonzero_integers! {
-    NonZeroU8,
-    NonZeroU16,
-    NonZeroU32,
-    NonZeroU64,
-    NonZeroU128,
-    NonZeroUsize,
-}
-
-#[cfg(not(no_num_nonzero_signed))]
-nonzero_integers! {
-    NonZeroI8,
-    NonZeroI16,
-    NonZeroI32,
-    NonZeroI64,
-    NonZeroI128,
-    NonZeroIsize,
-}
-
-impl<T> Serialize for Cell<T>
-where
-    T: Serialize + Copy,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.get().serialize(serializer)
-    }
-}
-
-impl<T: ?Sized> Serialize for RefCell<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.try_borrow() {
-            Ok(value) => value.serialize(serializer),
-            Err(_) => Err(S::Error::custom("already mutably borrowed")),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<T: ?Sized> Serialize for Mutex<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.lock() {
-            Ok(locked) => locked.serialize(serializer),
-            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl<T: ?Sized> Serialize for RwLock<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.read() {
-            Ok(locked) => locked.serialize(serializer),
-            Err(_) => Err(S::Error::custom("lock poison error while serializing")),
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T, E> Serialize for Result<T, E>
-where
-    T: Serialize,
-    E: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match *self {
-            Result::Ok(ref value) => serializer.serialize_newtype_variant("Result", 0, "Ok", value),
-            Result::Err(ref value) => {
-                serializer.serialize_newtype_variant("Result", 1, "Err", value)
-            }
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl Serialize for Duration {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let mut state = tri!(serializer.serialize_struct("Duration", 2));
-        tri!(state.serialize_field("secs", &self.as_secs()));
-        tri!(state.serialize_field("nanos", &self.subsec_nanos()));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for SystemTime {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use super::SerializeStruct;
-        let duration_since_epoch = match self.duration_since(UNIX_EPOCH) {
-            Ok(duration_since_epoch) => duration_since_epoch,
-            Err(_) => return Err(S::Error::custom("SystemTime must be later than UNIX_EPOCH")),
-        };
-        let mut state = tri!(serializer.serialize_struct("SystemTime", 2));
-        tri!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
-        tri!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
-        state.end()
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// Serialize a value that implements `Display` as a string, when that string is
-/// statically known to never have more than a constant `MAX_LEN` bytes.
-///
-/// Panics if the `Display` impl tries to write more than `MAX_LEN` bytes.
-#[cfg(feature = "std")]
-macro_rules! serialize_display_bounded_length {
-    ($value:expr, $max:expr, $serializer:expr) => {{
-        let mut buffer = [0u8; $max];
-        let remaining_len = {
-            let mut remaining = &mut buffer[..];
-            write!(remaining, "{}", $value).unwrap();
-            remaining.len()
-        };
-        let written_len = buffer.len() - remaining_len;
-        let written = &buffer[..written_len];
-
-        // write! only provides fmt::Formatter to Display implementations, which
-        // has methods write_str and write_char but no method to write arbitrary
-        // bytes. Therefore `written` must be valid UTF-8.
-        let written_str = str::from_utf8(written).expect("must be valid UTF-8");
-        $serializer.serialize_str(written_str)
-    }};
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for net::IpAddr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            match *self {
-                net::IpAddr::V4(ref a) => a.serialize(serializer),
-                net::IpAddr::V6(ref a) => a.serialize(serializer),
-            }
-        } else {
-            match *self {
-                net::IpAddr::V4(ref a) => {
-                    serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
-                }
-                net::IpAddr::V6(ref a) => {
-                    serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-const DEC_DIGITS_LUT: &[u8] = b"\
-      0001020304050607080910111213141516171819\
-      2021222324252627282930313233343536373839\
-      4041424344454647484950515253545556575859\
-      6061626364656667686970717273747576777879\
-      8081828384858687888990919293949596979899";
-
-#[cfg(feature = "std")]
-#[inline]
-fn format_u8(mut n: u8, out: &mut [u8]) -> usize {
-    if n >= 100 {
-        let d1 = ((n % 100) << 1) as usize;
-        n /= 100;
-        out[0] = b'0' + n;
-        out[1] = DEC_DIGITS_LUT[d1];
-        out[2] = DEC_DIGITS_LUT[d1 + 1];
-        3
-    } else if n >= 10 {
-        let d1 = (n << 1) as usize;
-        out[0] = DEC_DIGITS_LUT[d1];
-        out[1] = DEC_DIGITS_LUT[d1 + 1];
-        2
-    } else {
-        out[0] = b'0' + n;
-        1
-    }
-}
-
-#[cfg(feature = "std")]
-#[test]
-fn test_format_u8() {
-    let mut i = 0u8;
-
-    loop {
-        let mut buf = [0u8; 3];
-        let written = format_u8(i, &mut buf);
-        assert_eq!(i.to_string().as_bytes(), &buf[..written]);
-
-        match i.checked_add(1) {
-            Some(next) => i = next,
-            None => break,
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for net::Ipv4Addr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 15;
-            debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
-            let mut buf = [b'.'; MAX_LEN];
-            let mut written = format_u8(self.octets()[0], &mut buf);
-            for oct in &self.octets()[1..] {
-                // Skip over delimiters that we initialized buf with
-                written += format_u8(*oct, &mut buf[written + 1..]) + 1;
-            }
-            // Safety: We've only written ASCII bytes to the buffer, so it is valid UTF-8
-            let buf = unsafe { str::from_utf8_unchecked(&buf[..written]) };
-            serializer.serialize_str(buf)
-        } else {
-            self.octets().serialize(serializer)
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for net::Ipv6Addr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 39;
-            debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len());
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
-        } else {
-            self.octets().serialize(serializer)
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for net::SocketAddr {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            match *self {
-                net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
-                net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
-            }
-        } else {
-            match *self {
-                net::SocketAddr::V4(ref addr) => {
-                    serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr)
-                }
-                net::SocketAddr::V6(ref addr) => {
-                    serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr)
-                }
-            }
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for net::SocketAddrV4 {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 21;
-            debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len());
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
-        } else {
-            (self.ip(), self.port()).serialize(serializer)
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for net::SocketAddrV6 {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        if serializer.is_human_readable() {
-            const MAX_LEN: usize = 58;
-            debug_assert_eq!(
-                MAX_LEN,
-                "[1001:1002:1003:1004:1005:1006:1007:1008%4294967295]:65000".len()
-            );
-            serialize_display_bounded_length!(self, MAX_LEN, serializer)
-        } else {
-            (self.ip(), self.port()).serialize(serializer)
-        }
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for Path {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        match self.to_str() {
-            Some(s) => s.serialize(serializer),
-            None => Err(Error::custom("path contains invalid UTF-8 characters")),
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
-impl Serialize for PathBuf {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.as_path().serialize(serializer)
-    }
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
-impl Serialize for OsStr {
-    #[cfg(unix)]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use std::os::unix::ffi::OsStrExt;
-        serializer.serialize_newtype_variant("OsString", 0, "Unix", self.as_bytes())
-    }
-
-    #[cfg(windows)]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        use std::os::windows::ffi::OsStrExt;
-        let val = self.encode_wide().collect::<Vec<_>>();
-        serializer.serialize_newtype_variant("OsString", 1, "Windows", &val)
-    }
-}
-
-#[cfg(all(feature = "std", any(unix, windows)))]
-#[cfg_attr(doc_cfg, doc(cfg(all(feature = "std", any(unix, windows)))))]
-impl Serialize for OsString {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.as_os_str().serialize(serializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for Wrapping<T>
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.0.serialize(serializer)
-    }
-}
-
-impl<T> Serialize for Reverse<T>
-where
-    T: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        self.0.serialize(serializer)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-#[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 Serialize for $ty {
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                where
-                    S: Serializer,
-                {
-                    // Matches the atomic ordering used in libcore for the Debug impl
-                    self.load(Ordering::Relaxed).serialize(serializer)
-                }
-            }
-        )*
-    }
-}
-
-#[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"
-}
diff --git a/vendor/serde/src/ser/impossible.rs b/vendor/serde/src/ser/impossible.rs
deleted file mode 100644
index 479be94..0000000
--- a/vendor/serde/src/ser/impossible.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-//! This module contains `Impossible` serializer and its implementations.
-
-use crate::lib::*;
-
-use crate::ser::{
-    self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
-    SerializeTuple, SerializeTupleStruct, SerializeTupleVariant,
-};
-
-/// Helper type for implementing a `Serializer` that does not support
-/// serializing one of the compound types.
-///
-/// This type cannot be instantiated, but implements every one of the traits
-/// corresponding to the [`Serializer`] compound types: [`SerializeSeq`],
-/// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],
-/// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`].
-///
-/// ```edition2021
-/// # use serde::ser::{Serializer, Impossible};
-/// # use serde::__private::doc::Error;
-/// #
-/// # struct MySerializer;
-/// #
-/// impl Serializer for MySerializer {
-///     type Ok = ();
-///     type Error = Error;
-///
-///     type SerializeSeq = Impossible<(), Error>;
-///     /* other associated types */
-///
-///     /// This data format does not support serializing sequences.
-///     fn serialize_seq(self,
-///                      len: Option<usize>)
-///                      -> Result<Self::SerializeSeq, Error> {
-///         // Given Impossible cannot be instantiated, the only
-///         // thing we can do here is to return an error.
-/// #         stringify! {
-///         Err(...)
-/// #         };
-/// #         unimplemented!()
-///     }
-///
-///     /* other Serializer methods */
-/// #     serde::__serialize_unimplemented! {
-/// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some
-/// #         unit unit_struct unit_variant newtype_struct newtype_variant
-/// #         tuple tuple_struct tuple_variant map struct struct_variant
-/// #     }
-/// }
-/// ```
-///
-/// [`Serializer`]: trait.Serializer.html
-/// [`SerializeSeq`]: trait.SerializeSeq.html
-/// [`SerializeTuple`]: trait.SerializeTuple.html
-/// [`SerializeTupleStruct`]: trait.SerializeTupleStruct.html
-/// [`SerializeTupleVariant`]: trait.SerializeTupleVariant.html
-/// [`SerializeMap`]: trait.SerializeMap.html
-/// [`SerializeStruct`]: trait.SerializeStruct.html
-/// [`SerializeStructVariant`]: trait.SerializeStructVariant.html
-pub struct Impossible<Ok, Error> {
-    void: Void,
-    ok: PhantomData<Ok>,
-    error: PhantomData<Error>,
-}
-
-enum Void {}
-
-impl<Ok, Error> SerializeSeq for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTuple for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTupleStruct for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeTupleVariant for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeMap for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = key;
-        match self.void {}
-    }
-
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeStruct for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = key;
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
-
-impl<Ok, Error> SerializeStructVariant for Impossible<Ok, Error>
-where
-    Error: ser::Error,
-{
-    type Ok = Ok;
-    type Error = Error;
-
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
-    where
-        T: Serialize,
-    {
-        let _ = key;
-        let _ = value;
-        match self.void {}
-    }
-
-    fn end(self) -> Result<Ok, Error> {
-        match self.void {}
-    }
-}
diff --git a/vendor/serde/src/ser/mod.rs b/vendor/serde/src/ser/mod.rs
deleted file mode 100644
index 75c4514..0000000
--- a/vendor/serde/src/ser/mod.rs
+++ /dev/null
@@ -1,1952 +0,0 @@
-//! Generic data structure serialization framework.
-//!
-//! The two most important traits in this module are [`Serialize`] and
-//! [`Serializer`].
-//!
-//!  - **A type that implements `Serialize` is a data structure** that can be
-//!    serialized to any data format supported by Serde, and conversely
-//!  - **A type that implements `Serializer` is a data format** that can
-//!    serialize any data structure supported by Serde.
-//!
-//! # The Serialize trait
-//!
-//! Serde provides [`Serialize`] implementations for many Rust primitive and
-//! standard library types. The complete list is below. All of these can be
-//! serialized using Serde out of the box.
-//!
-//! Additionally, Serde provides a procedural macro called [`serde_derive`] to
-//! automatically generate [`Serialize`] 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 [`Serialize`] manually for
-//! some type in your program. See the [Implementing `Serialize`] section of the
-//! manual for more about this.
-//!
-//! Third-party crates may provide [`Serialize`] implementations for types that
-//! they expose. For example the [`linked-hash-map`] crate provides a
-//! [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate
-//! provides an implementation of [`Serialize`] for it.
-//!
-//! # The Serializer trait
-//!
-//! [`Serializer`] 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 Serialize provided by Serde
-//!
-//!  - **Primitive types**:
-//!    - bool
-//!    - i8, i16, i32, i64, i128, isize
-//!    - u8, u16, u32, u64, u128, usize
-//!    - f32, f64
-//!    - char
-//!    - str
-//!    - &T and &mut T
-//!  - **Compound types**:
-//!    - \[T\]
-//!    - \[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\>
-//!    - 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\>
-//!  - **FFI types**:
-//!    - CStr
-//!    - CString
-//!    - OsStr
-//!    - 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 `Serialize`]: https://serde.rs/impl-serialize.html
-//! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`Serialize`]: ../trait.Serialize.html
-//! [`Serializer`]: ../trait.Serializer.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::*;
-
-mod fmt;
-mod impls;
-mod impossible;
-
-pub use self::impossible::Impossible;
-
-#[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)::+)*) => {
-        /// Trait used by `Serialize` implementations to generically construct
-        /// errors belonging to the `Serializer` against which they are
-        /// currently running.
-        ///
-        /// # 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)::+)* {
-            /// Used when a [`Serialize`] implementation encounters any error
-            /// while serializing a type.
-            ///
-            /// The message should not be capitalized and should not end with a
-            /// period.
-            ///
-            /// For example, a filesystem [`Path`] may refuse to serialize
-            /// itself if it contains invalid UTF-8 data.
-            ///
-            /// ```edition2021
-            /// # struct Path;
-            /// #
-            /// # impl Path {
-            /// #     fn to_str(&self) -> Option<&str> {
-            /// #         unimplemented!()
-            /// #     }
-            /// # }
-            /// #
-            /// use serde::ser::{self, Serialize, Serializer};
-            ///
-            /// impl Serialize for Path {
-            ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            ///     where
-            ///         S: Serializer,
-            ///     {
-            ///         match self.to_str() {
-            ///             Some(s) => serializer.serialize_str(s),
-            ///             None => Err(ser::Error::custom("path contains invalid UTF-8 characters")),
-            ///         }
-            ///     }
-            /// }
-            /// ```
-            ///
-            /// [`Path`]: https://doc.rust-lang.org/std/path/struct.Path.html
-            /// [`Serialize`]: ../trait.Serialize.html
-            fn custom<T>(msg: T) -> Self
-            where
-                T: Display;
-        }
-    }
-}
-
-#[cfg(feature = "std")]
-declare_error_trait!(Error: Sized + StdError);
-
-#[cfg(not(feature = "std"))]
-declare_error_trait!(Error: Sized + Debug + Display);
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data structure** that can be serialized into any data format supported
-/// by Serde.
-///
-/// Serde provides `Serialize` implementations for many Rust primitive and
-/// standard library types. The complete list is [here][crate::ser]. All of
-/// these can be serialized using Serde out of the box.
-///
-/// Additionally, Serde provides a procedural macro called [`serde_derive`] to
-/// automatically generate `Serialize` 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 `Serialize` manually for some
-/// type in your program. See the [Implementing `Serialize`] section of the
-/// manual for more about this.
-///
-/// Third-party crates may provide `Serialize` implementations for types that
-/// they expose. For example the [`linked-hash-map`] crate provides a
-/// [`LinkedHashMap<K, V>`] type that is serializable by Serde because the crate
-/// provides an implementation of `Serialize` for it.
-///
-/// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
-/// [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-/// [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
-/// [`serde_derive`]: https://crates.io/crates/serde_derive
-/// [derive section of the manual]: https://serde.rs/derive.html
-pub trait Serialize {
-    /// Serialize this value into the given Serde serializer.
-    ///
-    /// See the [Implementing `Serialize`] section of the manual for more
-    /// information about how to implement this method.
-    ///
-    /// ```edition2021
-    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
-    ///
-    /// struct Person {
-    ///     name: String,
-    ///     age: u8,
-    ///     phones: Vec<String>,
-    /// }
-    ///
-    /// // This is what #[derive(Serialize)] would generate.
-    /// impl Serialize for Person {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut s = serializer.serialize_struct("Person", 3)?;
-    ///         s.serialize_field("name", &self.name)?;
-    ///         s.serialize_field("age", &self.age)?;
-    ///         s.serialize_field("phones", &self.phones)?;
-    ///         s.end()
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-/// A **data format** that can serialize any data structure supported by Serde.
-///
-/// The role of this trait is to define the serialization half of the [Serde
-/// data model], which is a way to categorize every Rust data structure into one
-/// of 29 possible types. Each method of the `Serializer` trait corresponds to
-/// one of the types of the data model.
-///
-/// Implementations of `Serialize` map themselves into this data model by
-/// invoking exactly one of the `Serializer` methods.
-///
-/// 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 } }`.
-///
-/// Many Serde serializers produce text or binary data as output, for example
-/// JSON or Postcard. This is not a requirement of the `Serializer` trait, and
-/// there are serializers that do not produce text or binary output. One example
-/// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
-/// serializer) that produces a `serde_json::Value` data structure in memory as
-/// output.
-///
-/// [Serde data model]: https://serde.rs/data-model.html
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website contains example code for
-/// a basic JSON `Serializer`.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait Serializer: Sized {
-    /// The output type produced by this `Serializer` during successful
-    /// serialization. Most serializers that produce text or binary output
-    /// should set `Ok = ()` and serialize into an [`io::Write`] or buffer
-    /// contained within the `Serializer` instance. Serializers that build
-    /// in-memory data structures may be simplified by using `Ok` to propagate
-    /// the data structure around.
-    ///
-    /// [`io::Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
-    type Ok;
-
-    /// The error type when some error occurs during serialization.
-    type Error: Error;
-
-    /// Type returned from [`serialize_seq`] for serializing the content of the
-    /// sequence.
-    ///
-    /// [`serialize_seq`]: #tymethod.serialize_seq
-    type SerializeSeq: SerializeSeq<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_tuple`] for serializing the content of
-    /// the tuple.
-    ///
-    /// [`serialize_tuple`]: #tymethod.serialize_tuple
-    type SerializeTuple: SerializeTuple<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_tuple_struct`] for serializing the
-    /// content of the tuple struct.
-    ///
-    /// [`serialize_tuple_struct`]: #tymethod.serialize_tuple_struct
-    type SerializeTupleStruct: SerializeTupleStruct<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_tuple_variant`] for serializing the
-    /// content of the tuple variant.
-    ///
-    /// [`serialize_tuple_variant`]: #tymethod.serialize_tuple_variant
-    type SerializeTupleVariant: SerializeTupleVariant<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_map`] for serializing the content of the
-    /// map.
-    ///
-    /// [`serialize_map`]: #tymethod.serialize_map
-    type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_struct`] for serializing the content of
-    /// the struct.
-    ///
-    /// [`serialize_struct`]: #tymethod.serialize_struct
-    type SerializeStruct: SerializeStruct<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Type returned from [`serialize_struct_variant`] for serializing the
-    /// content of the struct variant.
-    ///
-    /// [`serialize_struct_variant`]: #tymethod.serialize_struct_variant
-    type SerializeStructVariant: SerializeStructVariant<Ok = Self::Ok, Error = Self::Error>;
-
-    /// Serialize a `bool` value.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for bool {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_bool(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i8` value.
-    ///
-    /// If the format does not differentiate between `i8` and `i64`, a
-    /// reasonable implementation would be to cast the value to `i64` and
-    /// forward to `serialize_i64`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i8 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i8(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i16` value.
-    ///
-    /// If the format does not differentiate between `i16` and `i64`, a
-    /// reasonable implementation would be to cast the value to `i64` and
-    /// forward to `serialize_i64`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i16 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i16(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i32` value.
-    ///
-    /// If the format does not differentiate between `i32` and `i64`, a
-    /// reasonable implementation would be to cast the value to `i64` and
-    /// forward to `serialize_i64`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i32 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i32(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i64` value.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i64 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i64(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `i128` value.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for i128 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_i128(*self)
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// The default behavior unconditionally returns an error.
-    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
-        let _ = v;
-        Err(Error::custom("i128 is not supported"))
-    }
-
-    /// Serialize a `u8` value.
-    ///
-    /// If the format does not differentiate between `u8` and `u64`, a
-    /// reasonable implementation would be to cast the value to `u64` and
-    /// forward to `serialize_u64`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u8 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u8(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `u16` value.
-    ///
-    /// If the format does not differentiate between `u16` and `u64`, a
-    /// reasonable implementation would be to cast the value to `u64` and
-    /// forward to `serialize_u64`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u16 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u16(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `u32` value.
-    ///
-    /// If the format does not differentiate between `u32` and `u64`, a
-    /// reasonable implementation would be to cast the value to `u64` and
-    /// forward to `serialize_u64`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u32 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u32(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `u64` value.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u64 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u64(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `u128` value.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for u128 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_u128(*self)
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// The default behavior unconditionally returns an error.
-    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
-        let _ = v;
-        Err(Error::custom("u128 is not supported"))
-    }
-
-    /// Serialize an `f32` value.
-    ///
-    /// If the format does not differentiate between `f32` and `f64`, a
-    /// reasonable implementation would be to cast the value to `f64` and
-    /// forward to `serialize_f64`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for f32 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_f32(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize an `f64` value.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for f64 {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_f64(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a character.
-    ///
-    /// If the format does not support characters, it is reasonable to serialize
-    /// it as a single element `str` or a `u32`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for char {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_char(*self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a `&str`.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for str {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_str(self)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a chunk of raw byte data.
-    ///
-    /// Enables serializers to serialize byte slices more compactly or more
-    /// efficiently than other types of slices. If no efficient implementation
-    /// is available, a reasonable implementation would be to forward to
-    /// `serialize_seq`. If forwarded, the implementation looks usually just
-    /// like this:
-    ///
-    /// ```edition2021
-    /// # use serde::ser::{Serializer, SerializeSeq};
-    /// # use serde::__private::doc::Error;
-    /// #
-    /// # struct MySerializer;
-    /// #
-    /// # impl Serializer for MySerializer {
-    /// #     type Ok = ();
-    /// #     type Error = Error;
-    /// #
-    /// fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
-    ///     let mut seq = self.serialize_seq(Some(v.len()))?;
-    ///     for b in v {
-    ///         seq.serialize_element(b)?;
-    ///     }
-    ///     seq.end()
-    /// }
-    /// #
-    /// #     serde::__serialize_unimplemented! {
-    /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str none some
-    /// #         unit unit_struct unit_variant newtype_struct newtype_variant
-    /// #         seq tuple tuple_struct tuple_variant map struct struct_variant
-    /// #     }
-    /// # }
-    /// ```
-    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a [`None`] value.
-    ///
-    /// ```edition2021
-    /// # use serde::{Serialize, Serializer};
-    /// #
-    /// # enum Option<T> {
-    /// #     Some(T),
-    /// #     None,
-    /// # }
-    /// #
-    /// # use self::Option::{Some, None};
-    /// #
-    /// impl<T> Serialize for Option<T>
-    /// where
-    ///     T: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             Some(ref value) => serializer.serialize_some(value),
-    ///             None => serializer.serialize_none(),
-    ///         }
-    ///     }
-    /// }
-    /// #
-    /// # fn main() {}
-    /// ```
-    ///
-    /// [`None`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None
-    fn serialize_none(self) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a [`Some(T)`] value.
-    ///
-    /// ```edition2021
-    /// # use serde::{Serialize, Serializer};
-    /// #
-    /// # enum Option<T> {
-    /// #     Some(T),
-    /// #     None,
-    /// # }
-    /// #
-    /// # use self::Option::{Some, None};
-    /// #
-    /// impl<T> Serialize for Option<T>
-    /// where
-    ///     T: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             Some(ref value) => serializer.serialize_some(value),
-    ///             None => serializer.serialize_none(),
-    ///         }
-    ///     }
-    /// }
-    /// #
-    /// # fn main() {}
-    /// ```
-    ///
-    /// [`Some(T)`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a `()` value.
-    ///
-    /// ```edition2021
-    /// # use serde::Serializer;
-    /// #
-    /// # serde::__private_serialize!();
-    /// #
-    /// impl Serialize for () {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_unit()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a unit struct like `struct Unit` or `PhantomData<T>`.
-    ///
-    /// A reasonable implementation would be to forward to `serialize_unit`.
-    ///
-    /// ```edition2021
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// struct Nothing;
-    ///
-    /// impl Serialize for Nothing {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_unit_struct("Nothing")
-    ///     }
-    /// }
-    /// ```
-    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a unit variant like `E::A` in `enum E { A, B }`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, and the `variant` is the name of the
-    /// variant.
-    ///
-    /// ```edition2021
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// enum E {
-    ///     A,
-    ///     B,
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::A => serializer.serialize_unit_variant("E", 0, "A"),
-    ///             E::B => serializer.serialize_unit_variant("E", 1, "B"),
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_unit_variant(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-    ) -> Result<Self::Ok, Self::Error>;
-
-    /// Serialize a newtype struct like `struct Millimeters(u8)`.
-    ///
-    /// Serializers are encouraged to treat newtype structs as insignificant
-    /// wrappers around the data they contain. A reasonable implementation would
-    /// be to forward to `value.serialize(self)`.
-    ///
-    /// ```edition2021
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// struct Millimeters(u8);
-    ///
-    /// impl Serialize for Millimeters {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.serialize_newtype_struct("Millimeters", &self.0)
-    ///     }
-    /// }
-    /// ```
-    fn serialize_newtype_struct<T: ?Sized>(
-        self,
-        name: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, and the `variant` is the name of the
-    /// variant. The `value` is the data contained within this newtype variant.
-    ///
-    /// ```edition2021
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// enum E {
-    ///     M(String),
-    ///     N(u8),
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),
-    ///             E::N(n) => serializer.serialize_newtype_variant("E", 1, "N", &n),
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_newtype_variant<T: ?Sized>(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        value: &T,
-    ) -> Result<Self::Ok, Self::Error>
-    where
-        T: Serialize;
-
-    /// Begin to serialize a variably sized sequence. This call must be
-    /// followed by zero or more calls to `serialize_element`, then a call to
-    /// `end`.
-    ///
-    /// The argument is the number of elements in the sequence, which may or may
-    /// not be computable before the sequence is iterated. Some serializers only
-    /// support sequences whose length is known up front.
-    ///
-    /// ```edition2021
-    /// # use std::marker::PhantomData;
-    /// #
-    /// # struct Vec<T>(PhantomData<T>);
-    /// #
-    /// # impl<T> Vec<T> {
-    /// #     fn len(&self) -> usize {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// # impl<'a, T> IntoIterator for &'a Vec<T> {
-    /// #     type Item = &'a T;
-    /// #     type IntoIter = Box<dyn Iterator<Item = &'a T>>;
-    /// #
-    /// #     fn into_iter(self) -> Self::IntoIter {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::ser::{Serialize, SerializeSeq, Serializer};
-    ///
-    /// impl<T> Serialize for Vec<T>
-    /// where
-    ///     T: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
-    ///         for element in self {
-    ///             seq.serialize_element(element)?;
-    ///         }
-    ///         seq.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error>;
-
-    /// Begin to serialize a statically sized sequence whose length will be
-    /// known at deserialization time without looking at the serialized data.
-    /// This call must be followed by zero or more calls to `serialize_element`,
-    /// then a call to `end`.
-    ///
-    /// ```edition2021
-    /// use serde::ser::{Serialize, SerializeTuple, Serializer};
-    ///
-    /// # mod fool {
-    /// #     trait Serialize {}
-    /// impl<A, B, C> Serialize for (A, B, C)
-    /// #     {}
-    /// # }
-    /// #
-    /// # struct Tuple3<A, B, C>(A, B, C);
-    /// #
-    /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
-    /// where
-    ///     A: Serialize,
-    ///     B: Serialize,
-    ///     C: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut tup = serializer.serialize_tuple(3)?;
-    ///         tup.serialize_element(&self.0)?;
-    ///         tup.serialize_element(&self.1)?;
-    ///         tup.serialize_element(&self.2)?;
-    ///         tup.end()
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// ```edition2021
-    /// use serde::ser::{Serialize, SerializeTuple, Serializer};
-    ///
-    /// const VRAM_SIZE: usize = 386;
-    /// struct Vram([u16; VRAM_SIZE]);
-    ///
-    /// impl Serialize for Vram {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut seq = serializer.serialize_tuple(VRAM_SIZE)?;
-    ///         for element in &self.0[..] {
-    ///             seq.serialize_element(element)?;
-    ///         }
-    ///         seq.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error>;
-
-    /// Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This
-    /// call must be followed by zero or more calls to `serialize_field`, then a
-    /// call to `end`.
-    ///
-    /// The `name` is the name of the tuple struct and the `len` is the number
-    /// of data fields that will be serialized.
-    ///
-    /// ```edition2021
-    /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
-    ///
-    /// struct Rgb(u8, u8, u8);
-    ///
-    /// impl Serialize for Rgb {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
-    ///         ts.serialize_field(&self.0)?;
-    ///         ts.serialize_field(&self.1)?;
-    ///         ts.serialize_field(&self.2)?;
-    ///         ts.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_tuple_struct(
-        self,
-        name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct, Self::Error>;
-
-    /// Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8)
-    /// }`. This call must be followed by zero or more calls to
-    /// `serialize_field`, then a call to `end`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, the `variant` is the name of the variant,
-    /// and the `len` is the number of data fields that will be serialized.
-    ///
-    /// ```edition2021
-    /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
-    ///
-    /// enum E {
-    ///     T(u8, u8),
-    ///     U(String, u32, u32),
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::T(ref a, ref b) => {
-    ///                 let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
-    ///                 tv.serialize_field(a)?;
-    ///                 tv.serialize_field(b)?;
-    ///                 tv.end()
-    ///             }
-    ///             E::U(ref a, ref b, ref c) => {
-    ///                 let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
-    ///                 tv.serialize_field(a)?;
-    ///                 tv.serialize_field(b)?;
-    ///                 tv.serialize_field(c)?;
-    ///                 tv.end()
-    ///             }
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_tuple_variant(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant, Self::Error>;
-
-    /// Begin to serialize a map. This call must be followed by zero or more
-    /// calls to `serialize_key` and `serialize_value`, then a call to `end`.
-    ///
-    /// The argument is the number of elements in the map, which may or may not
-    /// be computable before the map is iterated. Some serializers only support
-    /// maps whose length is known up front.
-    ///
-    /// ```edition2021
-    /// # use std::marker::PhantomData;
-    /// #
-    /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
-    /// #
-    /// # impl<K, V> HashMap<K, V> {
-    /// #     fn len(&self) -> usize {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
-    /// #     type Item = (&'a K, &'a V);
-    /// #     type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a V)>>;
-    /// #
-    /// #     fn into_iter(self) -> Self::IntoIter {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::ser::{Serialize, SerializeMap, Serializer};
-    ///
-    /// impl<K, V> Serialize for HashMap<K, V>
-    /// where
-    ///     K: Serialize,
-    ///     V: Serialize,
-    /// {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut map = serializer.serialize_map(Some(self.len()))?;
-    ///         for (k, v) in self {
-    ///             map.serialize_entry(k, v)?;
-    ///         }
-    ///         map.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error>;
-
-    /// Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`.
-    /// This call must be followed by zero or more calls to `serialize_field`,
-    /// then a call to `end`.
-    ///
-    /// The `name` is the name of the struct and the `len` is the number of
-    /// data fields that will be serialized.
-    ///
-    /// ```edition2021
-    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
-    ///
-    /// struct Rgb {
-    ///     r: u8,
-    ///     g: u8,
-    ///     b: u8,
-    /// }
-    ///
-    /// impl Serialize for Rgb {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
-    ///         rgb.serialize_field("r", &self.r)?;
-    ///         rgb.serialize_field("g", &self.g)?;
-    ///         rgb.serialize_field("b", &self.b)?;
-    ///         rgb.end()
-    ///     }
-    /// }
-    /// ```
-    fn serialize_struct(
-        self,
-        name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStruct, Self::Error>;
-
-    /// Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8,
-    /// g: u8, b: u8 } }`. This call must be followed by zero or more calls to
-    /// `serialize_field`, then a call to `end`.
-    ///
-    /// The `name` is the name of the enum, the `variant_index` is the index of
-    /// this variant within the enum, the `variant` is the name of the variant,
-    /// and the `len` is the number of data fields that will be serialized.
-    ///
-    /// ```edition2021
-    /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
-    ///
-    /// enum E {
-    ///     S { r: u8, g: u8, b: u8 },
-    /// }
-    ///
-    /// impl Serialize for E {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         match *self {
-    ///             E::S {
-    ///                 ref r,
-    ///                 ref g,
-    ///                 ref b,
-    ///             } => {
-    ///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
-    ///                 sv.serialize_field("r", r)?;
-    ///                 sv.serialize_field("g", g)?;
-    ///                 sv.serialize_field("b", b)?;
-    ///                 sv.end()
-    ///             }
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    fn serialize_struct_variant(
-        self,
-        name: &'static str,
-        variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeStructVariant, Self::Error>;
-
-    /// Collect an iterator as a sequence.
-    ///
-    /// The default implementation serializes each item yielded by the iterator
-    /// using [`serialize_seq`]. Implementors should not need to override this
-    /// method.
-    ///
-    /// ```edition2021
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// struct SecretlyOneHigher {
-    ///     data: Vec<i32>,
-    /// }
-    ///
-    /// impl Serialize for SecretlyOneHigher {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_seq(self.data.iter().map(|x| x + 1))
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`serialize_seq`]: #tymethod.serialize_seq
-    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
-    where
-        I: IntoIterator,
-        <I as IntoIterator>::Item: Serialize,
-    {
-        let mut iter = iter.into_iter();
-        let mut serializer = tri!(self.serialize_seq(iterator_len_hint(&iter)));
-        tri!(iter.try_for_each(|item| serializer.serialize_element(&item)));
-        serializer.end()
-    }
-
-    /// Collect an iterator as a map.
-    ///
-    /// The default implementation serializes each pair yielded by the iterator
-    /// using [`serialize_map`]. Implementors should not need to override this
-    /// method.
-    ///
-    /// ```edition2021
-    /// use serde::{Serialize, Serializer};
-    /// use std::collections::BTreeSet;
-    ///
-    /// struct MapToUnit {
-    ///     keys: BTreeSet<i32>,
-    /// }
-    ///
-    /// // Serializes as a map in which the values are all unit.
-    /// impl Serialize for MapToUnit {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_map(self.keys.iter().map(|k| (k, ())))
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`serialize_map`]: #tymethod.serialize_map
-    fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
-    where
-        K: Serialize,
-        V: Serialize,
-        I: IntoIterator<Item = (K, V)>,
-    {
-        let mut iter = iter.into_iter();
-        let mut serializer = tri!(self.serialize_map(iterator_len_hint(&iter)));
-        tri!(iter.try_for_each(|(key, value)| serializer.serialize_entry(&key, &value)));
-        serializer.end()
-    }
-
-    /// Serialize a string produced by an implementation of `Display`.
-    ///
-    /// The default implementation builds a heap-allocated [`String`] and
-    /// delegates to [`serialize_str`]. Serializers are encouraged to provide a
-    /// more efficient implementation if possible.
-    ///
-    /// ```edition2021
-    /// # struct DateTime;
-    /// #
-    /// # impl DateTime {
-    /// #     fn naive_local(&self) -> () { () }
-    /// #     fn offset(&self) -> () { () }
-    /// # }
-    /// #
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// impl Serialize for DateTime {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset()))
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
-    /// [`serialize_str`]: #tymethod.serialize_str
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Display,
-    {
-        self.serialize_str(&value.to_string())
-    }
-
-    /// Serialize a string produced by an implementation of `Display`.
-    ///
-    /// Serializers that use `no_std` are required to provide an implementation
-    /// of this method. If no more sensible behavior is possible, the
-    /// implementation is expected to return an error.
-    ///
-    /// ```edition2021
-    /// # struct DateTime;
-    /// #
-    /// # impl DateTime {
-    /// #     fn naive_local(&self) -> () { () }
-    /// #     fn offset(&self) -> () { () }
-    /// # }
-    /// #
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// impl Serialize for DateTime {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset()))
-    ///     }
-    /// }
-    /// ```
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
-    where
-        T: Display;
-
-    /// Determine whether `Serialize` implementations should serialize in
-    /// 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::fmt::{self, Display};
-    /// #
-    /// # struct Timestamp;
-    /// #
-    /// # impl Timestamp {
-    /// #     fn seconds_since_epoch(&self) -> u64 { unimplemented!() }
-    /// # }
-    /// #
-    /// # impl Display for Timestamp {
-    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// use serde::{Serialize, Serializer};
-    ///
-    /// impl Serialize for Timestamp {
-    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///     where
-    ///         S: Serializer,
-    ///     {
-    ///         if serializer.is_human_readable() {
-    ///             // Serialize to a human-readable string "2015-05-15T17:01:00Z".
-    ///             self.to_string().serialize(serializer)
-    ///         } else {
-    ///             // Serialize to a compact binary representation.
-    ///             self.seconds_since_epoch().serialize(serializer)
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// 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
-    }
-}
-
-/// Returned from `Serializer::serialize_seq`.
-///
-/// # Example use
-///
-/// ```edition2021
-/// # use std::marker::PhantomData;
-/// #
-/// # struct Vec<T>(PhantomData<T>);
-/// #
-/// # impl<T> Vec<T> {
-/// #     fn len(&self) -> usize {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// # impl<'a, T> IntoIterator for &'a Vec<T> {
-/// #     type Item = &'a T;
-/// #     type IntoIter = Box<dyn Iterator<Item = &'a T>>;
-/// #     fn into_iter(self) -> Self::IntoIter {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// use serde::ser::{Serialize, SerializeSeq, Serializer};
-///
-/// impl<T> Serialize for Vec<T>
-/// where
-///     T: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
-///         for element in self {
-///             seq.serialize_element(element)?;
-///         }
-///         seq.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeSeq` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeSeq {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a sequence element.
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a sequence.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_tuple`.
-///
-/// # Example use
-///
-/// ```edition2021
-/// use serde::ser::{Serialize, SerializeTuple, Serializer};
-///
-/// # mod fool {
-/// #     trait Serialize {}
-/// impl<A, B, C> Serialize for (A, B, C)
-/// #     {}
-/// # }
-/// #
-/// # struct Tuple3<A, B, C>(A, B, C);
-/// #
-/// # impl<A, B, C> Serialize for Tuple3<A, B, C>
-/// where
-///     A: Serialize,
-///     B: Serialize,
-///     C: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut tup = serializer.serialize_tuple(3)?;
-///         tup.serialize_element(&self.0)?;
-///         tup.serialize_element(&self.1)?;
-///         tup.serialize_element(&self.2)?;
-///         tup.end()
-///     }
-/// }
-/// ```
-///
-/// ```edition2021
-/// # use std::marker::PhantomData;
-/// #
-/// # struct Array<T>(PhantomData<T>);
-/// #
-/// # impl<T> Array<T> {
-/// #     fn len(&self) -> usize {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// # impl<'a, T> IntoIterator for &'a Array<T> {
-/// #     type Item = &'a T;
-/// #     type IntoIter = Box<dyn Iterator<Item = &'a T>>;
-/// #     fn into_iter(self) -> Self::IntoIter {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// use serde::ser::{Serialize, SerializeTuple, Serializer};
-///
-/// # mod fool {
-/// #     trait Serialize {}
-/// impl<T> Serialize for [T; 16]
-/// #     {}
-/// # }
-/// #
-/// # impl<T> Serialize for Array<T>
-/// where
-///     T: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut seq = serializer.serialize_tuple(16)?;
-///         for element in self {
-///             seq.serialize_element(element)?;
-///         }
-///         seq.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeTuple` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeTuple {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a tuple element.
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a tuple.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_tuple_struct`.
-///
-/// # Example use
-///
-/// ```edition2021
-/// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
-///
-/// struct Rgb(u8, u8, u8);
-///
-/// impl Serialize for Rgb {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
-///         ts.serialize_field(&self.0)?;
-///         ts.serialize_field(&self.1)?;
-///         ts.serialize_field(&self.2)?;
-///         ts.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeTupleStruct` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeTupleStruct {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a tuple struct field.
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a tuple struct.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_tuple_variant`.
-///
-/// # Example use
-///
-/// ```edition2021
-/// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
-///
-/// enum E {
-///     T(u8, u8),
-///     U(String, u32, u32),
-/// }
-///
-/// impl Serialize for E {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         match *self {
-///             E::T(ref a, ref b) => {
-///                 let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
-///                 tv.serialize_field(a)?;
-///                 tv.serialize_field(b)?;
-///                 tv.end()
-///             }
-///             E::U(ref a, ref b, ref c) => {
-///                 let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
-///                 tv.serialize_field(a)?;
-///                 tv.serialize_field(b)?;
-///                 tv.serialize_field(c)?;
-///                 tv.end()
-///             }
-///         }
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeTupleVariant` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeTupleVariant {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a tuple variant field.
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Finish serializing a tuple variant.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_map`.
-///
-/// # Example use
-///
-/// ```edition2021
-/// # use std::marker::PhantomData;
-/// #
-/// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
-/// #
-/// # impl<K, V> HashMap<K, V> {
-/// #     fn len(&self) -> usize {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
-/// #     type Item = (&'a K, &'a V);
-/// #     type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a V)>>;
-/// #
-/// #     fn into_iter(self) -> Self::IntoIter {
-/// #         unimplemented!()
-/// #     }
-/// # }
-/// #
-/// use serde::ser::{Serialize, SerializeMap, Serializer};
-///
-/// impl<K, V> Serialize for HashMap<K, V>
-/// where
-///     K: Serialize,
-///     V: Serialize,
-/// {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut map = serializer.serialize_map(Some(self.len()))?;
-///         for (k, v) in self {
-///             map.serialize_entry(k, v)?;
-///         }
-///         map.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeMap` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeMap {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a map key.
-    ///
-    /// If possible, `Serialize` implementations are encouraged to use
-    /// `serialize_entry` instead as it may be implemented more efficiently in
-    /// some formats compared to a pair of calls to `serialize_key` and
-    /// `serialize_value`.
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a map value.
-    ///
-    /// # Panics
-    ///
-    /// Calling `serialize_value` before `serialize_key` is incorrect and is
-    /// allowed to panic or produce bogus results.
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Serialize a map entry consisting of a key and a value.
-    ///
-    /// Some [`Serialize`] types are not able to hold a key and value in memory
-    /// at the same time so `SerializeMap` implementations are required to
-    /// support [`serialize_key`] and [`serialize_value`] individually. The
-    /// `serialize_entry` method allows serializers to optimize for the case
-    /// where key and value are both available. [`Serialize`] implementations
-    /// are encouraged to use `serialize_entry` if possible.
-    ///
-    /// The default implementation delegates to [`serialize_key`] and
-    /// [`serialize_value`]. This is appropriate for serializers that do not
-    /// care about performance or are not able to optimize `serialize_entry` any
-    /// better than this.
-    ///
-    /// [`Serialize`]: ../trait.Serialize.html
-    /// [`serialize_key`]: #tymethod.serialize_key
-    /// [`serialize_value`]: #tymethod.serialize_value
-    fn serialize_entry<K: ?Sized, V: ?Sized>(
-        &mut self,
-        key: &K,
-        value: &V,
-    ) -> Result<(), Self::Error>
-    where
-        K: Serialize,
-        V: Serialize,
-    {
-        tri!(self.serialize_key(key));
-        self.serialize_value(value)
-    }
-
-    /// Finish serializing a map.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_struct`.
-///
-/// # Example use
-///
-/// ```edition2021
-/// use serde::ser::{Serialize, SerializeStruct, Serializer};
-///
-/// struct Rgb {
-///     r: u8,
-///     g: u8,
-///     b: u8,
-/// }
-///
-/// impl Serialize for Rgb {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
-///         rgb.serialize_field("r", &self.r)?;
-///         rgb.serialize_field("g", &self.g)?;
-///         rgb.serialize_field("b", &self.b)?;
-///         rgb.end()
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeStruct` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeStruct {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a struct field.
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Indicate that a struct field has been skipped.
-    #[inline]
-    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
-        let _ = key;
-        Ok(())
-    }
-
-    /// Finish serializing a struct.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-/// Returned from `Serializer::serialize_struct_variant`.
-///
-/// # Example use
-///
-/// ```edition2021
-/// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
-///
-/// enum E {
-///     S { r: u8, g: u8, b: u8 },
-/// }
-///
-/// impl Serialize for E {
-///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///     where
-///         S: Serializer,
-///     {
-///         match *self {
-///             E::S {
-///                 ref r,
-///                 ref g,
-///                 ref b,
-///             } => {
-///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
-///                 sv.serialize_field("r", r)?;
-///                 sv.serialize_field("g", g)?;
-///                 sv.serialize_field("b", b)?;
-///                 sv.end()
-///             }
-///         }
-///     }
-/// }
-/// ```
-///
-/// # Example implementation
-///
-/// The [example data format] presented on the website demonstrates an
-/// implementation of `SerializeStructVariant` for a basic JSON data format.
-///
-/// [example data format]: https://serde.rs/data-format.html
-pub trait SerializeStructVariant {
-    /// Must match the `Ok` type of our `Serializer`.
-    type Ok;
-
-    /// Must match the `Error` type of our `Serializer`.
-    type Error: Error;
-
-    /// Serialize a struct variant field.
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
-    where
-        T: Serialize;
-
-    /// Indicate that a struct variant field has been skipped.
-    #[inline]
-    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
-        let _ = key;
-        Ok(())
-    }
-
-    /// Finish serializing a struct variant.
-    fn end(self) -> Result<Self::Ok, Self::Error>;
-}
-
-fn iterator_len_hint<I>(iter: &I) -> Option<usize>
-where
-    I: Iterator,
-{
-    match iter.size_hint() {
-        (lo, Some(hi)) if lo == hi => Some(lo),
-        _ => None,
-    }
-}