API Reference

Append one %XX escape to a string under construction.

Copy the payload of every chunk in a range, skipping size lines, the CRLF after each, and the trailing CRLF of each chunk. Chunk extensions are skipped with the size line.

Decode an all-ASCII byte range, 64 bytes at a time so the concatenation stays linear instead of quadratic.

Decode a short all-ASCII byte range one character at a time. This is the inner step of asciiBlock(); use asciiBlock() for anything larger than a chunk.

True when the framing says the body is complete, which is how the read loop knows to stop.

Decode raw bytes as UTF-8 text. Blocks keep string building linear; a trailing split multibyte sequence carries into the next block. A byte that cannot start or finish a valid sequence is not replaced with a substitution character: the percent form is left in the output. There is no charset sniffing, so the input is always read as UTF-8.

Find the CRLF ending a chunk-size line.

Parse a chunk-size line as a hex byte count. Anything after a ; (chunk extensions) is ignored, and either hex case works.

Walk a chunked body to its terminating zero-size chunk, recursing chunk by chunk.

Trim a block boundary back so it never lands inside a multi-byte UTF-8 sequence. If the last bytes before to are an unfinished sequence, the boundary moves back to that sequence's lead byte, which bytesToString() then picks up on its next pass.

Decode a byte range that holds at least one non-ASCII byte, by percent-encoding it and handing it to decodeComponent(). The range must already be aligned to a sequence boundary; completePrefix() arranges that.

Percent-decode a string, assembling UTF-8 sequences into scalars. A multi-byte escape becomes one scalar only when the continuation bytes are all present and the result is a valid scalar; overlong forms, surrogates, and out-of-range values are rejected.

Well-known default port per scheme, "" when none. Serialization uses this to drop a port that adds nothing: https://a.com:443/ and https://a.com/ produce the same href, and port() still reports 443 because that field keeps what the text said.

Percent-encode a string as UTF-8 with uppercase hex. Every scalar above 127 becomes its UTF-8 bytes, each written as %XX. URLSearchParams.toString() uses this with form set, which is why a space turns into + there.

Minimal HTTP/1.1 client over @std/net.TcpStream: http:// only, Connection: close requests, Content-Length / close-delimited / chunked bodies. Rejects on DNS, connect, framing, and truncation failures.

The request it builds is a plain HTTP/1.1 request line plus Host, Connection: close, User-Agent: Rasmalai/1.0, and a wildcard Accept, then the headers from RequestOptions, then Content-Length when a body was set, then a blank line and the body. Cookies, redirects, compression, keep-alive, and HTTP/2 are all out of scope: a redirect comes back as a 3xx response for you to handle, and every call opens a fresh connection. Body and response text are ASCII plus whatever UTF-8 the bytes hold, decoded by bytesToString(). There is no timeout, so a server that accepts and never answers leaves the call waiting.

A 4xx or 5xx resolves normally; only transport and framing problems reject.

Build the request bytes and dispatch to TCP or TLS. This is the part of fetch() that reads the options, so call it directly only if you already have a method, header table, and body in hand.

Send a prepared request over plain TCP and parse the reply. Reads the status line, folds every header name to lowercase, then picks the body framing: chunked when Transfer-Encoding says chunked, otherwise Content-Length when the header is there, otherwise read to close. Transfer-Encoding: chunked wins over Content-Length, matching HTTP/1.1. Only the status line's first two fields are required; the reason phrase is kept as sent and may be empty.

Send a prepared request over TLS and parse the reply. Opens a TCP connection, wraps it in a TlsStream using host as the SNI and certificate domain, then does the same status line, header, and body framing work as fetchOverTcp().

Find the end of an HTTP header block, which is the blank line after the last header. Only CRLF counts, so this waits for more bytes when a server sends bare LF line endings.

One uppercase hex digit for a nibble, the encoder side of hexPair().

Decode two hex characters into a byte value, one %XX escape without the percent sign.

Value of one hex digit. Both cases count, so this reads a percent-escape written by any producer.

True for every-char-digits strings (empty counts as false). Used to tell a port from a host when splitting an authority, where an empty or non-numeric tail means there was no port at all.

True when every byte in a range is below 128.

True for 4xx codes. A 4xx means the request needs to change before it can succeed.

True for the scalar codes of ASCII 0-9.

True for a scalar allowed in a URL scheme, per RFC 3986.

True for 5xx codes. A 5xx means the request was fine and the server failed; retrying can help.

True for 2xx codes. Works on any number, so it also answers for codes HttpStatus has no variant for, such as 207.

True for the scalars RFC 3986 calls unreserved: letters, digits, and - . _ ~. These pass through percent-encoding untouched because no layer has to escape them.

Lexicographic less-than for strings, scalar by scalar. Compares scalar values, not UTF-8 bytes, and a prefix sorts before the longer string that starts with it. Used to order parameter names.

ASCII-only lowercase fold for header names and schemes.

Merge a relative reference path onto a base path: everything up to and including the base's last / is kept, and the reference is appended. A base with no / at all cannot be merged, so the reference becomes the whole path under the root.

Parse an absolute URL into parts. Surrounding whitespace is trimmed, the scheme is required and lowercased, and //authority is optional, so mailto:[email protected] parses with no host. A hosted URL with an empty path gets /. Dot segments are left alone here; only relative resolution removes them.

Split an authority into host and port. The host is lowercased; the port is kept as digits, without a leading :. A colon with a non-numeric tail is not a port, so the whole string stays the host: that keeps IPv6 literals and host: from being mangled.

Parse a non-negative decimal integer.

Read a response body, stopping when bodyDone() says the framing is satisfied or the stream ends. A stream that ends early does not throw here; the caller compares the byte count against the framing and decides whether that is a truncated body.

Read a response body over TLS, stopping when bodyDone() says the framing is satisfied or the stream ends. An early end does not throw here; the caller compares the byte count and raises the truncated body message.

Read until the CRLFCRLF that ends the header block shows up in the buffer. Bytes past the header end are left in the buffer, since they are usually the start of the body.

Read until the CRLFCRLF that ends the header block shows up in the buffer, over TLS. Bytes past the header end stay in the buffer.

Read one chunk from a stream and append it to a growing buffer.

Read one chunk from a TLS stream and append it to a growing buffer.

Resolve dot segments in a path, preserving empty segments. . drops a segment, .. drops one and its parent, and a trailing .. or . leaves the trailing slash in place. A .. at the root is dropped, since there is nothing above it.

Cut the body out of the receive buffer according to its framing.

Copy a range of a byte array.

Peel the fragment and then the query off a URL tail, storing both in the holder. The fragment is cut first because anything after a # belongs to it, including a ?.

Numeric code for a status.

Look up a status by numeric code, the reverse of statusCode(). Only the 17 codes named by HttpStatus are known; anything else has no variant, which is why the result is nullable.

Reason phrase for a status, the text a server puts after the code in a status line.

String to scalar codes, one array element per character. A character above 127 becomes its UTF-8 bytes, so the array is the UTF-8 encoding of the string and is what a socket write wants.