std/text/json

#__jsonIsWs

true for JSON's whitespace set (space, tab, LF, CR).

#__jsonIsDigit

true for an ASCII decimal digit.

#__jsonSkipWs

Position of the first non-whitespace byte at or after pos.

#__jsonEat

Consume one expected byte; returns pos + 1 or -1 if it doesn't match.

#__jsonEatKeyword

Consume the literal keyword byte-for-byte (no allocation); -1 on mismatch.

#__jsonParseValue

Any JSON value: object, array, string, keyword literal or number.

#__jsonParseObject

{ (string ':' value (',' string ':' value)*)? }.

#__jsonParseArray

[ value (',' value)* ]?.

#__jsonParseString

A quoted string, its escapes checked but not decoded (validation
only). \" \\ \/ \b \f \n \r \t are the short escapes;
\uXXXX needs exactly 4 hex digits; any other byte after \ is
invalid, and raw control bytes (< 0x20) are rejected unescaped.

#__jsonParseNumber

A JSON number: optional -, integer part, optional fraction, optional exponent.

#jsonValidate

Recursive-descent yes/no validity check, allocating no output tree —
use it to gate untrusted input before further processing.

#__escapeInto

Escape the bytes of src into buffer at offset using JSON rules:
" \ \n \r \t \b \f get their short escapes, other control bytes
(< 0x20) become \u00XX, and every other byte is copied verbatim
(so valid UTF-8 round-trips). Returns the offset past the output.

#jsonEscapeString

String escaping (the body without surrounding quotes — useful when
concatenating into a larger structure).

#jsonQuoteString

Full quoted form: "..." with inner escaping.

#jsonI64ToString

Decimal text of a signed 64-bit value (digits emitted
least-significant-first then reversed; handles the minimum value
without negating).

#jsonF64ToString

Float → JSON literal. Stays native: NaN / ±∞ map to null, finite
values use the exact IEEE-754 shortest round-trip form.

#jsonBoolToString

The JSON literal true or false.

#jsonNull

The JSON literal null.

#__jsonKeyEquals

Does the quoted key at start (its opening quote) and ending at end
(past its closing quote) spell key?

Compared as bytes when the span carries no escape, which is every key an
API sends; a span holding one is decoded first, so "a\\u0062" still
matches "ab".

#__jsonDecodeString

The quoted string spanning [start, end) — start at its opening quote,
end past its closing one — with its escapes decoded.

A lone surrogate, or a high surrogate with no low one after it, encodes as
U+FFFD: [__txtPutUtf8] refuses to emit a surrogate, and a decoder that
dropped the byte instead would shorten the string a caller measured.

#__jsonHex4

The scalar four hex digits at pos spell, or U+FFFD when they do not.

#__jsonMember

Byte position of the value bound to key in the object starting at pos,
or -1 when there is no such member — or when pos does not start an
object at all, which is the same answer for the same reason: the caller
asked for a field and there is none.

The loop is the one in __jsonParseObject, written once more because that
one discards the two positions this needs. Validation already ran, so a
malformed shape here is impossible rather than merely unhandled.

#__jsonSpan

The raw bytes of src[start..end) as a string — no escape handling.

#constructor

Take a cursor over text without validating it — parse is
the entry point, and this is what it calls once the document has been
checked.

Safe on a malformed document all the same: every accessor answers the
neutral value on a shape it cannot read, so an unchecked cursor simply
answers nothing rather than reading past anything.

#parse

#has

#text

#int

#num

#flag