API Reference

URL

The URL class provides URL parsing following the WHATWG URL Standard.

Constructor

new URL(url)
new URL(url, base)

Properties

Example

const url = new URL("https://example.com:8080/path?key=value#section");
console.log(url.hostname);  // "example.com"
console.log(url.searchParams.get("key"));  // "value"

URLSearchParams

The URLSearchParams class provides methods for working with URL query strings.

Constructor

new URLSearchParams()
new URLSearchParams(init)

Methods

Example

const params = new URLSearchParams("foo=1&bar=2");
params.append("baz", "3");
console.log(params.get("foo"));  // "1"
console.log(params.toString());  // "foo=1&bar=2&baz=3"

Headers

The Headers class provides methods for working with HTTP headers following the Fetch API Standard.

Constructor

new Headers()
new Headers(init)

Methods

Example

const headers = new Headers({"Content-Type": "application/json"});
headers.append("Accept", "text/html");
headers.append("Accept", "application/json");
console.log(headers.get("Accept"));  // "text/html, application/json"

Request

The Request class represents an HTTP request following the Fetch API Standard.

Constructor

new Request(input)
new Request(input, options)

Properties

Methods

Example

const req = new Request("https://api.example.com/data", {
    method: "POST",
    headers: {"Content-Type": "application/json"},
    body: JSON.stringify({key: "value"})
});
console.log(req.method);  // "POST"

Response

The Response class represents an HTTP response following the Fetch API Standard.

Constructor

new Response(body)
new Response(body, options)

Properties

Methods

Static Methods

Example

const res = new Response("Hello", {status: 200});
const json = Response.json({message: "ok"});

fetch

The global fetch() function makes HTTP requests following the Fetch API Standard.

Syntax

fetch(input)
fetch(input, options)

Options

Return Value

Returns a Promise that resolves to a Response object.

Example

// Simple GET request
const res = await fetch("https://api.example.com/data");
const data = await res.json();

// POST request with JSON body
const res = await fetch("https://api.example.com/users", {
    method: "POST",
    headers: {"Content-Type": "application/json"},
    body: JSON.stringify({name: "John"})
});

// With timeout and proxy target
const res = await fetch("https://api.example.com/data", {
    target: "http://127.0.0.1:8080",
    host: "api.example.com",
    timeout: 5000
});

// Skip TLS verification (for development)
const res = await fetch("https://localhost:8443/api", {
    verify: false
});

Error Handling

try {
    const res = await fetch("https://api.example.com/data");
    if (!res.ok) {
        throw new Error(HTTP error: ${res.status});
    }
    const data = await res.json();
} catch (e) {
    console.log("Fetch failed:", e.message);
}

Base64

Global functions and Base64 object for Base64 encoding/decoding.

Global Functions

Base64 Object Methods

Example

// Web standard btoa/atob
const encoded = btoa("Hello");      // "SGVsbG8="
const decoded = atob("SGVsbG8=");   // "Hello"

// Base64 object - works with binary data
const bytes = new Uint8Array([72, 101, 108, 108, 111]);
const b64 = Base64.encode(bytes);   // "SGVsbG8="
const buf = Base64.decode(b64);     // ArrayBuffer

// Base64URL for JWT/URLs (no padding, URL-safe chars)
const urlSafe = Base64.encodeUrl("Hello");  // "SGVsbG8"

TextEncoder / TextDecoder

Standard Web APIs for encoding and decoding text.

TextEncoder

Encodes strings to UTF-8 bytes.

const encoder = new TextEncoder();
const bytes = encoder.encode("Hello");  // Uint8Array [72, 101, 108, 108, 111]
console.log(encoder.encoding);          // "utf-8"

TextDecoder

Decodes UTF-8 bytes to strings.

const decoder = new TextDecoder();
const bytes = new Uint8Array([72, 101, 108, 108, 111]);
const text = decoder.decode(bytes);     // "Hello"
console.log(decoder.encoding);          // "utf-8"

Crypto

Web Crypto API for cryptographic operations. Requires JS_SSL=1 build flag.

crypto.getRandomValues(typedArray)

Fills a TypedArray with cryptographically secure random values.

const array = new Uint8Array(16);
crypto.getRandomValues(array);

crypto.subtle.digest(algorithm, data)

Computes a hash digest. Supported algorithms: SHA-1, SHA-256, SHA-384, SHA-512.

const hash = crypto.subtle.digest("SHA-256", "hello");
// Returns ArrayBuffer

crypto.subtle.sign(algorithm, key, data)

Creates a digital signature. Supports HMAC and RSA.

// HMAC signing
const sig = crypto.subtle.sign(
    { name: "HMAC", hash: "SHA-256" },
    "secret-key",
    "message"
);

// RSA signing (requires CryptoKey)
const sig = crypto.subtle.sign(
    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
    privateKey,
    data
);

crypto.subtle.verify(algorithm, key, signature, data)

Verifies an HMAC signature.

const valid = crypto.subtle.verify(
    { name: "HMAC", hash: "SHA-256" },
    key, signature, data
);

crypto.subtle.generateKey(algorithm, extractable, keyUsages)

Generates an RSA key pair.

const keyPair = await crypto.subtle.generateKey(
    { name: "RSASSA-PKCS1-v1_5", modulusLength: 2048 },
    true,
    ["sign", "verify"]
);
// Returns { publicKey, privateKey }

crypto.subtle.exportKey(format, key)

Exports a CryptoKey. Formats: jwk, pkcs8 (private), spki (public).

const jwk = await crypto.subtle.exportKey("jwk", privateKey);
const pem = await crypto.subtle.exportKey("pkcs8", privateKey);

crypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages)

Imports a key from JWK format.

const key = await crypto.subtle.importKey(
    "jwk", jwkData,
    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
    true, ["sign"]
);

crypto.generateCSR(domains, privateKey)

Generates a Certificate Signing Request (CSR) for ACME.

const csr = crypto.generateCSR(
    ["example.com", "www.example.com"],
    keyPair.privateKey
);
// Returns ArrayBuffer (DER format)

Cache

Global cache object for in-memory key-value storage with LRU eviction and TTL support.

cache.set(key, value, options?)

Stores a value in the cache.

cache.set("user:123", "John");
cache.set("session", "abc123", { ttl: 3600 });  // expires in 1 hour

cache.get(key)

Retrieves a value from the cache.

Returns the value as a string, or null if not found or expired.

const value = cache.get("user:123");  // "John" or null

cache.has(key)

Checks if a key exists in the cache.

if (cache.has("user:123")) {
    // key exists and not expired
}

cache.delete(key)

Removes a key from the cache. Returns true if the key was deleted, false if not found.

cache.delete("user:123");

Example

var app = new App();

app.get("/cache-demo", (req) => {
    // Set with TTL
    cache.set("visits", "1", { ttl: 60 });

    // Get value


    // Update
    cache.set("visits", String(parseInt(visits) + 1), { ttl: 60 });

    return new Response(Visits: ${visits});
});

export default app;