js/globals/encoding

function btoa(data: string): string

Encode a Latin-1 binary string to base64 (web btoa).

Each character of the input is treated as one byte, so the input must be a "binary string" whose character codes are all in [0, 255. Throws a TypeError if any character code is greater than 255 — encode real text to UTF-8 bytes with TextEncoder first if it may contain non-Latin-1 characters. The output is standard base64 with = padding.

btoa('hi'); // "aGk="

// Base64-encode arbitrary bytes:
const bytes = new TextEncoder().encode('héllo');
const b64 = btoa(String.fromCharCode(...bytes));

function atob(encodedData: string): string

Decode a base64 string to a Latin-1 binary string (web atob).

Each character of the result holds one decoded byte. ASCII whitespace (space, tab, LF, CR, FF) in the input is ignored, and missing = padding is accepted for valid 2- and 3-character remainders. Throws a TypeError on any other malformed input: characters outside the base64 alphabet, misplaced padding, or a whitespace-stripped length of % 4 == 1 (which no padding can make valid).

atob('aGk='); // "hi"
atob('aGk');  // "hi" — missing padding accepted

// Recover bytes from base64:
const bytes = Uint8Array.from(atob('aGk='), (c) => c.charCodeAt(0));

function structuredClone<T>(value: T, options?: { transfer?: ArrayBuffer[]; }): T

Deep-clone a value using V8's structured serialization machinery.

Fino routes ordinary JavaScript values through the runtime's V8 ValueSerializer / ValueDeserializer binding, the same native machinery used by realm messaging. JS-defined platform objects that V8 cannot reconstruct by itself, such as Blob, File, and CryptoKey, are cloned through narrow Fino host-object helpers.

structured-clone support matrix

Transfer lists support only ArrayBuffer. V8 transfers the backing data into the clone and detaches the source buffer, so the source buffer's byteLength becomes zero. Supplying the same buffer more than once in the transfer list throws DataCloneError.

Functions, symbols, weak collections, objects with custom prototypes, streams, direct MessagePort values, stream transfer entries, and MessagePort transfer entries throw DataCloneError.

const original: any = { nested: new Map([['x', 1]]) };
original.self = original;
const copy = structuredClone(original);
copy.self === copy; // true

// Transfer instead of copy — detaches the source buffer:
const buf = new ArrayBuffer(1024);
const moved = structuredClone(buf, { transfer: [buf] });
buf.byteLength; // 0

class DOMException extends Error {

Web DOMException class used by platform APIs and structuredClone errors.

The name, message, and legacy numeric code properties follow the DOM standard names used by browsers. Unknown names receive code 0. The legacy INDEX_SIZE_ERR-style numeric constants are defined on both the constructor and the prototype, matching the WebIDL surface.

Fino's own APIs throw plain Error subclasses; this class exists for web-platform compatibility — primarily structuredClone()'s DataCloneError — and for userland code that expects the global.

try {
  structuredClone(() => {});
} catch (err) {
  if (err instanceof DOMException && err.name === 'DataCloneError') {
    console.log(err.code); // 25
  }
}

Constructors

const err = new DOMException('operation was aborted', 'AbortError');

Getters

new DOMException('', 'AbortError').code; // 20
new DOMException('', 'SomethingElse').code; // 0

class QuotaExceededError extends DOMException {

Web quota exceeded error.

Some web APIs throw this specialized DOMException subclass so tests and userland code can check the constructor as well as the QuotaExceededError name and legacy code.

throw new QuotaExceededError('storage quota exceeded');

Readonly Properties

Constructors

const err = new QuotaExceededError('too much data', { requested: null, quota: null });

class TextEncoder {

WHATWG TextEncoder — encodes strings to UTF-8 bytes.

Per the spec, TextEncoder supports only UTF-8; there is no label argument. The constructor takes no options and instances are stateless, so one shared encoder can serve a whole module. Lone surrogates in the input are replaced with U+FFFD rather than throwing, matching browsers.

const encoder = new TextEncoder();
const bytes = encoder.encode('héllo'); // Uint8Array of UTF-8 bytes

// Zero-allocation encoding into an existing buffer:
const dest = new Uint8Array(64);
const { read, written } = encoder.encodeInto('héllo', dest);

https://encoding.spec.whatwg.org/#interface-textencoder

Getters

new TextEncoder().encoding; // "utf-8"

Methods

const bytes = new TextEncoder().encode('ok');
bytes[0]; // 111 ('o')

const dest = new Uint8Array(2);
const result = new TextEncoder().encodeInto('abc', dest);
result.read;    // 2
result.written; // 2

class TextDecoder {

WHATWG TextDecoder — decodes UTF-8, UTF-16LE, and UTF-16BE bytes to strings.

The constructor accepts the UTF-8 label aliases from the WHATWG Encoding spec plus utf-16, utf-16le, and utf-16be; any other label throws a RangeError. Malformed input is replaced with U+FFFD by default, or throws a TypeError when constructed with fatal: true. A leading BOM is stripped unless ignoreBOM: true.

Passing { stream: true } to decode() buffers an incomplete trailing multi-byte sequence (or a trailing UTF-16 lead surrogate) instead of replacing it, and prepends the buffered bytes to the next call — so a byte stream can be decoded chunk by chunk without splitting characters. A decoder used for streaming is stateful; use one instance per stream.

new TextDecoder().decode(new Uint8Array([0x68, 0x69])); // "hi"

// Chunked decoding — "€" (0xE2 0x82 0xAC) split across two reads:
const decoder = new TextDecoder();
decoder.decode(new Uint8Array([0xe2, 0x82]), { stream: true }); // ""
decoder.decode(new Uint8Array([0xac])); // "€"

https://encoding.spec.whatwg.org/#interface-textdecoder

Constructors

const decoder = new TextDecoder('utf8', { fatal: true });
decoder.encoding; // "utf-8"
new TextDecoder('shift-jis'); // throws RangeError

Getters

new TextDecoder('unicode-1-1-utf-8').encoding; // "utf-8"
new TextDecoder('utf-16').encoding; // "utf-16le"

new TextDecoder('utf-8', { fatal: true }).fatal; // true

new TextDecoder('utf-8', { ignoreBOM: true }).ignoreBOM; // true

Methods

const decoder = new TextDecoder();
for await (const chunk of byteStream) {
  process(decoder.decode(chunk, { stream: true }));
}
process(decoder.decode()); // flush