moon-sfv
RFC 9651 Structured Field Values parser, serializer, and conformance toolkit for MoonBit.
moon add 6P66006/moon-sfv@0.1.0
Download zipAuthor
Version
0.1.0
License
Apache-2.0
Repository
Last updated
11 days ago
Downloads
3
README#moon-sfv
RFC 9651 Structured Field Values for HTTP — parser, serializer, and
conformance toolkit for MoonBit.
moon-sfv is a strict, dependency-free implementation of RFC 9651
("Structured Field Values for HTTP", formerly RFC 8941). It parses and
serializes the three Structured Fields top-level types — Items, Lists,
and Dictionaries — with exact, lossless semantics, and ships a
conformance harness that runs the official
HTTP Working Group test vectors
against the implementation.
#Goals and scope
Goal. Provide a strict, exact, dependency-free MoonBit implementation of
RFC 9651 so MoonBit applications can build and consume Structured Fields
interoperably, plus tooling to prove conformance.
Scope.
- Full parse / serialize / canonicalize support for all eight bare-item types and all three top-level containers (Item, List, Dictionary), including parameters, inner lists, multi-line fields, and the omit-empty-field rule.
- Exact decimal arithmetic (no floating point), structured errors, and configurable input limits for hostile HTTP traffic.
- A conformance harness running the official HTTP Working Group test vectors, and a CLI (sfv-tool) for ad-hoc checking.
Out of scope. Field-specific semantics (what a given field means) and
stdin input for the CLI. The module namespace is 6P66006/moon-sfv.
#What is RFC 9651?
HTTP headers are normally defined as opaque strings, which forces every
implementation to reinvent fragile parsing. RFC 9651 standardizes a small
set of data types — integers, decimals, strings, tokens, byte sequences,
booleans, dates, and display strings — and the exact algorithms for parsing
and serializing them. Fields built on Structured Fields get a well-defined
syntax, a canonical wire form, and interoperable behavior by construction.
Common fields already defined in terms of Structured Fields include
Cache-Status, CDN-Cache-Control, Priority, Accept-CH, and many
others.
#Supported types
moon-sfv implements every abstract type in RFC 9651:
| Type | Wire example | BareItem variant |
|---|---|---|
| Integer | 42, -123456789012345 | Integer(Int64) |
| Decimal | 4.5, -0.125 | Decimal(SfDecimal) |
| String | "hello world" | StringItem(String) |
| Token | foo/bar:baz | Token(String) |
| Byte Sequence | :cHJldGVuZCB0aGlzIGlzIGJpbmFyeSBjb250ZW50Lg==: | ByteSequence(Bytes) |
| Boolean | ?1, ?0 | Boolean(Bool) |
| Date | @1659578233 | Date(Int64) |
| Display String | %"hello %c3%a9" | DisplayString(String) |
The three top-level containers are Item, SfList, and SfDictionary;
items can carry Parameters, and lists and dictionaries can contain
InnerList members. Decimals use an exact coefficient × 10^-scale
representation (no floating point), and serialization rounds to three
decimal places using ties-to-even, exactly as the RFC requires.
#Parsing
fn main {
match parse_item("5; foo=bar") {
Err(e) => println(e.to_string())
Ok(item) => {
// item.bare -> Integer(5)
// item.parameters.len() -> 1
// item.parameters.get_by_key("foo") -> Some(Token("bar"))
}
}
}The public entry points are parse_item, parse_list, and
parse_dictionary (plus *_bytes and *_with_limits variants), and the
multi-line helpers parse_item_lines, parse_list_lines, and
parse_dictionary_lines.
#Serialization
let item = parse_item("5; a=?1; b=?0")?
match serialize_item(item) {
Err(e) => println(e.to_string())
Ok(wire) => println(wire) // "5;a;b=?0" — Boolean true is omitted
}serialize_item returns Result[String, SfError]; serialize_list and
serialize_dictionary return Result[SerializedField, SfError], where the
Omit variant expresses the RFC 9651 rule that an empty List or
Dictionary is represented by omitting the field entirely — the caller can
distinguish "field omitted" from "field with an empty value".
#Canonicalization
// "0002" -> "2"
// "4.500" -> "4.5"
// "5; a=?1" -> "5;a"
// "1, 42" -> "1, 42"
canonicalize(input, FieldType::List)?canonicalize parses then strictly re-serializes, producing the canonical
wire form. It is idempotent: canonicalize(canonicalize(x)) equals
canonicalize(x), and parse(serialize(value)) is semantically equal to
value.
#Error handling
Errors are structured, never bare strings:
match parse_item("abc, def") {
Err(e) => {
e.kind() // SfErrorKind::TrailingInput
e.offset() // 3 — a UTF-8 byte offset into the input
e.to_string() // "trailing input after value at byte 3: near \", def\""
}
Ok(_) => ()
}There are 25 distinct SfErrorKind values covering every failure category.
Offsets are UTF-8 byte offsets (the same unit the parser works in), and
error context is truncated so errors never echo unbounded input back.
#Command-line tool
sfv-tool is a small checker built on the library.
sfv-tool parse --type item "5; foo=bar"
sfv-tool validate --type list "1, 42"
sfv-tool canonicalize --type dictionary "a=1, b=2;c"
sfv-tool roundtrip --type item "0002"
sfv-tool conformanceField commands read the input from the single positional argument; errors
are printed with the error kind and byte offset and exit with a non-zero
status. Byte sequences are rendered as hex, and dates keep their raw
seconds value.
#Building and running
Requires the MoonBit toolchain (moon, moonc, moonrun). No external
MoonBit dependency is used beyond the standard library.
# check, build, and test on the default target
moon check
moon build
moon test
# test a specific target
moon test --target native
moon test --target js
moon test --target wasm-gc
# run the CLI
moon run cmd/sfv-tool -- --help
# run an example
moon run examples/parse_item
# run the official httpwg conformance suite
moon run cmd/sfv-tool -- conformance
# full verification for all targets (format, build, test, snapshot check)
powershell -ExecutionPolicy Bypass -File scripts/verify_all.ps1#Security limits
Parsing is bounded by a configurable ParseLimits structure. The
defaults satisfy every RFC 9651 requirement (1024+ List members, 256
parameters, 1024+ String characters, 512+ Token characters, 16384+ decoded
Byte Sequence octets) while capping hostile inputs: 4 MiB of input, 100k
members, and 1 MiB per string/sequence. Every cursor read is bounds-checked,
and truncation at any byte position is covered by tests.
#Test status
- 113 unit/property tests, covering every type, boundaries, rounding, escaping, truncation safety, multi-line fields, and a fixed-seed fuzzer that round-trips thousands of generated values.
- 1591 official HTTP Working Group vectors imported into the conformance harness. Current results: required valid 721/721, required invalid 864/864, canonical round-trip 721/721, optional 6/6, expected structure 717/717, zero failures.
- Verified on the native, js, and wasm-gc targets with 0 errors and 0 warnings.
#Not yet verified / out of scope
- Reading input from stdin in sfv-tool (the CLI currently accepts input only as a command-line argument).
- Benchmarks and long-running fuzz campaigns (the bundled fuzzer is deterministic and bounded for CI).
- Field-level semantics beyond the RFC grammar — this library validates and canonicalizes syntax, it does not interpret field-specific meaning.
#Development
See docs/architecture.md for the internal design,
docs/testing.md for how to run the full suite, and
CONTRIBUTING.md for contribution guidelines. The import
of official test data is documented in THIRD_PARTY_NOTICES.md.
This is a local development project. It is not published, and no
maintainer or author information is attached.
#BareItem
A bare item: one of the eight Structured Fields scalar types.
#BareItem::integer
Convenience constructors for bare items.
#ConformanceStats
pub(all) struct ConformanceStats {
required_valid_total : Int
required_valid_passed : Int
required_invalid_total : Int
required_invalid_passed : Int
canonical_total : Int
canonical_passed : Int
optional_total : Int
optional_passed : Int
optional_failed : Int
expected_total : Int
expected_passed : Int
failures : Array[String]
} derive(Eq, Debug)The conformance harness that runs the imported httpwg
structured-field-tests vectors against this implementation and
reports categorized pass/fail statistics.
Required tests (per RFC 9651 MUST/SHOULD behavior) must all pass; a
single required failure is a conformance bug. Optional (can_fail)
tests are counted and reported but do not fail the run. The report is
also used by the sfv-tool conformance CLI command.
#ConformanceStats::summary_line
A one-line summary line for the CLI / test report.
#Cursor
pub struct Cursor {
input : Bytes
position : Int
}A bounds-checked cursor over the UTF-8 byte encoding of a structured
field value.
All reads are checked against the end of the input; index arithmetic
never reaches the underlying array without a length check first. The
cursor's position is reported in UTF-8 byte offsets, which is exactly
the unit used for error offsets in [SfError].
#Cursor::at
Reads the byte at absolute offset offset, or None out of bounds.
#Cursor::checkpoint
Saves the current position for later restoration.
#Cursor::consume
Reads and consumes the byte at the current position, or None at end
of input.
#Cursor::consume_if
Consumes b if it is the next byte, returning whether it matched.
#Cursor::context_string
Builds a short, lossy-decoded display context starting at byte offset
(see [SfError::context]). The slice is capped so errors never echo an
unbounded amount of input.
#Cursor::expect
Alias of [Cursor::consume_if] for call sites that read more naturally
with "expect".
#Cursor::input
The full input behind the cursor, copied.
#Cursor::input_length
The total length of the input, without copying.
#Cursor::is_end
Whether the cursor has reached the end of the input.
#Cursor::peek
The byte at the current position, or None at end of input.
#Cursor::peek_n
The byte n bytes ahead of the current position, or None if that
offset is past the end of the input.
#Cursor::remaining
Number of bytes remaining after the current position.
#Cursor::restore
Restores a previously saved position.
#Cursor::skip_ows
Skips OWS (SP / HTAB). Used between List and Dictionary members, where
the RFC allows tab characters.
#Cursor::skip_spaces
Skips SP (0x20) characters. The Item grammar only permits SP, not HTAB.
#DictionaryEntry
One member of a Dictionary.
#ExpectedBare
pub enum ExpectedBare {
ExpInteger(Int64)
ExpDecimal(Int64, Int)
ExpString(String)
ExpToken(String)
ExpBinary(String)
ExpBoolean(Bool)
ExpDate(Int64)
ExpDisplayString(String)
}The abstract types used to express expected values from the
httpwg test suite.
#ExpectedField
pub enum ExpectedField {
ExpItemField(ExpectedItem)
ExpListField(Array[ExpectedMember])
ExpDictField(Array[(String, ExpectedMember)])
}#ExpectedMember
pub enum ExpectedMember {
ExpItemMember(ExpectedItem)
ExpInnerList(Array[ExpectedItem], Array[ExpectedParam])
}#FieldType
The three top-level Structured Fields types.
#FieldType::from_wire_name
Parses a wire field-type name ("item", "list", "dictionary").
#FieldType::parse
Parses input as a field of the given type, returning a type-erased
[ParsedValue]. Useful when the field type is only known at runtime.
#HttpwgCase
pub struct HttpwgCase {
name : String
header_type : String
raw : Array[String]
must_fail : Bool
can_fail : Bool
canonical : Array[String]?
expected : ExpectedField?
}#InnerList
An Inner List: an ordered array of Items plus its own parameters.
#InnerList::items
The ordered Items of an Inner List.
#InnerList::len
The number of Items in the Inner List.
#Item
An Item: a bare item with associated parameters.
#Item::of
Convenience constructor for an Item from a bare item with no parameters.
#Item::with_parameters
Convenience constructor for an Item from a bare item and parameters.
#ListMember
One member of a List or Dictionary: an Item or an Inner List.
#ListMember::inner_list
Convenience constructor for a member holding an Inner List.
#ListMember::item
Convenience constructor for a member holding an Item.
#Parameter
A single key/value parameter.
#Parameters
An ordered map of parameters attached to an Item or Inner List.
Duplicate keys parsed from the wire collapse to their last occurrence
(RFC 9651 §4.2.3.2). The map preserves insertion order.
#Parameters::entries
The ordered list of (key, value) entries.
#Parameters::get_by_index
Access by position.
#Parameters::get_by_key
Access by key; returns the stored value.
#Parameters::is_empty
Whether the parameter map is empty.
#Parameters::keys
A list of the parameter keys, in order.
#Parameters::set
Insert or replace (by key) a parameter. A duplicate key keeps its
original position and receives the new value, matching RFC 9651
§4.2.3.2.
#ParseLimits
Resource limits applied while parsing. RFC 9651 requires parsers to
support at least 1024 List/Dictionary members, 256 parameters, 1024
String characters, 512 Token characters, and 16384 decoded Byte
Sequence octets; the defaults below satisfy all of those while still
bounding hostile inputs.
#ParseLimits::default
The default [ParseLimits], comfortably above every RFC requirement.
#ParsedValue
The parsed field value, erased across the three top-level types.
#ParsedValue::serialize
Serializes a type-erased parsed value back to its canonical wire form.
#SerializedField
The result of serializing a whole field. An empty List or Dictionary is
represented by omitting the field entirely (RFC 9651 §4.1 step 1), so
the result is [Omit] rather than an empty string, letting callers
distinguish "field omitted" from "field with an empty value".
#SerializedField::is_omitted
Whether the field is omitted entirely.
#SerializedField::to_string
Convenience accessors for [SerializedField].
#SfDecimal
Exact decimal arithmetic for Structured Field Decimals (RFC 9651 §3.3.2).
A decimal is stored as an exact rational coefficient × 10^-scale
using an Int64 coefficient. No floating-point type is used anywhere
in the value's representation, so parsing, comparison, and rounding are
exact.
Wire-format restrictions (at most 3 fractional digits, at most 12
integer digits) are enforced by the parser and by serialization.
#SfDecimal::coefficient
The signed coefficient.
#SfDecimal::compare
Exact comparison. Returns a negative value if self < other, zero if
equal, positive if self > other.
#SfDecimal::from_parts
Constructs a decimal from raw parts; alias of [SfDecimal::new].
#SfDecimal::is_negative
Whether the value is negative (nonzero).
#SfDecimal::new
Constructs a decimal coefficient × 10^-scale, normalizing -0.
#SfDecimal::normalize
Strips trailing zeros from the fractional part and normalizes -0.
Example: 1.200 (1200, 3) becomes 1.2 (12, 1).
#SfDecimal::scale
The exponent (value = coefficient × 10^-scale).
#SfDictionary
A Dictionary: an ordered map of key to member.
Duplicate keys parsed from the wire collapse to their last occurrence
(RFC 9651 §4.2.2). The map preserves insertion order.
#SfDictionary::entries
The ordered list of (key, member) entries.
#SfDictionary::get_by_index
Access a member by position.
#SfDictionary::get_by_key
Access a member by key.
#SfDictionary::is_empty
Whether the Dictionary is empty (i.e. the field should be omitted).
#SfDictionary::keys
A list of the member keys, in order.
#SfDictionary::set
Insert or replace (by key) a member. A duplicate key keeps its original
position and receives the new value, matching RFC 9651 §4.2.2.
#SfError
#SfError::context
A short description of the surrounding input.
#SfError::make
Builds a structured error.
#SfError::offset
The UTF-8 byte offset into the input at which the failure occurred.
#SfErrorKind
pub(all) enum SfErrorKind {
UnexpectedEnd
UnexpectedByte(Byte)
InvalidTopLevelType
InvalidKey
InvalidInteger
IntegerOutOfRange
InvalidDecimal
DecimalOutOfRange
InvalidString
InvalidEscape
InvalidToken
InvalidByteSequence
InvalidBase64
InvalidBoolean
InvalidDate
InvalidDisplayString
InvalidPercentEncoding
InvalidUtf8
InvalidParameter
InvalidInnerList
InvalidDictionary
TrailingInput
TooManyMembers
TooManyParameters
InputTooLarge
SerializationError
} derive(Eq, Debug)Structured error type for all parsing, serialization, and
canonicalization failures in this crate.
The error carries a structured kind, a UTF-8 byte offset into the
original input, and a short human-readable context. Offsets are byte
offsets into the UTF-8 encoding of the input, not Unicode scalar counts.
#SfErrorKind::label
Returns the label of an error kind without offset/context details.
#SfList
A List: an ordered array of members.
#SfList::get_by_index
Access a member by position.
#SfList::is_empty
Whether the List is empty (i.e. the field should be omitted).
#SfList::members
The ordered list of members.
#canonicalize
Canonicalizes a field value of the given type.
#canonicalize_dictionary
Canonicalizes a Dictionary field value.
#canonicalize_item
Canonicalizes an Item field value.
#canonicalize_list
Canonicalizes a List field value.
#combine_field_lines
Combines field lines with ", ", matching the combining convention the
httpwg structured-field-tests suite assumes. Empty lines contribute
empty members (which fail to parse, per the RFC's strict behavior).
#decode_base64_lenient
Decodes base64 content with missing-padding and non-zero-pad-bit
tolerance. The content must already have been alphabet-validated by the
caller. base_offset is the byte offset of content inside the
original input, used for error reporting.
#expected_matches
Compares a parsed field against its expected abstract structure.
#is_base64_char
fn is_base64_char(b : Byte) -> BoolCharacters allowed in the base64 content of a Byte Sequence:
ALPHA / DIGIT / "+" / "/" / "=".
#is_h_tab
fn is_h_tab(b : Byte) -> BoolHorizontal tab (0x09), allowed only as part of OWS in List/Dictionary.
#is_key_char
fn is_key_char(b : Byte) -> BoolSubsequent characters of a key: lcalpha / DIGIT / "_" / "-" / "." / "*".
#is_lower_hex
fn is_lower_hex(b : Byte) -> BoolPercent-encoding hex digits in Display Strings must be 0-9 or
lowercase a-f (RFC 9651 §4.2.10 step 4.3.2).
#is_sp
fn is_sp(b : Byte) -> BoolSpace (0x20), the only whitespace permitted by the Item grammar.
#is_tchar
fn is_tchar(b : Byte) -> Booltchar from RFC 9110:
! / # / $ / % / & / ' / * / + / - / . / ^ / _ /
` / | / ~ / DIGIT / ALPHA.
#is_visible_ascii
fn is_visible_ascii(b : Byte) -> BoolVisible ASCII for String / Display String content: %x20-7E.
#parse_bare_item_cursor
Parses a bare item, dispatching on the first byte.
#parse_boolean_cursor
Parses a Boolean (RFC 9651 §4.2.8): exactly ?0 or ?1.
#parse_byte_sequence_cursor
Parses a Byte Sequence (RFC 9651 §4.2.7), delimited by colons and
base64-encoded. Padding is synthesized when missing, matching the RFC's
"SHOULD NOT fail" guidance for both missing padding and non-zero pad
bits.
#parse_date_cursor
Parses a Date (RFC 9651 §4.2.9): @ followed by an Integer. The value
is kept as a UTC seconds delta; no timezone conversion is performed.
#parse_dictionary
Parses input as a Dictionary field value.
#parse_dictionary_bytes
Parses input as a Dictionary field value, in UTF-8 bytes.
#parse_dictionary_cursor
Parses a Dictionary.
#parse_dictionary_lines
Parses a Dictionary field that may be spread across multiple lines.
#parse_dictionary_with_limits
fn parse_dictionary_with_limits(input : String, limits : ParseLimits) -> Result[SfDictionary, SfError]Parses input as a Dictionary field value with custom limits.
#parse_display_string_cursor
Parses a Display String (RFC 9651 §4.2.10): %"..." with percent-encoded
UTF-8 bytes. Percent hex digits must be lowercase.
#parse_field_bytes
fn[T] parse_field_bytes(input : Bytes, limits : ParseLimits, parse_fn : (Cursor, ParseLimits) -> Result[T, SfError]) -> Result[T, SfError]Runs the top-level field parsing algorithm (RFC 9651 §4.2): discard
leading SP, parse by the given function, discard trailing SP, and
require that nothing remains. This enforces the field-value boundary
and produces [TrailingInput] errors for stray characters.
#parse_inner_list_cursor
Parsing of Inner Lists (RFC 9651 §4.2.1.2).
An Inner List is "(" SP *[item *(SP item)] ")" followed by its own
parameters. Items are separated by one or more spaces.
#parse_integer_or_decimal_cursor
fn parse_integer_or_decimal_cursor(cursor : Cursor, _limits : ParseLimits) -> Result[BareItem, SfError]Parses an Integer or Decimal (RFC 9651 §4.2.4). Returns an
[BareItem] carrying the parsed value.
#parse_item
Parses input as an Item field value.
#parse_item_bytes
Parses input as an Item field value, in UTF-8 bytes. Avoids a
redundant string-to-bytes conversion when the input is already bytes.
#parse_item_cursor
Parses an Item: a bare item followed by its parameters.
#parse_item_lines
Parses an Item field that may be spread across multiple lines.
#parse_item_or_inner_list_cursor
fn parse_item_or_inner_list_cursor(cursor : Cursor, limits : ParseLimits) -> Result[ListMember, SfError]Parses an Item or Inner List (RFC 9651 §4.2.1.1).
#parse_item_with_limits
Parses input as an Item field value with custom limits.
#parse_key
Parses a Structured Fields key (RFC 9651 §4.2.3.3).
Grammar: key = ( lcalpha / "*" ) *( lcalpha / DIGIT / "_" / "-" / "." / "*" ).
#parse_list
Parses input as a List field value.
#parse_list_bytes
Parses input as a List field value, in UTF-8 bytes.
#parse_list_cursor
Parses a List: comma-separated Items and Inner Lists.
#parse_list_lines
Parses a List field that may be spread across multiple lines.
#parse_list_with_limits
Parses input as a List field value with custom limits.
#parse_parameters_cursor
Parsing of Parameters (RFC 9651 §4.2.3.2).
Each parameter starts with ;, optionally followed by SP, a key, and
an optional =value. A parameter with no explicit value is Boolean
true. Duplicate keys collapse to their last occurrence.
#parse_string_cursor
Parses a quoted String (RFC 9651 §4.2.5). Only printable ASCII and the
two permitted escapes (\" and \\) are accepted.
#parse_token_cursor
Parses a Token (RFC 9651 §4.2.6). The first character must be ALPHA or
*; subsequent characters are tchar / : / /.
#run_conformance
Runs every imported httpwg vector and returns the statistics.
#serialize_bare_item
Serializes a bare item, dispatching on its variant.
#serialize_boolean
Serializes a Boolean (RFC 9651 §4.1.9).
#serialize_byte_sequence
Serializes a Byte Sequence (RFC 9651 §4.1.8) using canonical padded
base64.
#serialize_date
Serializes a Date (RFC 9651 §4.1.10): @ followed by an Integer.
The value is a UTC seconds delta; no timezone conversion is performed.
#serialize_dictionary
Serializes a Dictionary. An empty Dictionary is represented by omitting
the field entirely, so the result is [Omit] rather than an empty
string.
#serialize_dictionary_impl
Serializes a Dictionary into buf. Empty Dictionaries are not written
here; the top-level [serialize_dictionary] reports [Omit] for them.
#serialize_display_string
Serializes a Display String (RFC 9651 §4.1.11): %"..." with
percent-encoded UTF-8 bytes. Percent hex digits are lowercase.
#serialize_inner_list
Serializes an Inner List into buf.
#serialize_integer
Serializes an Integer (RFC 9651 §4.1.4), validating the fifteen-digit
range.
#serialize_item
Serializes an Item to its ASCII wire form.
#serialize_item_impl
Serializes an Item into buf.
#serialize_key
Serializes a key (RFC 9651 §4.1.1.3). The key must start with lcalpha
or * and otherwise contain only key characters.
#serialize_list
Serializes a List. An empty List is represented by omitting the field
entirely, so the result is [Omit] rather than an empty string.
#serialize_list_impl
Serializes a List into buf. Empty Lists are not written here; the
top-level [serialize_list] reports [Omit] for them.
#serialize_parameters
Serializes Parameters (RFC 9651 §4.1.1.2). A Boolean true parameter
omits its value.
#serialize_string
Serializes a String (RFC 9651 §4.1.6), escaping " and \.
#serialize_token
Serializes a Token (RFC 9651 §4.1.7).
Source Files
- ascii.mbt
- base64.mbt
- canonicalize.mbt
- conformance.mbt
- cursor.mbt
- decimal.mbt
- error.mbt
- field_lines.mbt
- httpwg_conformance_data.mbt
- httpwg_conformance_data_part_0.mbt
- httpwg_conformance_data_part_1.mbt
- httpwg_conformance_data_part_2.mbt
- httpwg_conformance_data_part_3.mbt
- httpwg_conformance_data_part_4.mbt
- httpwg_conformance_data_part_5.mbt
- httpwg_conformance_data_part_6.mbt
- httpwg_conformance_data_part_7.mbt
- httpwg_conformance_data_part_8.mbt
- httpwg_conformance_data_part_9.mbt
- model.mbt
- ordered_map.mbt
- parser_bare_item.mbt
- parser_common.mbt
- parser_dictionary.mbt
- parser_inner_list.mbt
- parser_item.mbt
- parser_list.mbt
- parser_parameters.mbt
- percent_encoding.mbt
- serializer_bare_item.mbt
- serializer_common.mbt
- serializer_dictionary.mbt
- serializer_item.mbt
- serializer_list.mbt
RFC 9651 Structured Field Values parser, serializer, and conformance toolkit for MoonBit.
0.1.0
Apache-2.0
Updated 11 days ago
3 downloads