Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

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

7 files changed, 2967 insertions, 0 deletions

diff --git a/third_party/rust/sfv/src/lib.rs b/third_party/rust/sfv/src/lib.rs
new file mode 100644
index 0000000000..f7aebfcdd2
--- /dev/null
+++ b/third_party/rust/sfv/src/lib.rs
@@ -0,0 +1,440 @@
+/*!
+`sfv` crate is an implementation of *Structured Field Values for HTTP* as specified in [RFC 8941](https://httpwg.org/specs/rfc8941.html) for parsing and serializing HTTP field values.
+It also exposes a set of types that might be useful for defining new structured fields.
+
+# Data Structures
+
+There are three types of structured fields:
+
+- `Item` - can be an `Integer`, `Decimal`, `String`, `Token`, `Byte Sequence`, or `Boolean`. It can have associated `Parameters`.
+- `List` - array of zero or more members, each of which can be an `Item` or an `InnerList`, both of which can be `Parameterized`.
+- `Dictionary` - ordered map of name-value pairs, where the names are short textual strings and the values are `Items` or arrays of `Items` (represented with `InnerList`), both of which can be `Parameterized`. There can be zero or more members, and their names are unique in the scope of the `Dictionary` they occur within.
+
+There's also a few primitive types used to construct structured field values:
+- `BareItem` used as `Item`'s value or as a parameter value in `Parameters`.
+- `Parameters` are an ordered map of key-value pairs that are associated with an `Item` or `InnerList`. The keys are unique within the scope the `Parameters` they occur within, and the values are `BareItem`.
+- `InnerList` is an array of zero or more `Items`. Can have `Parameters`.
+- `ListEntry` represents either `Item` or `InnerList` as a member of `List` or as member-value in `Dictionary`.
+
+# Examples
+
+### Parsing
+
+```
+use sfv::Parser;
+
+// Parsing structured field value of Item type.
+let item_header_input = "12.445;foo=bar";
+let item = Parser::parse_item(item_header_input.as_bytes());
+assert!(item.is_ok());
+println!("{:#?}", item);
+
+// Parsing structured field value of List type.
+let list_header_input = "1;a=tok, (\"foo\" \"bar\");baz, ()";
+let list = Parser::parse_list(list_header_input.as_bytes());
+assert!(list.is_ok());
+println!("{:#?}", list);
+
+// Parsing structured field value of Dictionary type.
+let dict_header_input = "a=?0, b, c; foo=bar, rating=1.5, fruits=(apple pear)";
+let dict = Parser::parse_dictionary(dict_header_input.as_bytes());
+assert!(dict.is_ok());
+println!("{:#?}", dict);
+```
+
+### Getting Parsed Value Members
+```
+use sfv::*;
+
+let dict_header = "u=2, n=(* foo 2)";
+    let dict = Parser::parse_dictionary(dict_header.as_bytes()).unwrap();
+
+    // Case 1 - handling value if it's an Item of Integer type
+    let u_val = match dict.get("u") {
+        Some(ListEntry::Item(item)) => item.bare_item.as_int(),
+        _ => None,
+    };
+
+    if let Some(u_val) = u_val {
+        println!("{}", u_val);
+    }
+
+    // Case 2 - matching on all possible types
+    match dict.get("u") {
+        Some(ListEntry::Item(item)) => match &item.bare_item {
+            BareItem::Token(val) => {
+                // do something if it's a Token
+                println!("{}", val);
+            }
+            BareItem::Integer(val) => {
+                // do something if it's an Integer
+                println!("{}", val);
+            }
+            BareItem::Boolean(val) => {
+                // do something if it's a Boolean
+                println!("{}", val);
+            }
+            BareItem::Decimal(val) => {
+                // do something if it's a Decimal
+                println!("{}", val);
+            }
+            BareItem::String(val) => {
+                // do something if it's a String
+                println!("{}", val);
+            }
+            BareItem::ByteSeq(val) => {
+                // do something if it's a ByteSeq
+                println!("{:?}", val);
+            }
+        },
+        Some(ListEntry::InnerList(inner_list)) => {
+            // do something if it's an InnerList
+            println!("{:?}", inner_list.items);
+        }
+        None => panic!("key not found"),
+    }
+```
+
+### Structured Field Value Construction and Serialization
+Creates `Item` with empty parameters:
+```
+use sfv::{Item, BareItem, SerializeValue};
+
+let str_item = Item::new(BareItem::String(String::from("foo")));
+assert_eq!(str_item.serialize_value().unwrap(), "\"foo\"");
+```
+
+
+Creates `Item` field value with parameters:
+```
+use sfv::{Item, BareItem, SerializeValue, Parameters, Decimal, FromPrimitive};
+
+let mut params = Parameters::new();
+let decimal = Decimal::from_f64(13.45655).unwrap();
+params.insert("key".into(), BareItem::Decimal(decimal));
+let int_item = Item::with_params(BareItem::Integer(99), params);
+assert_eq!(int_item.serialize_value().unwrap(), "99;key=13.457");
+```
+
+Creates `List` field value with `Item` and parametrized `InnerList` as members:
+```
+use sfv::{Item, BareItem, InnerList, List, SerializeValue, Parameters};
+
+let tok_item = BareItem::Token("tok".into());
+
+// Creates Item.
+let str_item = Item::new(BareItem::String(String::from("foo")));
+
+// Creates InnerList members.
+let mut int_item_params = Parameters::new();
+int_item_params.insert("key".into(), BareItem::Boolean(false));
+let int_item = Item::with_params(BareItem::Integer(99), int_item_params);
+
+// Creates InnerList.
+let mut inner_list_params = Parameters::new();
+inner_list_params.insert("bar".into(), BareItem::Boolean(true));
+let inner_list = InnerList::with_params(vec![int_item, str_item], inner_list_params);
+
+
+let list: List = vec![Item::new(tok_item).into(), inner_list.into()];
+assert_eq!(
+    list.serialize_value().unwrap(),
+    "tok, (99;key=?0 \"foo\");bar"
+);
+```
+
+Creates `Dictionary` field value:
+```
+use sfv::{Parser, Item, BareItem, SerializeValue, ParseValue, Dictionary};
+
+let member_value1 = Item::new(BareItem::String(String::from("apple")));
+let member_value2 = Item::new(BareItem::Boolean(true));
+let member_value3 = Item::new(BareItem::Boolean(false));
+
+let mut dict = Dictionary::new();
+dict.insert("key1".into(), member_value1.into());
+dict.insert("key2".into(), member_value2.into());
+dict.insert("key3".into(), member_value3.into());
+
+assert_eq!(
+    dict.serialize_value().unwrap(),
+    "key1=\"apple\", key2, key3=?0"
+);
+
+```
+*/
+
+mod parser;
+mod ref_serializer;
+mod serializer;
+mod utils;
+
+#[cfg(test)]
+mod test_parser;
+#[cfg(test)]
+mod test_serializer;
+use indexmap::IndexMap;
+
+pub use rust_decimal::{
+    prelude::{FromPrimitive, FromStr},
+    Decimal,
+};
+
+pub use parser::{ParseMore, ParseValue, Parser};
+pub use ref_serializer::{RefDictSerializer, RefItemSerializer, RefListSerializer};
+pub use serializer::SerializeValue;
+
+type SFVResult<T> = std::result::Result<T, &'static str>;
+
+/// Represents `Item` type structured field value.
+/// Can be used as a member of `List` or `Dictionary`.
+// sf-item   = bare-item parameters
+// bare-item = sf-integer / sf-decimal / sf-string / sf-token
+//             / sf-binary / sf-boolean
+#[derive(Debug, PartialEq, Clone)]
+pub struct Item {
+    /// Value of `Item`.
+    pub bare_item: BareItem,
+    /// `Item`'s associated parameters. Can be empty.
+    pub params: Parameters,
+}
+
+impl Item {
+    /// Returns new `Item` with empty `Parameters`.
+    pub fn new(bare_item: BareItem) -> Item {
+        Item {
+            bare_item,
+            params: Parameters::new(),
+        }
+    }
+    /// Returns new `Item` with specified `Parameters`.
+    pub fn with_params(bare_item: BareItem, params: Parameters) -> Item {
+        Item { bare_item, params }
+    }
+}
+
+/// Represents `Dictionary` type structured field value.
+// sf-dictionary  = dict-member *( OWS "," OWS dict-member )
+// dict-member    = member-name [ "=" member-value ]
+// member-name    = key
+// member-value   = sf-item / inner-list
+pub type Dictionary = IndexMap<String, ListEntry>;
+
+/// Represents `List` type structured field value.
+// sf-list       = list-member *( OWS "," OWS list-member )
+// list-member   = sf-item / inner-list
+pub type List = Vec<ListEntry>;
+
+/// Parameters of `Item` or `InnerList`.
+// parameters    = *( ";" *SP parameter )
+// parameter     = param-name [ "=" param-value ]
+// param-name    = key
+// key           = ( lcalpha / "*" )
+//                 *( lcalpha / DIGIT / "_" / "-" / "." / "*" )
+// lcalpha       = %x61-7A ; a-z
+// param-value   = bare-item
+pub type Parameters = IndexMap<String, BareItem>;
+
+/// Represents a member of `List` or `Dictionary` structured field value.
+#[derive(Debug, PartialEq, Clone)]
+pub enum ListEntry {
+    /// Member of `Item` type.
+    Item(Item),
+    /// Member of `InnerList` (array of `Items`) type.
+    InnerList(InnerList),
+}
+
+impl From<Item> for ListEntry {
+    fn from(item: Item) -> Self {
+        ListEntry::Item(item)
+    }
+}
+
+impl From<InnerList> for ListEntry {
+    fn from(item: InnerList) -> Self {
+        ListEntry::InnerList(item)
+    }
+}
+
+/// Array of `Items` with associated `Parameters`.
+// inner-list    = "(" *SP [ sf-item *( 1*SP sf-item ) *SP ] ")"
+//                 parameters
+#[derive(Debug, PartialEq, Clone)]
+pub struct InnerList {
+    /// `Items` that `InnerList` contains. Can be empty.
+    pub items: Vec<Item>,
+    /// `InnerList`'s associated parameters. Can be empty.
+    pub params: Parameters,
+}
+
+impl InnerList {
+    /// Returns new `InnerList` with empty `Parameters`.
+    pub fn new(items: Vec<Item>) -> InnerList {
+        InnerList {
+            items,
+            params: Parameters::new(),
+        }
+    }
+
+    /// Returns new `InnerList` with specified `Parameters`.
+    pub fn with_params(items: Vec<Item>, params: Parameters) -> InnerList {
+        InnerList { items, params }
+    }
+}
+
+/// `BareItem` type is used to construct `Items` or `Parameters` values.
+#[derive(Debug, PartialEq, Clone)]
+pub enum BareItem {
+    /// Decimal number
+    // sf-decimal  = ["-"] 1*12DIGIT "." 1*3DIGIT
+    Decimal(Decimal),
+    /// Integer number
+    // sf-integer = ["-"] 1*15DIGIT
+    Integer(i64),
+    // sf-string = DQUOTE *chr DQUOTE
+    // chr       = unescaped / escaped
+    // unescaped = %x20-21 / %x23-5B / %x5D-7E
+    // escaped   = "\" ( DQUOTE / "\" )
+    String(String),
+    // ":" *(base64) ":"
+    // base64    = ALPHA / DIGIT / "+" / "/" / "="
+    ByteSeq(Vec<u8>),
+    // sf-boolean = "?" boolean
+    // boolean    = "0" / "1"
+    Boolean(bool),
+    // sf-token = ( ALPHA / "*" ) *( tchar / ":" / "/" )
+    Token(String),
+}
+
+impl BareItem {
+    /// If `BareItem` is a decimal, returns `Decimal`, otherwise returns `None`.
+    /// ```
+    /// # use sfv::{BareItem, Decimal, FromPrimitive};
+    /// let decimal_number = Decimal::from_f64(415.566).unwrap();
+    /// let bare_item: BareItem = decimal_number.into();
+    /// assert_eq!(bare_item.as_decimal().unwrap(), decimal_number);
+    /// ```
+    pub fn as_decimal(&self) -> Option<Decimal> {
+        match *self {
+            BareItem::Decimal(val) => Some(val),
+            _ => None,
+        }
+    }
+    /// If `BareItem` is an integer, returns `i64`, otherwise returns `None`.
+    /// ```
+    /// # use sfv::BareItem;
+    /// let bare_item: BareItem = 100.into();
+    /// assert_eq!(bare_item.as_int().unwrap(), 100);
+    /// ```
+    pub fn as_int(&self) -> Option<i64> {
+        match *self {
+            BareItem::Integer(val) => Some(val),
+            _ => None,
+        }
+    }
+    /// If `BareItem` is `String`, returns `&str`, otherwise returns `None`.
+    /// ```
+    /// # use sfv::BareItem;
+    /// let bare_item = BareItem::String("foo".into());
+    /// assert_eq!(bare_item.as_str().unwrap(), "foo");
+    /// ```
+    pub fn as_str(&self) -> Option<&str> {
+        match *self {
+            BareItem::String(ref val) => Some(val),
+            _ => None,
+        }
+    }
+    /// If `BareItem` is a `ByteSeq`, returns `&Vec<u8>`, otherwise returns `None`.
+    /// ```
+    /// # use sfv::BareItem;
+    /// let bare_item = BareItem::ByteSeq("foo".to_owned().into_bytes());
+    /// assert_eq!(bare_item.as_byte_seq().unwrap().as_slice(), "foo".as_bytes());
+    /// ```
+    pub fn as_byte_seq(&self) -> Option<&Vec<u8>> {
+        match *self {
+            BareItem::ByteSeq(ref val) => Some(val),
+            _ => None,
+        }
+    }
+    /// If `BareItem` is a `Boolean`, returns `bool`, otherwise returns `None`.
+    /// ```
+    /// # use sfv::{BareItem, Decimal, FromPrimitive};
+    /// let bare_item = BareItem::Boolean(true);
+    /// assert_eq!(bare_item.as_bool().unwrap(), true);
+    /// ```
+    pub fn as_bool(&self) -> Option<bool> {
+        match *self {
+            BareItem::Boolean(val) => Some(val),
+            _ => None,
+        }
+    }
+    /// If `BareItem` is a `Token`, returns `&str`, otherwise returns `None`.
+    /// ```
+    /// use sfv::BareItem;
+    ///
+    /// let bare_item = BareItem::Token("*bar".into());
+    /// assert_eq!(bare_item.as_token().unwrap(), "*bar");
+    /// ```
+    pub fn as_token(&self) -> Option<&str> {
+        match *self {
+            BareItem::Token(ref val) => Some(val),
+            _ => None,
+        }
+    }
+}
+
+impl From<i64> for BareItem {
+    /// Converts `i64` into `BareItem::Integer`.
+    /// ```
+    /// # use sfv::BareItem;
+    /// let bare_item: BareItem = 456.into();
+    /// assert_eq!(bare_item.as_int().unwrap(), 456);
+    /// ```
+    fn from(item: i64) -> Self {
+        BareItem::Integer(item)
+    }
+}
+
+impl From<Decimal> for BareItem {
+    /// Converts `Decimal` into `BareItem::Decimal`.
+    /// ```
+    /// # use sfv::{BareItem, Decimal, FromPrimitive};
+    /// let decimal_number = Decimal::from_f64(48.01).unwrap();
+    /// let bare_item: BareItem = decimal_number.into();
+    /// assert_eq!(bare_item.as_decimal().unwrap(), decimal_number);
+    /// ```
+    fn from(item: Decimal) -> Self {
+        BareItem::Decimal(item)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum Num {
+    Decimal(Decimal),
+    Integer(i64),
+}
+
+/// Similar to `BareItem`, but used to serialize values via `RefItemSerializer`, `RefListSerializer`, `RefDictSerializer`.
+#[derive(Debug, PartialEq, Clone)]
+pub enum RefBareItem<'a> {
+    Integer(i64),
+    Decimal(Decimal),
+    String(&'a str),
+    ByteSeq(&'a [u8]),
+    Boolean(bool),
+    Token(&'a str),
+}
+
+impl BareItem {
+    /// Converts `BareItem` into `RefBareItem`.
+    fn to_ref_bare_item(&self) -> RefBareItem {
+        match self {
+            BareItem::Integer(val) => RefBareItem::Integer(*val),
+            BareItem::Decimal(val) => RefBareItem::Decimal(*val),
+            BareItem::String(val) => RefBareItem::String(val),
+            BareItem::ByteSeq(val) => RefBareItem::ByteSeq(val.as_slice()),
+            BareItem::Boolean(val) => RefBareItem::Boolean(*val),
+            BareItem::Token(val) => RefBareItem::Token(val),
+        }
+    }
+}
diff --git a/third_party/rust/sfv/src/parser.rs b/third_party/rust/sfv/src/parser.rs
new file mode 100644
index 0000000000..943380f279
--- /dev/null
+++ b/third_party/rust/sfv/src/parser.rs
@@ -0,0 +1,473 @@
+use crate::utils;
+use crate::{
+    BareItem, Decimal, Dictionary, FromStr, InnerList, Item, List, ListEntry, Num, Parameters,
+    SFVResult,
+};
+use std::iter::Peekable;
+use std::str::{from_utf8, Chars};
+
+/// Implements parsing logic for each structured field value type.
+pub trait ParseValue {
+    /// This method should not be used for parsing input into structured field value.
+    /// Use `Parser::parse_item`, `Parser::parse_list` or `Parsers::parse_dictionary` for that.
+    fn parse(input_chars: &mut Peekable<Chars>) -> SFVResult<Self>
+    where
+        Self: Sized;
+}
+
+/// If structured field value of List or Dictionary type is split into multiple lines,
+/// allows to parse more lines and merge them into already existing structure field value.
+pub trait ParseMore {
+    /// If structured field value is split across lines,
+    /// parses and merges next line into a single structured field value.
+    /// # Examples
+    /// ```
+    /// # use sfv::{Parser, SerializeValue, ParseMore};
+    ///
+    /// let mut list_field = Parser::parse_list("11, (12 13)".as_bytes()).unwrap();
+    /// list_field.parse_more("\"foo\",        \"bar\"".as_bytes()).unwrap();
+    ///
+    /// assert_eq!(list_field.serialize_value().unwrap(), "11, (12 13), \"foo\", \"bar\"");
+    fn parse_more(&mut self, input_bytes: &[u8]) -> SFVResult<()>
+    where
+        Self: Sized;
+}
+
+impl ParseValue for Item {
+    fn parse(input_chars: &mut Peekable<Chars>) -> SFVResult<Item> {
+        // https://httpwg.org/specs/rfc8941.html#parse-item
+        let bare_item = Parser::parse_bare_item(input_chars)?;
+        let params = Parser::parse_parameters(input_chars)?;
+
+        Ok(Item { bare_item, params })
+    }
+}
+
+impl ParseValue for List {
+    fn parse(input_chars: &mut Peekable<Chars>) -> SFVResult<List> {
+        // https://httpwg.org/specs/rfc8941.html#parse-list
+        // List represents an array of (item_or_inner_list, parameters)
+
+        let mut members = vec![];
+
+        while input_chars.peek().is_some() {
+            members.push(Parser::parse_list_entry(input_chars)?);
+
+            utils::consume_ows_chars(input_chars);
+
+            if input_chars.peek().is_none() {
+                return Ok(members);
+            }
+
+            if let Some(c) = input_chars.next() {
+                if c != ',' {
+                    return Err("parse_list: trailing characters after list member");
+                }
+            }
+
+            utils::consume_ows_chars(input_chars);
+
+            if input_chars.peek().is_none() {
+                return Err("parse_list: trailing comma");
+            }
+        }
+
+        Ok(members)
+    }
+}
+
+impl ParseValue for Dictionary {
+    fn parse(input_chars: &mut Peekable<Chars>) -> SFVResult<Dictionary> {
+        let mut dict = Dictionary::new();
+
+        while input_chars.peek().is_some() {
+            let this_key = Parser::parse_key(input_chars)?;
+
+            if let Some('=') = input_chars.peek() {
+                input_chars.next();
+                let member = Parser::parse_list_entry(input_chars)?;
+                dict.insert(this_key, member);
+            } else {
+                let value = true;
+                let params = Parser::parse_parameters(input_chars)?;
+                let member = Item {
+                    bare_item: BareItem::Boolean(value),
+                    params,
+                };
+                dict.insert(this_key, member.into());
+            }
+
+            utils::consume_ows_chars(input_chars);
+
+            if input_chars.peek().is_none() {
+                return Ok(dict);
+            }
+
+            if let Some(c) = input_chars.next() {
+                if c != ',' {
+                    return Err("parse_dict: trailing characters after dictionary member");
+                }
+            }
+
+            utils::consume_ows_chars(input_chars);
+
+            if input_chars.peek().is_none() {
+                return Err("parse_dict: trailing comma");
+            }
+        }
+        Ok(dict)
+    }
+}
+
+impl ParseMore for List {
+    fn parse_more(&mut self, input_bytes: &[u8]) -> SFVResult<()> {
+        let parsed_list = Parser::parse_list(input_bytes)?;
+        self.extend(parsed_list);
+        Ok(())
+    }
+}
+
+impl ParseMore for Dictionary {
+    fn parse_more(&mut self, input_bytes: &[u8]) -> SFVResult<()> {
+        let parsed_dict = Parser::parse_dictionary(input_bytes)?;
+        self.extend(parsed_dict);
+        Ok(())
+    }
+}
+
+/// Exposes methods for parsing input into structured field value.
+pub struct Parser;
+
+impl Parser {
+    /// Parses input into structured field value of Dictionary type
+    pub fn parse_dictionary(input_bytes: &[u8]) -> SFVResult<Dictionary> {
+        Self::parse::<Dictionary>(input_bytes)
+    }
+
+    /// Parses input into structured field value of List type
+    pub fn parse_list(input_bytes: &[u8]) -> SFVResult<List> {
+        Self::parse::<List>(input_bytes)
+    }
+
+    /// Parses input into structured field value of Item type
+    pub fn parse_item(input_bytes: &[u8]) -> SFVResult<Item> {
+        Self::parse::<Item>(input_bytes)
+    }
+
+    // Generic parse method for checking input before parsing
+    // and handling trailing text error
+    fn parse<T: ParseValue>(input_bytes: &[u8]) -> SFVResult<T> {
+        // https://httpwg.org/specs/rfc8941.html#text-parse
+        if !input_bytes.is_ascii() {
+            return Err("parse: non-ascii characters in input");
+        }
+
+        let mut input_chars = from_utf8(input_bytes)
+            .map_err(|_| "parse: conversion from bytes to str failed")?
+            .chars()
+            .peekable();
+        utils::consume_sp_chars(&mut input_chars);
+
+        let output = T::parse(&mut input_chars)?;
+
+        utils::consume_sp_chars(&mut input_chars);
+
+        if input_chars.next().is_some() {
+            return Err("parse: trailing characters after parsed value");
+        };
+        Ok(output)
+    }
+
+    fn parse_list_entry(input_chars: &mut Peekable<Chars>) -> SFVResult<ListEntry> {
+        // https://httpwg.org/specs/rfc8941.html#parse-item-or-list
+        // ListEntry represents a tuple (item_or_inner_list, parameters)
+
+        match input_chars.peek() {
+            Some('(') => {
+                let parsed = Self::parse_inner_list(input_chars)?;
+                Ok(ListEntry::InnerList(parsed))
+            }
+            _ => {
+                let parsed = Item::parse(input_chars)?;
+                Ok(ListEntry::Item(parsed))
+            }
+        }
+    }
+
+    pub(crate) fn parse_inner_list(input_chars: &mut Peekable<Chars>) -> SFVResult<InnerList> {
+        // https://httpwg.org/specs/rfc8941.html#parse-innerlist
+
+        if Some('(') != input_chars.next() {
+            return Err("parse_inner_list: input does not start with '('");
+        }
+
+        let mut inner_list = Vec::new();
+        while input_chars.peek().is_some() {
+            utils::consume_sp_chars(input_chars);
+
+            if Some(&')') == input_chars.peek() {
+                input_chars.next();
+                let params = Self::parse_parameters(input_chars)?;
+                return Ok(InnerList {
+                    items: inner_list,
+                    params,
+                });
+            }
+
+            let parsed_item = Item::parse(input_chars)?;
+            inner_list.push(parsed_item);
+
+            if let Some(c) = input_chars.peek() {
+                if c != &' ' && c != &')' {
+                    return Err("parse_inner_list: bad delimitation");
+                }
+            }
+        }
+
+        Err("parse_inner_list: the end of the inner list was not found")
+    }
+
+    pub(crate) fn parse_bare_item(input_chars: &mut Peekable<Chars>) -> SFVResult<BareItem> {
+        // https://httpwg.org/specs/rfc8941.html#parse-bare-item
+        if input_chars.peek().is_none() {
+            return Err("parse_bare_item: empty item");
+        }
+
+        match input_chars.peek() {
+            Some(&'?') => Ok(BareItem::Boolean(Self::parse_bool(input_chars)?)),
+            Some(&'"') => Ok(BareItem::String(Self::parse_string(input_chars)?)),
+            Some(&':') => Ok(BareItem::ByteSeq(Self::parse_byte_sequence(input_chars)?)),
+            Some(&c) if c == '*' || c.is_ascii_alphabetic() => {
+                Ok(BareItem::Token(Self::parse_token(input_chars)?))
+            }
+            Some(&c) if c == '-' || c.is_ascii_digit() => match Self::parse_number(input_chars)? {
+                Num::Decimal(val) => Ok(BareItem::Decimal(val)),
+                Num::Integer(val) => Ok(BareItem::Integer(val)),
+            },
+            _ => Err("parse_bare_item: item type can't be identified"),
+        }
+    }
+
+    pub(crate) fn parse_bool(input_chars: &mut Peekable<Chars>) -> SFVResult<bool> {
+        // https://httpwg.org/specs/rfc8941.html#parse-boolean
+
+        if input_chars.next() != Some('?') {
+            return Err("parse_bool: first character is not '?'");
+        }
+
+        match input_chars.next() {
+            Some('0') => Ok(false),
+            Some('1') => Ok(true),
+            _ => Err("parse_bool: invalid variant"),
+        }
+    }
+
+    pub(crate) fn parse_string(input_chars: &mut Peekable<Chars>) -> SFVResult<String> {
+        // https://httpwg.org/specs/rfc8941.html#parse-string
+
+        if input_chars.next() != Some('\"') {
+            return Err("parse_string: first character is not '\"'");
+        }
+
+        let mut output_string = String::from("");
+        while let Some(curr_char) = input_chars.next() {
+            match curr_char {
+                '\"' => return Ok(output_string),
+                '\x7f' | '\x00'..='\x1f' => return Err("parse_string: not a visible character"),
+                '\\' => match input_chars.next() {
+                    Some(c) if c == '\\' || c == '\"' => {
+                        output_string.push(c);
+                    }
+                    None => return Err("parse_string: last input character is '\\'"),
+                    _ => return Err("parse_string: disallowed character after '\\'"),
+                },
+                _ => output_string.push(curr_char),
+            }
+        }
+        Err("parse_string: no closing '\"'")
+    }
+
+    pub(crate) fn parse_token(input_chars: &mut Peekable<Chars>) -> SFVResult<String> {
+        // https://httpwg.org/specs/rfc8941.html#parse-token
+
+        if let Some(first_char) = input_chars.peek() {
+            if !first_char.is_ascii_alphabetic() && first_char != &'*' {
+                return Err("parse_token: first character is not ALPHA or '*'");
+            }
+        } else {
+            return Err("parse_token: empty input string");
+        }
+
+        let mut output_string = String::from("");
+        while let Some(curr_char) = input_chars.peek() {
+            if !utils::is_tchar(*curr_char) && curr_char != &':' && curr_char != &'/' {
+                return Ok(output_string);
+            }
+
+            match input_chars.next() {
+                Some(c) => output_string.push(c),
+                None => return Err("parse_token: end of the string"),
+            }
+        }
+        Ok(output_string)
+    }
+
+    pub(crate) fn parse_byte_sequence(input_chars: &mut Peekable<Chars>) -> SFVResult<Vec<u8>> {
+        // https://httpwg.org/specs/rfc8941.html#parse-binary
+
+        if input_chars.next() != Some(':') {
+            return Err("parse_byte_seq: first char is not ':'");
+        }
+
+        if !input_chars.clone().any(|c| c == ':') {
+            return Err("parse_byte_seq: no closing ':'");
+        }
+
+        let b64_content = input_chars.take_while(|c| c != &':').collect::<String>();
+        if !b64_content.chars().all(utils::is_allowed_b64_content) {
+            return Err("parse_byte_seq: invalid char in byte sequence");
+        }
+        match utils::base64()?.decode(b64_content.as_bytes()) {
+            Ok(content) => Ok(content),
+            Err(_) => Err("parse_byte_seq: decoding error"),
+        }
+    }
+
+    pub(crate) fn parse_number(input_chars: &mut Peekable<Chars>) -> SFVResult<Num> {
+        // https://httpwg.org/specs/rfc8941.html#parse-number
+
+        let mut sign = 1;
+        if let Some('-') = input_chars.peek() {
+            sign = -1;
+            input_chars.next();
+        }
+
+        match input_chars.peek() {
+            Some(c) if !c.is_ascii_digit() => {
+                return Err("parse_number: input number does not start with a digit")
+            }
+            None => return Err("parse_number: input number lacks a digit"),
+            _ => (),
+        }
+
+        // Get number from input as a string and identify whether it's a decimal or integer
+        let (is_integer, input_number) = Self::extract_digits(input_chars)?;
+
+        // Parse input_number from string into integer
+        if is_integer {
+            let output_number = input_number
+                .parse::<i64>()
+                .map_err(|_err| "parse_number: parsing i64 failed")?
+                * sign;
+
+            let (min_int, max_int) = (-999_999_999_999_999_i64, 999_999_999_999_999_i64);
+            if !(min_int <= output_number && output_number <= max_int) {
+                return Err("parse_number: integer number is out of range");
+            }
+
+            return Ok(Num::Integer(output_number));
+        }
+
+        // Parse input_number from string into decimal
+        let chars_after_dot = input_number
+            .find('.')
+            .map(|dot_pos| input_number.len() - dot_pos - 1);
+
+        match chars_after_dot {
+            Some(0) => Err("parse_number: decimal ends with '.'"),
+            Some(1..=3) => {
+                let mut output_number = Decimal::from_str(&input_number)
+                    .map_err(|_err| "parse_number: parsing f64 failed")?;
+
+                if sign == -1 {
+                    output_number.set_sign_negative(true)
+                }
+
+                Ok(Num::Decimal(output_number))
+            }
+            _ => Err("parse_number: invalid decimal fraction length"),
+        }
+    }
+
+    fn extract_digits(input_chars: &mut Peekable<Chars>) -> SFVResult<(bool, String)> {
+        let mut is_integer = true;
+        let mut input_number = String::from("");
+        while let Some(curr_char) = input_chars.peek() {
+            if curr_char.is_ascii_digit() {
+                input_number.push(*curr_char);
+                input_chars.next();
+            } else if curr_char == &'.' && is_integer {
+                if input_number.len() > 12 {
+                    return Err(
+                        "parse_number: decimal too long, illegal position for decimal point",
+                    );
+                }
+                input_number.push(*curr_char);
+                is_integer = false;
+                input_chars.next();
+            } else {
+                break;
+            }
+
+            if is_integer && input_number.len() > 15 {
+                return Err("parse_number: integer too long, length > 15");
+            }
+
+            if !is_integer && input_number.len() > 16 {
+                return Err("parse_number: decimal too long, length > 16");
+            }
+        }
+        Ok((is_integer, input_number))
+    }
+
+    pub(crate) fn parse_parameters(input_chars: &mut Peekable<Chars>) -> SFVResult<Parameters> {
+        // https://httpwg.org/specs/rfc8941.html#parse-param
+
+        let mut params = Parameters::new();
+
+        while let Some(curr_char) = input_chars.peek() {
+            if curr_char == &';' {
+                input_chars.next();
+            } else {
+                break;
+            }
+
+            utils::consume_sp_chars(input_chars);
+
+            let param_name = Self::parse_key(input_chars)?;
+            let param_value = match input_chars.peek() {
+                Some('=') => {
+                    input_chars.next();
+                    Self::parse_bare_item(input_chars)?
+                }
+                _ => BareItem::Boolean(true),
+            };
+            params.insert(param_name, param_value);
+        }
+
+        // If parameters already contains a name param_name (comparing character-for-character), overwrite its value.
+        // Note that when duplicate Parameter keys are encountered, this has the effect of ignoring all but the last instance.
+        Ok(params)
+    }
+
+    pub(crate) fn parse_key(input_chars: &mut Peekable<Chars>) -> SFVResult<String> {
+        match input_chars.peek() {
+            Some(c) if c == &'*' || c.is_ascii_lowercase() => (),
+            _ => return Err("parse_key: first character is not lcalpha or '*'"),
+        }
+
+        let mut output = String::new();
+        while let Some(curr_char) = input_chars.peek() {
+            if !curr_char.is_ascii_lowercase()
+                && !curr_char.is_ascii_digit()
+                && !"_-*.".contains(*curr_char)
+            {
+                return Ok(output);
+            }
+
+            output.push(*curr_char);
+            input_chars.next();
+        }
+        Ok(output)
+    }
+}
diff --git a/third_party/rust/sfv/src/ref_serializer.rs b/third_party/rust/sfv/src/ref_serializer.rs
new file mode 100644
index 0000000000..4bcd29ff3a
--- /dev/null
+++ b/third_party/rust/sfv/src/ref_serializer.rs
@@ -0,0 +1,310 @@
+use crate::serializer::Serializer;
+use crate::{RefBareItem, SFVResult};
+use std::marker::PhantomData;
+
+/// Serializes `Item` field value components incrementally.
+/// ```
+/// use sfv::{RefBareItem, RefItemSerializer};
+///
+/// let mut serialized_item = String::new();
+/// let serializer = RefItemSerializer::new(&mut serialized_item);
+/// serializer
+/// .bare_item(&RefBareItem::Integer(11))
+/// .unwrap()
+/// .parameter("foo", &RefBareItem::Boolean(true))
+/// .unwrap();
+/// assert_eq!(serialized_item, "11;foo");
+/// ```
+#[derive(Debug)]
+pub struct RefItemSerializer<'a> {
+    pub buffer: &'a mut String,
+}
+
+impl<'a> RefItemSerializer<'a> {
+    pub fn new(buffer: &'a mut String) -> Self {
+        RefItemSerializer { buffer }
+    }
+
+    pub fn bare_item(self, bare_item: &RefBareItem) -> SFVResult<RefParameterSerializer<'a>> {
+        Serializer::serialize_ref_bare_item(bare_item, self.buffer)?;
+        Ok(RefParameterSerializer {
+            buffer: self.buffer,
+        })
+    }
+}
+
+/// Used by `RefItemSerializer`, `RefListSerializer`, `RefDictSerializer` to serialize a single `Parameter`.
+#[derive(Debug)]
+pub struct RefParameterSerializer<'a> {
+    buffer: &'a mut String,
+}
+
+impl<'a> RefParameterSerializer<'a> {
+    pub fn parameter(self, name: &str, value: &RefBareItem) -> SFVResult<Self> {
+        Serializer::serialize_ref_parameter(name, value, self.buffer)?;
+        Ok(self)
+    }
+}
+
+/// Serializes `List` field value components incrementally.
+/// ```
+/// use sfv::{RefBareItem, RefListSerializer};
+///
+/// let mut serialized_item = String::new();
+/// let serializer = RefListSerializer::new(&mut serialized_item);
+/// serializer
+///     .bare_item(&RefBareItem::Integer(11))
+///     .unwrap()
+///     .parameter("foo", &RefBareItem::Boolean(true))
+///     .unwrap()
+///     .open_inner_list()
+///     .inner_list_bare_item(&RefBareItem::Token("abc"))
+///     .unwrap()
+///     .inner_list_parameter("abc_param", &RefBareItem::Boolean(false))
+///     .unwrap()
+///     .inner_list_bare_item(&RefBareItem::Token("def"))
+///     .unwrap()
+///     .close_inner_list()
+///     .parameter("bar", &RefBareItem::String("val"))
+///     .unwrap();
+/// assert_eq!(
+///     serialized_item,
+///     "11;foo, (abc;abc_param=?0 def);bar=\"val\""
+/// );
+/// ```
+#[derive(Debug)]
+pub struct RefListSerializer<'a> {
+    buffer: &'a mut String,
+}
+
+impl<'a> RefListSerializer<'a> {
+    pub fn new(buffer: &'a mut String) -> Self {
+        RefListSerializer { buffer }
+    }
+
+    pub fn bare_item(self, bare_item: &RefBareItem) -> SFVResult<Self> {
+        if !self.buffer.is_empty() {
+            self.buffer.push_str(", ");
+        }
+        Serializer::serialize_ref_bare_item(bare_item, self.buffer)?;
+        Ok(RefListSerializer {
+            buffer: self.buffer,
+        })
+    }
+
+    pub fn parameter(self, name: &str, value: &RefBareItem) -> SFVResult<Self> {
+        if self.buffer.is_empty() {
+            return Err("parameters must be serialized after bare item or inner list");
+        }
+        Serializer::serialize_ref_parameter(name, value, self.buffer)?;
+        Ok(RefListSerializer {
+            buffer: self.buffer,
+        })
+    }
+    pub fn open_inner_list(self) -> RefInnerListSerializer<'a, Self> {
+        if !self.buffer.is_empty() {
+            self.buffer.push_str(", ");
+        }
+        self.buffer.push('(');
+        RefInnerListSerializer::<RefListSerializer> {
+            buffer: self.buffer,
+            caller_type: PhantomData,
+        }
+    }
+}
+
+/// Serializes `Dictionary` field value components incrementally.
+/// ```
+/// use sfv::{RefBareItem, RefDictSerializer, Decimal, FromPrimitive};
+///
+/// let mut serialized_item = String::new();
+/// let serializer = RefDictSerializer::new(&mut serialized_item);
+/// serializer
+///    .bare_item_member("member1", &RefBareItem::Integer(11))
+///    .unwrap()
+///    .parameter("foo", &RefBareItem::Boolean(true))
+///    .unwrap()
+///    .open_inner_list("member2")
+///    .unwrap()
+///    .inner_list_bare_item(&RefBareItem::Token("abc"))
+///    .unwrap()
+///    .inner_list_parameter("abc_param", &RefBareItem::Boolean(false))
+///    .unwrap()
+///    .inner_list_bare_item(&RefBareItem::Token("def"))
+///    .unwrap()
+///    .close_inner_list()
+///    .parameter("bar", &RefBareItem::String("val"))
+///    .unwrap()
+///    .bare_item_member(
+///         "member3",
+///         &RefBareItem::Decimal(Decimal::from_f64(12.34566).unwrap()),
+///    )
+///    .unwrap();
+/// assert_eq!(
+///    serialized_item,
+///    "member1=11;foo, member2=(abc;abc_param=?0 def);bar=\"val\", member3=12.346"
+/// );
+/// ```
+#[derive(Debug)]
+pub struct RefDictSerializer<'a> {
+    buffer: &'a mut String,
+}
+
+impl<'a> RefDictSerializer<'a> {
+    pub fn new(buffer: &'a mut String) -> Self {
+        RefDictSerializer { buffer }
+    }
+
+    pub fn bare_item_member(self, name: &str, value: &RefBareItem) -> SFVResult<Self> {
+        if !self.buffer.is_empty() {
+            self.buffer.push_str(", ");
+        }
+        Serializer::serialize_key(name, self.buffer)?;
+        if value != &RefBareItem::Boolean(true) {
+            self.buffer.push('=');
+            Serializer::serialize_ref_bare_item(value, self.buffer)?;
+        }
+        Ok(self)
+    }
+
+    pub fn parameter(self, name: &str, value: &RefBareItem) -> SFVResult<Self> {
+        if self.buffer.is_empty() {
+            return Err("parameters must be serialized after bare item or inner list");
+        }
+        Serializer::serialize_ref_parameter(name, value, self.buffer)?;
+        Ok(RefDictSerializer {
+            buffer: self.buffer,
+        })
+    }
+
+    pub fn open_inner_list(self, name: &str) -> SFVResult<RefInnerListSerializer<'a, Self>> {
+        if !self.buffer.is_empty() {
+            self.buffer.push_str(", ");
+        }
+        Serializer::serialize_key(name, self.buffer)?;
+        self.buffer.push_str("=(");
+        Ok(RefInnerListSerializer::<RefDictSerializer> {
+            buffer: self.buffer,
+            caller_type: PhantomData,
+        })
+    }
+}
+
+/// Used by `RefItemSerializer`, `RefListSerializer`, `RefDictSerializer` to serialize `InnerList`.
+#[derive(Debug)]
+pub struct RefInnerListSerializer<'a, T> {
+    buffer: &'a mut String,
+    caller_type: PhantomData<T>,
+}
+
+impl<'a, T: Container<'a>> RefInnerListSerializer<'a, T> {
+    pub fn inner_list_bare_item(self, bare_item: &RefBareItem) -> SFVResult<Self> {
+        if !self.buffer.is_empty() & !self.buffer.ends_with('(') {
+            self.buffer.push(' ');
+        }
+        Serializer::serialize_ref_bare_item(bare_item, self.buffer)?;
+        Ok(RefInnerListSerializer {
+            buffer: self.buffer,
+            caller_type: PhantomData,
+        })
+    }
+
+    pub fn inner_list_parameter(self, name: &str, value: &RefBareItem) -> SFVResult<Self> {
+        if self.buffer.is_empty() {
+            return Err("parameters must be serialized after bare item or inner list");
+        }
+        Serializer::serialize_ref_parameter(name, value, self.buffer)?;
+        Ok(RefInnerListSerializer {
+            buffer: self.buffer,
+            caller_type: PhantomData,
+        })
+    }
+
+    pub fn close_inner_list(self) -> T {
+        self.buffer.push(')');
+        T::new(self.buffer)
+    }
+}
+
+pub trait Container<'a> {
+    fn new(buffer: &'a mut String) -> Self;
+}
+
+impl<'a> Container<'a> for RefListSerializer<'a> {
+    fn new(buffer: &mut String) -> RefListSerializer {
+        RefListSerializer { buffer }
+    }
+}
+
+impl<'a> Container<'a> for RefDictSerializer<'a> {
+    fn new(buffer: &mut String) -> RefDictSerializer {
+        RefDictSerializer { buffer }
+    }
+}
+
+#[cfg(test)]
+mod alternative_serializer_tests {
+    use super::*;
+    use crate::{Decimal, FromPrimitive};
+
+    #[test]
+    fn test_fast_serialize_item() -> SFVResult<()> {
+        let mut output = String::new();
+        let ser = RefItemSerializer::new(&mut output);
+        ser.bare_item(&RefBareItem::Token("hello"))?
+            .parameter("abc", &RefBareItem::Boolean(true))?;
+        assert_eq!("hello;abc", output);
+        Ok(())
+    }
+
+    #[test]
+    fn test_fast_serialize_list() -> SFVResult<()> {
+        let mut output = String::new();
+        let ser = RefListSerializer::new(&mut output);
+        ser.bare_item(&RefBareItem::Token("hello"))?
+            .parameter("key1", &RefBareItem::Boolean(true))?
+            .parameter("key2", &RefBareItem::Boolean(false))?
+            .open_inner_list()
+            .inner_list_bare_item(&RefBareItem::String("some_string"))?
+            .inner_list_bare_item(&RefBareItem::Integer(12))?
+            .inner_list_parameter("inner-member-key", &RefBareItem::Boolean(true))?
+            .close_inner_list()
+            .parameter("inner-list-param", &RefBareItem::Token("*"))?;
+        assert_eq!(
+            "hello;key1;key2=?0, (\"some_string\" 12;inner-member-key);inner-list-param=*",
+            output
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn test_fast_serialize_dict() -> SFVResult<()> {
+        let mut output = String::new();
+        let ser = RefDictSerializer::new(&mut output);
+        ser.bare_item_member("member1", &RefBareItem::Token("hello"))?
+            .parameter("key1", &RefBareItem::Boolean(true))?
+            .parameter("key2", &RefBareItem::Boolean(false))?
+            .bare_item_member("member2", &RefBareItem::Boolean(true))?
+            .parameter(
+                "key3",
+                &RefBareItem::Decimal(Decimal::from_f64(45.4586).unwrap()),
+            )?
+            .parameter("key4", &RefBareItem::String("str"))?
+            .open_inner_list("key5")?
+            .inner_list_bare_item(&RefBareItem::Integer(45))?
+            .inner_list_bare_item(&RefBareItem::Integer(0))?
+            .close_inner_list()
+            .bare_item_member("key6", &RefBareItem::String("foo"))?
+            .open_inner_list("key7")?
+            .inner_list_bare_item(&RefBareItem::ByteSeq("some_string".as_bytes()))?
+            .inner_list_bare_item(&RefBareItem::ByteSeq("other_string".as_bytes()))?
+            .close_inner_list()
+            .parameter("lparam", &RefBareItem::Integer(10))?
+            .bare_item_member("key8", &RefBareItem::Boolean(true))?;
+        assert_eq!(
+            "member1=hello;key1;key2=?0, member2;key3=45.459;key4=\"str\", key5=(45 0), key6=\"foo\", key7=(:c29tZV9zdHJpbmc=: :b3RoZXJfc3RyaW5n:);lparam=10, key8",
+            output
+        );
+        Ok(())
+    }
+}
diff --git a/third_party/rust/sfv/src/serializer.rs b/third_party/rust/sfv/src/serializer.rs
new file mode 100644
index 0000000000..b0ed021766
--- /dev/null
+++ b/third_party/rust/sfv/src/serializer.rs
@@ -0,0 +1,319 @@
+use crate::utils;
+use crate::{
+    BareItem, Decimal, Dictionary, InnerList, Item, List, ListEntry, Parameters, RefBareItem,
+    SFVResult,
+};
+use data_encoding::BASE64;
+
+/// Serializes structured field value into String.
+pub trait SerializeValue {
+    /// Serializes structured field value into String.
+    /// # Examples
+    /// ```
+    /// # use sfv::{Parser, SerializeValue, ParseValue};
+    ///
+    /// let parsed_list_field = Parser::parse_list("\"london\", \t\t\"berlin\"".as_bytes());
+    /// assert!(parsed_list_field.is_ok());
+    ///
+    /// assert_eq!(
+    ///     parsed_list_field.unwrap().serialize_value().unwrap(),
+    ///     "\"london\", \"berlin\""
+    /// );
+    /// ```
+    fn serialize_value(&self) -> SFVResult<String>;
+}
+
+impl SerializeValue for Dictionary {
+    fn serialize_value(&self) -> SFVResult<String> {
+        let mut output = String::new();
+        Serializer::serialize_dict(self, &mut output)?;
+        Ok(output)
+    }
+}
+
+impl SerializeValue for List {
+    fn serialize_value(&self) -> SFVResult<String> {
+        let mut output = String::new();
+        Serializer::serialize_list(self, &mut output)?;
+        Ok(output)
+    }
+}
+
+impl SerializeValue for Item {
+    fn serialize_value(&self) -> SFVResult<String> {
+        let mut output = String::new();
+        Serializer::serialize_item(self, &mut output)?;
+        Ok(output)
+    }
+}
+
+/// Container serialization functions
+pub(crate) struct Serializer;
+
+impl Serializer {
+    pub(crate) fn serialize_item(input_item: &Item, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-item
+
+        Self::serialize_bare_item(&input_item.bare_item, output)?;
+        Self::serialize_parameters(&input_item.params, output)?;
+        Ok(())
+    }
+
+    #[allow(clippy::ptr_arg)]
+    pub(crate) fn serialize_list(input_list: &List, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-list
+        if input_list.is_empty() {
+            return Err("serialize_list: serializing empty field is not allowed");
+        }
+
+        for (idx, member) in input_list.iter().enumerate() {
+            match member {
+                ListEntry::Item(item) => {
+                    Self::serialize_item(item, output)?;
+                }
+                ListEntry::InnerList(inner_list) => {
+                    Self::serialize_inner_list(inner_list, output)?;
+                }
+            };
+
+            // If more items remain in input_list:
+            //      Append “,” to output.
+            //      Append a single SP to output.
+            if idx < input_list.len() - 1 {
+                output.push_str(", ");
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn serialize_dict(input_dict: &Dictionary, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-dictionary
+        if input_dict.is_empty() {
+            return Err("serialize_dictionary: serializing empty field is not allowed");
+        }
+
+        for (idx, (member_name, member_value)) in input_dict.iter().enumerate() {
+            Serializer::serialize_key(member_name, output)?;
+
+            match member_value {
+                ListEntry::Item(ref item) => {
+                    // If dict member is boolean true, no need to serialize it: only its params must be serialized
+                    // Otherwise serialize entire item with its params
+                    if item.bare_item == BareItem::Boolean(true) {
+                        Self::serialize_parameters(&item.params, output)?;
+                    } else {
+                        output.push('=');
+                        Self::serialize_item(item, output)?;
+                    }
+                }
+                ListEntry::InnerList(inner_list) => {
+                    output.push('=');
+                    Self::serialize_inner_list(inner_list, output)?;
+                }
+            }
+
+            // If more items remain in input_dictionary:
+            //      Append “,” to output.
+            //      Append a single SP to output.
+            if idx < input_dict.len() - 1 {
+                output.push_str(", ");
+            }
+        }
+        Ok(())
+    }
+
+    fn serialize_inner_list(input_inner_list: &InnerList, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-innerlist
+
+        let items = &input_inner_list.items;
+        let inner_list_parameters = &input_inner_list.params;
+
+        output.push('(');
+        for (idx, item) in items.iter().enumerate() {
+            Self::serialize_item(item, output)?;
+
+            // If more values remain in inner_list, append a single SP to output
+            if idx < items.len() - 1 {
+                output.push(' ');
+            }
+        }
+        output.push(')');
+        Self::serialize_parameters(inner_list_parameters, output)?;
+        Ok(())
+    }
+
+    pub(crate) fn serialize_bare_item(
+        input_bare_item: &BareItem,
+        output: &mut String,
+    ) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-bare-item
+
+        let ref_bare_item = input_bare_item.to_ref_bare_item();
+        Self::serialize_ref_bare_item(&ref_bare_item, output)
+    }
+
+    pub(crate) fn serialize_ref_bare_item(
+        value: &RefBareItem,
+        output: &mut String,
+    ) -> SFVResult<()> {
+        match value {
+            RefBareItem::Boolean(value) => Self::serialize_bool(*value, output)?,
+            RefBareItem::String(value) => Self::serialize_string(value, output)?,
+            RefBareItem::ByteSeq(value) => Self::serialize_byte_sequence(value, output)?,
+            RefBareItem::Token(value) => Self::serialize_token(value, output)?,
+            RefBareItem::Integer(value) => Self::serialize_integer(*value, output)?,
+            RefBareItem::Decimal(value) => Self::serialize_decimal(*value, output)?,
+        };
+        Ok(())
+    }
+
+    pub(crate) fn serialize_parameters(
+        input_params: &Parameters,
+        output: &mut String,
+    ) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-params
+
+        for (param_name, param_value) in input_params.iter() {
+            Self::serialize_ref_parameter(param_name, &param_value.to_ref_bare_item(), output)?;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn serialize_ref_parameter(
+        name: &str,
+        value: &RefBareItem,
+        output: &mut String,
+    ) -> SFVResult<()> {
+        output.push(';');
+        Self::serialize_key(name, output)?;
+
+        if value != &RefBareItem::Boolean(true) {
+            output.push('=');
+            Self::serialize_ref_bare_item(value, output)?;
+        }
+        Ok(())
+    }
+
+    pub(crate) fn serialize_key(input_key: &str, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-key
+
+        let disallowed_chars =
+            |c: char| !(c.is_ascii_lowercase() || c.is_ascii_digit() || "_-*.".contains(c));
+
+        if input_key.chars().any(disallowed_chars) {
+            return Err("serialize_key: disallowed character in input");
+        }
+
+        if let Some(char) = input_key.chars().next() {
+            if !(char.is_ascii_lowercase() || char == '*') {
+                return Err("serialize_key: first character is not lcalpha or '*'");
+            }
+        }
+        output.push_str(input_key);
+        Ok(())
+    }
+
+    pub(crate) fn serialize_integer(value: i64, output: &mut String) -> SFVResult<()> {
+        //https://httpwg.org/specs/rfc8941.html#ser-integer
+
+        let (min_int, max_int) = (-999_999_999_999_999_i64, 999_999_999_999_999_i64);
+        if !(min_int <= value && value <= max_int) {
+            return Err("serialize_integer: integer is out of range");
+        }
+        output.push_str(&value.to_string());
+        Ok(())
+    }
+
+    pub(crate) fn serialize_decimal(value: Decimal, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-decimal
+
+        let integer_comp_length = 12;
+        let fraction_length = 3;
+
+        let decimal = value.round_dp(fraction_length);
+        let int_comp = decimal.trunc();
+        let fract_comp = decimal.fract();
+
+        // TODO: Replace with > 999_999_999_999_u64
+        if int_comp.abs().to_string().len() > integer_comp_length {
+            return Err("serialize_decimal: integer component > 12 digits");
+        }
+
+        if fract_comp.is_zero() {
+            output.push_str(&int_comp.to_string());
+            output.push('.');
+            output.push('0');
+        } else {
+            output.push_str(&decimal.to_string());
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn serialize_string(value: &str, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-integer
+
+        if !value.is_ascii() {
+            return Err("serialize_string: non-ascii character");
+        }
+
+        let vchar_or_sp = |char| char == '\x7f' || ('\x00'..='\x1f').contains(&char);
+        if value.chars().any(vchar_or_sp) {
+            return Err("serialize_string: not a visible character");
+        }
+
+        output.push('\"');
+        for char in value.chars() {
+            if char == '\\' || char == '\"' {
+                output.push('\\');
+            }
+            output.push(char);
+        }
+        output.push('\"');
+
+        Ok(())
+    }
+
+    pub(crate) fn serialize_token(value: &str, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-token
+
+        if !value.is_ascii() {
+            return Err("serialize_string: non-ascii character");
+        }
+
+        let mut chars = value.chars();
+        if let Some(char) = chars.next() {
+            if !(char.is_ascii_alphabetic() || char == '*') {
+                return Err("serialise_token: first character is not ALPHA or '*'");
+            }
+        }
+
+        if chars
+            .clone()
+            .any(|c| !(utils::is_tchar(c) || c == ':' || c == '/'))
+        {
+            return Err("serialise_token: disallowed character");
+        }
+
+        output.push_str(value);
+        Ok(())
+    }
+
+    pub(crate) fn serialize_byte_sequence(value: &[u8], output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-binary
+
+        output.push(':');
+        let encoded = BASE64.encode(value.as_ref());
+        output.push_str(&encoded);
+        output.push(':');
+        Ok(())
+    }
+
+    pub(crate) fn serialize_bool(value: bool, output: &mut String) -> SFVResult<()> {
+        // https://httpwg.org/specs/rfc8941.html#ser-boolean
+
+        let val = if value { "?1" } else { "?0" };
+        output.push_str(val);
+        Ok(())
+    }
+}
diff --git a/third_party/rust/sfv/src/test_parser.rs b/third_party/rust/sfv/src/test_parser.rs
new file mode 100644
index 0000000000..97404eb951
--- /dev/null
+++ b/third_party/rust/sfv/src/test_parser.rs
@@ -0,0 +1,850 @@
+use crate::FromStr;
+use crate::{BareItem, Decimal, Dictionary, InnerList, Item, List, Num, Parameters};
+use crate::{ParseMore, ParseValue, Parser};
+use std::error::Error;
+use std::iter::FromIterator;
+
+#[test]
+fn parse() -> Result<(), Box<dyn Error>> {
+    let input = "\"some_value\"".as_bytes();
+    let parsed_item = Item::new(BareItem::String("some_value".to_owned()));
+    let expected = parsed_item;
+    assert_eq!(expected, Parser::parse_item(input)?);
+
+    let input = "12.35;a ".as_bytes();
+    let params = Parameters::from_iter(vec![("a".to_owned(), BareItem::Boolean(true))]);
+    let expected = Item::with_params(Decimal::from_str("12.35")?.into(), params);
+
+    assert_eq!(expected, Parser::parse_item(input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_errors() -> Result<(), Box<dyn Error>> {
+    let input = "\"some_value¢\"".as_bytes();
+    assert_eq!(
+        Err("parse: non-ascii characters in input"),
+        Parser::parse_item(input)
+    );
+    let input = "\"some_value\" trailing_text".as_bytes();
+    assert_eq!(
+        Err("parse: trailing characters after parsed value"),
+        Parser::parse_item(input)
+    );
+    assert_eq!(
+        Err("parse_bare_item: empty item"),
+        Parser::parse_item("".as_bytes())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_list_of_numbers() -> Result<(), Box<dyn Error>> {
+    let mut input = "1,42".chars().peekable();
+    let item1 = Item::new(1.into());
+    let item2 = Item::new(42.into());
+    let expected_list: List = vec![item1.into(), item2.into()];
+    assert_eq!(expected_list, List::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_list_with_multiple_spaces() -> Result<(), Box<dyn Error>> {
+    let mut input = "1  ,  42".chars().peekable();
+    let item1 = Item::new(1.into());
+    let item2 = Item::new(42.into());
+    let expected_list: List = vec![item1.into(), item2.into()];
+    assert_eq!(expected_list, List::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_list_of_lists() -> Result<(), Box<dyn Error>> {
+    let mut input = "(1 2), (42 43)".chars().peekable();
+    let item1 = Item::new(1.into());
+    let item2 = Item::new(2.into());
+    let item3 = Item::new(42.into());
+    let item4 = Item::new(43.into());
+    let inner_list_1 = InnerList::new(vec![item1, item2]);
+    let inner_list_2 = InnerList::new(vec![item3, item4]);
+    let expected_list: List = vec![inner_list_1.into(), inner_list_2.into()];
+    assert_eq!(expected_list, List::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_list_empty_inner_list() -> Result<(), Box<dyn Error>> {
+    let mut input = "()".chars().peekable();
+    let inner_list = InnerList::new(vec![]);
+    let expected_list: List = vec![inner_list.into()];
+    assert_eq!(expected_list, List::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_list_empty() -> Result<(), Box<dyn Error>> {
+    let mut input = "".chars().peekable();
+    let expected_list: List = vec![];
+    assert_eq!(expected_list, List::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_list_of_lists_with_param_and_spaces() -> Result<(), Box<dyn Error>> {
+    let mut input = "(  1  42  ); k=*".chars().peekable();
+    let item1 = Item::new(1.into());
+    let item2 = Item::new(42.into());
+    let inner_list_param =
+        Parameters::from_iter(vec![("k".to_owned(), BareItem::Token("*".to_owned()))]);
+    let inner_list = InnerList::with_params(vec![item1, item2], inner_list_param);
+    let expected_list: List = vec![inner_list.into()];
+    assert_eq!(expected_list, List::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_list_of_items_and_lists_with_param() -> Result<(), Box<dyn Error>> {
+    let mut input = "12, 14, (a  b); param=\"param_value_1\", ()"
+        .chars()
+        .peekable();
+    let item1 = Item::new(12.into());
+    let item2 = Item::new(14.into());
+    let item3 = Item::new(BareItem::Token("a".to_owned()));
+    let item4 = Item::new(BareItem::Token("b".to_owned()));
+    let inner_list_param = Parameters::from_iter(vec![(
+        "param".to_owned(),
+        BareItem::String("param_value_1".to_owned()),
+    )]);
+    let inner_list = InnerList::with_params(vec![item3, item4], inner_list_param);
+    let empty_inner_list = InnerList::new(vec![]);
+    let expected_list: List = vec![
+        item1.into(),
+        item2.into(),
+        inner_list.into(),
+        empty_inner_list.into(),
+    ];
+    assert_eq!(expected_list, List::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_list_errors() -> Result<(), Box<dyn Error>> {
+    let mut input = ",".chars().peekable();
+    assert_eq!(
+        Err("parse_bare_item: item type can't be identified"),
+        List::parse(&mut input)
+    );
+
+    let mut input = "a, b c".chars().peekable();
+    assert_eq!(
+        Err("parse_list: trailing characters after list member"),
+        List::parse(&mut input)
+    );
+
+    let mut input = "a,".chars().peekable();
+    assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
+
+    let mut input = "a     ,    ".chars().peekable();
+    assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
+
+    let mut input = "a\t \t ,\t ".chars().peekable();
+    assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
+
+    let mut input = "a\t\t,\t\t\t".chars().peekable();
+    assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
+
+    let mut input = "(a b),".chars().peekable();
+    assert_eq!(Err("parse_list: trailing comma"), List::parse(&mut input));
+
+    let mut input = "(1, 2, (a b)".chars().peekable();
+    assert_eq!(
+        Err("parse_inner_list: bad delimitation"),
+        List::parse(&mut input)
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_inner_list_errors() -> Result<(), Box<dyn Error>> {
+    let mut input = "c b); a=1".chars().peekable();
+    assert_eq!(
+        Err("parse_inner_list: input does not start with '('"),
+        Parser::parse_inner_list(&mut input)
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_inner_list_with_param_and_spaces() -> Result<(), Box<dyn Error>> {
+    let mut input = "(c b); a=1".chars().peekable();
+    let inner_list_param = Parameters::from_iter(vec![("a".to_owned(), 1.into())]);
+
+    let item1 = Item::new(BareItem::Token("c".to_owned()));
+    let item2 = Item::new(BareItem::Token("b".to_owned()));
+    let expected = InnerList::with_params(vec![item1, item2], inner_list_param);
+    assert_eq!(expected, Parser::parse_inner_list(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_item_int_with_space() -> Result<(), Box<dyn Error>> {
+    let mut input = "12 ".chars().peekable();
+    assert_eq!(Item::new(12.into()), Item::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_item_decimal_with_bool_param_and_space() -> Result<(), Box<dyn Error>> {
+    let mut input = "12.35;a ".chars().peekable();
+    let param = Parameters::from_iter(vec![("a".to_owned(), BareItem::Boolean(true))]);
+    assert_eq!(
+        Item::with_params(Decimal::from_str("12.35")?.into(), param),
+        Item::parse(&mut input)?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_item_number_with_param() -> Result<(), Box<dyn Error>> {
+    let param = Parameters::from_iter(vec![("a1".to_owned(), BareItem::Token("*".to_owned()))]);
+    assert_eq!(
+        Item::with_params(BareItem::String("12.35".to_owned()), param),
+        Item::parse(&mut "\"12.35\";a1=*".chars().peekable())?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_item_errors() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Err("parse_bare_item: empty item"),
+        Item::parse(&mut "".chars().peekable())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_dict_empty() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Dictionary::new(),
+        Dictionary::parse(&mut "".chars().peekable())?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_dict_errors() -> Result<(), Box<dyn Error>> {
+    let mut input = "abc=123;a=1;b=2 def".chars().peekable();
+    assert_eq!(
+        Err("parse_dict: trailing characters after dictionary member"),
+        Dictionary::parse(&mut input)
+    );
+    let mut input = "abc=123;a=1,".chars().peekable();
+    assert_eq!(
+        Err("parse_dict: trailing comma"),
+        Dictionary::parse(&mut input)
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_dict_with_spaces_and_params() -> Result<(), Box<dyn Error>> {
+    let mut input = "abc=123;a=1;b=2, def=456, ghi=789;q=9;r=\"+w\""
+        .chars()
+        .peekable();
+    let item1_params =
+        Parameters::from_iter(vec![("a".to_owned(), 1.into()), ("b".to_owned(), 2.into())]);
+    let item3_params = Parameters::from_iter(vec![
+        ("q".to_owned(), 9.into()),
+        ("r".to_owned(), BareItem::String("+w".to_owned())),
+    ]);
+
+    let item1 = Item::with_params(123.into(), item1_params);
+    let item2 = Item::new(456.into());
+    let item3 = Item::with_params(789.into(), item3_params);
+
+    let expected_dict = Dictionary::from_iter(vec![
+        ("abc".to_owned(), item1.into()),
+        ("def".to_owned(), item2.into()),
+        ("ghi".to_owned(), item3.into()),
+    ]);
+    assert_eq!(expected_dict, Dictionary::parse(&mut input)?);
+
+    Ok(())
+}
+
+#[test]
+fn parse_dict_empty_value() -> Result<(), Box<dyn Error>> {
+    let mut input = "a=()".chars().peekable();
+    let inner_list = InnerList::new(vec![]);
+    let expected_dict = Dictionary::from_iter(vec![("a".to_owned(), inner_list.into())]);
+    assert_eq!(expected_dict, Dictionary::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_dict_with_token_param() -> Result<(), Box<dyn Error>> {
+    let mut input = "a=1, b;foo=*, c=3".chars().peekable();
+    let item2_params =
+        Parameters::from_iter(vec![("foo".to_owned(), BareItem::Token("*".to_owned()))]);
+    let item1 = Item::new(1.into());
+    let item2 = Item::with_params(BareItem::Boolean(true), item2_params);
+    let item3 = Item::new(3.into());
+    let expected_dict = Dictionary::from_iter(vec![
+        ("a".to_owned(), item1.into()),
+        ("b".to_owned(), item2.into()),
+        ("c".to_owned(), item3.into()),
+    ]);
+    assert_eq!(expected_dict, Dictionary::parse(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_dict_multiple_spaces() -> Result<(), Box<dyn Error>> {
+    // input1, input2, input3 must be parsed into the same structure
+    let item1 = Item::new(1.into());
+    let item2 = Item::new(2.into());
+    let expected_dict = Dictionary::from_iter(vec![
+        ("a".to_owned(), item1.into()),
+        ("b".to_owned(), item2.into()),
+    ]);
+
+    let mut input1 = "a=1 ,  b=2".chars().peekable();
+    let mut input2 = "a=1\t,\tb=2".chars().peekable();
+    let mut input3 = "a=1, b=2".chars().peekable();
+    assert_eq!(expected_dict, Dictionary::parse(&mut input1)?);
+    assert_eq!(expected_dict, Dictionary::parse(&mut input2)?);
+    assert_eq!(expected_dict, Dictionary::parse(&mut input3)?);
+
+    Ok(())
+}
+
+#[test]
+fn parse_bare_item() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        BareItem::Boolean(false),
+        Parser::parse_bare_item(&mut "?0".chars().peekable())?
+    );
+    assert_eq!(
+        BareItem::String("test string".to_owned()),
+        Parser::parse_bare_item(&mut "\"test string\"".chars().peekable())?
+    );
+    assert_eq!(
+        BareItem::Token("*token".to_owned()),
+        Parser::parse_bare_item(&mut "*token".chars().peekable())?
+    );
+    assert_eq!(
+        BareItem::ByteSeq("base_64 encoding test".to_owned().into_bytes()),
+        Parser::parse_bare_item(&mut ":YmFzZV82NCBlbmNvZGluZyB0ZXN0:".chars().peekable())?
+    );
+    assert_eq!(
+        BareItem::Decimal(Decimal::from_str("-3.55")?),
+        Parser::parse_bare_item(&mut "-3.55".chars().peekable())?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_bare_item_errors() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Err("parse_bare_item: item type can't be identified"),
+        Parser::parse_bare_item(&mut "!?0".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_bare_item: item type can't be identified"),
+        Parser::parse_bare_item(&mut "_11abc".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_bare_item: item type can't be identified"),
+        Parser::parse_bare_item(&mut "   ".chars().peekable())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_bool() -> Result<(), Box<dyn Error>> {
+    let mut input = "?0gk".chars().peekable();
+    assert_eq!(false, Parser::parse_bool(&mut input)?);
+    assert_eq!(input.collect::<String>(), "gk");
+
+    assert_eq!(false, Parser::parse_bool(&mut "?0".chars().peekable())?);
+    assert_eq!(true, Parser::parse_bool(&mut "?1".chars().peekable())?);
+    Ok(())
+}
+
+#[test]
+fn parse_bool_errors() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Err("parse_bool: first character is not '?'"),
+        Parser::parse_bool(&mut "".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_bool: invalid variant"),
+        Parser::parse_bool(&mut "?".chars().peekable())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_string() -> Result<(), Box<dyn Error>> {
+    let mut input = "\"some string\" ;not string".chars().peekable();
+    assert_eq!("some string".to_owned(), Parser::parse_string(&mut input)?);
+    assert_eq!(input.collect::<String>(), " ;not string");
+
+    assert_eq!(
+        "test".to_owned(),
+        Parser::parse_string(&mut "\"test\"".chars().peekable())?
+    );
+    assert_eq!(
+        r#"te\st"#.to_owned(),
+        Parser::parse_string(&mut "\"te\\\\st\"".chars().peekable())?
+    );
+    assert_eq!(
+        "".to_owned(),
+        Parser::parse_string(&mut "\"\"".chars().peekable())?
+    );
+    assert_eq!(
+        "some string".to_owned(),
+        Parser::parse_string(&mut "\"some string\"".chars().peekable())?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_string_errors() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Err("parse_string: first character is not '\"'"),
+        Parser::parse_string(&mut "test".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_string: last input character is '\\'"),
+        Parser::parse_string(&mut "\"\\".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_string: disallowed character after '\\'"),
+        Parser::parse_string(&mut "\"\\l\"".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_string: not a visible character"),
+        Parser::parse_string(&mut "\"\u{1f}\"".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_string: no closing '\"'"),
+        Parser::parse_string(&mut "\"smth".chars().peekable())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_token() -> Result<(), Box<dyn Error>> {
+    let mut input = "*some:token}not token".chars().peekable();
+    assert_eq!("*some:token".to_owned(), Parser::parse_token(&mut input)?);
+    assert_eq!(input.collect::<String>(), "}not token");
+
+    assert_eq!(
+        "token".to_owned(),
+        Parser::parse_token(&mut "token".chars().peekable())?
+    );
+    assert_eq!(
+        "a_b-c.d3:f%00/*".to_owned(),
+        Parser::parse_token(&mut "a_b-c.d3:f%00/*".chars().peekable())?
+    );
+    assert_eq!(
+        "TestToken".to_owned(),
+        Parser::parse_token(&mut "TestToken".chars().peekable())?
+    );
+    assert_eq!(
+        "some".to_owned(),
+        Parser::parse_token(&mut "some@token".chars().peekable())?
+    );
+    assert_eq!(
+        "*TestToken*".to_owned(),
+        Parser::parse_token(&mut "*TestToken*".chars().peekable())?
+    );
+    assert_eq!(
+        "*".to_owned(),
+        Parser::parse_token(&mut "*[@:token".chars().peekable())?
+    );
+    assert_eq!(
+        "test".to_owned(),
+        Parser::parse_token(&mut "test token".chars().peekable())?
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_token_errors() -> Result<(), Box<dyn Error>> {
+    let mut input = "765token".chars().peekable();
+    assert_eq!(
+        Err("parse_token: first character is not ALPHA or '*'"),
+        Parser::parse_token(&mut input)
+    );
+    assert_eq!(input.collect::<String>(), "765token");
+
+    assert_eq!(
+        Err("parse_token: first character is not ALPHA or '*'"),
+        Parser::parse_token(&mut "7token".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_token: empty input string"),
+        Parser::parse_token(&mut "".chars().peekable())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_byte_sequence() -> Result<(), Box<dyn Error>> {
+    let mut input = ":aGVsbG8:rest_of_str".chars().peekable();
+    assert_eq!(
+        "hello".to_owned().into_bytes(),
+        Parser::parse_byte_sequence(&mut input)?
+    );
+    assert_eq!("rest_of_str", input.collect::<String>());
+
+    assert_eq!(
+        "hello".to_owned().into_bytes(),
+        Parser::parse_byte_sequence(&mut ":aGVsbG8:".chars().peekable())?
+    );
+    assert_eq!(
+        "test_encode".to_owned().into_bytes(),
+        Parser::parse_byte_sequence(&mut ":dGVzdF9lbmNvZGU:".chars().peekable())?
+    );
+    assert_eq!(
+        "new:year tree".to_owned().into_bytes(),
+        Parser::parse_byte_sequence(&mut ":bmV3OnllYXIgdHJlZQ==:".chars().peekable())?
+    );
+    assert_eq!(
+        "".to_owned().into_bytes(),
+        Parser::parse_byte_sequence(&mut "::".chars().peekable())?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_byte_sequence_errors() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Err("parse_byte_seq: first char is not ':'"),
+        Parser::parse_byte_sequence(&mut "aGVsbG8".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_byte_seq: invalid char in byte sequence"),
+        Parser::parse_byte_sequence(&mut ":aGVsb G8=:".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_byte_seq: no closing ':'"),
+        Parser::parse_byte_sequence(&mut ":aGVsbG8=".chars().peekable())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_number_int() -> Result<(), Box<dyn Error>> {
+    let mut input = "-733333333332d.14".chars().peekable();
+    assert_eq!(
+        Num::Integer(-733333333332),
+        Parser::parse_number(&mut input)?
+    );
+    assert_eq!("d.14", input.collect::<String>());
+
+    assert_eq!(
+        Num::Integer(42),
+        Parser::parse_number(&mut "42".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(-42),
+        Parser::parse_number(&mut "-42".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(-42),
+        Parser::parse_number(&mut "-042".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(0),
+        Parser::parse_number(&mut "0".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(0),
+        Parser::parse_number(&mut "00".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(123456789012345),
+        Parser::parse_number(&mut "123456789012345".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(-123456789012345),
+        Parser::parse_number(&mut "-123456789012345".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(2),
+        Parser::parse_number(&mut "2,3".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(4),
+        Parser::parse_number(&mut "4-2".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(-999999999999999),
+        Parser::parse_number(&mut "-999999999999999".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Integer(999999999999999),
+        Parser::parse_number(&mut "999999999999999".chars().peekable())?
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_number_decimal() -> Result<(), Box<dyn Error>> {
+    let mut input = "00.42 test string".chars().peekable();
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("0.42")?),
+        Parser::parse_number(&mut input)?
+    );
+    assert_eq!(" test string", input.collect::<String>());
+
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("1.5")?),
+        Parser::parse_number(&mut "1.5.4.".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("1.8")?),
+        Parser::parse_number(&mut "1.8.".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("1.7")?),
+        Parser::parse_number(&mut "1.7.0".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("3.14")?),
+        Parser::parse_number(&mut "3.14".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("-3.14")?),
+        Parser::parse_number(&mut "-3.14".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("123456789012.1")?),
+        Parser::parse_number(&mut "123456789012.1".chars().peekable())?
+    );
+    assert_eq!(
+        Num::Decimal(Decimal::from_str("1234567890.112")?),
+        Parser::parse_number(&mut "1234567890.112".chars().peekable())?
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_number_errors() -> Result<(), Box<dyn Error>> {
+    let mut input = ":aGVsbG8:rest".chars().peekable();
+    assert_eq!(
+        Err("parse_number: input number does not start with a digit"),
+        Parser::parse_number(&mut input)
+    );
+    assert_eq!(":aGVsbG8:rest", input.collect::<String>());
+
+    let mut input = "-11.5555 test string".chars().peekable();
+    assert_eq!(
+        Err("parse_number: invalid decimal fraction length"),
+        Parser::parse_number(&mut input)
+    );
+    assert_eq!(" test string", input.collect::<String>());
+
+    assert_eq!(
+        Err("parse_number: input number does not start with a digit"),
+        Parser::parse_number(&mut "--0".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: decimal too long, illegal position for decimal point"),
+        Parser::parse_number(&mut "1999999999999.1".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: decimal ends with '.'"),
+        Parser::parse_number(&mut "19888899999.".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: integer too long, length > 15"),
+        Parser::parse_number(&mut "1999999999999999".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: decimal too long, length > 16"),
+        Parser::parse_number(&mut "19999999999.99991".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: input number does not start with a digit"),
+        Parser::parse_number(&mut "- 42".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: input number does not start with a digit"),
+        Parser::parse_number(&mut "- 42".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: decimal ends with '.'"),
+        Parser::parse_number(&mut "1..4".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: input number lacks a digit"),
+        Parser::parse_number(&mut "-".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: decimal ends with '.'"),
+        Parser::parse_number(&mut "-5. 14".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: decimal ends with '.'"),
+        Parser::parse_number(&mut "7. 1".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: invalid decimal fraction length"),
+        Parser::parse_number(&mut "-7.3333333333".chars().peekable())
+    );
+    assert_eq!(
+        Err("parse_number: decimal too long, illegal position for decimal point"),
+        Parser::parse_number(&mut "-7333333333323.12".chars().peekable())
+    );
+
+    Ok(())
+}
+
+#[test]
+fn parse_params_string() -> Result<(), Box<dyn Error>> {
+    let mut input = ";b=\"param_val\"".chars().peekable();
+    let expected = Parameters::from_iter(vec![(
+        "b".to_owned(),
+        BareItem::String("param_val".to_owned()),
+    )]);
+    assert_eq!(expected, Parser::parse_parameters(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_params_bool() -> Result<(), Box<dyn Error>> {
+    let mut input = ";b;a".chars().peekable();
+    let expected = Parameters::from_iter(vec![
+        ("b".to_owned(), BareItem::Boolean(true)),
+        ("a".to_owned(), BareItem::Boolean(true)),
+    ]);
+    assert_eq!(expected, Parser::parse_parameters(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_params_mixed_types() -> Result<(), Box<dyn Error>> {
+    let mut input = ";key1=?0;key2=746.15".chars().peekable();
+    let expected = Parameters::from_iter(vec![
+        ("key1".to_owned(), BareItem::Boolean(false)),
+        ("key2".to_owned(), Decimal::from_str("746.15")?.into()),
+    ]);
+    assert_eq!(expected, Parser::parse_parameters(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_params_with_spaces() -> Result<(), Box<dyn Error>> {
+    let mut input = "; key1=?0; key2=11111".chars().peekable();
+    let expected = Parameters::from_iter(vec![
+        ("key1".to_owned(), BareItem::Boolean(false)),
+        ("key2".to_owned(), 11111.into()),
+    ]);
+    assert_eq!(expected, Parser::parse_parameters(&mut input)?);
+    Ok(())
+}
+
+#[test]
+fn parse_params_empty() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Parameters::new(),
+        Parser::parse_parameters(&mut " key1=?0; key2=11111".chars().peekable())?
+    );
+    assert_eq!(
+        Parameters::new(),
+        Parser::parse_parameters(&mut "".chars().peekable())?
+    );
+    assert_eq!(
+        Parameters::new(),
+        Parser::parse_parameters(&mut "[;a=1".chars().peekable())?
+    );
+    assert_eq!(
+        Parameters::new(),
+        Parser::parse_parameters(&mut String::new().chars().peekable())?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_key() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        "a".to_owned(),
+        Parser::parse_key(&mut "a=1".chars().peekable())?
+    );
+    assert_eq!(
+        "a1".to_owned(),
+        Parser::parse_key(&mut "a1=10".chars().peekable())?
+    );
+    assert_eq!(
+        "*1".to_owned(),
+        Parser::parse_key(&mut "*1=10".chars().peekable())?
+    );
+    assert_eq!(
+        "f".to_owned(),
+        Parser::parse_key(&mut "f[f=10".chars().peekable())?
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_key_errors() -> Result<(), Box<dyn Error>> {
+    assert_eq!(
+        Err("parse_key: first character is not lcalpha or '*'"),
+        Parser::parse_key(&mut "[*f=10".chars().peekable())
+    );
+    Ok(())
+}
+
+#[test]
+fn parse_more_list() -> Result<(), Box<dyn Error>> {
+    let item1 = Item::new(1.into());
+    let item2 = Item::new(2.into());
+    let item3 = Item::new(42.into());
+    let inner_list_1 = InnerList::new(vec![item1, item2]);
+    let expected_list: List = vec![inner_list_1.into(), item3.into()];
+
+    let mut parsed_header = Parser::parse_list("(1 2)".as_bytes())?;
+    let _ = parsed_header.parse_more("42".as_bytes())?;
+    assert_eq!(expected_list, parsed_header);
+    Ok(())
+}
+
+#[test]
+fn parse_more_dict() -> Result<(), Box<dyn Error>> {
+    let item2_params =
+        Parameters::from_iter(vec![("foo".to_owned(), BareItem::Token("*".to_owned()))]);
+    let item1 = Item::new(1.into());
+    let item2 = Item::with_params(BareItem::Boolean(true), item2_params);
+    let item3 = Item::new(3.into());
+    let expected_dict = Dictionary::from_iter(vec![
+        ("a".to_owned(), item1.into()),
+        ("b".to_owned(), item2.into()),
+        ("c".to_owned(), item3.into()),
+    ]);
+
+    let mut parsed_header = Parser::parse_dictionary("a=1, b;foo=*\t\t".as_bytes())?;
+    let _ = parsed_header.parse_more(" c=3".as_bytes())?;
+    assert_eq!(expected_dict, parsed_header);
+    Ok(())
+}
+
+#[test]
+fn parse_more_errors() -> Result<(), Box<dyn Error>> {
+    let parsed_dict_header =
+        Parser::parse_dictionary("a=1, b;foo=*".as_bytes())?.parse_more(",a".as_bytes());
+    assert!(parsed_dict_header.is_err());
+
+    let parsed_list_header =
+        Parser::parse_list("a, b;foo=*".as_bytes())?.parse_more("(a, 2)".as_bytes());
+    assert!(parsed_list_header.is_err());
+    Ok(())
+}
diff --git a/third_party/rust/sfv/src/test_serializer.rs b/third_party/rust/sfv/src/test_serializer.rs
new file mode 100644
index 0000000000..edcc79ce2a
--- /dev/null
+++ b/third_party/rust/sfv/src/test_serializer.rs
@@ -0,0 +1,531 @@
+use crate::serializer::Serializer;
+use crate::FromStr;
+use crate::SerializeValue;
+use crate::{BareItem, Decimal, Dictionary, InnerList, Item, List, Parameters};
+use std::error::Error;
+use std::iter::FromIterator;
+
+#[test]
+fn serialize_value_empty_dict() -> Result<(), Box<dyn Error>> {
+    let dict_field_value = Dictionary::new();
+    assert_eq!(
+        Err("serialize_dictionary: serializing empty field is not allowed"),
+        dict_field_value.serialize_value()
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_value_empty_list() -> Result<(), Box<dyn Error>> {
+    let list_field_value = List::new();
+    assert_eq!(
+        Err("serialize_list: serializing empty field is not allowed"),
+        list_field_value.serialize_value()
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_value_list_mixed_members_with_params() -> Result<(), Box<dyn Error>> {
+    let item1 = Item::new(Decimal::from_str("42.4568")?.into());
+    let item2_param = Parameters::from_iter(vec![("itm2_p".to_owned(), BareItem::Boolean(true))]);
+    let item2 = Item::with_params(17.into(), item2_param);
+
+    let inner_list_item1_param =
+        Parameters::from_iter(vec![("in1_p".to_owned(), BareItem::Boolean(false))]);
+    let inner_list_item1 =
+        Item::with_params(BareItem::String("str1".to_owned()), inner_list_item1_param);
+    let inner_list_item2_param = Parameters::from_iter(vec![(
+        "in2_p".to_owned(),
+        BareItem::String("valu\\e".to_owned()),
+    )]);
+    let inner_list_item2 =
+        Item::with_params(BareItem::Token("str2".to_owned()), inner_list_item2_param);
+    let inner_list_param = Parameters::from_iter(vec![(
+        "inner_list_param".to_owned(),
+        BareItem::ByteSeq("weather".as_bytes().to_vec()),
+    )]);
+    let inner_list =
+        InnerList::with_params(vec![inner_list_item1, inner_list_item2], inner_list_param);
+
+    let list_field_value: List = vec![item1.into(), item2.into(), inner_list.into()];
+    let expected = "42.457, 17;itm2_p, (\"str1\";in1_p=?0 str2;in2_p=\"valu\\\\e\");inner_list_param=:d2VhdGhlcg==:";
+    assert_eq!(expected, list_field_value.serialize_value()?);
+    Ok(())
+}
+
+#[test]
+fn serialize_value_errors() -> Result<(), Box<dyn Error>> {
+    let disallowed_item = Item::new(BareItem::String("non-ascii text 🐹".into()));
+    assert_eq!(
+        Err("serialize_string: non-ascii character"),
+        disallowed_item.serialize_value()
+    );
+
+    let disallowed_item = Item::new(Decimal::from_str("12345678912345.123")?.into());
+    assert_eq!(
+        Err("serialize_decimal: integer component > 12 digits"),
+        disallowed_item.serialize_value()
+    );
+
+    let param_with_disallowed_key = Parameters::from_iter(vec![("_key".to_owned(), 13.into())]);
+    let disallowed_item = Item::with_params(12.into(), param_with_disallowed_key);
+    assert_eq!(
+        Err("serialize_key: first character is not lcalpha or '*'"),
+        disallowed_item.serialize_value()
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_item_byteseq_with_param() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let item_param = ("a".to_owned(), BareItem::Token("*ab_1".into()));
+    let item_param = Parameters::from_iter(vec![item_param]);
+    let item = Item::with_params(BareItem::ByteSeq("parser".as_bytes().to_vec()), item_param);
+    Serializer::serialize_item(&item, &mut buf)?;
+    assert_eq!(":cGFyc2Vy:;a=*ab_1", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_item_without_params() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    let item = Item::new(1.into());
+    Serializer::serialize_item(&item, &mut buf)?;
+    assert_eq!("1", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_item_with_bool_true_param() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    let param = Parameters::from_iter(vec![("a".to_owned(), BareItem::Boolean(true))]);
+    let item = Item::with_params(Decimal::from_str("12.35")?.into(), param);
+    Serializer::serialize_item(&item, &mut buf)?;
+    assert_eq!("12.35;a", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_item_with_token_param() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    let param = Parameters::from_iter(vec![("a1".to_owned(), BareItem::Token("*tok".to_owned()))]);
+    let item = Item::with_params(BareItem::String("12.35".to_owned()), param);
+    Serializer::serialize_item(&item, &mut buf)?;
+    assert_eq!("\"12.35\";a1=*tok", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_integer() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    Serializer::serialize_integer(-12, &mut buf)?;
+    assert_eq!("-12", &buf);
+
+    buf.clear();
+    Serializer::serialize_integer(0, &mut buf)?;
+    assert_eq!("0", &buf);
+
+    buf.clear();
+    Serializer::serialize_integer(999_999_999_999_999, &mut buf)?;
+    assert_eq!("999999999999999", &buf);
+
+    buf.clear();
+    Serializer::serialize_integer(-999_999_999_999_999, &mut buf)?;
+    assert_eq!("-999999999999999", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_integer_errors() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    assert_eq!(
+        Err("serialize_integer: integer is out of range"),
+        Serializer::serialize_integer(1_000_000_000_000_000, &mut buf)
+    );
+
+    buf.clear();
+    assert_eq!(
+        Err("serialize_integer: integer is out of range"),
+        Serializer::serialize_integer(-1_000_000_000_000_000, &mut buf)
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_decimal() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    Serializer::serialize_decimal(Decimal::from_str("-99.1346897")?, &mut buf)?;
+    assert_eq!("-99.135", &buf);
+
+    buf.clear();
+    Serializer::serialize_decimal(Decimal::from_str("-1.00")?, &mut buf)?;
+    assert_eq!("-1.0", &buf);
+
+    buf.clear();
+    Serializer::serialize_decimal(
+        Decimal::from_str("-00000000000000000000000099.1346897")?,
+        &mut buf,
+    )?;
+    assert_eq!("-99.135", &buf);
+
+    buf.clear();
+    Serializer::serialize_decimal(Decimal::from_str("100.13")?, &mut buf)?;
+    assert_eq!("100.13", &buf);
+
+    buf.clear();
+    Serializer::serialize_decimal(Decimal::from_str("-100.130")?, &mut buf)?;
+    assert_eq!("-100.130", &buf);
+
+    buf.clear();
+    Serializer::serialize_decimal(Decimal::from_str("-137.0")?, &mut buf)?;
+    assert_eq!("-137.0", &buf);
+
+    buf.clear();
+    Serializer::serialize_decimal(Decimal::from_str("137121212112.123")?, &mut buf)?;
+    assert_eq!("137121212112.123", &buf);
+
+    buf.clear();
+    Serializer::serialize_decimal(Decimal::from_str("137121212112.1238")?, &mut buf)?;
+    assert_eq!("137121212112.124", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_decimal_errors() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    assert_eq!(
+        Err("serialize_decimal: integer component > 12 digits"),
+        Serializer::serialize_decimal(Decimal::from_str("1371212121121.1")?, &mut buf)
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_string() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    Serializer::serialize_string("1.1 text", &mut buf)?;
+    assert_eq!("\"1.1 text\"", &buf);
+
+    buf.clear();
+    Serializer::serialize_string("hello \"name\"", &mut buf)?;
+    assert_eq!("\"hello \\\"name\\\"\"", &buf);
+
+    buf.clear();
+    Serializer::serialize_string("something\\nothing", &mut buf)?;
+    assert_eq!("\"something\\\\nothing\"", &buf);
+
+    buf.clear();
+    Serializer::serialize_string("", &mut buf)?;
+    assert_eq!("\"\"", &buf);
+
+    buf.clear();
+    Serializer::serialize_string(" ", &mut buf)?;
+    assert_eq!("\" \"", &buf);
+
+    buf.clear();
+    Serializer::serialize_string("    ", &mut buf)?;
+    assert_eq!("\"    \"", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_string_errors() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    assert_eq!(
+        Err("serialize_string: not a visible character"),
+        Serializer::serialize_string("text \x00", &mut buf)
+    );
+
+    assert_eq!(
+        Err("serialize_string: not a visible character"),
+        Serializer::serialize_string("text \x1f", &mut buf)
+    );
+    assert_eq!(
+        Err("serialize_string: not a visible character"),
+        Serializer::serialize_string("text \x7f", &mut buf)
+    );
+    assert_eq!(
+        Err("serialize_string: non-ascii character"),
+        Serializer::serialize_string("рядок", &mut buf)
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_token() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    Serializer::serialize_token("*", &mut buf)?;
+    assert_eq!("*", &buf);
+
+    buf.clear();
+    Serializer::serialize_token("abc", &mut buf)?;
+    assert_eq!("abc", &buf);
+
+    buf.clear();
+    Serializer::serialize_token("abc:de", &mut buf)?;
+    assert_eq!("abc:de", &buf);
+
+    buf.clear();
+    Serializer::serialize_token("smth/#!else", &mut buf)?;
+    assert_eq!("smth/#!else", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_token_errors() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    assert_eq!(
+        Err("serialise_token: first character is not ALPHA or '*'"),
+        Serializer::serialize_token("#some", &mut buf)
+    );
+    assert_eq!(
+        Err("serialise_token: disallowed character"),
+        Serializer::serialize_token("s ", &mut buf)
+    );
+    assert_eq!(
+        Err("serialise_token: disallowed character"),
+        Serializer::serialize_token("abc:de\t", &mut buf)
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_byte_sequence() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    Serializer::serialize_byte_sequence("hello".as_bytes(), &mut buf)?;
+    assert_eq!(":aGVsbG8=:", &buf);
+
+    buf.clear();
+    Serializer::serialize_byte_sequence("test_encode".as_bytes(), &mut buf)?;
+    assert_eq!(":dGVzdF9lbmNvZGU=:", &buf);
+
+    buf.clear();
+    Serializer::serialize_byte_sequence("".as_bytes(), &mut buf)?;
+    assert_eq!("::", &buf);
+
+    buf.clear();
+    Serializer::serialize_byte_sequence("pleasure.".as_bytes(), &mut buf)?;
+    assert_eq!(":cGxlYXN1cmUu:", &buf);
+
+    buf.clear();
+    Serializer::serialize_byte_sequence("leasure.".as_bytes(), &mut buf)?;
+    assert_eq!(":bGVhc3VyZS4=:", &buf);
+
+    buf.clear();
+    Serializer::serialize_byte_sequence("easure.".as_bytes(), &mut buf)?;
+    assert_eq!(":ZWFzdXJlLg==:", &buf);
+
+    buf.clear();
+    Serializer::serialize_byte_sequence("asure.".as_bytes(), &mut buf)?;
+    assert_eq!(":YXN1cmUu:", &buf);
+
+    buf.clear();
+    Serializer::serialize_byte_sequence("sure.".as_bytes(), &mut buf)?;
+    assert_eq!(":c3VyZS4=:", &buf);
+
+    Ok(())
+}
+
+#[test]
+fn serialize_bool() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    Serializer::serialize_bool(true, &mut buf)?;
+    assert_eq!("?1", &buf);
+
+    buf.clear();
+    Serializer::serialize_bool(false, &mut buf)?;
+    assert_eq!("?0", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_params_bool() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let input = Parameters::from_iter(vec![
+        ("*b".to_owned(), BareItem::Boolean(true)),
+        ("a.a".to_owned(), BareItem::Boolean(true)),
+    ]);
+
+    Serializer::serialize_parameters(&input, &mut buf)?;
+    assert_eq!(";*b;a.a", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_params_string() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let input = Parameters::from_iter(vec![(
+        "b".to_owned(),
+        BareItem::String("param_val".to_owned()),
+    )]);
+    Serializer::serialize_parameters(&input, &mut buf)?;
+    assert_eq!(";b=\"param_val\"", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_params_numbers() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let input = Parameters::from_iter(vec![
+        ("key1".to_owned(), Decimal::from_str("746.15")?.into()),
+        ("key2".to_owned(), 11111.into()),
+    ]);
+    Serializer::serialize_parameters(&input, &mut buf)?;
+    assert_eq!(";key1=746.15;key2=11111", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_params_mixed_types() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let input = Parameters::from_iter(vec![
+        ("key1".to_owned(), BareItem::Boolean(false)),
+        ("key2".to_owned(), Decimal::from_str("1354.091878")?.into()),
+    ]);
+    Serializer::serialize_parameters(&input, &mut buf)?;
+    assert_eq!(";key1=?0;key2=1354.092", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_key() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+    Serializer::serialize_key("*a_fg", &mut buf)?;
+    assert_eq!("*a_fg", &buf);
+
+    buf.clear();
+    Serializer::serialize_key("*a_fg*", &mut buf)?;
+    assert_eq!("*a_fg*", &buf);
+
+    buf.clear();
+    Serializer::serialize_key("key1", &mut buf)?;
+    assert_eq!("key1", &buf);
+
+    buf.clear();
+    Serializer::serialize_key("ke-y.1", &mut buf)?;
+    assert_eq!("ke-y.1", &buf);
+
+    Ok(())
+}
+
+#[test]
+fn serialize_key_erros() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    assert_eq!(
+        Err("serialize_key: disallowed character in input"),
+        Serializer::serialize_key("AND", &mut buf)
+    );
+    assert_eq!(
+        Err("serialize_key: first character is not lcalpha or '*'"),
+        Serializer::serialize_key("_key", &mut buf)
+    );
+    assert_eq!(
+        Err("serialize_key: first character is not lcalpha or '*'"),
+        Serializer::serialize_key("7key", &mut buf)
+    );
+    Ok(())
+}
+
+#[test]
+fn serialize_list_of_items_and_inner_list() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let item1 = Item::new(12.into());
+    let item2 = Item::new(14.into());
+    let item3 = Item::new(BareItem::Token("a".to_owned()));
+    let item4 = Item::new(BareItem::Token("b".to_owned()));
+    let inner_list_param = Parameters::from_iter(vec![(
+        "param".to_owned(),
+        BareItem::String("param_value_1".to_owned()),
+    )]);
+    let inner_list = InnerList::with_params(vec![item3, item4], inner_list_param);
+    let input: List = vec![item1.into(), item2.into(), inner_list.into()];
+
+    Serializer::serialize_list(&input, &mut buf)?;
+    assert_eq!("12, 14, (a b);param=\"param_value_1\"", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_list_of_lists() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let item1 = Item::new(1.into());
+    let item2 = Item::new(2.into());
+    let item3 = Item::new(42.into());
+    let item4 = Item::new(43.into());
+    let inner_list_1 = InnerList::new(vec![item1, item2]);
+    let inner_list_2 = InnerList::new(vec![item3, item4]);
+    let input: List = vec![inner_list_1.into(), inner_list_2.into()];
+
+    Serializer::serialize_list(&input, &mut buf)?;
+    assert_eq!("(1 2), (42 43)", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_list_with_bool_item_and_bool_params() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let item1_params = Parameters::from_iter(vec![
+        ("a".to_owned(), BareItem::Boolean(true)),
+        ("b".to_owned(), BareItem::Boolean(false)),
+    ]);
+    let item1 = Item::with_params(BareItem::Boolean(false), item1_params);
+    let item2 = Item::new(BareItem::Token("cde_456".to_owned()));
+
+    let input: List = vec![item1.into(), item2.into()];
+    Serializer::serialize_list(&input, &mut buf)?;
+    assert_eq!("?0;a;b=?0, cde_456", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_dictionary_with_params() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let item1_params = Parameters::from_iter(vec![
+        ("a".to_owned(), 1.into()),
+        ("b".to_owned(), BareItem::Boolean(true)),
+    ]);
+    let item2_params = Parameters::new();
+    let item3_params = Parameters::from_iter(vec![
+        ("q".to_owned(), BareItem::Boolean(false)),
+        ("r".to_owned(), BareItem::String("+w".to_owned())),
+    ]);
+
+    let item1 = Item::with_params(123.into(), item1_params);
+    let item2 = Item::with_params(456.into(), item2_params);
+    let item3 = Item::with_params(789.into(), item3_params);
+
+    let input = Dictionary::from_iter(vec![
+        ("abc".to_owned(), item1.into()),
+        ("def".to_owned(), item2.into()),
+        ("ghi".to_owned(), item3.into()),
+    ]);
+
+    Serializer::serialize_dict(&input, &mut buf)?;
+    assert_eq!("abc=123;a=1;b, def=456, ghi=789;q=?0;r=\"+w\"", &buf);
+    Ok(())
+}
+
+#[test]
+fn serialize_dict_empty_member_value() -> Result<(), Box<dyn Error>> {
+    let mut buf = String::new();
+
+    let inner_list = InnerList::new(vec![]);
+    let input = Dictionary::from_iter(vec![("a".to_owned(), inner_list.into())]);
+    Serializer::serialize_dict(&input, &mut buf)?;
+    assert_eq!("a=()", &buf);
+    Ok(())
+}
diff --git a/third_party/rust/sfv/src/utils.rs b/third_party/rust/sfv/src/utils.rs
new file mode 100644
index 0000000000..7eb79340ba
--- /dev/null
+++ b/third_party/rust/sfv/src/utils.rs
@@ -0,0 +1,44 @@
+use data_encoding::{Encoding, Specification};
+use std::iter::Peekable;
+use std::str::Chars;
+
+pub(crate) fn base64() -> Result<Encoding, &'static str> {
+    let mut spec = Specification::new();
+    spec.check_trailing_bits = false;
+    spec.symbols
+        .push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
+    spec.padding = None;
+    spec.ignore = "=".to_owned();
+    spec.encoding()
+        .map_err(|_err| "invalid base64 specification")
+}
+
+pub(crate) fn is_tchar(c: char) -> bool {
+    // See tchar values list in https://tools.ietf.org/html/rfc7230#section-3.2.6
+    let tchars = "!#$%&'*+-.^_`|~";
+    tchars.contains(c) || c.is_ascii_alphanumeric()
+}
+
+pub(crate) fn is_allowed_b64_content(c: char) -> bool {
+    c.is_ascii_alphanumeric() || c == '+' || c == '=' || c == '/'
+}
+
+pub(crate) fn consume_ows_chars(input_chars: &mut Peekable<Chars>) {
+    while let Some(c) = input_chars.peek() {
+        if c == &' ' || c == &'\t' {
+            input_chars.next();
+        } else {
+            break;
+        }
+    }
+}
+
+pub(crate) fn consume_sp_chars(input_chars: &mut Peekable<Chars>) {
+    while let Some(c) = input_chars.peek() {
+        if c == &' ' {
+            input_chars.next();
+        } else {
+            break;
+        }
+    }
+}