Deleted vendor folder

6 files changed, 0 insertions, 4120 deletions

diff --git a/vendor/serde_json/src/value/de.rs b/vendor/serde_json/src/value/de.rs
deleted file mode 100644
index 1e8b5ac..0000000
--- a/vendor/serde_json/src/value/de.rs
+++ /dev/null
@@ -1,1419 +0,0 @@
-use crate::error::{Error, ErrorCode};
-use crate::map::Map;
-use crate::number::Number;
-use crate::value::Value;
-use alloc::borrow::{Cow, ToOwned};
-use alloc::string::String;
-#[cfg(feature = "raw_value")]
-use alloc::string::ToString;
-use alloc::vec::{self, Vec};
-use core::fmt;
-use core::slice;
-use core::str::FromStr;
-use serde::de::{
-    self, Deserialize, DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess,
-    SeqAccess, Unexpected, VariantAccess, Visitor,
-};
-use serde::forward_to_deserialize_any;
-
-#[cfg(feature = "arbitrary_precision")]
-use crate::number::NumberFromString;
-
-impl<'de> Deserialize<'de> for Value {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct ValueVisitor;
-
-        impl<'de> Visitor<'de> for ValueVisitor {
-            type Value = Value;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("any valid JSON value")
-            }
-
-            #[inline]
-            fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
-                Ok(Value::Bool(value))
-            }
-
-            #[inline]
-            fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
-                Ok(Value::Number(value.into()))
-            }
-
-            #[inline]
-            fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
-                Ok(Value::Number(value.into()))
-            }
-
-            #[inline]
-            fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
-                Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
-            }
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            #[inline]
-            fn visit_str<E>(self, value: &str) -> Result<Value, E>
-            where
-                E: serde::de::Error,
-            {
-                self.visit_string(String::from(value))
-            }
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            #[inline]
-            fn visit_string<E>(self, value: String) -> Result<Value, E> {
-                Ok(Value::String(value))
-            }
-
-            #[inline]
-            fn visit_none<E>(self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                Deserialize::deserialize(deserializer)
-            }
-
-            #[inline]
-            fn visit_unit<E>(self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
-            where
-                V: SeqAccess<'de>,
-            {
-                let mut vec = Vec::new();
-
-                while let Some(elem) = tri!(visitor.next_element()) {
-                    vec.push(elem);
-                }
-
-                Ok(Value::Array(vec))
-            }
-
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
-            where
-                V: MapAccess<'de>,
-            {
-                match tri!(visitor.next_key_seed(KeyClassifier)) {
-                    #[cfg(feature = "arbitrary_precision")]
-                    Some(KeyClass::Number) => {
-                        let number: NumberFromString = tri!(visitor.next_value());
-                        Ok(Value::Number(number.value))
-                    }
-                    #[cfg(feature = "raw_value")]
-                    Some(KeyClass::RawValue) => {
-                        let value = tri!(visitor.next_value_seed(crate::raw::BoxedFromString));
-                        crate::from_str(value.get()).map_err(de::Error::custom)
-                    }
-                    Some(KeyClass::Map(first_key)) => {
-                        let mut values = Map::new();
-
-                        values.insert(first_key, tri!(visitor.next_value()));
-                        while let Some((key, value)) = tri!(visitor.next_entry()) {
-                            values.insert(key, value);
-                        }
-
-                        Ok(Value::Object(values))
-                    }
-                    None => Ok(Value::Object(Map::new())),
-                }
-            }
-        }
-
-        deserializer.deserialize_any(ValueVisitor)
-    }
-}
-
-impl FromStr for Value {
-    type Err = Error;
-    fn from_str(s: &str) -> Result<Value, Error> {
-        super::super::de::from_str(s)
-    }
-}
-
-macro_rules! deserialize_number {
-    ($method:ident) => {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.deserialize_any(visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        #[cfg(feature = "arbitrary_precision")]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.$method(visitor),
-                _ => self.deserialize_any(visitor),
-            }
-        }
-    };
-}
-
-fn visit_array<'de, V>(array: Vec<Value>, visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = array.len();
-    let mut deserializer = SeqDeserializer::new(array);
-    let seq = tri!(visitor.visit_seq(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(seq)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in array",
-        ))
-    }
-}
-
-fn visit_object<'de, V>(object: Map<String, Value>, visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = object.len();
-    let mut deserializer = MapDeserializer::new(object);
-    let map = tri!(visitor.visit_map(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(map)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in map",
-        ))
-    }
-}
-
-impl<'de> serde::Deserializer<'de> for Value {
-    type Error = Error;
-
-    #[inline]
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(v),
-            Value::Number(n) => n.deserialize_any(visitor),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::String(v) => visitor.visit_string(v),
-            Value::Array(v) => visit_array(v, visitor),
-            Value::Object(v) => visit_object(v, visitor),
-        }
-    }
-
-    deserialize_number!(deserialize_i8);
-    deserialize_number!(deserialize_i16);
-    deserialize_number!(deserialize_i32);
-    deserialize_number!(deserialize_i64);
-    deserialize_number!(deserialize_i128);
-    deserialize_number!(deserialize_u8);
-    deserialize_number!(deserialize_u16);
-    deserialize_number!(deserialize_u32);
-    deserialize_number!(deserialize_u64);
-    deserialize_number!(deserialize_u128);
-    deserialize_number!(deserialize_f32);
-    deserialize_number!(deserialize_f64);
-
-    #[inline]
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_none(),
-            _ => visitor.visit_some(self),
-        }
-    }
-
-    #[inline]
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        let (variant, value) = match self {
-            Value::Object(value) => {
-                let mut iter = value.into_iter();
-                let (variant, value) = match iter.next() {
-                    Some(v) => v,
-                    None => {
-                        return Err(serde::de::Error::invalid_value(
-                            Unexpected::Map,
-                            &"map with a single key",
-                        ));
-                    }
-                };
-                // enums are encoded in json as maps with a single key:value pair
-                if iter.next().is_some() {
-                    return Err(serde::de::Error::invalid_value(
-                        Unexpected::Map,
-                        &"map with a single key",
-                    ));
-                }
-                (variant, Some(value))
-            }
-            Value::String(variant) => (variant, None),
-            other => {
-                return Err(serde::de::Error::invalid_type(
-                    other.unexpected(),
-                    &"string or map",
-                ));
-            }
-        };
-
-        visitor.visit_enum(EnumDeserializer { variant, value })
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        #[cfg(feature = "raw_value")]
-        {
-            if name == crate::raw::TOKEN {
-                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
-                    raw_value: Some(self.to_string()),
-                });
-            }
-        }
-
-        let _ = name;
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Bool(v) => visitor.visit_bool(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_string(visitor)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_string(visitor)
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::String(v) => visitor.visit_string(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_byte_buf(visitor)
-    }
-
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::String(v) => visitor.visit_string(v),
-            Value::Array(v) => visit_array(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_unit(),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_unit(visitor)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Object(v) => visit_object(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array(v, visitor),
-            Value::Object(v) => visit_object(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_string(visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        drop(self);
-        visitor.visit_unit()
-    }
-}
-
-struct EnumDeserializer {
-    variant: String,
-    value: Option<Value>,
-}
-
-impl<'de> EnumAccess<'de> for EnumDeserializer {
-    type Error = Error;
-    type Variant = VariantDeserializer;
-
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Error>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        let variant = self.variant.into_deserializer();
-        let visitor = VariantDeserializer { value: self.value };
-        seed.deserialize(variant).map(|v| (v, visitor))
-    }
-}
-
-impl<'de> IntoDeserializer<'de, Error> for Value {
-    type Deserializer = Self;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-impl<'de> IntoDeserializer<'de, Error> for &'de Value {
-    type Deserializer = Self;
-
-    fn into_deserializer(self) -> Self::Deserializer {
-        self
-    }
-}
-
-struct VariantDeserializer {
-    value: Option<Value>,
-}
-
-impl<'de> VariantAccess<'de> for VariantDeserializer {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<(), Error> {
-        match self.value {
-            Some(value) => Deserialize::deserialize(value),
-            None => Ok(()),
-        }
-    }
-
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"newtype variant",
-            )),
-        }
-    }
-
-    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Array(v)) => {
-                if v.is_empty() {
-                    visitor.visit_unit()
-                } else {
-                    visit_array(v, visitor)
-                }
-            }
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"tuple variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"tuple variant",
-            )),
-        }
-    }
-
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Object(v)) => visit_object(v, visitor),
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"struct variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"struct variant",
-            )),
-        }
-    }
-}
-
-struct SeqDeserializer {
-    iter: vec::IntoIter<Value>,
-}
-
-impl SeqDeserializer {
-    fn new(vec: Vec<Value>) -> Self {
-        SeqDeserializer {
-            iter: vec.into_iter(),
-        }
-    }
-}
-
-impl<'de> SeqAccess<'de> for SeqDeserializer {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(value) => seed.deserialize(value).map(Some),
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-struct MapDeserializer {
-    iter: <Map<String, Value> as IntoIterator>::IntoIter,
-    value: Option<Value>,
-}
-
-impl MapDeserializer {
-    fn new(map: Map<String, Value>) -> Self {
-        MapDeserializer {
-            iter: map.into_iter(),
-            value: None,
-        }
-    }
-}
-
-impl<'de> MapAccess<'de> for MapDeserializer {
-    type Error = Error;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.value = Some(value);
-                let key_de = MapKeyDeserializer {
-                    key: Cow::Owned(key),
-                };
-                seed.deserialize(key_de).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value.take() {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::custom("value is missing")),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-macro_rules! deserialize_value_ref_number {
-    ($method:ident) => {
-        #[cfg(not(feature = "arbitrary_precision"))]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.deserialize_any(visitor),
-                _ => Err(self.invalid_type(&visitor)),
-            }
-        }
-
-        #[cfg(feature = "arbitrary_precision")]
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            match self {
-                Value::Number(n) => n.$method(visitor),
-                _ => self.deserialize_any(visitor),
-            }
-        }
-    };
-}
-
-fn visit_array_ref<'de, V>(array: &'de [Value], visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = array.len();
-    let mut deserializer = SeqRefDeserializer::new(array);
-    let seq = tri!(visitor.visit_seq(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(seq)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in array",
-        ))
-    }
-}
-
-fn visit_object_ref<'de, V>(object: &'de Map<String, Value>, visitor: V) -> Result<V::Value, Error>
-where
-    V: Visitor<'de>,
-{
-    let len = object.len();
-    let mut deserializer = MapRefDeserializer::new(object);
-    let map = tri!(visitor.visit_map(&mut deserializer));
-    let remaining = deserializer.iter.len();
-    if remaining == 0 {
-        Ok(map)
-    } else {
-        Err(serde::de::Error::invalid_length(
-            len,
-            &"fewer elements in map",
-        ))
-    }
-}
-
-impl<'de> serde::Deserializer<'de> for &'de Value {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(*v),
-            Value::Number(n) => n.deserialize_any(visitor),
-            Value::String(v) => visitor.visit_borrowed_str(v),
-            Value::Array(v) => visit_array_ref(v, visitor),
-            Value::Object(v) => visit_object_ref(v, visitor),
-        }
-    }
-
-    deserialize_value_ref_number!(deserialize_i8);
-    deserialize_value_ref_number!(deserialize_i16);
-    deserialize_value_ref_number!(deserialize_i32);
-    deserialize_value_ref_number!(deserialize_i64);
-    deserialize_number!(deserialize_i128);
-    deserialize_value_ref_number!(deserialize_u8);
-    deserialize_value_ref_number!(deserialize_u16);
-    deserialize_value_ref_number!(deserialize_u32);
-    deserialize_value_ref_number!(deserialize_u64);
-    deserialize_number!(deserialize_u128);
-    deserialize_value_ref_number!(deserialize_f32);
-    deserialize_value_ref_number!(deserialize_f64);
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match *self {
-            Value::Null => visitor.visit_none(),
-            _ => visitor.visit_some(self),
-        }
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        let (variant, value) = match self {
-            Value::Object(value) => {
-                let mut iter = value.into_iter();
-                let (variant, value) = match iter.next() {
-                    Some(v) => v,
-                    None => {
-                        return Err(serde::de::Error::invalid_value(
-                            Unexpected::Map,
-                            &"map with a single key",
-                        ));
-                    }
-                };
-                // enums are encoded in json as maps with a single key:value pair
-                if iter.next().is_some() {
-                    return Err(serde::de::Error::invalid_value(
-                        Unexpected::Map,
-                        &"map with a single key",
-                    ));
-                }
-                (variant, Some(value))
-            }
-            Value::String(variant) => (variant, None),
-            other => {
-                return Err(serde::de::Error::invalid_type(
-                    other.unexpected(),
-                    &"string or map",
-                ));
-            }
-        };
-
-        visitor.visit_enum(EnumRefDeserializer { variant, value })
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V>(
-        self,
-        name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        #[cfg(feature = "raw_value")]
-        {
-            if name == crate::raw::TOKEN {
-                return visitor.visit_map(crate::raw::OwnedRawDeserializer {
-                    raw_value: Some(self.to_string()),
-                });
-            }
-        }
-
-        let _ = name;
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match *self {
-            Value::Bool(v) => visitor.visit_bool(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::String(v) => visitor.visit_borrowed_str(v),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::String(v) => visitor.visit_borrowed_str(v),
-            Value::Array(v) => visit_array_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_bytes(visitor)
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match *self {
-            Value::Null => visitor.visit_unit(),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_unit(visitor)
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_seq(visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Object(v) => visit_object_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &'static str,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self {
-            Value::Array(v) => visit_array_ref(v, visitor),
-            Value::Object(v) => visit_object_ref(v, visitor),
-            _ => Err(self.invalid_type(&visitor)),
-        }
-    }
-
-    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.deserialize_str(visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_unit()
-    }
-}
-
-struct EnumRefDeserializer<'de> {
-    variant: &'de str,
-    value: Option<&'de Value>,
-}
-
-impl<'de> EnumAccess<'de> for EnumRefDeserializer<'de> {
-    type Error = Error;
-    type Variant = VariantRefDeserializer<'de>;
-
-    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
-    where
-        V: DeserializeSeed<'de>,
-    {
-        let variant = self.variant.into_deserializer();
-        let visitor = VariantRefDeserializer { value: self.value };
-        seed.deserialize(variant).map(|v| (v, visitor))
-    }
-}
-
-struct VariantRefDeserializer<'de> {
-    value: Option<&'de Value>,
-}
-
-impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<(), Error> {
-        match self.value {
-            Some(value) => Deserialize::deserialize(value),
-            None => Ok(()),
-        }
-    }
-
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"newtype variant",
-            )),
-        }
-    }
-
-    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Array(v)) => {
-                if v.is_empty() {
-                    visitor.visit_unit()
-                } else {
-                    visit_array_ref(v, visitor)
-                }
-            }
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"tuple variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"tuple variant",
-            )),
-        }
-    }
-
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        match self.value {
-            Some(Value::Object(v)) => visit_object_ref(v, visitor),
-            Some(other) => Err(serde::de::Error::invalid_type(
-                other.unexpected(),
-                &"struct variant",
-            )),
-            None => Err(serde::de::Error::invalid_type(
-                Unexpected::UnitVariant,
-                &"struct variant",
-            )),
-        }
-    }
-}
-
-struct SeqRefDeserializer<'de> {
-    iter: slice::Iter<'de, Value>,
-}
-
-impl<'de> SeqRefDeserializer<'de> {
-    fn new(slice: &'de [Value]) -> Self {
-        SeqRefDeserializer { iter: slice.iter() }
-    }
-}
-
-impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de> {
-    type Error = Error;
-
-    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some(value) => seed.deserialize(value).map(Some),
-            None => Ok(None),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-struct MapRefDeserializer<'de> {
-    iter: <&'de Map<String, Value> as IntoIterator>::IntoIter,
-    value: Option<&'de Value>,
-}
-
-impl<'de> MapRefDeserializer<'de> {
-    fn new(map: &'de Map<String, Value>) -> Self {
-        MapRefDeserializer {
-            iter: map.into_iter(),
-            value: None,
-        }
-    }
-}
-
-impl<'de> MapAccess<'de> for MapRefDeserializer<'de> {
-    type Error = Error;
-
-    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.value = Some(value);
-                let key_de = MapKeyDeserializer {
-                    key: Cow::Borrowed(&**key),
-                };
-                seed.deserialize(key_de).map(Some)
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
-    where
-        T: DeserializeSeed<'de>,
-    {
-        match self.value.take() {
-            Some(value) => seed.deserialize(value),
-            None => Err(serde::de::Error::custom("value is missing")),
-        }
-    }
-
-    fn size_hint(&self) -> Option<usize> {
-        match self.iter.size_hint() {
-            (lower, Some(upper)) if lower == upper => Some(upper),
-            _ => None,
-        }
-    }
-}
-
-struct MapKeyDeserializer<'de> {
-    key: Cow<'de, str>,
-}
-
-macro_rules! deserialize_numeric_key {
-    ($method:ident) => {
-        deserialize_numeric_key!($method, deserialize_number);
-    };
-
-    ($method:ident, $using:ident) => {
-        fn $method<V>(self, visitor: V) -> Result<V::Value, Error>
-        where
-            V: Visitor<'de>,
-        {
-            let mut de = crate::Deserializer::from_str(&self.key);
-
-            match tri!(de.peek()) {
-                Some(b'0'..=b'9' | b'-') => {}
-                _ => return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0)),
-            }
-
-            let number = tri!(de.$using(visitor));
-
-            if tri!(de.peek()).is_some() {
-                return Err(Error::syntax(ErrorCode::ExpectedNumericKey, 0, 0));
-            }
-
-            Ok(number)
-        }
-    };
-}
-
-impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        BorrowedCowStrDeserializer::new(self.key).deserialize_any(visitor)
-    }
-
-    deserialize_numeric_key!(deserialize_i8);
-    deserialize_numeric_key!(deserialize_i16);
-    deserialize_numeric_key!(deserialize_i32);
-    deserialize_numeric_key!(deserialize_i64);
-    deserialize_numeric_key!(deserialize_u8);
-    deserialize_numeric_key!(deserialize_u16);
-    deserialize_numeric_key!(deserialize_u32);
-    deserialize_numeric_key!(deserialize_u64);
-    #[cfg(not(feature = "float_roundtrip"))]
-    deserialize_numeric_key!(deserialize_f32);
-    deserialize_numeric_key!(deserialize_f64);
-
-    #[cfg(feature = "float_roundtrip")]
-    deserialize_numeric_key!(deserialize_f32, do_deserialize_f32);
-    deserialize_numeric_key!(deserialize_i128, do_deserialize_i128);
-    deserialize_numeric_key!(deserialize_u128, do_deserialize_u128);
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        if self.key == "true" {
-            visitor.visit_bool(true)
-        } else if self.key == "false" {
-            visitor.visit_bool(false)
-        } else {
-            Err(serde::de::Error::invalid_type(
-                Unexpected::Str(&self.key),
-                &visitor,
-            ))
-        }
-    }
-
-    #[inline]
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        // Map keys cannot be null.
-        visitor.visit_some(self)
-    }
-
-    #[inline]
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &'static str,
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        name: &'static str,
-        variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: Visitor<'de>,
-    {
-        self.key
-            .into_deserializer()
-            .deserialize_enum(name, variants, visitor)
-    }
-
-    forward_to_deserialize_any! {
-        char str string bytes byte_buf unit unit_struct seq tuple tuple_struct
-        map struct identifier ignored_any
-    }
-}
-
-struct KeyClassifier;
-
-enum KeyClass {
-    Map(String),
-    #[cfg(feature = "arbitrary_precision")]
-    Number,
-    #[cfg(feature = "raw_value")]
-    RawValue,
-}
-
-impl<'de> DeserializeSeed<'de> for KeyClassifier {
-    type Value = KeyClass;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_str(self)
-    }
-}
-
-impl<'de> Visitor<'de> for KeyClassifier {
-    type Value = KeyClass;
-
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string key")
-    }
-
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        match s {
-            #[cfg(feature = "arbitrary_precision")]
-            crate::number::TOKEN => Ok(KeyClass::Number),
-            #[cfg(feature = "raw_value")]
-            crate::raw::TOKEN => Ok(KeyClass::RawValue),
-            _ => Ok(KeyClass::Map(s.to_owned())),
-        }
-    }
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        match s.as_str() {
-            #[cfg(feature = "arbitrary_precision")]
-            crate::number::TOKEN => Ok(KeyClass::Number),
-            #[cfg(feature = "raw_value")]
-            crate::raw::TOKEN => Ok(KeyClass::RawValue),
-            _ => Ok(KeyClass::Map(s)),
-        }
-    }
-}
-
-impl Value {
-    #[cold]
-    fn invalid_type<E>(&self, exp: &dyn Expected) -> E
-    where
-        E: serde::de::Error,
-    {
-        serde::de::Error::invalid_type(self.unexpected(), exp)
-    }
-
-    #[cold]
-    fn unexpected(&self) -> Unexpected {
-        match self {
-            Value::Null => Unexpected::Unit,
-            Value::Bool(b) => Unexpected::Bool(*b),
-            Value::Number(n) => n.unexpected(),
-            Value::String(s) => Unexpected::Str(s),
-            Value::Array(_) => Unexpected::Seq,
-            Value::Object(_) => Unexpected::Map,
-        }
-    }
-}
-
-struct BorrowedCowStrDeserializer<'de> {
-    value: Cow<'de, str>,
-}
-
-impl<'de> BorrowedCowStrDeserializer<'de> {
-    fn new(value: Cow<'de, str>) -> Self {
-        BorrowedCowStrDeserializer { value }
-    }
-}
-
-impl<'de> de::Deserializer<'de> for BorrowedCowStrDeserializer<'de> {
-    type Error = Error;
-
-    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        match self.value {
-            Cow::Borrowed(string) => visitor.visit_borrowed_str(string),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Cow::Owned(string) => visitor.visit_string(string),
-        }
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _name: &str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        visitor.visit_enum(self)
-    }
-
-    forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
-        tuple_struct map struct identifier ignored_any
-    }
-}
-
-impl<'de> de::EnumAccess<'de> for BorrowedCowStrDeserializer<'de> {
-    type Error = Error;
-    type Variant = UnitOnly;
-
-    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        let value = tri!(seed.deserialize(self));
-        Ok((value, UnitOnly))
-    }
-}
-
-struct UnitOnly;
-
-impl<'de> de::VariantAccess<'de> for UnitOnly {
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<(), Error> {
-        Ok(())
-    }
-
-    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Error>
-    where
-        T: de::DeserializeSeed<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"newtype variant",
-        ))
-    }
-
-    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"tuple variant",
-        ))
-    }
-
-    fn struct_variant<V>(
-        self,
-        _fields: &'static [&'static str],
-        _visitor: V,
-    ) -> Result<V::Value, Error>
-    where
-        V: de::Visitor<'de>,
-    {
-        Err(de::Error::invalid_type(
-            Unexpected::UnitVariant,
-            &"struct variant",
-        ))
-    }
-}
diff --git a/vendor/serde_json/src/value/from.rs b/vendor/serde_json/src/value/from.rs
deleted file mode 100644
index ed1e333..0000000
--- a/vendor/serde_json/src/value/from.rs
+++ /dev/null
@@ -1,278 +0,0 @@
-use super::Value;
-use crate::map::Map;
-use crate::number::Number;
-use alloc::borrow::Cow;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-
-macro_rules! from_integer {
-    ($($ty:ident)*) => {
-        $(
-            impl From<$ty> for Value {
-                fn from(n: $ty) -> Self {
-                    Value::Number(n.into())
-                }
-            }
-        )*
-    };
-}
-
-from_integer! {
-    i8 i16 i32 i64 isize
-    u8 u16 u32 u64 usize
-}
-
-#[cfg(feature = "arbitrary_precision")]
-from_integer! {
-    i128 u128
-}
-
-impl From<f32> for Value {
-    /// Convert 32-bit floating point number to `Value::Number`, or
-    /// `Value::Null` if infinite or NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let f: f32 = 13.37;
-    /// let x: Value = f.into();
-    /// ```
-    fn from(f: f32) -> Self {
-        Number::from_f32(f).map_or(Value::Null, Value::Number)
-    }
-}
-
-impl From<f64> for Value {
-    /// Convert 64-bit floating point number to `Value::Number`, or
-    /// `Value::Null` if infinite or NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let f: f64 = 13.37;
-    /// let x: Value = f.into();
-    /// ```
-    fn from(f: f64) -> Self {
-        Number::from_f64(f).map_or(Value::Null, Value::Number)
-    }
-}
-
-impl From<bool> for Value {
-    /// Convert boolean to `Value::Bool`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let b = false;
-    /// let x: Value = b.into();
-    /// ```
-    fn from(f: bool) -> Self {
-        Value::Bool(f)
-    }
-}
-
-impl From<String> for Value {
-    /// Convert `String` to `Value::String`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let s: String = "lorem".to_string();
-    /// let x: Value = s.into();
-    /// ```
-    fn from(f: String) -> Self {
-        Value::String(f)
-    }
-}
-
-impl From<&str> for Value {
-    /// Convert string slice to `Value::String`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let s: &str = "lorem";
-    /// let x: Value = s.into();
-    /// ```
-    fn from(f: &str) -> Self {
-        Value::String(f.to_string())
-    }
-}
-
-impl<'a> From<Cow<'a, str>> for Value {
-    /// Convert copy-on-write string to `Value::String`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    /// use std::borrow::Cow;
-    ///
-    /// let s: Cow<str> = Cow::Borrowed("lorem");
-    /// let x: Value = s.into();
-    /// ```
-    ///
-    /// ```
-    /// use serde_json::Value;
-    /// use std::borrow::Cow;
-    ///
-    /// let s: Cow<str> = Cow::Owned("lorem".to_string());
-    /// let x: Value = s.into();
-    /// ```
-    fn from(f: Cow<'a, str>) -> Self {
-        Value::String(f.into_owned())
-    }
-}
-
-impl From<Number> for Value {
-    /// Convert `Number` to `Value::Number`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::{Number, Value};
-    ///
-    /// let n = Number::from(7);
-    /// let x: Value = n.into();
-    /// ```
-    fn from(f: Number) -> Self {
-        Value::Number(f)
-    }
-}
-
-impl From<Map<String, Value>> for Value {
-    /// Convert map (with string keys) to `Value::Object`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::{Map, Value};
-    ///
-    /// let mut m = Map::new();
-    /// m.insert("Lorem".to_string(), "ipsum".into());
-    /// let x: Value = m.into();
-    /// ```
-    fn from(f: Map<String, Value>) -> Self {
-        Value::Object(f)
-    }
-}
-
-impl<T: Into<Value>> From<Vec<T>> for Value {
-    /// Convert a `Vec` to `Value::Array`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v = vec!["lorem", "ipsum", "dolor"];
-    /// let x: Value = v.into();
-    /// ```
-    fn from(f: Vec<T>) -> Self {
-        Value::Array(f.into_iter().map(Into::into).collect())
-    }
-}
-
-impl<T: Clone + Into<Value>> From<&[T]> for Value {
-    /// Convert a slice to `Value::Array`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v: &[&str] = &["lorem", "ipsum", "dolor"];
-    /// let x: Value = v.into();
-    /// ```
-    fn from(f: &[T]) -> Self {
-        Value::Array(f.iter().cloned().map(Into::into).collect())
-    }
-}
-
-impl<T: Into<Value>> FromIterator<T> for Value {
-    /// Create a `Value::Array` by collecting an iterator of array elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v = std::iter::repeat(42).take(5);
-    /// let x: Value = v.collect();
-    /// ```
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v: Vec<_> = vec!["lorem", "ipsum", "dolor"];
-    /// let x: Value = v.into_iter().collect();
-    /// ```
-    ///
-    /// ```
-    /// use std::iter::FromIterator;
-    /// use serde_json::Value;
-    ///
-    /// let x: Value = Value::from_iter(vec!["lorem", "ipsum", "dolor"]);
-    /// ```
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
-        Value::Array(iter.into_iter().map(Into::into).collect())
-    }
-}
-
-impl<K: Into<String>, V: Into<Value>> FromIterator<(K, V)> for Value {
-    /// Create a `Value::Object` by collecting an iterator of key-value pairs.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let v: Vec<_> = vec![("lorem", 40), ("ipsum", 2)];
-    /// let x: Value = v.into_iter().collect();
-    /// ```
-    fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
-        Value::Object(
-            iter.into_iter()
-                .map(|(k, v)| (k.into(), v.into()))
-                .collect(),
-        )
-    }
-}
-
-impl From<()> for Value {
-    /// Convert `()` to `Value::Null`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// let u = ();
-    /// let x: Value = u.into();
-    /// ```
-    fn from((): ()) -> Self {
-        Value::Null
-    }
-}
-
-impl<T> From<Option<T>> for Value
-where
-    T: Into<Value>,
-{
-    fn from(opt: Option<T>) -> Self {
-        match opt {
-            None => Value::Null,
-            Some(value) => Into::into(value),
-        }
-    }
-}
diff --git a/vendor/serde_json/src/value/index.rs b/vendor/serde_json/src/value/index.rs
deleted file mode 100644
index 891ca8e..0000000
--- a/vendor/serde_json/src/value/index.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use super::Value;
-use crate::map::Map;
-use alloc::borrow::ToOwned;
-use alloc::string::String;
-use core::fmt::{self, Display};
-use core::ops;
-
-/// A type that can be used to index into a `serde_json::Value`.
-///
-/// The [`get`] and [`get_mut`] methods of `Value` accept any type that
-/// implements `Index`, as does the [square-bracket indexing operator]. This
-/// trait is implemented for strings which are used as the index into a JSON
-/// map, and for `usize` which is used as the index into a JSON array.
-///
-/// [`get`]: ../enum.Value.html#method.get
-/// [`get_mut`]: ../enum.Value.html#method.get_mut
-/// [square-bracket indexing operator]: ../enum.Value.html#impl-Index%3CI%3E
-///
-/// This trait is sealed and cannot be implemented for types outside of
-/// `serde_json`.
-///
-/// # Examples
-///
-/// ```
-/// # use serde_json::json;
-/// #
-/// let data = json!({ "inner": [1, 2, 3] });
-///
-/// // Data is a JSON map so it can be indexed with a string.
-/// let inner = &data["inner"];
-///
-/// // Inner is a JSON array so it can be indexed with an integer.
-/// let first = &inner[0];
-///
-/// assert_eq!(first, 1);
-/// ```
-pub trait Index: private::Sealed {
-    /// Return None if the key is not already in the array or object.
-    #[doc(hidden)]
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value>;
-
-    /// Return None if the key is not already in the array or object.
-    #[doc(hidden)]
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value>;
-
-    /// Panic if array index out of bounds. If key is not already in the object,
-    /// insert it with a value of null. Panic if Value is a type that cannot be
-    /// indexed into, except if Value is null then it can be treated as an empty
-    /// object.
-    #[doc(hidden)]
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value;
-}
-
-impl Index for usize {
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        match v {
-            Value::Array(vec) => vec.get(*self),
-            _ => None,
-        }
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        match v {
-            Value::Array(vec) => vec.get_mut(*self),
-            _ => None,
-        }
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        match v {
-            Value::Array(vec) => {
-                let len = vec.len();
-                vec.get_mut(*self).unwrap_or_else(|| {
-                    panic!(
-                        "cannot access index {} of JSON array of length {}",
-                        self, len
-                    )
-                })
-            }
-            _ => panic!("cannot access index {} of JSON {}", self, Type(v)),
-        }
-    }
-}
-
-impl Index for str {
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        match v {
-            Value::Object(map) => map.get(self),
-            _ => None,
-        }
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        match v {
-            Value::Object(map) => map.get_mut(self),
-            _ => None,
-        }
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        if let Value::Null = v {
-            *v = Value::Object(Map::new());
-        }
-        match v {
-            Value::Object(map) => map.entry(self.to_owned()).or_insert(Value::Null),
-            _ => panic!("cannot access key {:?} in JSON {}", self, Type(v)),
-        }
-    }
-}
-
-impl Index for String {
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        self[..].index_into(v)
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        self[..].index_into_mut(v)
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        self[..].index_or_insert(v)
-    }
-}
-
-impl<T> Index for &T
-where
-    T: ?Sized + Index,
-{
-    fn index_into<'v>(&self, v: &'v Value) -> Option<&'v Value> {
-        (**self).index_into(v)
-    }
-    fn index_into_mut<'v>(&self, v: &'v mut Value) -> Option<&'v mut Value> {
-        (**self).index_into_mut(v)
-    }
-    fn index_or_insert<'v>(&self, v: &'v mut Value) -> &'v mut Value {
-        (**self).index_or_insert(v)
-    }
-}
-
-// Prevent users from implementing the Index trait.
-mod private {
-    pub trait Sealed {}
-    impl Sealed for usize {}
-    impl Sealed for str {}
-    impl Sealed for alloc::string::String {}
-    impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {}
-}
-
-/// Used in panic messages.
-struct Type<'a>(&'a Value);
-
-impl<'a> Display for Type<'a> {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match *self.0 {
-            Value::Null => formatter.write_str("null"),
-            Value::Bool(_) => formatter.write_str("boolean"),
-            Value::Number(_) => formatter.write_str("number"),
-            Value::String(_) => formatter.write_str("string"),
-            Value::Array(_) => formatter.write_str("array"),
-            Value::Object(_) => formatter.write_str("object"),
-        }
-    }
-}
-
-// The usual semantics of Index is to panic on invalid indexing.
-//
-// That said, the usual semantics are for things like Vec and BTreeMap which
-// have different use cases than Value. If you are working with a Vec, you know
-// that you are working with a Vec and you can get the len of the Vec and make
-// sure your indices are within bounds. The Value use cases are more
-// loosey-goosey. You got some JSON from an endpoint and you want to pull values
-// out of it. Outside of this Index impl, you already have the option of using
-// value.as_array() and working with the Vec directly, or matching on
-// Value::Array and getting the Vec directly. The Index impl means you can skip
-// that and index directly into the thing using a concise syntax. You don't have
-// to check the type, you don't have to check the len, it is all about what you
-// expect the Value to look like.
-//
-// Basically the use cases that would be well served by panicking here are
-// better served by using one of the other approaches: get and get_mut,
-// as_array, or match. The value of this impl is that it adds a way of working
-// with Value that is not well served by the existing approaches: concise and
-// careless and sometimes that is exactly what you want.
-impl<I> ops::Index<I> for Value
-where
-    I: Index,
-{
-    type Output = Value;
-
-    /// Index into a `serde_json::Value` using the syntax `value[0]` or
-    /// `value["k"]`.
-    ///
-    /// Returns `Value::Null` if the type of `self` does not match the type of
-    /// the index, for example if the index is a string and `self` is an array
-    /// or a number. Also returns `Value::Null` if the given key does not exist
-    /// in the map or the given index is not within the bounds of the array.
-    ///
-    /// For retrieving deeply nested values, you should have a look at the
-    /// `Value::pointer` method.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let data = json!({
-    ///     "x": {
-    ///         "y": ["z", "zz"]
-    ///     }
-    /// });
-    ///
-    /// assert_eq!(data["x"]["y"], json!(["z", "zz"]));
-    /// assert_eq!(data["x"]["y"][0], json!("z"));
-    ///
-    /// assert_eq!(data["a"], json!(null)); // returns null for undefined values
-    /// assert_eq!(data["a"]["b"], json!(null)); // does not panic
-    /// ```
-    fn index(&self, index: I) -> &Value {
-        static NULL: Value = Value::Null;
-        index.index_into(self).unwrap_or(&NULL)
-    }
-}
-
-impl<I> ops::IndexMut<I> for Value
-where
-    I: Index,
-{
-    /// Write into a `serde_json::Value` using the syntax `value[0] = ...` or
-    /// `value["k"] = ...`.
-    ///
-    /// If the index is a number, the value must be an array of length bigger
-    /// than the index. Indexing into a value that is not an array or an array
-    /// that is too small will panic.
-    ///
-    /// If the index is a string, the value must be an object or null which is
-    /// treated like an empty object. If the key is not already present in the
-    /// object, it will be inserted with a value of null. Indexing into a value
-    /// that is neither an object nor null will panic.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut data = json!({ "x": 0 });
-    ///
-    /// // replace an existing key
-    /// data["x"] = json!(1);
-    ///
-    /// // insert a new key
-    /// data["y"] = json!([false, false, false]);
-    ///
-    /// // replace an array value
-    /// data["y"][0] = json!(true);
-    ///
-    /// // inserted a deeply nested key
-    /// data["a"]["b"]["c"]["d"] = json!(true);
-    ///
-    /// println!("{}", data);
-    /// ```
-    fn index_mut(&mut self, index: I) -> &mut Value {
-        index.index_or_insert(self)
-    }
-}
diff --git a/vendor/serde_json/src/value/mod.rs b/vendor/serde_json/src/value/mod.rs
deleted file mode 100644
index b3f51ea..0000000
--- a/vendor/serde_json/src/value/mod.rs
+++ /dev/null
@@ -1,1009 +0,0 @@
-//! The Value enum, a loosely typed way of representing any valid JSON value.
-//!
-//! # Constructing JSON
-//!
-//! Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
-//! objects with very natural JSON syntax.
-//!
-//! ```
-//! use serde_json::json;
-//!
-//! fn main() {
-//!     // The type of `john` is `serde_json::Value`
-//!     let john = json!({
-//!         "name": "John Doe",
-//!         "age": 43,
-//!         "phones": [
-//!             "+44 1234567",
-//!             "+44 2345678"
-//!         ]
-//!     });
-//!
-//!     println!("first phone number: {}", john["phones"][0]);
-//!
-//!     // Convert to a string of JSON and print it out
-//!     println!("{}", john.to_string());
-//! }
-//! ```
-//!
-//! The `Value::to_string()` function converts a `serde_json::Value` into a
-//! `String` of JSON text.
-//!
-//! One neat thing about the `json!` macro is that variables and expressions can
-//! be interpolated directly into the JSON value as you are building it. Serde
-//! will check at compile time that the value you are interpolating is able to
-//! be represented as JSON.
-//!
-//! ```
-//! # use serde_json::json;
-//! #
-//! # fn random_phone() -> u16 { 0 }
-//! #
-//! let full_name = "John Doe";
-//! let age_last_year = 42;
-//!
-//! // The type of `john` is `serde_json::Value`
-//! let john = json!({
-//!     "name": full_name,
-//!     "age": age_last_year + 1,
-//!     "phones": [
-//!         format!("+44 {}", random_phone())
-//!     ]
-//! });
-//! ```
-//!
-//! A string of JSON data can be parsed into a `serde_json::Value` by the
-//! [`serde_json::from_str`][from_str] function. There is also
-//! [`from_slice`][from_slice] for parsing from a byte slice `&[u8]` and
-//! [`from_reader`][from_reader] for parsing from any `io::Read` like a File or
-//! a TCP stream.
-//!
-//! ```
-//! use serde_json::{json, Value, Error};
-//!
-//! fn untyped_example() -> Result<(), Error> {
-//!     // Some JSON input data as a &str. Maybe this comes from the user.
-//!     let data = r#"
-//!         {
-//!             "name": "John Doe",
-//!             "age": 43,
-//!             "phones": [
-//!                 "+44 1234567",
-//!                 "+44 2345678"
-//!             ]
-//!         }"#;
-//!
-//!     // Parse the string of data into serde_json::Value.
-//!     let v: Value = serde_json::from_str(data)?;
-//!
-//!     // Access parts of the data by indexing with square brackets.
-//!     println!("Please call {} at the number {}", v["name"], v["phones"][0]);
-//!
-//!     Ok(())
-//! }
-//! #
-//! # untyped_example().unwrap();
-//! ```
-//!
-//! [macro]: crate::json
-//! [from_str]: crate::de::from_str
-//! [from_slice]: crate::de::from_slice
-//! [from_reader]: crate::de::from_reader
-
-use crate::error::Error;
-use crate::io;
-use alloc::string::String;
-use alloc::vec::Vec;
-use core::fmt::{self, Debug, Display};
-use core::mem;
-use core::str;
-use serde::de::DeserializeOwned;
-use serde::ser::Serialize;
-
-pub use self::index::Index;
-pub use self::ser::Serializer;
-pub use crate::map::Map;
-pub use crate::number::Number;
-
-#[cfg(feature = "raw_value")]
-#[cfg_attr(docsrs, doc(cfg(feature = "raw_value")))]
-pub use crate::raw::{to_raw_value, RawValue};
-
-/// Represents any valid JSON value.
-///
-/// See the [`serde_json::value` module documentation](self) for usage examples.
-#[derive(Clone, Eq, PartialEq)]
-pub enum Value {
-    /// Represents a JSON null value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(null);
-    /// ```
-    Null,
-
-    /// Represents a JSON boolean.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(true);
-    /// ```
-    Bool(bool),
-
-    /// Represents a JSON number, whether integer or floating point.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(12.5);
-    /// ```
-    Number(Number),
-
-    /// Represents a JSON string.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!("a string");
-    /// ```
-    String(String),
-
-    /// Represents a JSON array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!(["an", "array"]);
-    /// ```
-    Array(Vec<Value>),
-
-    /// Represents a JSON object.
-    ///
-    /// By default the map is backed by a BTreeMap. Enable the `preserve_order`
-    /// feature of serde_json to use IndexMap instead, which preserves
-    /// entries in the order they are inserted into the map. In particular, this
-    /// allows JSON data to be deserialized into a Value and serialized to a
-    /// string while retaining the order of map keys in the input.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "an": "object" });
-    /// ```
-    Object(Map<String, Value>),
-}
-
-impl Debug for Value {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Value::Null => formatter.write_str("Null"),
-            Value::Bool(boolean) => write!(formatter, "Bool({})", boolean),
-            Value::Number(number) => Debug::fmt(number, formatter),
-            Value::String(string) => write!(formatter, "String({:?})", string),
-            Value::Array(vec) => {
-                tri!(formatter.write_str("Array "));
-                Debug::fmt(vec, formatter)
-            }
-            Value::Object(map) => {
-                tri!(formatter.write_str("Object "));
-                Debug::fmt(map, formatter)
-            }
-        }
-    }
-}
-
-impl Display for Value {
-    /// Display a JSON value as a string.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let json = json!({ "city": "London", "street": "10 Downing Street" });
-    ///
-    /// // Compact format:
-    /// //
-    /// // {"city":"London","street":"10 Downing Street"}
-    /// let compact = format!("{}", json);
-    /// assert_eq!(compact,
-    ///     "{\"city\":\"London\",\"street\":\"10 Downing Street\"}");
-    ///
-    /// // Pretty format:
-    /// //
-    /// // {
-    /// //   "city": "London",
-    /// //   "street": "10 Downing Street"
-    /// // }
-    /// let pretty = format!("{:#}", json);
-    /// assert_eq!(pretty,
-    ///     "{\n  \"city\": \"London\",\n  \"street\": \"10 Downing Street\"\n}");
-    /// ```
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        struct WriterFormatter<'a, 'b: 'a> {
-            inner: &'a mut fmt::Formatter<'b>,
-        }
-
-        impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
-            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-                // Safety: the serializer below only emits valid utf8 when using
-                // the default formatter.
-                let s = unsafe { str::from_utf8_unchecked(buf) };
-                tri!(self.inner.write_str(s).map_err(io_error));
-                Ok(buf.len())
-            }
-
-            fn flush(&mut self) -> io::Result<()> {
-                Ok(())
-            }
-        }
-
-        fn io_error(_: fmt::Error) -> io::Error {
-            // Error value does not matter because Display impl just maps it
-            // back to fmt::Error.
-            io::Error::new(io::ErrorKind::Other, "fmt error")
-        }
-
-        let alternate = f.alternate();
-        let mut wr = WriterFormatter { inner: f };
-        if alternate {
-            // {:#}
-            super::ser::to_writer_pretty(&mut wr, self).map_err(|_| fmt::Error)
-        } else {
-            // {}
-            super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
-        }
-    }
-}
-
-fn parse_index(s: &str) -> Option<usize> {
-    if s.starts_with('+') || (s.starts_with('0') && s.len() != 1) {
-        return None;
-    }
-    s.parse().ok()
-}
-
-impl Value {
-    /// Index into a JSON array or map. A string index can be used to access a
-    /// value in a map, and a usize index can be used to access an element of an
-    /// array.
-    ///
-    /// Returns `None` if the type of `self` does not match the type of the
-    /// index, for example if the index is a string and `self` is an array or a
-    /// number. Also returns `None` if the given key does not exist in the map
-    /// or the given index is not within the bounds of the array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let object = json!({ "A": 65, "B": 66, "C": 67 });
-    /// assert_eq!(*object.get("A").unwrap(), json!(65));
-    ///
-    /// let array = json!([ "A", "B", "C" ]);
-    /// assert_eq!(*array.get(2).unwrap(), json!("C"));
-    ///
-    /// assert_eq!(array.get("A"), None);
-    /// ```
-    ///
-    /// Square brackets can also be used to index into a value in a more concise
-    /// way. This returns `Value::Null` in cases where `get` would have returned
-    /// `None`.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let object = json!({
-    ///     "A": ["a", "á", "à"],
-    ///     "B": ["b", "b́"],
-    ///     "C": ["c", "ć", "ć̣", "ḉ"],
-    /// });
-    /// assert_eq!(object["B"][0], json!("b"));
-    ///
-    /// assert_eq!(object["D"], json!(null));
-    /// assert_eq!(object[0]["x"]["y"]["z"], json!(null));
-    /// ```
-    pub fn get<I: Index>(&self, index: I) -> Option<&Value> {
-        index.index_into(self)
-    }
-
-    /// Mutably index into a JSON array or map. A string index can be used to
-    /// access a value in a map, and a usize index can be used to access an
-    /// element of an array.
-    ///
-    /// Returns `None` if the type of `self` does not match the type of the
-    /// index, for example if the index is a string and `self` is an array or a
-    /// number. Also returns `None` if the given key does not exist in the map
-    /// or the given index is not within the bounds of the array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut object = json!({ "A": 65, "B": 66, "C": 67 });
-    /// *object.get_mut("A").unwrap() = json!(69);
-    ///
-    /// let mut array = json!([ "A", "B", "C" ]);
-    /// *array.get_mut(2).unwrap() = json!("D");
-    /// ```
-    pub fn get_mut<I: Index>(&mut self, index: I) -> Option<&mut Value> {
-        index.index_into_mut(self)
-    }
-
-    /// Returns true if the `Value` is an Object. Returns false otherwise.
-    ///
-    /// For any Value on which `is_object` returns true, `as_object` and
-    /// `as_object_mut` are guaranteed to return the map representation of the
-    /// object.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let obj = json!({ "a": { "nested": true }, "b": ["an", "array"] });
-    ///
-    /// assert!(obj.is_object());
-    /// assert!(obj["a"].is_object());
-    ///
-    /// // array, not an object
-    /// assert!(!obj["b"].is_object());
-    /// ```
-    pub fn is_object(&self) -> bool {
-        self.as_object().is_some()
-    }
-
-    /// If the `Value` is an Object, returns the associated Map. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": { "nested": true }, "b": ["an", "array"] });
-    ///
-    /// // The length of `{"nested": true}` is 1 entry.
-    /// assert_eq!(v["a"].as_object().unwrap().len(), 1);
-    ///
-    /// // The array `["an", "array"]` is not an object.
-    /// assert_eq!(v["b"].as_object(), None);
-    /// ```
-    pub fn as_object(&self) -> Option<&Map<String, Value>> {
-        match self {
-            Value::Object(map) => Some(map),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is an Object, returns the associated mutable Map.
-    /// Returns None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut v = json!({ "a": { "nested": true } });
-    ///
-    /// v["a"].as_object_mut().unwrap().clear();
-    /// assert_eq!(v, json!({ "a": {} }));
-    /// ```
-    pub fn as_object_mut(&mut self) -> Option<&mut Map<String, Value>> {
-        match self {
-            Value::Object(map) => Some(map),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is an Array. Returns false otherwise.
-    ///
-    /// For any Value on which `is_array` returns true, `as_array` and
-    /// `as_array_mut` are guaranteed to return the vector representing the
-    /// array.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let obj = json!({ "a": ["an", "array"], "b": { "an": "object" } });
-    ///
-    /// assert!(obj["a"].is_array());
-    ///
-    /// // an object, not an array
-    /// assert!(!obj["b"].is_array());
-    /// ```
-    pub fn is_array(&self) -> bool {
-        self.as_array().is_some()
-    }
-
-    /// If the `Value` is an Array, returns the associated vector. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": ["an", "array"], "b": { "an": "object" } });
-    ///
-    /// // The length of `["an", "array"]` is 2 elements.
-    /// assert_eq!(v["a"].as_array().unwrap().len(), 2);
-    ///
-    /// // The object `{"an": "object"}` is not an array.
-    /// assert_eq!(v["b"].as_array(), None);
-    /// ```
-    pub fn as_array(&self) -> Option<&Vec<Value>> {
-        match self {
-            Value::Array(array) => Some(array),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is an Array, returns the associated mutable vector.
-    /// Returns None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut v = json!({ "a": ["an", "array"] });
-    ///
-    /// v["a"].as_array_mut().unwrap().clear();
-    /// assert_eq!(v, json!({ "a": [] }));
-    /// ```
-    pub fn as_array_mut(&mut self) -> Option<&mut Vec<Value>> {
-        match self {
-            Value::Array(list) => Some(list),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a String. Returns false otherwise.
-    ///
-    /// For any Value on which `is_string` returns true, `as_str` is guaranteed
-    /// to return the string slice.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": "some string", "b": false });
-    ///
-    /// assert!(v["a"].is_string());
-    ///
-    /// // The boolean `false` is not a string.
-    /// assert!(!v["b"].is_string());
-    /// ```
-    pub fn is_string(&self) -> bool {
-        self.as_str().is_some()
-    }
-
-    /// If the `Value` is a String, returns the associated str. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": "some string", "b": false });
-    ///
-    /// assert_eq!(v["a"].as_str(), Some("some string"));
-    ///
-    /// // The boolean `false` is not a string.
-    /// assert_eq!(v["b"].as_str(), None);
-    ///
-    /// // JSON values are printed in JSON representation, so strings are in quotes.
-    /// //
-    /// //    The value is: "some string"
-    /// println!("The value is: {}", v["a"]);
-    ///
-    /// // Rust strings are printed without quotes.
-    /// //
-    /// //    The value is: some string
-    /// println!("The value is: {}", v["a"].as_str().unwrap());
-    /// ```
-    pub fn as_str(&self) -> Option<&str> {
-        match self {
-            Value::String(s) => Some(s),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a Number. Returns false otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 1, "b": "2" });
-    ///
-    /// assert!(v["a"].is_number());
-    ///
-    /// // The string `"2"` is a string, not a number.
-    /// assert!(!v["b"].is_number());
-    /// ```
-    pub fn is_number(&self) -> bool {
-        match *self {
-            Value::Number(_) => true,
-            _ => false,
-        }
-    }
-
-    /// If the `Value` is a Number, returns the associated [`Number`]. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::{json, Number};
-    /// #
-    /// let v = json!({ "a": 1, "b": 2.2, "c": -3, "d": "4" });
-    ///
-    /// assert_eq!(v["a"].as_number(), Some(&Number::from(1u64)));
-    /// assert_eq!(v["b"].as_number(), Some(&Number::from_f64(2.2).unwrap()));
-    /// assert_eq!(v["c"].as_number(), Some(&Number::from(-3i64)));
-    ///
-    /// // The string `"4"` is not a number.
-    /// assert_eq!(v["d"].as_number(), None);
-    /// ```
-    pub fn as_number(&self) -> Option<&Number> {
-        match self {
-            Value::Number(number) => Some(number),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is an integer between `i64::MIN` and
-    /// `i64::MAX`.
-    ///
-    /// For any Value on which `is_i64` returns true, `as_i64` is guaranteed to
-    /// return the integer value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let big = i64::max_value() as u64 + 10;
-    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
-    ///
-    /// assert!(v["a"].is_i64());
-    ///
-    /// // Greater than i64::MAX.
-    /// assert!(!v["b"].is_i64());
-    ///
-    /// // Numbers with a decimal point are not considered integers.
-    /// assert!(!v["c"].is_i64());
-    /// ```
-    pub fn is_i64(&self) -> bool {
-        match self {
-            Value::Number(n) => n.is_i64(),
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is an integer between zero and `u64::MAX`.
-    ///
-    /// For any Value on which `is_u64` returns true, `as_u64` is guaranteed to
-    /// return the integer value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
-    ///
-    /// assert!(v["a"].is_u64());
-    ///
-    /// // Negative integer.
-    /// assert!(!v["b"].is_u64());
-    ///
-    /// // Numbers with a decimal point are not considered integers.
-    /// assert!(!v["c"].is_u64());
-    /// ```
-    pub fn is_u64(&self) -> bool {
-        match self {
-            Value::Number(n) => n.is_u64(),
-            _ => false,
-        }
-    }
-
-    /// Returns true if the `Value` is a number that can be represented by f64.
-    ///
-    /// For any Value on which `is_f64` returns true, `as_f64` is guaranteed to
-    /// return the floating point value.
-    ///
-    /// Currently this function returns true if and only if both `is_i64` and
-    /// `is_u64` return false but this is not a guarantee in the future.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
-    ///
-    /// assert!(v["a"].is_f64());
-    ///
-    /// // Integers.
-    /// assert!(!v["b"].is_f64());
-    /// assert!(!v["c"].is_f64());
-    /// ```
-    pub fn is_f64(&self) -> bool {
-        match self {
-            Value::Number(n) => n.is_f64(),
-            _ => false,
-        }
-    }
-
-    /// If the `Value` is an integer, represent it as i64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let big = i64::max_value() as u64 + 10;
-    /// let v = json!({ "a": 64, "b": big, "c": 256.0 });
-    ///
-    /// assert_eq!(v["a"].as_i64(), Some(64));
-    /// assert_eq!(v["b"].as_i64(), None);
-    /// assert_eq!(v["c"].as_i64(), None);
-    /// ```
-    pub fn as_i64(&self) -> Option<i64> {
-        match self {
-            Value::Number(n) => n.as_i64(),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is an integer, represent it as u64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 64, "b": -64, "c": 256.0 });
-    ///
-    /// assert_eq!(v["a"].as_u64(), Some(64));
-    /// assert_eq!(v["b"].as_u64(), None);
-    /// assert_eq!(v["c"].as_u64(), None);
-    /// ```
-    pub fn as_u64(&self) -> Option<u64> {
-        match self {
-            Value::Number(n) => n.as_u64(),
-            _ => None,
-        }
-    }
-
-    /// If the `Value` is a number, represent it as f64 if possible. Returns
-    /// None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": 256.0, "b": 64, "c": -64 });
-    ///
-    /// assert_eq!(v["a"].as_f64(), Some(256.0));
-    /// assert_eq!(v["b"].as_f64(), Some(64.0));
-    /// assert_eq!(v["c"].as_f64(), Some(-64.0));
-    /// ```
-    pub fn as_f64(&self) -> Option<f64> {
-        match self {
-            Value::Number(n) => n.as_f64(),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
-    ///
-    /// For any Value on which `is_boolean` returns true, `as_bool` is
-    /// guaranteed to return the boolean value.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": false, "b": "false" });
-    ///
-    /// assert!(v["a"].is_boolean());
-    ///
-    /// // The string `"false"` is a string, not a boolean.
-    /// assert!(!v["b"].is_boolean());
-    /// ```
-    pub fn is_boolean(&self) -> bool {
-        self.as_bool().is_some()
-    }
-
-    /// If the `Value` is a Boolean, returns the associated bool. Returns None
-    /// otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": false, "b": "false" });
-    ///
-    /// assert_eq!(v["a"].as_bool(), Some(false));
-    ///
-    /// // The string `"false"` is a string, not a boolean.
-    /// assert_eq!(v["b"].as_bool(), None);
-    /// ```
-    pub fn as_bool(&self) -> Option<bool> {
-        match *self {
-            Value::Bool(b) => Some(b),
-            _ => None,
-        }
-    }
-
-    /// Returns true if the `Value` is a Null. Returns false otherwise.
-    ///
-    /// For any Value on which `is_null` returns true, `as_null` is guaranteed
-    /// to return `Some(())`.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": null, "b": false });
-    ///
-    /// assert!(v["a"].is_null());
-    ///
-    /// // The boolean `false` is not null.
-    /// assert!(!v["b"].is_null());
-    /// ```
-    pub fn is_null(&self) -> bool {
-        self.as_null().is_some()
-    }
-
-    /// If the `Value` is a Null, returns (). Returns None otherwise.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let v = json!({ "a": null, "b": false });
-    ///
-    /// assert_eq!(v["a"].as_null(), Some(()));
-    ///
-    /// // The boolean `false` is not null.
-    /// assert_eq!(v["b"].as_null(), None);
-    /// ```
-    pub fn as_null(&self) -> Option<()> {
-        match *self {
-            Value::Null => Some(()),
-            _ => None,
-        }
-    }
-
-    /// Looks up a value by a JSON Pointer.
-    ///
-    /// JSON Pointer defines a string syntax for identifying a specific value
-    /// within a JavaScript Object Notation (JSON) document.
-    ///
-    /// A Pointer is a Unicode string with the reference tokens separated by `/`.
-    /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
-    /// addressed value is returned and if there is no such value `None` is
-    /// returned.
-    ///
-    /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let data = json!({
-    ///     "x": {
-    ///         "y": ["z", "zz"]
-    ///     }
-    /// });
-    ///
-    /// assert_eq!(data.pointer("/x/y/1").unwrap(), &json!("zz"));
-    /// assert_eq!(data.pointer("/a/b/c"), None);
-    /// ```
-    pub fn pointer(&self, pointer: &str) -> Option<&Value> {
-        if pointer.is_empty() {
-            return Some(self);
-        }
-        if !pointer.starts_with('/') {
-            return None;
-        }
-        pointer
-            .split('/')
-            .skip(1)
-            .map(|x| x.replace("~1", "/").replace("~0", "~"))
-            .try_fold(self, |target, token| match target {
-                Value::Object(map) => map.get(&token),
-                Value::Array(list) => parse_index(&token).and_then(|x| list.get(x)),
-                _ => None,
-            })
-    }
-
-    /// Looks up a value by a JSON Pointer and returns a mutable reference to
-    /// that value.
-    ///
-    /// JSON Pointer defines a string syntax for identifying a specific value
-    /// within a JavaScript Object Notation (JSON) document.
-    ///
-    /// A Pointer is a Unicode string with the reference tokens separated by `/`.
-    /// Inside tokens `/` is replaced by `~1` and `~` is replaced by `~0`. The
-    /// addressed value is returned and if there is no such value `None` is
-    /// returned.
-    ///
-    /// For more information read [RFC6901](https://tools.ietf.org/html/rfc6901).
-    ///
-    /// # Example of Use
-    ///
-    /// ```
-    /// use serde_json::Value;
-    ///
-    /// fn main() {
-    ///     let s = r#"{"x": 1.0, "y": 2.0}"#;
-    ///     let mut value: Value = serde_json::from_str(s).unwrap();
-    ///
-    ///     // Check value using read-only pointer
-    ///     assert_eq!(value.pointer("/x"), Some(&1.0.into()));
-    ///     // Change value with direct assignment
-    ///     *value.pointer_mut("/x").unwrap() = 1.5.into();
-    ///     // Check that new value was written
-    ///     assert_eq!(value.pointer("/x"), Some(&1.5.into()));
-    ///     // Or change the value only if it exists
-    ///     value.pointer_mut("/x").map(|v| *v = 1.5.into());
-    ///
-    ///     // "Steal" ownership of a value. Can replace with any valid Value.
-    ///     let old_x = value.pointer_mut("/x").map(Value::take).unwrap();
-    ///     assert_eq!(old_x, 1.5);
-    ///     assert_eq!(value.pointer("/x").unwrap(), &Value::Null);
-    /// }
-    /// ```
-    pub fn pointer_mut(&mut self, pointer: &str) -> Option<&mut Value> {
-        if pointer.is_empty() {
-            return Some(self);
-        }
-        if !pointer.starts_with('/') {
-            return None;
-        }
-        pointer
-            .split('/')
-            .skip(1)
-            .map(|x| x.replace("~1", "/").replace("~0", "~"))
-            .try_fold(self, |target, token| match target {
-                Value::Object(map) => map.get_mut(&token),
-                Value::Array(list) => parse_index(&token).and_then(move |x| list.get_mut(x)),
-                _ => None,
-            })
-    }
-
-    /// Takes the value out of the `Value`, leaving a `Null` in its place.
-    ///
-    /// ```
-    /// # use serde_json::json;
-    /// #
-    /// let mut v = json!({ "x": "y" });
-    /// assert_eq!(v["x"].take(), json!("y"));
-    /// assert_eq!(v, json!({ "x": null }));
-    /// ```
-    pub fn take(&mut self) -> Value {
-        mem::replace(self, Value::Null)
-    }
-}
-
-/// The default value is `Value::Null`.
-///
-/// This is useful for handling omitted `Value` fields when deserializing.
-///
-/// # Examples
-///
-/// ```
-/// # use serde::Deserialize;
-/// use serde_json::Value;
-///
-/// #[derive(Deserialize)]
-/// struct Settings {
-///     level: i32,
-///     #[serde(default)]
-///     extras: Value,
-/// }
-///
-/// # fn try_main() -> Result<(), serde_json::Error> {
-/// let data = r#" { "level": 42 } "#;
-/// let s: Settings = serde_json::from_str(data)?;
-///
-/// assert_eq!(s.level, 42);
-/// assert_eq!(s.extras, Value::Null);
-/// #
-/// #     Ok(())
-/// # }
-/// #
-/// # try_main().unwrap()
-/// ```
-impl Default for Value {
-    fn default() -> Value {
-        Value::Null
-    }
-}
-
-mod de;
-mod from;
-mod index;
-mod partial_eq;
-mod ser;
-
-/// Convert a `T` into `serde_json::Value` which is an enum that can represent
-/// any valid JSON data.
-///
-/// # Example
-///
-/// ```
-/// use serde::Serialize;
-/// use serde_json::json;
-/// use std::error::Error;
-///
-/// #[derive(Serialize)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn compare_json_values() -> Result<(), Box<dyn Error>> {
-///     let u = User {
-///         fingerprint: "0xF9BA143B95FF6D82".to_owned(),
-///         location: "Menlo Park, CA".to_owned(),
-///     };
-///
-///     // The type of `expected` is `serde_json::Value`
-///     let expected = json!({
-///         "fingerprint": "0xF9BA143B95FF6D82",
-///         "location": "Menlo Park, CA",
-///     });
-///
-///     let v = serde_json::to_value(u).unwrap();
-///     assert_eq!(v, expected);
-///
-///     Ok(())
-/// }
-/// #
-/// # compare_json_values().unwrap();
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if `T`'s implementation of `Serialize` decides to
-/// fail, or if `T` contains a map with non-string keys.
-///
-/// ```
-/// use std::collections::BTreeMap;
-///
-/// fn main() {
-///     // The keys in this map are vectors, not strings.
-///     let mut map = BTreeMap::new();
-///     map.insert(vec![32, 64], "x86");
-///
-///     println!("{}", serde_json::to_value(map).unwrap_err());
-/// }
-/// ```
-// Taking by value is more friendly to iterator adapters, option and result
-// consumers, etc. See https://github.com/serde-rs/json/pull/149.
-pub fn to_value<T>(value: T) -> Result<Value, Error>
-where
-    T: Serialize,
-{
-    value.serialize(Serializer)
-}
-
-/// Interpret a `serde_json::Value` as an instance of type `T`.
-///
-/// # Example
-///
-/// ```
-/// use serde::Deserialize;
-/// use serde_json::json;
-///
-/// #[derive(Deserialize, Debug)]
-/// struct User {
-///     fingerprint: String,
-///     location: String,
-/// }
-///
-/// fn main() {
-///     // The type of `j` is `serde_json::Value`
-///     let j = json!({
-///         "fingerprint": "0xF9BA143B95FF6D82",
-///         "location": "Menlo Park, CA"
-///     });
-///
-///     let u: User = serde_json::from_value(j).unwrap();
-///     println!("{:#?}", u);
-/// }
-/// ```
-///
-/// # Errors
-///
-/// This conversion can fail if the structure of the Value does not match the
-/// structure expected by `T`, for example if `T` is a struct type but the Value
-/// contains something other than a JSON map. It can also fail if the structure
-/// is correct but `T`'s implementation of `Deserialize` decides that something
-/// is wrong with the data, for example required struct fields are missing from
-/// the JSON map or some number is too big to fit in the expected primitive
-/// type.
-pub fn from_value<T>(value: Value) -> Result<T, Error>
-where
-    T: DeserializeOwned,
-{
-    T::deserialize(value)
-}
diff --git a/vendor/serde_json/src/value/partial_eq.rs b/vendor/serde_json/src/value/partial_eq.rs
deleted file mode 100644
index 46c1dbc..0000000
--- a/vendor/serde_json/src/value/partial_eq.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use super::Value;
-use alloc::string::String;
-
-fn eq_i64(value: &Value, other: i64) -> bool {
-    value.as_i64().map_or(false, |i| i == other)
-}
-
-fn eq_u64(value: &Value, other: u64) -> bool {
-    value.as_u64().map_or(false, |i| i == other)
-}
-
-fn eq_f32(value: &Value, other: f32) -> bool {
-    match value {
-        Value::Number(n) => n.as_f32().map_or(false, |i| i == other),
-        _ => false,
-    }
-}
-
-fn eq_f64(value: &Value, other: f64) -> bool {
-    value.as_f64().map_or(false, |i| i == other)
-}
-
-fn eq_bool(value: &Value, other: bool) -> bool {
-    value.as_bool().map_or(false, |i| i == other)
-}
-
-fn eq_str(value: &Value, other: &str) -> bool {
-    value.as_str().map_or(false, |i| i == other)
-}
-
-impl PartialEq<str> for Value {
-    fn eq(&self, other: &str) -> bool {
-        eq_str(self, other)
-    }
-}
-
-impl PartialEq<&str> for Value {
-    fn eq(&self, other: &&str) -> bool {
-        eq_str(self, *other)
-    }
-}
-
-impl PartialEq<Value> for str {
-    fn eq(&self, other: &Value) -> bool {
-        eq_str(other, self)
-    }
-}
-
-impl PartialEq<Value> for &str {
-    fn eq(&self, other: &Value) -> bool {
-        eq_str(other, *self)
-    }
-}
-
-impl PartialEq<String> for Value {
-    fn eq(&self, other: &String) -> bool {
-        eq_str(self, other.as_str())
-    }
-}
-
-impl PartialEq<Value> for String {
-    fn eq(&self, other: &Value) -> bool {
-        eq_str(other, self.as_str())
-    }
-}
-
-macro_rules! partialeq_numeric {
-    ($($eq:ident [$($ty:ty)*])*) => {
-        $($(
-            impl PartialEq<$ty> for Value {
-                fn eq(&self, other: &$ty) -> bool {
-                    $eq(self, *other as _)
-                }
-            }
-
-            impl PartialEq<Value> for $ty {
-                fn eq(&self, other: &Value) -> bool {
-                    $eq(other, *self as _)
-                }
-            }
-
-            impl<'a> PartialEq<$ty> for &'a Value {
-                fn eq(&self, other: &$ty) -> bool {
-                    $eq(*self, *other as _)
-                }
-            }
-
-            impl<'a> PartialEq<$ty> for &'a mut Value {
-                fn eq(&self, other: &$ty) -> bool {
-                    $eq(*self, *other as _)
-                }
-            }
-        )*)*
-    }
-}
-
-partialeq_numeric! {
-    eq_i64[i8 i16 i32 i64 isize]
-    eq_u64[u8 u16 u32 u64 usize]
-    eq_f32[f32]
-    eq_f64[f64]
-    eq_bool[bool]
-}
diff --git a/vendor/serde_json/src/value/ser.rs b/vendor/serde_json/src/value/ser.rs
deleted file mode 100644
index 835fa90..0000000
--- a/vendor/serde_json/src/value/ser.rs
+++ /dev/null
@@ -1,1053 +0,0 @@
-use crate::error::{Error, ErrorCode, Result};
-use crate::map::Map;
-use crate::value::{to_value, Value};
-use alloc::borrow::ToOwned;
-use alloc::string::{String, ToString};
-use alloc::vec::Vec;
-use core::fmt::Display;
-use core::result;
-use serde::ser::{Impossible, Serialize};
-
-impl Serialize for Value {
-    #[inline]
-    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
-    where
-        S: ::serde::Serializer,
-    {
-        match self {
-            Value::Null => serializer.serialize_unit(),
-            Value::Bool(b) => serializer.serialize_bool(*b),
-            Value::Number(n) => n.serialize(serializer),
-            Value::String(s) => serializer.serialize_str(s),
-            Value::Array(v) => v.serialize(serializer),
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            Value::Object(m) => {
-                use serde::ser::SerializeMap;
-                let mut map = tri!(serializer.serialize_map(Some(m.len())));
-                for (k, v) in m {
-                    tri!(map.serialize_entry(k, v));
-                }
-                map.end()
-            }
-        }
-    }
-}
-
-/// Serializer whose output is a `Value`.
-///
-/// This is the serializer that backs [`serde_json::to_value`][crate::to_value].
-/// Unlike the main serde_json serializer which goes from some serializable
-/// value of type `T` to JSON text, this one goes from `T` to
-/// `serde_json::Value`.
-///
-/// The `to_value` function is implementable as:
-///
-/// ```
-/// use serde::Serialize;
-/// use serde_json::{Error, Value};
-///
-/// pub fn to_value<T>(input: T) -> Result<Value, Error>
-/// where
-///     T: Serialize,
-/// {
-///     input.serialize(serde_json::value::Serializer)
-/// }
-/// ```
-pub struct Serializer;
-
-impl serde::Serializer for Serializer {
-    type Ok = Value;
-    type Error = Error;
-
-    type SerializeSeq = SerializeVec;
-    type SerializeTuple = SerializeVec;
-    type SerializeTupleStruct = SerializeVec;
-    type SerializeTupleVariant = SerializeTupleVariant;
-    type SerializeMap = SerializeMap;
-    type SerializeStruct = SerializeMap;
-    type SerializeStructVariant = SerializeStructVariant;
-
-    #[inline]
-    fn serialize_bool(self, value: bool) -> Result<Value> {
-        Ok(Value::Bool(value))
-    }
-
-    #[inline]
-    fn serialize_i8(self, value: i8) -> Result<Value> {
-        self.serialize_i64(value as i64)
-    }
-
-    #[inline]
-    fn serialize_i16(self, value: i16) -> Result<Value> {
-        self.serialize_i64(value as i64)
-    }
-
-    #[inline]
-    fn serialize_i32(self, value: i32) -> Result<Value> {
-        self.serialize_i64(value as i64)
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<Value> {
-        Ok(Value::Number(value.into()))
-    }
-
-    fn serialize_i128(self, value: i128) -> Result<Value> {
-        #[cfg(feature = "arbitrary_precision")]
-        {
-            Ok(Value::Number(value.into()))
-        }
-
-        #[cfg(not(feature = "arbitrary_precision"))]
-        {
-            if let Ok(value) = u64::try_from(value) {
-                Ok(Value::Number(value.into()))
-            } else if let Ok(value) = i64::try_from(value) {
-                Ok(Value::Number(value.into()))
-            } else {
-                Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0))
-            }
-        }
-    }
-
-    #[inline]
-    fn serialize_u8(self, value: u8) -> Result<Value> {
-        self.serialize_u64(value as u64)
-    }
-
-    #[inline]
-    fn serialize_u16(self, value: u16) -> Result<Value> {
-        self.serialize_u64(value as u64)
-    }
-
-    #[inline]
-    fn serialize_u32(self, value: u32) -> Result<Value> {
-        self.serialize_u64(value as u64)
-    }
-
-    #[inline]
-    fn serialize_u64(self, value: u64) -> Result<Value> {
-        Ok(Value::Number(value.into()))
-    }
-
-    fn serialize_u128(self, value: u128) -> Result<Value> {
-        #[cfg(feature = "arbitrary_precision")]
-        {
-            Ok(Value::Number(value.into()))
-        }
-
-        #[cfg(not(feature = "arbitrary_precision"))]
-        {
-            if let Ok(value) = u64::try_from(value) {
-                Ok(Value::Number(value.into()))
-            } else {
-                Err(Error::syntax(ErrorCode::NumberOutOfRange, 0, 0))
-            }
-        }
-    }
-
-    #[inline]
-    fn serialize_f32(self, float: f32) -> Result<Value> {
-        Ok(Value::from(float))
-    }
-
-    #[inline]
-    fn serialize_f64(self, float: f64) -> Result<Value> {
-        Ok(Value::from(float))
-    }
-
-    #[inline]
-    fn serialize_char(self, value: char) -> Result<Value> {
-        let mut s = String::new();
-        s.push(value);
-        Ok(Value::String(s))
-    }
-
-    #[inline]
-    fn serialize_str(self, value: &str) -> Result<Value> {
-        Ok(Value::String(value.to_owned()))
-    }
-
-    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
-        let vec = value.iter().map(|&b| Value::Number(b.into())).collect();
-        Ok(Value::Array(vec))
-    }
-
-    #[inline]
-    fn serialize_unit(self) -> Result<Value> {
-        Ok(Value::Null)
-    }
-
-    #[inline]
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
-        self.serialize_unit()
-    }
-
-    #[inline]
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<Value> {
-        self.serialize_str(variant)
-    }
-
-    #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        value: &T,
-    ) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        let mut values = Map::new();
-        values.insert(String::from(variant), tri!(to_value(value)));
-        Ok(Value::Object(values))
-    }
-
-    #[inline]
-    fn serialize_none(self) -> Result<Value> {
-        self.serialize_unit()
-    }
-
-    #[inline]
-    fn serialize_some<T>(self, value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Ok(SerializeVec {
-            vec: Vec::with_capacity(len.unwrap_or(0)),
-        })
-    }
-
-    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        self.serialize_seq(Some(len))
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Ok(SerializeTupleVariant {
-            name: String::from(variant),
-            vec: Vec::with_capacity(len),
-        })
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Ok(SerializeMap::Map {
-            map: Map::new(),
-            next_key: None,
-        })
-    }
-
-    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
-        match name {
-            #[cfg(feature = "arbitrary_precision")]
-            crate::number::TOKEN => Ok(SerializeMap::Number { out_value: None }),
-            #[cfg(feature = "raw_value")]
-            crate::raw::TOKEN => Ok(SerializeMap::RawValue { out_value: None }),
-            _ => self.serialize_map(Some(len)),
-        }
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Ok(SerializeStructVariant {
-            name: String::from(variant),
-            map: Map::new(),
-        })
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<Value>
-    where
-        T: ?Sized + Display,
-    {
-        Ok(Value::String(value.to_string()))
-    }
-}
-
-pub struct SerializeVec {
-    vec: Vec<Value>,
-}
-
-pub struct SerializeTupleVariant {
-    name: String,
-    vec: Vec<Value>,
-}
-
-pub enum SerializeMap {
-    Map {
-        map: Map<String, Value>,
-        next_key: Option<String>,
-    },
-    #[cfg(feature = "arbitrary_precision")]
-    Number { out_value: Option<Value> },
-    #[cfg(feature = "raw_value")]
-    RawValue { out_value: Option<Value> },
-}
-
-pub struct SerializeStructVariant {
-    name: String,
-    map: Map<String, Value>,
-}
-
-impl serde::ser::SerializeSeq for SerializeVec {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        self.vec.push(tri!(to_value(value)));
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value> {
-        Ok(Value::Array(self.vec))
-    }
-}
-
-impl serde::ser::SerializeTuple for SerializeVec {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        serde::ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<Value> {
-        serde::ser::SerializeSeq::end(self)
-    }
-}
-
-impl serde::ser::SerializeTupleStruct for SerializeVec {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        serde::ser::SerializeSeq::serialize_element(self, value)
-    }
-
-    fn end(self) -> Result<Value> {
-        serde::ser::SerializeSeq::end(self)
-    }
-}
-
-impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        self.vec.push(tri!(to_value(value)));
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value> {
-        let mut object = Map::new();
-
-        object.insert(self.name, Value::Array(self.vec));
-
-        Ok(Value::Object(object))
-    }
-}
-
-impl serde::ser::SerializeMap for SerializeMap {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            SerializeMap::Map { next_key, .. } => {
-                *next_key = Some(tri!(key.serialize(MapKeySerializer)));
-                Ok(())
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            SerializeMap::Map { map, next_key } => {
-                let key = next_key.take();
-                // Panic because this indicates a bug in the program rather than an
-                // expected failure.
-                let key = key.expect("serialize_value called before serialize_key");
-                map.insert(key, tri!(to_value(value)));
-                Ok(())
-            }
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { .. } => unreachable!(),
-        }
-    }
-
-    fn end(self) -> Result<Value> {
-        match self {
-            SerializeMap::Map { map, .. } => Ok(Value::Object(map)),
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { .. } => unreachable!(),
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { .. } => unreachable!(),
-        }
-    }
-}
-
-struct MapKeySerializer;
-
-fn key_must_be_a_string() -> Error {
-    Error::syntax(ErrorCode::KeyMustBeAString, 0, 0)
-}
-
-fn float_key_must_be_finite() -> Error {
-    Error::syntax(ErrorCode::FloatKeyMustBeFinite, 0, 0)
-}
-
-impl serde::Serializer for MapKeySerializer {
-    type Ok = String;
-    type Error = Error;
-
-    type SerializeSeq = Impossible<String, Error>;
-    type SerializeTuple = Impossible<String, Error>;
-    type SerializeTupleStruct = Impossible<String, Error>;
-    type SerializeTupleVariant = Impossible<String, Error>;
-    type SerializeMap = Impossible<String, Error>;
-    type SerializeStruct = Impossible<String, Error>;
-    type SerializeStructVariant = Impossible<String, Error>;
-
-    #[inline]
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        variant: &'static str,
-    ) -> Result<String> {
-        Ok(variant.to_owned())
-    }
-
-    #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<String>
-    where
-        T: ?Sized + Serialize,
-    {
-        value.serialize(self)
-    }
-
-    fn serialize_bool(self, value: bool) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i8(self, value: i8) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i16(self, value: i16) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i32(self, value: i32) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_i64(self, value: i64) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u8(self, value: u8) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u16(self, value: u16) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u32(self, value: u32) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_u64(self, value: u64) -> Result<String> {
-        Ok(value.to_string())
-    }
-
-    fn serialize_f32(self, value: f32) -> Result<String> {
-        if value.is_finite() {
-            Ok(ryu::Buffer::new().format_finite(value).to_owned())
-        } else {
-            Err(float_key_must_be_finite())
-        }
-    }
-
-    fn serialize_f64(self, value: f64) -> Result<String> {
-        if value.is_finite() {
-            Ok(ryu::Buffer::new().format_finite(value).to_owned())
-        } else {
-            Err(float_key_must_be_finite())
-        }
-    }
-
-    #[inline]
-    fn serialize_char(self, value: char) -> Result<String> {
-        Ok({
-            let mut s = String::new();
-            s.push(value);
-            s
-        })
-    }
-
-    #[inline]
-    fn serialize_str(self, value: &str) -> Result<String> {
-        Ok(value.to_owned())
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_unit(self) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<String>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_none(self) -> Result<String> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<String>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(key_must_be_a_string())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(key_must_be_a_string())
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<String>
-    where
-        T: ?Sized + Display,
-    {
-        Ok(value.to_string())
-    }
-}
-
-impl serde::ser::SerializeStruct for SerializeMap {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        match self {
-            SerializeMap::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value),
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { out_value } => {
-                if key == crate::number::TOKEN {
-                    *out_value = Some(tri!(value.serialize(NumberValueEmitter)));
-                    Ok(())
-                } else {
-                    Err(invalid_number())
-                }
-            }
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { out_value } => {
-                if key == crate::raw::TOKEN {
-                    *out_value = Some(tri!(value.serialize(RawValueEmitter)));
-                    Ok(())
-                } else {
-                    Err(invalid_raw_value())
-                }
-            }
-        }
-    }
-
-    fn end(self) -> Result<Value> {
-        match self {
-            SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
-            #[cfg(feature = "arbitrary_precision")]
-            SerializeMap::Number { out_value, .. } => {
-                Ok(out_value.expect("number value was not emitted"))
-            }
-            #[cfg(feature = "raw_value")]
-            SerializeMap::RawValue { out_value, .. } => {
-                Ok(out_value.expect("raw value was not emitted"))
-            }
-        }
-    }
-}
-
-impl serde::ser::SerializeStructVariant for SerializeStructVariant {
-    type Ok = Value;
-    type Error = Error;
-
-    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
-    where
-        T: ?Sized + Serialize,
-    {
-        self.map.insert(String::from(key), tri!(to_value(value)));
-        Ok(())
-    }
-
-    fn end(self) -> Result<Value> {
-        let mut object = Map::new();
-
-        object.insert(self.name, Value::Object(self.map));
-
-        Ok(Value::Object(object))
-    }
-}
-
-#[cfg(feature = "arbitrary_precision")]
-struct NumberValueEmitter;
-
-#[cfg(feature = "arbitrary_precision")]
-fn invalid_number() -> Error {
-    Error::syntax(ErrorCode::InvalidNumber, 0, 0)
-}
-
-#[cfg(feature = "arbitrary_precision")]
-impl serde::ser::Serializer for NumberValueEmitter {
-    type Ok = Value;
-    type Error = Error;
-
-    type SerializeSeq = Impossible<Value, Error>;
-    type SerializeTuple = Impossible<Value, Error>;
-    type SerializeTupleStruct = Impossible<Value, Error>;
-    type SerializeTupleVariant = Impossible<Value, Error>;
-    type SerializeMap = Impossible<Value, Error>;
-    type SerializeStruct = Impossible<Value, Error>;
-    type SerializeStructVariant = Impossible<Value, Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_char(self, _v: char) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Value> {
-        let n = tri!(value.to_owned().parse());
-        Ok(Value::Number(n))
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_none(self) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit(self) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Value> {
-        Err(invalid_number())
-    }
-
-    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_number())
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(invalid_number())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(invalid_number())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(invalid_number())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(invalid_number())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(invalid_number())
-    }
-}
-
-#[cfg(feature = "raw_value")]
-struct RawValueEmitter;
-
-#[cfg(feature = "raw_value")]
-fn invalid_raw_value() -> Error {
-    Error::syntax(ErrorCode::ExpectedSomeValue, 0, 0)
-}
-
-#[cfg(feature = "raw_value")]
-impl serde::ser::Serializer for RawValueEmitter {
-    type Ok = Value;
-    type Error = Error;
-
-    type SerializeSeq = Impossible<Value, Error>;
-    type SerializeTuple = Impossible<Value, Error>;
-    type SerializeTupleStruct = Impossible<Value, Error>;
-    type SerializeTupleVariant = Impossible<Value, Error>;
-    type SerializeMap = Impossible<Value, Error>;
-    type SerializeStruct = Impossible<Value, Error>;
-    type SerializeStructVariant = Impossible<Value, Error>;
-
-    fn serialize_bool(self, _v: bool) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i8(self, _v: i8) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i16(self, _v: i16) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i32(self, _v: i32) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_i64(self, _v: i64) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u8(self, _v: u8) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u16(self, _v: u16) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u32(self, _v: u32) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_u64(self, _v: u64) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_f32(self, _v: f32) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_f64(self, _v: f64) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_char(self, _v: char) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_str(self, value: &str) -> Result<Value> {
-        crate::from_str(value)
-    }
-
-    fn serialize_bytes(self, _value: &[u8]) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_none(self) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_some<T>(self, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_unit(self) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_unit_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-    ) -> Result<Value> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_newtype_variant<T>(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _value: &T,
-    ) -> Result<Value>
-    where
-        T: ?Sized + Serialize,
-    {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_tuple_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeTupleVariant> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Err(invalid_raw_value())
-    }
-
-    fn serialize_struct_variant(
-        self,
-        _name: &'static str,
-        _variant_index: u32,
-        _variant: &'static str,
-        _len: usize,
-    ) -> Result<Self::SerializeStructVariant> {
-        Err(invalid_raw_value())
-    }
-
-    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
-    where
-        T: ?Sized + Display,
-    {
-        self.serialize_str(&value.to_string())
-    }
-}