Serde Wasm Bindgen

https://docs.rs/serde-wasm-bindgen/latest/
Admin
Serde Wasm Bindgen is a native integration of Serde with wasm-bindgen, enabling efficient conversion...
Tokens:32,212
Snippets:321
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Interact with Rust data in JavaScript

Source: https://docs.rs/serde-wasm-bindgen/latest/index.html

Example of importing and using the exported WebAssembly functions within a JavaScript environment.

```javascript
import { send_example_to_js, receive_example_from_js } from "example";

// Get the example object from wasm.
let example = send_example_to_js();

// Add another "Vec" element to the end of the "Vec<Vec<f32>>"
example.field2.push([5, 6]);

// Send the example object back to wasm.
receive_example_from_js(example);
```

--------------------------------

### Preserving JavaScript Objects

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/lib.rs.html?search=

Example of using the preserve module to keep JavaScript objects unchanged during serialization.

```rust
/// ```rust
/// #[derive(serde::Serialize)]
/// struct MyStruct {
///     int_field: i32,
///     #[serde(with = "serde_wasm_bindgen::preserve")]
///     js_field: js_sys::Int8Array,
/// }
///
/// let s = MyStruct {
///     int_field: 5,
///     js_field: js_sys::Int8Array::new_with_length(1000),
/// };
/// ```
```

--------------------------------

### Serializer implementation methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating and configuring a Serializer instance.

```rust
pub const fn new() -> Self
```

```rust
pub const fn json_compatible() -> Self
```

```rust
pub const fn serialize_missing_as_null(self, value: bool) -> Self
```

```rust
pub const fn serialize_maps_as_objects(self, value: bool) -> Self
```

```rust
pub const fn serialize_large_number_types_as_bigints(self, value: bool) -> Self
```

```rust
pub const fn serialize_bytes_as_arrays(self, value: bool) -> Self
```

--------------------------------

### Utility Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=u32+-%3E+bool

Utility methods for serialization configuration and string display.

```APIDOC
## fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
## fn is_human_readable(&self) -> bool

### Description
`collect_str` serializes a string produced by a `Display` implementation. `is_human_readable` checks if the serializer should produce human-readable output.
```

--------------------------------

### Core Library Implementation

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/lib.rs.html?search=

The main library file defining the Deserializer, Serializer, and conversion functions.

```rust
1#![doc = include_str!("../README.md")]
2#![warn(missing_docs)]
3#![warn(clippy::missing_const_for_fn)]
4
5use js_sys::JsString;
6use wasm_bindgen::prelude::*;
7
8mod de;
9mod error;
10mod ser;
11
12pub use de::Deserializer;
13pub use error::Error;
14pub use ser::Serializer;
15
16type Result<T> = std::result::Result<T, Error>;
17
18fn static_str_to_js(s: &'static str) -> JsString {
19    use std::cell::RefCell;
20    use std::collections::HashMap;
21
22    #[derive(Default)]
23    struct PtrHasher {
24        addr: usize,
25    }
26
27    impl std::hash::Hasher for PtrHasher {
28        fn write(&mut self, _bytes: &[u8]) {
29            unreachable!();
30        }
31
32        fn write_usize(&mut self, addr_or_len: usize) {
33            if self.addr == 0 {
34                self.addr = addr_or_len;
35            }
36        }
37
38        fn finish(&self) -> u64 {
39            self.addr as _
40        }
41    }
42
43    type PtrBuildHasher = std::hash::BuildHasherDefault<PtrHasher>;
44
45    thread_local! {
46        // Since we're mainly optimising for converting the exact same string literal over and over again,
47        // which will always have the same pointer, we can speed things up by indexing by the string's pointer
48        // instead of its value.
49        static CACHE: RefCell<HashMap<*const str, JsString, PtrBuildHasher>> = Default::default();
50    }
51    CACHE.with(|cache| {
52        cache
53            .borrow_mut()
54            .entry(s)
55            .or_insert_with(|| s.into())
56            .clone()
57    })
58}
59
60/// Custom bindings to avoid using fallible `Reflect` for plain objects.
61#[wasm_bindgen]
62extern "C" {
63    type ObjectExt;
64
65    #[wasm_bindgen(method, indexing_getter)]
66    fn get_with_ref_key(this: &ObjectExt, key: &JsString) -> JsValue;
67
68    #[wasm_bindgen(method, indexing_setter)]
69    fn set(this: &ObjectExt, key: JsString, value: JsValue);
70}
71
72/// Converts [`JsValue`] into a Rust type.
73pub fn from_value<T: serde::de::DeserializeOwned>(value: JsValue) -> Result<T> {
74    T::deserialize(Deserializer::from(value))
75}
76
77/// Converts a Rust value into a [`JsValue`].
78pub fn to_value<T: serde::ser::Serialize + ?Sized>(value: &T) -> Result<JsValue> {
79    value.serialize(&Serializer::new())
80}
```

--------------------------------

### Serializer::new

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html

Creates a new default Serializer instance.

```APIDOC
## pub const fn new() -> Self

### Description
Creates a new default `Serializer` instance for converting Rust values into `JsValue`.

### Signature
`pub const fn new() -> Self`
```

--------------------------------

### Serializer::new

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new default Serializer instance.

```APIDOC
## pub const fn new() -> Self

### Description
Creates a new default `Serializer`.
```

--------------------------------

### Serializer::new

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=

Creates a new default Serializer instance.

```APIDOC
### pub const fn new() -> Self

Creates a new default `Serializer`.
```

--------------------------------

### Configuration Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=

Utility methods for checking serialization configuration.

```APIDOC
### fn is_human_readable(&self) -> bool
Determine whether Serialize implementations should serialize in human-readable form.
```

--------------------------------

### Configure Cargo dependencies

Source: https://docs.rs/serde-wasm-bindgen/latest/index.html

Add the necessary dependencies to your Cargo.toml file to enable Serde serialization and deserialization.

```toml
[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde-wasm-bindgen = "0.4"
```

--------------------------------

### Serializer Configuration Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html

Methods to configure the serialization behavior of the Serializer instance.

```APIDOC
## Configuration Methods

### serialize_missing_as_null(self, value: bool) -> Self
Set to `true` to serialize `()`, unit structs and `Option::None` to `null` instead of `undefined`.

### serialize_maps_as_objects(self, value: bool) -> Self
Set to `true` to serialize maps into plain JavaScript objects instead of ES2015 `Map`s.

### serialize_large_number_types_as_bigints(self, value: bool) -> Self
Set to `true` to serialize 64-bit numbers to JavaScript `BigInt` instead of plain numbers.

### serialize_bytes_as_arrays(self, value: bool) -> Self
Set to `true` to serialize bytes into plain JavaScript arrays instead of ES2015 `Uint8Array`s.
```

--------------------------------

### Serializer Configuration Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to configure the serialization behavior of the Serializer.

```APIDOC
## Configuration Methods

### serialize_missing_as_null(self, value: bool) -> Self
Set to `true` to serialize `()`, unit structs and `Option::None` to `null` instead of `undefined` in JS.

### serialize_maps_as_objects(self, value: bool) -> Self
Set to `true` to serialize maps into plain JavaScript objects instead of ES2015 `Map`s.

### serialize_large_number_types_as_bigints(self, value: bool) -> Self
Set to `true` to serialize 64-bit numbers to JavaScript `BigInt` instead of plain numbers.

### serialize_bytes_as_arrays(self, value: bool) -> Self
Set to `true` to serialize bytes into plain JavaScript arrays instead of ES2015 `Uint8Array`s.
```

--------------------------------

### Serializer::json_compatible

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html

Creates a JSON compatible serializer that uses null instead of undefined and plain objects instead of ES maps.

```APIDOC
## pub const fn json_compatible() -> Self

### Description
Creates a JSON compatible serializer. This uses null instead of undefined, and uses plain objects instead of ES maps, ensuring compatibility with JSON stringification.

### Signature
`pub const fn json_compatible() -> Self`
```

--------------------------------

### Serializer::json_compatible

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a JSON compatible serializer that uses null instead of undefined and plain objects instead of ES maps.

```APIDOC
## pub const fn json_compatible() -> Self

### Description
Creates a JSON compatible serializer. This uses null instead of undefined, and uses plain objects instead of ES maps.
```

--------------------------------

### Utility Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Deserializer.html?search=u32+-%3E+bool

Methods for checking deserialization context and converting types.

```APIDOC
## fn is_human_readable(&self) -> bool
Determine whether Deserialize implementations should expect to deserialize their human-readable form.

## fn from(value: JsValue) -> Self
Converts a JsValue into a Deserializer instance.

## fn into_deserializer(self) -> Self::Deserializer
Convert this value into a deserializer.
```

--------------------------------

### Implement SeqAccess for JS Iterators

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html

Provides a SeqAccess implementation that consumes a js_sys::IntoIter to deserialize elements.

```rust
struct SeqAccess {
    iter: js_sys::IntoIter,
}

impl<'de> de::SeqAccess<'de> for SeqAccess {
    type Error = Error;

    fn next_element_seed<T: de::DeserializeSeed<'de>>(
        &mut self,
        seed: T,
    ) -> Result<Option<T::Value>> {
        Ok(match self.iter.next().transpose()? {
            Some(value) => Some(seed.deserialize(Deserializer::from(value))?),
            None => None,
        })
    }
}
```

--------------------------------

### Forwarding Macro

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A helper macro to forward primitive serialization calls directly to their Into implementation.

```rust
macro_rules! forward_to_into {
    ($($name:ident($ty:ty);)*) => {
        $(fn $name(self, v: $ty) -> Result {
            Ok(v.into())
        })*
    };
}
```

--------------------------------

### Serializer Configuration and Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html

Defines the Serializer struct and configuration methods for customizing how Rust types are mapped to JavaScript.

```rust
/// A [`serde::Serializer`] that converts supported Rust values into a [`JsValue`].
#[derive(Default)]
pub struct Serializer {
    serialize_missing_as_null: bool,
    serialize_maps_as_objects: bool,
    serialize_large_number_types_as_bigints: bool,
    serialize_bytes_as_arrays: bool,
}

impl Serializer {
    /// Creates a new default [`Serializer`].
    pub const fn new() -> Self {
        Self {
            serialize_missing_as_null: false,
            serialize_maps_as_objects: false,
            serialize_large_number_types_as_bigints: false,
            serialize_bytes_as_arrays: false,
        }
    }

    /// Creates a JSON compatible serializer. This uses null instead of undefined, and
    /// uses plain objects instead of ES maps. So you will get the same result of
    /// `JsValue::from_serde`, and you can stringify results to JSON and store
    /// it without data loss.
    pub const fn json_compatible() -> Self {
        Self {
            serialize_missing_as_null: true,
            serialize_maps_as_objects: true,
            serialize_large_number_types_as_bigints: false,
            serialize_bytes_as_arrays: true,
        }
    }

    /// Set to `true` to serialize `()`, unit structs and `Option::None` to `null`
    /// instead of `undefined` in JS. `false` by default.
    pub const fn serialize_missing_as_null(mut self, value: bool) -> Self {
        self.serialize_missing_as_null = value;
        self
    }

    /// Set to `true` to serialize maps into plain JavaScript objects instead of
    /// ES2015 `Map`s. `false` by default.
    pub const fn serialize_maps_as_objects(mut self, value: bool) -> Self {
        self.serialize_maps_as_objects = value;
        self
    }

    /// Set to `true` to serialize 64-bit numbers to JavaScript `BigInt` instead of
    /// plain numbers. `false` by default.
    pub const fn serialize_large_number_types_as_bigints(mut self, value: bool) -> Self {
        self.serialize_large_number_types_as_bigints = value;
        self
    }

    /// Set to `true` to serialize bytes into plain JavaScript arrays instead of
    /// ES2015 `Uint8Array`s. `false` by default.
    pub const fn serialize_bytes_as_arrays(mut self, value: bool) -> Self {
        self.serialize_bytes_as_arrays = value;
        self
    }
}
```

--------------------------------

### Serializer Configuration

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods to configure how Rust types are mapped to JavaScript, including JSON compatibility modes.

```rust
impl Serializer {
    /// Creates a new default [`Serializer`].
    pub const fn new() -> Self {
        Self {
            serialize_missing_as_null: false,
            serialize_maps_as_objects: false,
            serialize_large_number_types_as_bigints: false,
            serialize_bytes_as_arrays: false,
        }
    }

    /// Creates a JSON compatible serializer. This uses null instead of undefined, and
    /// uses plain objects instead of ES maps. So you will get the same result of
    /// `JsValue::from_serde`, and you can stringify results to JSON and store
    /// it without data loss.
    pub const fn json_compatible() -> Self {
        Self {
            serialize_missing_as_null: true,
            serialize_maps_as_objects: true,
            serialize_large_number_types_as_bigints: false,
            serialize_bytes_as_arrays: true,
        }
    }

    /// Set to `true` to serialize `()`, unit structs and `Option::None` to `null`
    /// instead of `undefined` in JS. `false` by default.
    pub const fn serialize_missing_as_null(mut self, value: bool) -> Self {
        self.serialize_missing_as_null = value;
        self
    }

    /// Set to `true` to serialize maps into plain JavaScript objects instead of
    /// ES2015 `Map`s. `false` by default.
    pub const fn serialize_maps_as_objects(mut self, value: bool) -> Self {
        self.serialize_maps_as_objects = value;
        self
    }

    /// Set to `true` to serialize 64-bit numbers to JavaScript `BigInt` instead of
    /// plain numbers. `false` by default.
    pub const fn serialize_large_number_types_as_bigints(mut self, value: bool) -> Self {
        self.serialize_large_number_types_as_bigints = value;
        self
    }

    /// Set to `true` to serialize bytes into plain JavaScript arrays instead of
    /// ES2015 `Uint8Array`s. `false` by default.
    pub const fn serialize_bytes_as_arrays(mut self, value: bool) -> Self {
        self.serialize_bytes_as_arrays = value;
        self
    }
}
```

--------------------------------

### Deserializer Trait Implementation

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html

Main entry point for the Serde Deserializer trait, handling various JS types.

```rust
impl<'de> de::Deserializer<'de> for Deserializer {
    type Error = Error;

    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        if self.is_nullish() {
            visitor.visit_unit()
        } else if let Some(v) = self.value.as_bool() {
            visitor.visit_bool(v)
        } else if self.value.is_bigint() {
            match i64::try_from(self.value) {
                Ok(v) => visitor.visit_i64(v),
                Err(value) => match u64::try_from(value) {
                    Ok(v) => visitor.visit_u64(v),
                    Err(_) => Err(de::Error::custom("Couldn't deserialize i64 or u64 from a BigInt outside i64::MIN..u64::MAX bounds"))
```

--------------------------------

### Implement SeqAccess for Preserved Values

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html

Handles deserialization of preserved values by injecting a magic string tag.

```rust
enum PreservedValueAccess {
    OnMagic(JsValue),
    OnValue(JsValue),
    Done,
}

impl<'de> de::SeqAccess<'de> for PreservedValueAccess {
    type Error = Error;

    fn next_element_seed<T: de::DeserializeSeed<'de>>(
        &mut self,
        seed: T,
    ) -> Result<Option<T::Value>> {
        // Temporary replacement to avoid borrow checker issues when moving out `JsValue`.
        let this = std::mem::replace(self, Self::Done);
        match this {
            Self::OnMagic(value) => {
                *self = Self::OnValue(value);
                seed.deserialize(str_deserializer(PRESERVED_VALUE_MAGIC))
                    .map(Some)
            }
            Self::OnValue(value) => seed
                .deserialize(Deserializer {
                    value: JsValue::from(value.into_abi()),
                })
                .map(Some),
            Self::Done => Ok(None),
        }
    }
}
```

--------------------------------

### Serializer Configuration

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/index.html?search=

Methods available on the Serializer instance to customize how Rust types are mapped to JavaScript values.

```APIDOC
## Serializer Configuration

### Description
Customize serialization behavior from Rust to JavaScript by configuring the `Serializer` instance.

### Methods
- `.serialize_missing_as_null(bool)`: If true, serializes `()`, unit structs, and `Option::None` to `null` instead of `undefined`.
- `.serialize_maps_as_objects(bool)`: If true, serializes maps into plain JavaScript objects instead of ES2015 Maps.
- `.serialize_large_number_types_as_bigints(bool)`: If true, serializes `u64`, `i64`, `usize`, and `isize` to `bigint`s.
- `.serialize_bytes_as_arrays(bool)`: If true, serializes bytes into plain JavaScript arrays instead of `Uint8Array`s.
- `Serializer::json_compatible()`: A preset that enables `serialize_missing_as_null`, `serialize_maps_as_objects`, and `serialize_bytes_as_arrays`.
```

--------------------------------

### Error::new

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Error.html?search=

Creates a new JavaScript Error instance with the provided message.

```APIDOC
## pub fn new<T: Display>(msg: T) -> Self

### Description
Creates a JavaScript `Error` with a given message.

### Parameters
- **msg** (T: Display) - Required - The error message to be displayed in the JavaScript exception.
```

--------------------------------

### Floating Point and String Deserialization

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for deserializing f32, f64, and string types.

```rust
361    fn deserialize_f32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
362        self.deserialize_f64(visitor) 
363    } 
364 
365    fn deserialize_f64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
366        if let Some(v) = self.value.as_f64() { 
367            visitor.visit_f64(v) 
368        } else { 
369            self.invalid_type(visitor) 
370        } 
371    } 
372 
373    fn deserialize_identifier<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
374        self.deserialize_str(visitor) 
375    } 
376 
377    fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
378        self.deserialize_string(visitor) 
379    } 
380 
381    fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
382        if let Some(v) = self.value.as_string() { 
383            visitor.visit_string(v) 
384        } else { 
385            self.invalid_type(visitor) 
386        } 
387    }
```

--------------------------------

### Serialize Unit and None Types

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=

Handles serialization of None, unit types, and unit structs, mapping them to null or undefined based on configuration.

```rust
fn serialize_none(self) -> Result {
        self.serialize_unit()
    }
```

```rust
fn serialize_unit(self) -> Result {
        Ok(if self.serialize_missing_as_null {
            JsValue::NULL
        } else {
            JsValue::UNDEFINED
        })
    }
```

```rust
fn serialize_unit_struct(self, _name: &'static str) -> Result {
        self.serialize_unit()
    }
```

--------------------------------

### Preserve Module Implementation

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/lib.rs.html?search=

Internal implementation details for the preserve module, including magic string handling.

```rust
pub mod preserve {
    use serde::{de::Error, Deserialize, Serialize};
    use wasm_bindgen::{
        convert::{FromWasmAbi, IntoWasmAbi},
        JsCast, JsValue,
    };

    // Some arbitrary string that no one will collide with unless they try.
    pub(crate) const PRESERVED_VALUE_MAGIC: &str = "1fc430ca-5b7f-4295-92de-33cf2b145d38";

    struct Magic;

    impl<'de> serde::de::Deserialize<'de> for Magic {
        fn deserialize<D: serde::de::Deserializer<'de>>(de: D) -> Result<Self, D::Error> {
            struct Visitor;

            impl<'de> serde::de::Visitor<'de> for Visitor {
                type Value = Magic;

                fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                    formatter.write_str("serde-wasm-bindgen's magic string")
                }

                fn visit_str<E: Error>(self, s: &str) -> Result<Self::Value, E> {
                    if s == PRESERVED_VALUE_MAGIC {
                        Ok(Magic)
                    } else {
                        Err(E::invalid_value(serde::de::Unexpected::Str(s), &self))
                    }
                }
            }

            de.deserialize_str(Visitor)
        }
    }

    #[derive(Serialize)]
    #[serde(rename = "1fc430ca-5b7f-4295-92de-33cf2b145d38")]
    struct PreservedValueSerWrapper(u32);

    // Intentionally asymmetrical wrapper to ensure that only serde-wasm-bindgen preserves roundtrip.
    #[derive(Deserialize)]
    #[serde(rename = "1fc430ca-5b7f-4295-92de-33cf2b145d38")]
```

--------------------------------

### Primitive Serialization Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Serializer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for serializing primitive Rust types into JavaScript values.

```APIDOC
## serialize_bool(v: bool) -> Result<JsValue, Error>
## serialize_i8(v: i8) -> Result<JsValue, Error>
## serialize_i16(v: i16) -> Result<JsValue, Error>
## serialize_i32(v: i32) -> Result<JsValue, Error>
## serialize_u8(v: u8) -> Result<JsValue, Error>
## serialize_u16(v: u16) -> Result<JsValue, Error>
## serialize_u32(v: u32) -> Result<JsValue, Error>
## serialize_f32(v: f32) -> Result<JsValue, Error>
## serialize_f64(v: f64) -> Result<JsValue, Error>
## serialize_str(v: &str) -> Result<JsValue, Error>

### Description
These methods serialize the corresponding Rust primitive type into a `JsValue`.
```

--------------------------------

### Using preserve with serde(with)

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/preserve/index.html?search=u32+-%3E+bool

Apply the preserve module to struct fields to ensure JavaScript objects are passed through without modification during serialization.

```rust
#[derive(serde::Serialize)]
struct MyStruct {
    int_field: i32,
    #[serde(with = "serde_wasm_bindgen::preserve")]
    js_field: js_sys::Int8Array,
}

let s = MyStruct {
    int_field: 5,
    js_field: js_sys::Int8Array::new_with_length(1000),
};
```

--------------------------------

### Deserializer Methods

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/struct.Deserializer.html?search=std%3A%3Avec

Methods for hinting the expected type during deserialization.

```APIDOC
## deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error>
Hint that the Deserialize type is expecting a bool value.

## deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error>
Hint that the Deserialize type is expecting a f32 value.

## deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error>
Hint that the Deserialize type is expecting a f64 value.

## deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error>
Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data.

## deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Error>
Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data.
```

--------------------------------

### MapSerializer Implementation

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Serializes Rust maps into either JavaScript Map objects or plain JavaScript objects depending on configuration.

```rust
pub enum MapResult {
    Map(Map),
    Object(Object),
}

/// Serializes Rust maps into JS `Map` or plain JS objects.
///
/// Plain JS objects are used if `serialize_maps_as_objects` is set to `true`,
/// but then only string keys are supported.
pub struct MapSerializer<'s> {
    serializer: &'s Serializer,
    target: MapResult,
    next_key: Option<JsValue>,
}

impl<'s> MapSerializer<'s> {
    pub fn new(serializer: &'s Serializer, as_object: bool) -> Self {
        Self {
            serializer,
            target: if as_object {
                MapResult::Object(Object::new())
            } else {
                MapResult::Map(Map::new())
            },
            next_key: None,
        }
    }
}
```

--------------------------------

### Integer Deserialization Forwarding

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Forwards various integer types to 64-bit methods to optimize WASM size.

```rust
392    fn deserialize_i8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
393        self.deserialize_from_js_number_signed(visitor) 
394    } 
395 
396    fn deserialize_i16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
397        self.deserialize_from_js_number_signed(visitor) 
398    } 
399 
400    fn deserialize_i32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
401        self.deserialize_from_js_number_signed(visitor) 
402    } 
403 
404    fn deserialize_u8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
405        self.deserialize_from_js_number_unsigned(visitor) 
406    } 
407 
408    fn deserialize_u16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
409        self.deserialize_from_js_number_unsigned(visitor) 
410    } 
411 
412    fn deserialize_u32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
413        self.deserialize_from_js_number_unsigned(visitor) 
414    }
```

--------------------------------

### Implement MapSerializer for Maps and Objects

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=

Serializes Rust maps into either JS Map objects or plain JS objects depending on configuration.

```rust
pub struct MapSerializer<'s> {
    serializer: &'s Serializer,
    target: MapResult,
    next_key: Option<JsValue>,
}

impl<'s> MapSerializer<'s> {
    pub fn new(serializer: &'s Serializer, as_object: bool) -> Self {
        Self {
            serializer,
            target: if as_object {
                MapResult::Object(Object::new())
            } else {
                MapResult::Map(Map::new())
            },
            next_key: None,
        }
    }
}
```

--------------------------------

### Numeric Deserialization Helpers

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html?search=std%3A%3Avec

Methods to handle safe integer conversion from JS numbers.

```rust
fn as_safe_integer(&self) -> Option<i64> {
    if Number::is_safe_integer(&self.value) {
        return Some(self.value.unchecked_into_f64() as i64);
    }
    None
}

fn deserialize_from_js_number_signed<'de, V: de::Visitor<'de>>(
    &self,
    visitor: V,
) -> Result<V::Value> {
    match self.as_safe_integer() {
        Some(v) => visitor.visit_i64(v),
        _ => self.invalid_type(visitor),
    }
}

fn deserialize_from_js_number_unsigned<'de, V: de::Visitor<'de>>(
    &self,
    visitor: V,
) -> Result<V::Value> {
    match self.as_safe_integer() {
        Some(v) if v >= 0 => visitor.visit_u64(v as _),
        _ => self.invalid_type(visitor),
    }
}
```

--------------------------------

### Floating Point Deserialization

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html?search=std%3A%3Avec

Handles f32 and f64 deserialization by forwarding to the f64 implementation.

```rust
    // Serde happily converts `f64` to `f32` (with checks), so we can forward.
    fn deserialize_f32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        self.deserialize_f64(visitor)
    }

    fn deserialize_f64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        if let Some(v) = self.value.as_f64() {
            visitor.visit_f64(v)
        } else {
            self.invalid_type(visitor)
        }
    }
```

--------------------------------

### ObjectSerializer Implementation

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Handles the serialization of Rust structs into plain JavaScript objects.

```rust
pub struct ObjectSerializer<'s> {
    serializer: &'s Serializer,
    target: ObjectExt,
}

impl<'s> ObjectSerializer<'s> {
    pub fn new(serializer: &'s Serializer) -> Self {
        Self {
            serializer,
            target: Object::new().unchecked_into::<ObjectExt>(),
        }
    }
}

impl ser::SerializeStruct for ObjectSerializer<'_> {
    type Ok = JsValue;
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<()> {
        let value = value.serialize(self.serializer)?;
        self.target.set(static_str_to_js(key), value);
        Ok(())
    }

    fn end(self) -> Result {
        Ok(self.target.into())
    }
}
```

--------------------------------

### Map and Object Serialization Logic

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html

Handles the serialization of map entries into either JS Maps or plain objects based on the target configuration.

```rust
                map.set(&key, &value_ser);
            }
            MapResult::Object(object) => {
                let key = key.dyn_into::<JsString>().map_err(|_| {
                    Error::custom("Map key is not a string and cannot be an object key")
                })?;
                object.unchecked_ref::<ObjectExt>().set(key, value_ser);
            }
        }
        Ok(())
    }

    fn end(self) -> Result {
        debug_assert!(self.next_key.is_none());
        match self.target {
            MapResult::Map(map) => Ok(map.into()),
            MapResult::Object(object) => Ok(object.into()),
        }
    }
}
```

--------------------------------

### Static String to JsString Caching

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Optimizes conversion of static string literals to JsString by caching results in a thread-local HashMap indexed by the string pointer.

```rust
fn static_str_to_js(s: &'static str) -> JsString {
    use std::cell::RefCell;
    use std::collections::HashMap;

    #[derive(Default)]
    struct PtrHasher {
        addr: usize,
    }

    impl std::hash::Hasher for PtrHasher {
        fn write(&mut self, _bytes: &[u8]) {
            unreachable!();
        }

        fn write_usize(&mut self, addr_or_len: usize) {
            if self.addr == 0 {
                self.addr = addr_or_len;
            }
        }

        fn finish(&self) -> u64 {
            self.addr as _
        }
    }

    type PtrBuildHasher = std::hash::BuildHasherDefault<PtrHasher>;

    thread_local! {
        // Since we're mainly optimising for converting the exact same string literal over and over again,
        // which will always have the same pointer, we can speed things up by indexing by the string's pointer
        // instead of its value.
        static CACHE: RefCell<HashMap<*const str, JsString, PtrBuildHasher>> = Default::default();
    }
    CACHE.with(|cache| {
        cache
            .borrow_mut()
            .entry(s)
            .or_insert_with(|| s.into())
            .clone()
    })
}
```

--------------------------------

### Numeric and Array Deserialization Helpers

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html

Methods to handle safe integers and array sequences during deserialization.

```rust
    fn as_safe_integer(&self) -> Option<i64> {
        if Number::is_safe_integer(&self.value) {
            return Some(self.value.unchecked_into_f64() as i64);
        }
        None
    }

    fn deserialize_from_js_number_signed<'de, V: de::Visitor<'de>>(
        &self,
        visitor: V,
    ) -> Result<V::Value> {
        match self.as_safe_integer() {
            Some(v) => visitor.visit_i64(v),
            _ => self.invalid_type(visitor),
        }
    }

    fn deserialize_from_js_number_unsigned<'de, V: de::Visitor<'de>>(
        &self,
        visitor: V,
    ) -> Result<V::Value> {
        match self.as_safe_integer() {
            Some(v) if v >= 0 => visitor.visit_u64(v as _),
            _ => self.invalid_type(visitor),
        }
    }

    fn deserialize_from_array<'de, V: de::Visitor<'de>>(
        &self,
        visitor: V,
        array: &Array,
    ) -> Result<V::Value> {
        visitor.visit_seq(SeqDeserializer::new(array.iter().map(Deserializer::from)))
    }
```

--------------------------------

### to_value<T: Serialize + ?Sized>(value: &T) -> Result<JsValue, Error>

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/fn.to_value.html?search=

Converts a Rust value into a JsValue.

```APIDOC
## Function: to_value

### Description
Converts a Rust value into a `JsValue`. This function is used to serialize Rust data structures into a format compatible with JavaScript environments via `wasm-bindgen`.

### Signature
`pub fn to_value<T: Serialize + ?Sized>(value: &T) -> Result<JsValue, Error>`

### Parameters
- **value** (&T) - Required - A reference to the Rust value to be serialized. The type must implement the `Serialize` trait.

### Returns
- **Result<JsValue, Error>** - Returns a `JsValue` on success, or an `Error` if serialization fails.
```

--------------------------------

### to_value<T: Serialize + ?Sized>(value: &T) -> Result<JsValue, Error>

Source: https://docs.rs/serde-wasm-bindgen/latest/serde_wasm_bindgen/fn.to_value.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Converts a Rust value into a JsValue.

```APIDOC
## Function: to_value

### Description
Converts a Rust value into a `JsValue`.

### Signature
`pub fn to_value<T: Serialize + ?Sized>(value: &T) -> Result<JsValue, Error>`

### Parameters
- **value** (&T) - The Rust value to be serialized into a `JsValue`.

### Returns
- **Result<JsValue, Error>** - Returns a `JsValue` on success, or an `Error` if serialization fails.
```

--------------------------------

### ObjectSerializer Implementation

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html

Serializes Rust structs into plain JavaScript objects using the provided Serializer context.

```rust
/// Serializes Rust structs into plain JS objects.
pub struct ObjectSerializer<'s> {
    serializer: &'s Serializer,
    target: ObjectExt,
}

impl<'s> ObjectSerializer<'s> {
    pub fn new(serializer: &'s Serializer) -> Self {
        Self {
            serializer,
            target: Object::new().unchecked_into::<ObjectExt>(),
        }
    }
}

impl ser::SerializeStruct for ObjectSerializer<'_> {
    type Ok = JsValue;
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<()> {
        let value = value.serialize(self.serializer)?;
        self.target.set(static_str_to_js(key), value);
        Ok(())
    }

    fn end(self) -> Result {
        Ok(self.target.into())
    }
}
```

--------------------------------

### Serialize Unit Structs and Variants

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=std%3A%3Avec

Serializes unit structs and variants, with variants being converted to strings for compatibility.

```rust
fn serialize_unit_struct(self, _name: &'static str) -> Result {
    self.serialize_unit()
}

fn serialize_unit_variant(
    self,
    _name: &'static str,
    _variant_index: u32,
    variant: &'static str,
) -> Result {
    Ok(static_str_to_js(variant).into())
}
```

--------------------------------

### Serialize Sequences and Tuples

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/ser.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for serializing Rust iterables, tuples, and tuple structs into JS arrays.

```rust
fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
        Ok(ArraySerializer::new(self))
    }
```

```rust
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
        self.serialize_seq(Some(len))
    }
```

```rust
fn serialize_tuple_struct(
        self,
        _name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleStruct> {
        self.serialize_tuple(len)
    }
```

--------------------------------

### Implement MapAccess for JS Objects

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html

Provides a MapAccess implementation for iterating over specific fields of a JavaScript object.

```rust
struct ObjectAccess {
    obj: ObjectExt,
    fields: std::slice::Iter<'static, &'static str>,
    next_value: Option<Deserializer>,
}

impl ObjectAccess {
    fn new(obj: ObjectExt, fields: &'static [&'static str]) -> Self {
        Self {
            obj,
            fields: fields.iter(),
            next_value: None,
        }
    }
}

fn str_deserializer(s: &str) -> de::value::StrDeserializer<Error> {
    de::IntoDeserializer::into_deserializer(s)
}

impl<'de> de::MapAccess<'de> for ObjectAccess {
    type Error = Error;

    fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
        debug_assert!(self.next_value.is_none());

        for field in &mut self.fields {
            let js_field = static_str_to_js(field);
            let next_value = self.obj.get_with_ref_key(&js_field);
            // If this value is `undefined`, it might be actually a missing field;
            // double-check with an `in` operator if so.
            let is_missing_field = next_value.is_undefined() && !js_field.js_in(&self.obj);
            if !is_missing_field {
                self.next_value = Some(Deserializer::from(next_value));
                return Ok(Some(seed.deserialize(str_deserializer(field))?));
            }
        }

        Ok(None)
    }

    fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
        seed.deserialize(self.next_value.take().unwrap_throw())
    }
}
```

--------------------------------

### String and Identifier Deserialization

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html?search=std%3A%3Avec

Methods for deserializing string-like types.

```rust
    fn deserialize_identifier<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        self.deserialize_str(visitor)
    }

    fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        self.deserialize_string(visitor)
    }

    fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        if let Some(v) = self.value.as_string() {
            visitor.visit_string(v)
        } else {
            self.invalid_type(visitor)
        }
    }
```

--------------------------------

### Unit and Boolean Deserialization

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for handling unit types and boolean values from JavaScript.

```rust
336    fn deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
337        if self.is_nullish() { 
338            visitor.visit_unit() 
339        } else { 
340            self.invalid_type(visitor) 
341        } 
342    } 
343 
344    fn deserialize_unit_struct<V: de::Visitor<'de>>( 
345        self, 
346        _name: &'static str, 
347        visitor: V, 
348    ) -> Result<V::Value> { 
349        self.deserialize_unit(visitor) 
350    } 
351 
352    fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> { 
353        if let Some(v) = self.value.as_bool() { 
354            visitor.visit_bool(v) 
355        } else { 
356            self.invalid_type(visitor) 
357        } 
358    }
```

--------------------------------

### Deserialize Option

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html

Maps nullish values to None and all other values to Some.

```rust
fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        if !self.is_nullish() {
            visitor.visit_some(self)
        } else {
            visitor.visit_none()
        }
    }
```

--------------------------------

### Deserialization Access Implementations

Source: https://docs.rs/serde-wasm-bindgen/latest/src/serde_wasm_bindgen/de.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Internal structures and trait implementations for handling sequence, map, and object deserialization from JavaScript.

```rust
use js_sys::{Array, ArrayBuffer, JsString, Map, Number, Object, Symbol, Uint8Array};
use serde::de::value::{MapDeserializer, SeqDeserializer};
use serde::de::{self, IntoDeserializer};
use std::convert::TryFrom;
use wasm_bindgen::convert::IntoWasmAbi;
use wasm_bindgen::{JsCast, JsValue, UnwrapThrowExt};

use crate::preserve::PRESERVED_VALUE_MAGIC;
use crate::{static_str_to_js, Error, ObjectExt, Result};

/// Provides [`de::SeqAccess`] from any JS iterator.
struct SeqAccess {
    iter: js_sys::IntoIter,
}

impl<'de> de::SeqAccess<'de> for SeqAccess {
    type Error = Error;

    fn next_element_seed<T: de::DeserializeSeed<'de>>(
        &mut self,
        seed: T,
    ) -> Result<Option<T::Value>> {
        Ok(match self.iter.next().transpose()? {
            Some(value) => Some(seed.deserialize(Deserializer::from(value))?),
            None => None,
        })
    }
}

/// Provides [`de::MapAccess`] from any JS iterator that returns `[key, value]` pairs.
struct MapAccess {
    iter: js_sys::IntoIter,
    next_value: Option<Deserializer>,
}

impl MapAccess {
    const fn new(iter: js_sys::IntoIter) -> Self {
        Self {
            iter,
            next_value: None,
        }
    }
}

impl<'de> de::MapAccess<'de> for MapAccess {
    type Error = Error;

    fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
        debug_assert!(self.next_value.is_none());

        Ok(match self.iter.next().transpose()? {
            Some(pair) => {
                let (key, value) = convert_pair(pair);
                self.next_value = Some(value);
                Some(seed.deserialize(key)?)
            }
            None => None,
        })
    }

    fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
        seed.deserialize(self.next_value.take().unwrap_throw())
    }
}

struct ObjectAccess {
    obj: ObjectExt,
    fields: std::slice::Iter<'static, &'static str>,
    next_value: Option<Deserializer>,
}

impl ObjectAccess {
    fn new(obj: ObjectExt, fields: &'static [&'static str]) -> Self {
        Self {
            obj,
            fields: fields.iter(),
            next_value: None,
        }
    }
}

fn str_deserializer(s: &str) -> de::value::StrDeserializer<Error> {
    de::IntoDeserializer::into_deserializer(s)
}

impl<'de> de::MapAccess<'de> for ObjectAccess {
    type Error = Error;

    fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
        debug_assert!(self.next_value.is_none());

        for field in &mut self.fields {
            let js_field = static_str_to_js(field);
            let next_value = self.obj.get_with_ref_key(&js_field);
            // If this value is `undefined`, it might be actually a missing field;
            // double-check with an `in` operator if so.
            let is_missing_field = next_value.is_undefined() && !js_field.js_in(&self.obj);
            if !is_missing_field {
                self.next_value = Some(Deserializer::from(next_value));
                return Ok(Some(seed.deserialize(str_deserializer(field))?));
            }
        }

        Ok(None)
    }

    fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
        seed.deserialize(self.next_value.take().unwrap_throw())
    }
}

enum PreservedValueAccess {
    OnMagic(JsValue),
    OnValue(JsValue),
    Done,
}

impl<'de> de::SeqAccess<'de> for PreservedValueAccess {
    type Error = Error;

    fn next_element_seed<T: de::DeserializeSeed<'de>>(
        &mut self,
        seed: T,
    ) -> Result<Option<T::Value>> {
        // Temporary replacement to avoid borrow checker issues when moving out `JsValue`.
        let this = std::mem::replace(self, Self::Done);
        match this {
            Self::OnMagic(value) => {
                *self = Self::OnValue(value);
                seed.deserialize(str_deserializer(PRESERVED_VALUE_MAGIC))
                    .map(Some)
            }
            Self::OnValue(value) => seed
                .deserialize(Deserializer {
                    value: JsValue::from(value.into_abi()),
                })
                .map(Some),
            Self::Done => Ok(None),
        }
    }
}

/// Provides [`de::EnumAccess`] from given JS values for the `tag` and the `payload`.
struct EnumAccess {
    tag: Deserializer,
    payload: Deserializer,
}

impl<'de> de::EnumAccess<'de> for EnumAccess {
    type Error = Error;
```
Tokens:
Raw