@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/response/builder.js

@@ -0,0 +1,214 @@
+/**
+ * Response construction. `HoneyResponse` is a Response-shaped bag for Node: it keeps a buffered
+ * body and a plain header map so the adapter can `res.end` it without `new Response()`, and builds
+ * a Fetch body stream only when something reads one. The raw-body side table lets every reader
+ * (raw(), HEAD, compress, output validation) find a native response's buffered body (H18.1).
+ */
+import { headersToRecord, HoneyOutHeaders } from "./out-headers.js";
+/** The Node adapter sets this on a request so `HoneyRes` can skip `new Response()`. */
+export const NODE_OUTBOUND = /* @__PURE__ */ Symbol.for("honey.nodeOut");
+const HONEY_RESPONSE = /* @__PURE__ */ Symbol.for("honey.response");
+// per-process-constant: text-codec
+const encoder = /* @__PURE__ */ new TextEncoder();
+// per-process-constant: text-codec
+const decoder = /* @__PURE__ */ new TextDecoder();
+/* weak keys: a response's entry goes with the response; no property is defined on the host object.
+ * A stream honey produced (sse, stream, generate) is recorded under PRODUCED instead of a body. */
+// per-process-constant: raw-body
+const rawBodies = /* @__PURE__ */ new WeakMap();
+/** The entry of a response whose body is a stream honey produced: possibly endless, never buffered. */
+const PRODUCED = /* @__PURE__ */ Symbol("honey.produced");
+export function isNodeOutbound(req) {
+    return req[NODE_OUTBOUND] === true;
+}
+export function isHoneyResponse(value) {
+    return typeof value === "object" && value !== null && HONEY_RESPONSE in value;
+}
+/**
+ * Record the buffered body a native response was built from. Only for a response honey constructed:
+ * a recorded body also tells withHeaders the headers are mutable.
+ */
+export function withRawBody(response, body) {
+    rawBodies.set(response, body);
+    return response;
+}
+/** The buffered body a response was built from, or `null` for a streamed or foreign one. */
+export function rawBodyOf(response) {
+    if (isHoneyResponse(response))
+        return response.rawBody;
+    const raw = rawBodies.get(response);
+    return raw === undefined || raw === PRODUCED ? null : raw;
+}
+/** Record that `response` streams a body honey produced (sse, stream, generate). */
+export function withProducedBody(response) {
+    rawBodies.set(response, PRODUCED);
+    return response;
+}
+/** Whether `response` streams a body honey produced: one never to be buffered, as it may not end. */
+export function isProducedStream(response) {
+    return rawBodies.get(response) === PRODUCED;
+}
+function toArrayBuffer(bytes) {
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function toHeaderMap(headers) {
+    if (headers instanceof HoneyOutHeaders)
+        return headers.toRecord();
+    if (headers instanceof Headers)
+        return headersToRecord(headers);
+    return { ...headers };
+}
+export class HoneyResponse {
+    [HONEY_RESPONSE] = true;
+    ok;
+    redirected = false;
+    status;
+    statusText;
+    type = "default";
+    url = "";
+    #headerMap;
+    #headers = null;
+    #raw;
+    /* `undefined`: not built yet; built from `#raw` on first read of `body` */
+    #stream;
+    #bodyUsed = false;
+    constructor(init) {
+        this.status = init.status;
+        this.statusText = init.statusText ?? "";
+        this.ok = init.status >= 200 && init.status < 300;
+        this.#headerMap = init.headers;
+        this.#raw = init.raw ?? null;
+        this.#stream = init.stream;
+    }
+    get headers() {
+        this.#headers ??= new HoneyOutHeaders(this.#headerMap);
+        return this.#headers;
+    }
+    get body() {
+        if (this.#stream !== undefined)
+            return this.#stream;
+        const raw = this.#raw;
+        this.#stream =
+            raw === null
+                ? null
+                : new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(typeof raw === "string" ? encoder.encode(raw) : raw);
+                        controller.close();
+                    },
+                });
+        return this.#stream;
+    }
+    get bodyUsed() {
+        return this.#bodyUsed;
+    }
+    /** Plain header map for `res.writeHead`. */
+    get plainHeaders() {
+        return this.#headers ? this.#headers.toRecord() : this.#headerMap;
+    }
+    /** Known-size body for `res.end`. */
+    get rawBody() {
+        return this.#raw;
+    }
+    /** A body is read once, as with Fetch: a second read throws instead of returning nothing. */
+    #consume() {
+        if (this.#bodyUsed || (this.#stream?.locked ?? false))
+            throw new TypeError("Body has already been used");
+        this.#bodyUsed = true;
+    }
+    async arrayBuffer() {
+        this.#consume();
+        const raw = this.#raw;
+        if (raw === null)
+            return this.#stream ? new Response(this.#stream).arrayBuffer() : new ArrayBuffer(0);
+        return toArrayBuffer(typeof raw === "string" ? encoder.encode(raw) : raw);
+    }
+    async blob() {
+        return new Blob([await this.arrayBuffer()], { type: this.headers.get("content-type") ?? "" });
+    }
+    async bytes() {
+        return new Uint8Array(await this.arrayBuffer());
+    }
+    clone() {
+        if (this.#bodyUsed)
+            throw new TypeError("Body has already been used");
+        let stream = this.#stream;
+        if (stream) {
+            /* tee, keep one branch: the original stays readable */
+            const [mine, theirs] = stream.tee();
+            this.#stream = mine;
+            stream = theirs;
+        }
+        const copy = new HoneyResponse({
+            headers: { ...this.plainHeaders },
+            raw: this.#raw,
+            status: this.status,
+            statusText: this.statusText,
+            stream,
+        });
+        return copy;
+    }
+    async formData() {
+        const body = this.body;
+        this.#consume();
+        return new Response(body, { headers: this.plainHeaders, status: this.status }).formData();
+    }
+    async json() {
+        const text = await this.text();
+        return text.length === 0 ? null : JSON.parse(text);
+    }
+    async text() {
+        const raw = this.#raw;
+        if (raw === null)
+            return decoder.decode(await this.arrayBuffer());
+        this.#consume();
+        return typeof raw === "string" ? raw : decoder.decode(raw);
+    }
+    /** Copy this bag with new headers/status/body — keeps the Node `res.end` path. */
+    derive(init) {
+        return new HoneyResponse({
+            headers: init.headers === undefined ? { ...this.plainHeaders } : toHeaderMap(init.headers),
+            raw: init.raw === undefined ? this.#raw : init.raw,
+            status: init.status ?? this.status,
+            statusText: this.statusText,
+            stream: init.stream === undefined ? this.#stream : init.stream,
+        });
+    }
+}
+export function createHoneyResponse(init) {
+    return new HoneyResponse(init);
+}
+/** A body a HoneyResponse keeps buffered, or `undefined` for one it cannot (a stream, a Blob, form data). */
+function bufferedBody(body) {
+    if (body === null || typeof body === "string" || body instanceof Uint8Array)
+        return body;
+    if (body instanceof ArrayBuffer)
+        return new Uint8Array(body);
+    return undefined;
+}
+function headersToInit(headers) {
+    if (headers instanceof HoneyOutHeaders)
+        return headers.toRecord();
+    return headers;
+}
+/** Rebuild a response without dropping a HoneyResponse back to `new Response()`. */
+export function replaceResponse(response, init) {
+    /* an upgrade response belongs to the runtime: rebuilding it throws (RangeError) or breaks the socket */
+    if (response.status === 101)
+        return response;
+    if (isHoneyResponse(response)) {
+        if (init.body === undefined)
+            return response.derive({ headers: init.headers, status: init.status });
+        const raw = bufferedBody(init.body);
+        if (raw !== undefined) {
+            return response.derive({ headers: init.headers, raw, status: init.status, stream: null });
+        }
+    }
+    const status = init.status ?? response.status;
+    return new Response(init.body === undefined ? response.body : init.body, {
+        /* left out, the headers carry over: a status change must not drop them */
+        headers: headersToInit(init.headers ?? response.headers),
+        status,
+        statusText: status === response.status ? response.statusText : undefined,
+    });
+}

package/dist/response/cache-control.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `cacheControl()` (A4): the `Cache-Control` header for GET and HEAD answers, and time-based
+ * conditional GET. An answer's `Last-Modified` (its own, or `lastModified`'s, in whole seconds)
+ * meets the request's `If-Modified-Since`: not modified since is a 304. A request carrying
+ * `If-None-Match` is judged by that alone (RFC 9110 §13.1.3), so `If-Modified-Since` is ignored.
+ */
+import { type MiddlewareFn } from "../middleware/middleware.ts";
+export type CacheControlOptions = {
+    immutable?: boolean;
+    /** Seconds a response stays fresh (`max-age`). */
+    maxAge?: number;
+    mustRevalidate?: boolean;
+    noCache?: boolean;
+    noStore?: boolean;
+    private?: boolean;
+    public?: boolean;
+    /** Seconds a shared cache keeps it fresh (`s-maxage`). */
+    sMaxAge?: number;
+    /** Seconds a stale response may be served while it revalidates. */
+    staleWhileRevalidate?: number;
+    /** When the answer last changed, for an answer that does not say: sent in whole seconds. */
+    lastModified?: ((ctx: {
+        req: Request;
+    }) => Date | null | undefined) | undefined;
+};
+/** `date` as an HTTP-date (IMF-fixdate), in whole seconds. */
+export declare function httpDate(date: Date | number): string;
+export declare function cacheControl(options: CacheControlOptions): MiddlewareFn<{
+    req: Request;
+}>;

package/dist/response/cache-control.js

@@ -0,0 +1,74 @@
+/**
+ * `cacheControl()` (A4): the `Cache-Control` header for GET and HEAD answers, and time-based
+ * conditional GET. An answer's `Last-Modified` (its own, or `lastModified`'s, in whole seconds)
+ * meets the request's `If-Modified-Since`: not modified since is a 304. A request carrying
+ * `If-None-Match` is judged by that alone (RFC 9110 §13.1.3), so `If-Modified-Since` is ignored.
+ */
+import { namedMiddleware } from "../middleware/middleware.js";
+import { notModified } from "./etag.js";
+import { withHeaders } from "./with-headers.js";
+/** `date` as an HTTP-date (IMF-fixdate), in whole seconds. */
+export function httpDate(date) {
+    return new Date(date).toUTCString();
+}
+/** A duration directive, refused unless a whole, non-negative number of seconds. */
+function seconds(name, value) {
+    if (value === undefined)
+        return null;
+    if (!Number.isInteger(value) || value < 0) {
+        throw new TypeError(`cacheControl(): ${name} must be a whole, non-negative number of seconds`);
+    }
+    return `${name}=${value}`;
+}
+/** The header value, in one fixed order; `null` when no directive is given. */
+function directives(o) {
+    if (o.public === true && o.private === true)
+        throw new TypeError("cacheControl(): public and private contradict");
+    const parts = [
+        o.public === true ? "public" : null,
+        o.private === true ? "private" : null,
+        o.noCache === true ? "no-cache" : null,
+        o.noStore === true ? "no-store" : null,
+        seconds("max-age", o.maxAge),
+        seconds("s-maxage", o.sMaxAge),
+        o.mustRevalidate === true ? "must-revalidate" : null,
+        seconds("stale-while-revalidate", o.staleWhileRevalidate),
+        o.immutable === true ? "immutable" : null,
+    ].filter((part) => part !== null);
+    return parts.length === 0 ? null : parts.join(", ");
+}
+/** Whether the answer, last modified at `lastModified`, has not changed since `ifModifiedSince`. */
+function unmodifiedSince(lastModified, ifModifiedSince) {
+    if (lastModified === null)
+        return false;
+    const since = Date.parse(ifModifiedSince);
+    const modified = Date.parse(lastModified);
+    return !Number.isNaN(since) && !Number.isNaN(modified) && modified <= since;
+}
+export function cacheControl(options) {
+    const header = directives(options);
+    const lastModified = options.lastModified;
+    if (header === null && lastModified === undefined) {
+        throw new TypeError("cacheControl(): give at least one directive or lastModified");
+    }
+    return namedMiddleware("cacheControl", async (ctx, next) => {
+        const method = ctx.req.method;
+        if (method !== "GET" && method !== "HEAD")
+            return next();
+        const response = await next();
+        const status = response.status;
+        if (status !== 304 && (status < 200 || status > 299))
+            return response;
+        const modified = status === 200 && lastModified !== undefined ? lastModified(ctx) : null;
+        const dressed = withHeaders(response, (headers) => {
+            if (header !== null && !headers.has("cache-control"))
+                headers.set("cache-control", header);
+            if (modified != null && !headers.has("last-modified"))
+                headers.set("last-modified", httpDate(modified));
+        });
+        const since = ctx.req.headers.get("if-modified-since");
+        if (status !== 200 || since === null || ctx.req.headers.has("if-none-match"))
+            return dressed;
+        return unmodifiedSince(dressed.headers.get("last-modified"), since) ? notModified(dressed) : dressed;
+    });
+}

package/dist/response/etag.d.ts

@@ -0,0 +1,15 @@
+import { type MiddlewareFn } from "../middleware/middleware.ts";
+export type ETagOptions = {
+    /** A weak validator (`W/"…"`, the default), or a strong one with `false`. */
+    weak?: boolean;
+};
+/** Whether an `If-None-Match` value (`*` or a list of tags) matches `current`, compared weakly. */
+export declare function ifNoneMatchHits(header: string | null, current: string): boolean;
+/**
+ * `response` as a 304: its headers kept (validators, Cache-Control, Vary among them), no body. A
+ * body honey did not keep is cancelled unread, so a producer never starts.
+ */
+export declare function notModified(response: Response): Response;
+export declare function etag(options?: ETagOptions): MiddlewareFn<{
+    req: Request;
+}>;

package/dist/response/etag.js

@@ -0,0 +1,83 @@
+/**
+ * `etag()`: a validator for every GET or HEAD answered 200 with a body honey can hash, and the 304
+ * a matching `If-None-Match` earns (RFC 9110 §8.8.3, §13.1.2). A body honey built is hashed from
+ * the raw body it kept and handed on unread; a foreign body of declared length is read and
+ * rebuilt; a stream is never buffered (it may never end). A validator the handler set is never
+ * replaced.
+ */
+import { bodyKind, discardBody } from "../input/body-kind.js";
+import { namedMiddleware } from "../middleware/middleware.js";
+import { rawBodyOf, replaceResponse } from "./builder.js";
+import { withHeaders } from "./with-headers.js";
+// per-process-constant: text-codec
+const encoder = /* @__PURE__ */ new TextEncoder();
+/** Base64url of the first 16 bytes of the SHA-256 of `bytes`: 22 characters, no padding. */
+async function digest(bytes) {
+    const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes), 0, 16);
+    let binary = "";
+    for (const byte of hash)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+/* an entity tag, weak or strong: a quoted string may hold a comma */
+const ENTITY_TAG = /(?:W\/)?"[^"]*"/g;
+/* the weakness indicator: weak comparison (RFC 9110 §8.8.3.2) ignores it */
+const WEAK_PREFIX = /^W\//;
+/** The opaque tag, without its weakness indicator. */
+function opaque(tag) {
+    return tag.replace(WEAK_PREFIX, "");
+}
+/** Whether an `If-None-Match` value (`*` or a list of tags) matches `current`, compared weakly. */
+export function ifNoneMatchHits(header, current) {
+    if (header === null)
+        return false;
+    if (header.trim() === "*")
+        return true;
+    const target = opaque(current.trim());
+    for (const tag of header.match(ENTITY_TAG) ?? []) {
+        if (opaque(tag) === target)
+            return true;
+    }
+    return false;
+}
+/**
+ * `response` as a 304: its headers kept (validators, Cache-Control, Vary among them), no body. A
+ * body honey did not keep is cancelled unread, so a producer never starts.
+ */
+export function notModified(response) {
+    discardBody(response);
+    return replaceResponse(response, { body: null, status: 304 });
+}
+/** The bytes to hash, read from the raw body honey kept or from a foreign body of declared length. */
+async function bytesOf(response) {
+    const raw = rawBodyOf(response);
+    if (raw === null)
+        return { bytes: new Uint8Array(await response.arrayBuffer()), read: true };
+    return { bytes: typeof raw === "string" ? encoder.encode(raw) : raw, read: false };
+}
+export function etag(options = {}) {
+    const weak = options.weak !== false;
+    return namedMiddleware("etag", async (ctx, next) => {
+        const method = ctx.req.method;
+        if (method !== "GET" && method !== "HEAD")
+            return next();
+        const response = await next();
+        /* only a 200 has a selected representation a 304 can stand in for */
+        if (response.status !== 200)
+            return response;
+        const ifNoneMatch = ctx.req.headers.get("if-none-match");
+        const own = response.headers.get("etag");
+        if (own !== null)
+            return ifNoneMatchHits(ifNoneMatch, own) ? notModified(response) : response;
+        if (bodyKind(response) !== "buffered")
+            return response;
+        const { bytes, read } = await bytesOf(response);
+        /* a foreign body was read to hash it: the answer goes on with a fresh one */
+        const whole = read ? replaceResponse(response, { body: bytes }) : response;
+        if (bytes.byteLength === 0)
+            return whole;
+        const tag = weak ? `W/"${await digest(bytes)}"` : `"${await digest(bytes)}"`;
+        const tagged = withHeaders(whole, (headers) => headers.set("etag", tag));
+        return ifNoneMatchHits(ifNoneMatch, tag) ? notModified(tagged) : tagged;
+    });
+}

package/dist/response/media-type.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The media-type parser (RFC 9110 §8.3.1) for every place that reads a Content-Type: request
+ * body parsing, its content-type check, bodyLimit and negotiation. Type, subtype and parameter
+ * names are case-insensitive, so they are lowercased; parameter values keep their case.
+ */
+export type MediaType = {
+    /** `type/subtype`, lowercased, without parameters */
+    readonly essence: string;
+    /** parameters by lowercased name, the first of a repeated name kept; no prototype */
+    readonly params: Readonly<Record<string, string>>;
+    readonly subtype: string;
+    /** the structured-syntax suffix (`json` for `application/vnd.api+json`), or `null` */
+    readonly suffix: string | null;
+    readonly type: string;
+};
+/** The body parser a request's media type selects. */
+export type BodyParser = "json" | "multipart" | "urlencoded";
+/**
+ * Parse a Content-Type (or any media type). An absent or malformed value is `null`, so a caller
+ * never mistakes `application/jsonx` or a bare `json` for JSON.
+ */
+export declare function parseMediaType(value: string | null | undefined): MediaType | null;
+/** `application/json`, or a `+json` structured-syntax type such as `application/problem+json`. */
+export declare function isJsonMediaType(mt: MediaType | null): boolean;
+/** A text-like body: `text/*`, `application/xml`, or a `+xml` type. */
+export declare function isTextMediaType(mt: MediaType | null): boolean;
+/** The body parser a request Content-Type selects, or `null` when none applies. */
+export declare function bodyParserFor(contentType: string | null | undefined): BodyParser | null;

package/dist/response/media-type.js

@@ -0,0 +1,97 @@
+/**
+ * The media-type parser (RFC 9110 §8.3.1) for every place that reads a Content-Type: request
+ * body parsing, its content-type check, bodyLimit and negotiation. Type, subtype and parameter
+ * names are case-insensitive, so they are lowercased; parameter values keep their case.
+ */
+/* RFC 9110 token characters */
+const TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+/** Spaces, tabs and `;` between parameters. */
+function skipSeparators(value, i) {
+    let at = i;
+    while (at < value.length && (value[at] === " " || value[at] === "\t" || value[at] === ";"))
+        at++;
+    return at;
+}
+/** A quoted-string starting after its opening quote: its unescaped text and where it ended. */
+function quoted(value, start) {
+    let text = "";
+    let i = start;
+    while (i < value.length && value[i] !== '"') {
+        if (value[i] === "\\" && i + 1 < value.length)
+            i++;
+        text += value[i];
+        i++;
+    }
+    return { end: i + 1, text };
+}
+/** `; name=value` pairs from `start`; a malformed pair is skipped, as browsers and undici do. */
+function parseParams(value, start, out) {
+    let i = skipSeparators(value, start);
+    while (i < value.length) {
+        const eq = value.indexOf("=", i);
+        const semi = value.indexOf(";", i);
+        if (eq === -1 || (semi !== -1 && semi < eq)) {
+            i = semi === -1 ? value.length : skipSeparators(value, semi + 1);
+            continue;
+        }
+        const name = value.slice(i, eq).trim().toLowerCase();
+        let text;
+        let next;
+        if (value[eq + 1] === '"') {
+            const q = quoted(value, eq + 2);
+            text = q.text;
+            next = value.indexOf(";", q.end);
+        }
+        else {
+            next = value.indexOf(";", eq + 1);
+            text = (next === -1 ? value.slice(eq + 1) : value.slice(eq + 1, next)).trim();
+        }
+        if (TOKEN.test(name) && !Object.hasOwn(out, name))
+            out[name] = text;
+        i = next === -1 ? value.length : skipSeparators(value, next + 1);
+    }
+}
+/**
+ * Parse a Content-Type (or any media type). An absent or malformed value is `null`, so a caller
+ * never mistakes `application/jsonx` or a bare `json` for JSON.
+ */
+export function parseMediaType(value) {
+    if (value === null || value === undefined)
+        return null;
+    const semi = value.indexOf(";");
+    const head = (semi === -1 ? value : value.slice(0, semi)).trim();
+    const slash = head.indexOf("/");
+    if (slash === -1)
+        return null;
+    const type = head.slice(0, slash).toLowerCase();
+    const subtype = head.slice(slash + 1).toLowerCase();
+    if (!TOKEN.test(type) || !TOKEN.test(subtype))
+        return null;
+    const plus = subtype.lastIndexOf("+");
+    const suffix = plus > 0 && plus < subtype.length - 1 ? subtype.slice(plus + 1) : null;
+    const params = Object.create(null);
+    if (semi !== -1)
+        parseParams(value, semi + 1, params);
+    return { essence: `${type}/${subtype}`, params, subtype, suffix, type };
+}
+/** `application/json`, or a `+json` structured-syntax type such as `application/problem+json`. */
+export function isJsonMediaType(mt) {
+    return mt !== null && (mt.essence === "application/json" || mt.suffix === "json");
+}
+/** A text-like body: `text/*`, `application/xml`, or a `+xml` type. */
+export function isTextMediaType(mt) {
+    return mt !== null && (mt.type === "text" || mt.essence === "application/xml" || mt.suffix === "xml");
+}
+/** The body parser a request Content-Type selects, or `null` when none applies. */
+export function bodyParserFor(contentType) {
+    const mt = parseMediaType(contentType);
+    if (mt === null)
+        return null;
+    if (isJsonMediaType(mt))
+        return "json";
+    if (mt.essence === "multipart/form-data")
+        return "multipart";
+    if (mt.essence === "application/x-www-form-urlencoded")
+        return "urlencoded";
+    return null;
+}

package/dist/response/out-headers.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `HoneyOutHeaders`: a `Headers` view over the plain map a buffered response was built with.
+ * `get`/`has`/`getSetCookie`, plain iteration, `set` and `delete` use the map; a real `Headers` is
+ * built only when something appends or walks it through the native API. The map keys are lower-case, as Fetch keeps them.
+ */
+export type HeaderMap = Record<string, string | string[]>;
+/** Copy native `Headers` into a map, keeping each `Set-Cookie` as its own entry. */
+export declare function headersToRecord(headers: Headers): HeaderMap;
+export declare class HoneyOutHeaders {
+    #private;
+    constructor(map: HeaderMap);
+    append(name: string, value: string): void;
+    /** Removes `name`; on the plain map until something used the native API. */
+    delete(name: string): void;
+    get(name: string): string | null;
+    getSetCookie(): string[];
+    has(name: string): boolean;
+    /**
+     * Sets `name` on the plain map, validated and normalized as Fetch does, until something used the
+     * native API: a middleware's header write never builds native Headers.
+     */
+    set(name: string, value: string): void;
+    forEach(callback: (value: string, key: string, parent: Headers) => void, thisArg?: unknown): void;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    entries(): IterableIterator<[string, string]>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    get [Symbol.toStringTag](): string;
+    /** The headers as a plain map: the original map until something wrote through the native API. */
+    toRecord(): HeaderMap;
+}