@sproutboat/runtime 0.17.1 → 0.18.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @sproutboat/runtime
 
+## 0.18.0
+
+### Minor Changes
+
+- 145e3dc: `HTMLRewriter`, matching Cloudflare's API and lol-html's output.
+  
+  - **Handlers:** `on(selector, { element, text, comments })` and `onDocument({ doctype, text, comments, end })`.
+  - **Element methods:** attributes, `tagName`, `before`/`after`/`prepend`/`append`/`replace`/`setInnerContent` with `{ html }`, `remove`, `removeAndKeepContent` and `onEndTag`.
+  - **Selectors:** type, `*`, `#id`, `.class`, the attribute operators, descendant and child combinators, and lists.
+  - **Async:** handlers may be async.
+  
+  It reads the whole body before rewriting rather than streaming it. 37 cases are checked against Bun's lol-html-based HTMLRewriter, including where lol-html keeps attributes byte for byte and does not imply end tags.
+- 2541458: More of the Web platform, from sproutd's W2 conformance suite against workerd:
+  
+  - `CompressionStream` and `DecompressionStream` for `gzip`, `deflate` and `deflate-raw`, in JavaScript, because the native runtime links no zlib. Output decompresses with zlib, and zlib's output (stored, fixed and dynamic blocks) decompresses here. A corrupt or truncated input errors with a `TypeError`.
+  - A `Response` or `Request` whose body is a `ReadableStream` is read to the end by `text()`, `json()`, `arrayBuffer()` and `blob()`. Before, these returned `"[object ReadableStream]"`. Chunks must be bytes, as in workerd.
+  - `JSON.parse` applies its reviver: children first, `undefined` deletes the property, and `this` is the holder.
+
+### Patch Changes
+
+- 116ee47: sproutd builds the runtime again. In split builds Porffor cannot type a prelude function's parameters, and the compression checksums' `let c = ~crc` compiled to C that assigned a boxed value to a number. The checksums now start from the parameter itself.
+
 ## 0.17.1
 
 ### Patch Changes

package/WEB_STREAMS.md

@@ -14,8 +14,14 @@ the status and headers go out at once and each chunk is written as it is produce
 (chunked encoding), so Server-Sent Events and long responses work. Chunks must be bytes.
 Hosts that do not stream yet (sproutd's workers) read the stream to the end and send it
 buffered, at most 32 MiB. Request bodies and outbound fetch remain buffered.
-TextEncoderStream and TextDecoderStream are included; CompressionStream and
-DecompressionStream are not.
+TextEncoderStream and TextDecoderStream are included, and CompressionStream and
+DecompressionStream ("gzip", "deflate", "deflate-raw") in JavaScript, since the native
+runtime links no zlib. Compression writes one fixed-Huffman block per chunk as it arrives
+(close to zlib on text: 252 bytes against 221 for 22.5 KB); decompression inflates all
+block types once the input ends and checks the CRC-32 or Adler-32. Response and Request
+bodies that are ReadableStreams are read by text(), json(), arrayBuffer() and blob(), and
+their chunks must be bytes, as in workerd. A body given as a string, bytes or a Blob is
+still exposed as that value, not as a ReadableStream.
 BYOB buffer detachment requires transfer support from the underlying engine;
 the polyfill cannot supply that engine primitive. Full Web Platform Tests
 conformance has not been established for Porffor.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sproutboat/runtime",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "license": "MIT",
   "type": "module",
   "repository": {

package/src/native-fetch-prelude.js

@@ -2305,6 +2305,706 @@
 /* oxlint-enable */
 // END WEB STREAMS
 
+// COMPRESSION STREAMS: CompressionStream and DecompressionStream ("gzip", "deflate",
+// "deflate-raw"), in JavaScript: the native runtime links no zlib. Compression is LZ77 with
+// fixed Huffman codes, one block per written chunk, so output follows input as it arrives;
+// it is smaller than the input for text, not as small as zlib's. Decompression inflates
+// stored, fixed and dynamic blocks once the input ends, and checks the CRC-32 or Adler-32.
+// A malformed or truncated stream errors with a TypeError, as in workerd.
+
+const __sbCrcTable = (() => {
+  const table = new Int32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c;
+  }
+  return table;
+})();
+// c starts as the parameter itself. In split builds (sproutd) a prelude function may be
+// called from app code, so Porffor cannot type its parameters; it typed c as a number
+// from the loop but boxed ~crc (crc might be a BigInt), and the C did not compile.
+function __sbCrc32(crc, bytes) {
+  let c = crc;
+  c = ~c;
+  for (let i = 0; i < bytes.length; i++) c = __sbCrcTable[(c ^ bytes[i]) & 255] ^ (c >>> 8);
+  return ~c >>> 0;
+}
+function __sbAdler32(adler, bytes) {
+  let a = adler, b = adler;
+  a = a & 0xffff;
+  b = b >>> 16;
+  for (let i = 0; i < bytes.length; ) {
+    const end = Math.min(i + 3800, bytes.length);
+    for (; i < end; i++) { a += bytes[i]; b += a; }
+    a %= 65521; b %= 65521;
+  }
+  return ((b << 16) | a) >>> 0;
+}
+
+// Length and distance codes (RFC 1951 3.2.5).
+const __sbLenBase = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const __sbLenExtra = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+const __sbDistBase = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const __sbDistExtra = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+
+class __sbBitWriter {
+  constructor() { this.out = new Uint8Array(1024); this.length = 0; this.bits = 0; this.count = 0; }
+  byte(b) {
+    if (this.length == this.out.length) { const grown = new Uint8Array(this.out.length * 2); grown.set(this.out); this.out = grown; }
+    this.out[this.length++] = b;
+  }
+  // Values go out least significant bit first.
+  write(value, n) {
+    this.bits |= value << this.count;
+    this.count += n;
+    while (this.count >= 8) { this.byte(this.bits & 255); this.bits >>>= 8; this.count -= 8; }
+  }
+  // Huffman codes go out most significant bit first.
+  code(code, n) {
+    let reversed = 0;
+    for (let i = 0; i < n; i++) { reversed = (reversed << 1) | (code & 1); code >>= 1; }
+    this.write(reversed, n);
+  }
+  align() { if (this.count > 0) { this.byte(this.bits & 255); this.bits = 0; this.count = 0; } }
+  take() { const out = this.out.slice(0, this.length); this.length = 0; return out; }
+}
+function __sbFixedLiteral(w, v) {
+  if (v < 144) w.code(0x30 + v, 8);
+  else if (v < 256) w.code(0x190 + v - 144, 9);
+  else if (v < 280) w.code(v - 256, 7);
+  else w.code(0xc0 + v - 280, 8);
+}
+// One fixed-Huffman block for data, matching within it (a hash chain of 3-byte prefixes).
+function __sbDeflateBlock(w, data, last) {
+  w.write(last ? 1 : 0, 1);
+  w.write(1, 2);
+  const head = new Int32Array(1 << 15).fill(-1);
+  const prev = new Int32Array(Math.max(data.length, 1));
+  const hash = (i) => ((data[i] << 10) ^ (data[i + 1] << 5) ^ data[i + 2]) & 0x7fff;
+  let i = 0;
+  while (i < data.length) {
+    let bestLen = 0, bestDist = 0;
+    if (i + 2 < data.length) {
+      const h = hash(i);
+      let candidate = head[h], chain = 32;
+      while (candidate >= 0 && i - candidate <= 32768 && chain-- > 0) {
+        let len = 0;
+        const max = Math.min(258, data.length - i);
+        while (len < max && data[candidate + len] == data[i + len]) len++;
+        if (len > bestLen) { bestLen = len; bestDist = i - candidate; if (len == max) break; }
+        candidate = prev[candidate];
+      }
+      prev[i] = head[h];
+      head[h] = i;
+    }
+    if (bestLen >= 3) {
+      let code = 0;
+      while (code < 28 && __sbLenBase[code + 1] <= bestLen) code++;
+      __sbFixedLiteral(w, 257 + code);
+      if (__sbLenExtra[code]) w.write(bestLen - __sbLenBase[code], __sbLenExtra[code]);
+      let dcode = 0;
+      while (dcode < 29 && __sbDistBase[dcode + 1] <= bestDist) dcode++;
+      w.code(dcode, 5);
+      if (__sbDistExtra[dcode]) w.write(bestDist - __sbDistBase[dcode], __sbDistExtra[dcode]);
+      // Index the skipped positions so later matches can start inside this one.
+      for (let k = 1; k < bestLen && i + k + 2 < data.length; k++) { const h = hash(i + k); prev[i + k] = head[h]; head[h] = i + k; }
+      i += bestLen;
+    } else {
+      __sbFixedLiteral(w, data[i]);
+      i++;
+    }
+  }
+  __sbFixedLiteral(w, 256);
+}
+
+class __sbHuffman {
+  // Canonical code from code lengths, decoded bit by bit (RFC 1951 3.2.2).
+  constructor(lengths) {
+    this.counts = new Int32Array(16);
+    this.symbols = new Int32Array(lengths.length);
+    for (let i = 0; i < lengths.length; i++) this.counts[lengths[i]]++;
+    this.counts[0] = 0;
+    const offsets = new Int32Array(16);
+    for (let i = 1; i < 16; i++) offsets[i] = offsets[i - 1] + this.counts[i - 1];
+    for (let i = 0; i < lengths.length; i++) if (lengths[i]) this.symbols[offsets[lengths[i]]++] = i;
+  }
+}
+class __sbBitReader {
+  constructor(data, at) { this.data = data; this.at = at; this.bits = 0; this.count = 0; }
+  need(n) {
+    while (this.count < n) {
+      if (this.at >= this.data.length) throw new TypeError("Decompression failed: unexpected end of data");
+      this.bits |= this.data[this.at++] << this.count;
+      this.count += 8;
+    }
+  }
+  read(n) {
+    if (n == 0) return 0;
+    this.need(n);
+    const v = this.bits & ((1 << n) - 1);
+    this.bits >>>= n;
+    this.count -= n;
+    return v;
+  }
+  decode(h) {
+    let code = 0, first = 0, index = 0;
+    for (let len = 1; len < 16; len++) {
+      code |= this.read(1);
+      const count = h.counts[len];
+      if (code - count < first) return h.symbols[index + (code - first)];
+      index += count;
+      first += count;
+      first <<= 1;
+      code <<= 1;
+    }
+    throw new TypeError("Decompression failed: invalid Huffman code");
+  }
+  // The byte after the last bit read; stored blocks and trailers start on a byte.
+  byteAt() { return this.at - (this.count >> 3); }
+  align() { this.bits = 0; this.count = 0; }
+}
+const __sbFixedLit = (() => {
+  const l = new Uint8Array(288);
+  for (let i = 0; i < 288; i++) l[i] = i < 144 ? 8 : i < 256 ? 9 : i < 280 ? 7 : 8;
+  return new __sbHuffman(l);
+})();
+const __sbFixedDist = new __sbHuffman(new Uint8Array(30).fill(5));
+const __sbClOrder = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function __sbGrow(out, used, n) {
+  let size = out.length * 2;
+  while (size < used + n) size *= 2;
+  const grown = new Uint8Array(size);
+  grown.set(out.subarray(0, used));
+  return grown;
+}
+// Inflates raw deflate data from at; answers the output and the byte after the last block.
+function __sbInflate(data, at) {
+  const r = new __sbBitReader(data, at);
+  // Not named length: Porffor loses writes to a local of that name (Alpha 18).
+  let out = new Uint8Array(Math.max(1024, data.length * 4));
+  let used = 0;
+  let last = 0;
+  while (!last) {
+    last = r.read(1);
+    const type = r.read(2);
+    if (type == 0) {
+      r.align();
+      const p = r.at;
+      if (p + 4 > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+      const len = data[p] | (data[p + 1] << 8), nlen = data[p + 2] | (data[p + 3] << 8);
+      if ((len ^ 0xffff) != nlen) throw new TypeError("Decompression failed: invalid stored block");
+      if (p + 4 + len > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+      if (used + len > out.length) out = __sbGrow(out, used, len);
+      out.set(data.subarray(p + 4, p + 4 + len), used); used += len;
+      r.at = p + 4 + len;
+      continue;
+    }
+    let lit = __sbFixedLit, dist = __sbFixedDist;
+    if (type == 2) {
+      const hlit = r.read(5) + 257, hdist = r.read(5) + 1, hclen = r.read(4) + 4;
+      const cl = new Uint8Array(19);
+      for (let i = 0; i < hclen; i++) cl[__sbClOrder[i]] = r.read(3);
+      const clh = new __sbHuffman(cl);
+      const lengths = new Uint8Array(hlit + hdist);
+      for (let i = 0; i < hlit + hdist; ) {
+        const sym = r.decode(clh);
+        if (sym < 16) lengths[i++] = sym;
+        else {
+          let repeat = 0, value = 0;
+          if (sym == 16) { if (i == 0) throw new TypeError("Decompression failed: invalid code lengths"); value = lengths[i - 1]; repeat = 3 + r.read(2); }
+          else if (sym == 17) repeat = 3 + r.read(3);
+          else repeat = 11 + r.read(7);
+          if (i + repeat > hlit + hdist) throw new TypeError("Decompression failed: invalid code lengths");
+          while (repeat--) lengths[i++] = value;
+        }
+      }
+      lit = new __sbHuffman(lengths.subarray(0, hlit));
+      dist = new __sbHuffman(lengths.subarray(hlit));
+    } else if (type != 1) throw new TypeError("Decompression failed: invalid block type");
+    for (;;) {
+      const sym = r.decode(lit);
+      if (sym < 256) { if (used + 1 > out.length) out = __sbGrow(out, used, 1); out[used++] = sym; continue; }
+      if (sym == 256) break;
+      const code = sym - 257;
+      if (code >= 29) throw new TypeError("Decompression failed: invalid used code");
+      const len = __sbLenBase[code] + r.read(__sbLenExtra[code]);
+      const dcode = r.decode(dist);
+      if (dcode >= 30) throw new TypeError("Decompression failed: invalid distance code");
+      const d = __sbDistBase[dcode] + r.read(__sbDistExtra[dcode]);
+      if (d > used) throw new TypeError("Decompression failed: distance too far back");
+      if (used + len > out.length) out = __sbGrow(out, used, len);
+      for (let k = 0; k < len; k++) { out[used] = out[used - d]; used++; }
+    }
+  }
+  return { out: out.slice(0, used), end: r.byteAt() };
+}
+
+function __sbFormat(format, what) {
+  const f = String(format);
+  if (f != "gzip" && f != "deflate" && f != "deflate-raw") throw new TypeError("Unsupported " + what + " format: " + f);
+  return f;
+}
+function __sbChunkBytes(chunk) {
+  if (chunk instanceof Uint8Array) return chunk;
+  if (chunk instanceof ArrayBuffer) return new Uint8Array(chunk);
+  if (ArrayBuffer.isView(chunk)) return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+}
+
+class CompressionStream {
+  constructor(format) {
+    const kind = __sbFormat(format, "compression");
+    const w = new __sbBitWriter();
+    let check = kind == "deflate" ? 1 : 0, size = 0;
+    if (kind == "gzip") for (const b of [0x1f, 0x8b, 8, 0, 0, 0, 0, 0, 0, 0xff]) w.byte(b);
+    else if (kind == "deflate") { w.byte(0x78); w.byte(0x9c); }
+    const t = new TransformStream({
+      transform(chunk, controller) {
+        const bytes = __sbChunkBytes(chunk);
+        if (!bytes.length) return;
+        if (kind == "gzip") check = __sbCrc32(check, bytes);
+        else if (kind == "deflate") check = __sbAdler32(check, bytes);
+        size = (size + bytes.length) >>> 0;
+        __sbDeflateBlock(w, bytes, false);
+        const out = w.take();
+        if (out.length) controller.enqueue(out);
+      },
+      flush(controller) {
+        __sbDeflateBlock(w, new Uint8Array(0), true);
+        w.align();
+        if (kind == "gzip") for (const v of [check, size]) for (let k = 0; k < 4; k++) w.byte((v >>> (8 * k)) & 255);
+        else if (kind == "deflate") for (let k = 3; k >= 0; k--) w.byte((check >>> (8 * k)) & 255);
+        controller.enqueue(w.take());
+      },
+    });
+    this._t = t;
+  }
+  get readable() { return this._t.readable; }
+  get writable() { return this._t.writable; }
+}
+
+class DecompressionStream {
+  constructor(format) {
+    const kind = __sbFormat(format, "decompression");
+    const parts = [];
+    let total = 0;
+    const t = new TransformStream({
+      transform(chunk) { const bytes = __sbChunkBytes(chunk); parts.push(bytes.slice()); total += bytes.length; },
+      flush(controller) {
+        const data = new Uint8Array(total);
+        let at = 0;
+        for (const p of parts) { data.set(p, at); at += p.length; }
+        let start = 0;
+        if (kind == "gzip") {
+          if (data.length < 18 || data[0] != 0x1f || data[1] != 0x8b || data[2] != 8) throw new TypeError("Decompression failed: not gzip data");
+          const flags = data[3];
+          start = 10;
+          if (flags & 4) start += 2 + (data[start] | (data[start + 1] << 8));
+          if (flags & 8) { while (start < data.length && data[start]) start++; start++; }
+          if (flags & 16) { while (start < data.length && data[start]) start++; start++; }
+          if (flags & 2) start += 2;
+        } else if (kind == "deflate") {
+          if (data.length < 6 || (data[0] & 15) != 8 || ((data[0] << 8) | data[1]) % 31 != 0 || data[1] & 32) throw new TypeError("Decompression failed: not zlib data");
+          start = 2;
+        }
+        const { out, end } = __sbInflate(data, start);
+        if (kind == "gzip") {
+          if (end + 8 > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+          const crc = (data[end] | (data[end + 1] << 8) | (data[end + 2] << 16) | (data[end + 3] << 24)) >>> 0;
+          const isize = (data[end + 4] | (data[end + 5] << 8) | (data[end + 6] << 16) | (data[end + 7] << 24)) >>> 0;
+          if (crc != __sbCrc32(0, out) || isize != out.length >>> 0) throw new TypeError("Decompression failed: gzip checksum mismatch");
+        } else if (kind == "deflate") {
+          if (end + 4 > data.length) throw new TypeError("Decompression failed: unexpected end of data");
+          const adler = ((data[end] << 24) | (data[end + 1] << 16) | (data[end + 2] << 8) | data[end + 3]) >>> 0;
+          if (adler != __sbAdler32(1, out)) throw new TypeError("Decompression failed: deflate checksum mismatch");
+        }
+        if (out.length) controller.enqueue(out);
+      },
+    });
+    this._t = t;
+  }
+  get readable() { return this._t.readable; }
+  get writable() { return this._t.writable; }
+}
+// Static installs, so app code sees the names when it is compiled apart (see streams-entry.js).
+if (globalThis.CompressionStream == null) globalThis.CompressionStream = CompressionStream;
+if (globalThis.DecompressionStream == null) globalThis.DecompressionStream = DecompressionStream;
+// END COMPRESSION STREAMS
+
+// HTML REWRITER: Cloudflare's HTMLRewriter in JavaScript (workerd uses lol-html). It reads
+// the whole body, then tokenizes it once: elements, text and comments are matched against
+// the selectors given to on() and onDocument(), handlers run in document order (and may be
+// async), and the changes they ask for are written as the document is re-emitted.
+// Selectors: type, *, #id, .class, [attr], [attr=v], [attr~=v], [attr^=v], [attr$=v],
+// [attr*=v], [attr|=v], descendant and child combinators, and lists. Not :nth-child and
+// other pseudo-classes, which throw a TypeError on on(), as an unsupported selector does.
+
+const __sbVoidTags = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+const __sbRawTextTags = new Set(["script", "style", "textarea", "title", "xmp", "iframe", "noembed", "noframes", "plaintext"]);
+function __sbEscapeText(s) { return String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"); }
+function __sbEscapeAttr(s) { return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;"); }
+function __sbContent(content, options) { return options && options.html ? String(content) : __sbEscapeText(content); }
+
+// One compound selector: [{ tag, id, classes, attrs }] joined by combinators.
+function __sbParseSelector(text) {
+  const list = [];
+  for (const part of String(text).split(",")) {
+    const steps = [];
+    let s = part.trim(), combinator = " ";
+    if (!s) throw new TypeError("Invalid selector: " + text);
+    while (s.length) {
+      const step = { tag: null, id: null, classes: [], attrs: [], combinator };
+      let m;
+      let star = false;
+      if ((m = /^(\*|[a-zA-Z][\w-]*)/.exec(s))) { if (m[1] != "*") step.tag = m[1].toLowerCase(); else star = true; s = s.slice(m[0].length); }
+      for (;;) {
+        if ((m = /^#([\w-]+)/.exec(s))) { step.id = m[1]; s = s.slice(m[0].length); continue; }
+        if ((m = /^\.([\w-]+)/.exec(s))) { step.classes.push(m[1]); s = s.slice(m[0].length); continue; }
+        if ((m = /^\[\s*([\w:-]+)\s*(?:([~^$*|]?=)\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+))\s*)?(i)?\s*\]/.exec(s))) {
+          step.attrs.push({ name: m[1].toLowerCase(), op: m[2] || null, value: m[3] ?? m[4] ?? m[5] ?? "", ci: !!m[6] });
+          s = s.slice(m[0].length);
+          continue;
+        }
+        break;
+      }
+      if (s.length && s[0] == ":") throw new TypeError("Unsupported pseudo-class selector: " + text);
+      if (step.tag == null && step.id == null && !step.classes.length && !step.attrs.length && !star)
+        throw new TypeError("Invalid selector: " + text);
+      steps.push(step);
+      const ws = /^\s*/.exec(s)[0];
+      s = s.slice(ws.length);
+      if (!s.length) break;
+      if (s[0] == ">") { combinator = ">"; s = s.slice(1).trimStart(); }
+      else if (ws.length) combinator = " ";
+      else throw new TypeError("Invalid selector: " + text);
+    }
+    list.push(steps);
+  }
+  return list;
+}
+function __sbStepMatches(step, el) {
+  if (step.tag != null && step.tag != el.tag) return false;
+  if (step.id != null && el.attr("id") !== step.id) return false;
+  if (step.classes.length) {
+    const have = (el.attr("class") || "").split(/\s+/);
+    for (const c of step.classes) if (!have.includes(c)) return false;
+  }
+  for (const a of step.attrs) {
+    let v = el.attr(a.name);
+    if (v == null) return false;
+    if (!a.op) continue;
+    let want = a.value;
+    if (a.ci) { v = v.toLowerCase(); want = want.toLowerCase(); }
+    if (a.op == "=" && v !== want) return false;
+    if (a.op == "~=" && !v.split(/\s+/).includes(want)) return false;
+    if (a.op == "^=" && (!want || !v.startsWith(want))) return false;
+    if (a.op == "$=" && (!want || !v.endsWith(want))) return false;
+    if (a.op == "*=" && (!want || !v.includes(want))) return false;
+    if (a.op == "|=" && v !== want && !v.startsWith(want + "-")) return false;
+  }
+  return true;
+}
+// stack: the open elements, outermost first; the last is the candidate.
+function __sbSelectorMatches(steps, stack) {
+  const match = (si, ei) => {
+    if (!__sbStepMatches(steps[si], stack[ei])) return false;
+    if (si == 0) return true;
+    if (steps[si].combinator == ">") return ei > 0 && match(si - 1, ei - 1);
+    for (let k = ei - 1; k >= 0; k--) if (match(si - 1, k)) return true;
+    return false;
+  };
+  return match(steps.length - 1, stack.length - 1);
+}
+
+// Content to write around a node, from before/after/prepend/append/replace calls.
+class __sbEdits {
+  constructor() { this.before = ""; this.after = ""; this.replaced = null; this.removed = false; }
+}
+class __sbElement {
+  constructor(state) { this._s = state; }
+  get tagName() { return this._s.tag; }
+  set tagName(name) { this._s.tag = String(name).toLowerCase(); this._s.renamed = true; }
+  get namespaceURI() { return "http://www.w3.org/1999/xhtml"; }
+  get attributes() { return this._s.attrs.map((a) => [a[0], a[1]])[Symbol.iterator](); }
+  get removed() { return this._s.edits.removed; }
+  get selfClosing() { return this._s.selfClosing; }
+  get canHaveContent() { return !__sbVoidTags.has(this._s.tag); }
+  getAttribute(name) { return this._s.attr(String(name).toLowerCase()); }
+  hasAttribute(name) { return this._s.attr(String(name).toLowerCase()) != null; }
+  setAttribute(name, value) {
+    const n = String(name).toLowerCase();
+    const at = this._s.attrs.findIndex((a) => a[0] == n);
+    if (at >= 0) this._s.attrs[at] = [n, String(value), null]; else this._s.attrs.push([n, String(value), null]);
+    this._s.attrsChanged = true;
+    return this;
+  }
+  removeAttribute(name) {
+    const n = String(name).toLowerCase();
+    this._s.attrs = this._s.attrs.filter((a) => a[0] != n);
+    this._s.attrsChanged = true;
+    return this;
+  }
+  before(content, options) { this._s.edits.before += __sbContent(content, options); return this; }
+  after(content, options) { this._s.edits.after = __sbContent(content, options) + this._s.edits.after; return this; }
+  prepend(content, options) { this._s.prepend = __sbContent(content, options) + this._s.prepend; return this; }
+  append(content, options) { this._s.append += __sbContent(content, options); return this; }
+  setInnerContent(content, options) { this._s.inner = __sbContent(content, options); this._s.prepend = ""; this._s.append = ""; return this; }
+  replace(content, options) { this._s.edits.replaced = __sbContent(content, options); this._s.edits.removed = true; return this; }
+  remove() { this._s.edits.removed = true; this._s.edits.replaced = ""; return this; }
+  removeAndKeepContent() { this._s.keepContent = true; this._s.edits.removed = true; return this; }
+  onEndTag(handler) { this._s.endHandlers.push(handler); }
+}
+class __sbEndTag {
+  constructor(state) { this._s = state; }
+  get name() { return this._s.tag; }
+  set name(n) { this._s.tag = String(n).toLowerCase(); }
+  before(content, options) { this._s.endBefore += __sbContent(content, options); return this; }
+  after(content, options) { this._s.endAfter = __sbContent(content, options) + this._s.endAfter; return this; }
+  remove() { this._s.endRemoved = true; return this; }
+}
+class __sbTextChunk {
+  constructor(text, last) { this.text = text; this.lastInTextNode = last; this._e = new __sbEdits(); }
+  get removed() { return this._e.removed; }
+  before(content, options) { this._e.before += __sbContent(content, options); return this; }
+  after(content, options) { this._e.after = __sbContent(content, options) + this._e.after; return this; }
+  replace(content, options) { this._e.replaced = __sbContent(content, options); this._e.removed = true; return this; }
+  remove() { this._e.removed = true; this._e.replaced = ""; return this; }
+}
+class __sbComment {
+  constructor(text) { this.text = text; this._e = new __sbEdits(); }
+  get removed() { return this._e.removed; }
+  before(content, options) { this._e.before += __sbContent(content, options); return this; }
+  after(content, options) { this._e.after = __sbContent(content, options) + this._e.after; return this; }
+  replace(content, options) { this._e.replaced = __sbContent(content, options); this._e.removed = true; return this; }
+  remove() { this._e.removed = true; this._e.replaced = ""; return this; }
+}
+class __sbDocEnd {
+  constructor(out) { this._out = out; }
+  append(content, options) { this._out.push(__sbContent(content, options)); return this; }
+}
+
+class __sbRewriteRun {
+  constructor(handlers, documentHandlers, html) {
+    this.handlers = handlers;
+    this.documentHandlers = documentHandlers;
+    this.html = html;
+    this.out = [];
+    this.stack = [];
+    // Inner content of an element replaced by setInnerContent, remove or replace is skipped:
+    // the depth in the stack below which output is suppressed, or -1.
+    this.skipBelow = -1;
+  }
+  emit(s) { if (this.skipBelow < 0) this.out.push(s); }
+  async call(handler, method, arg) {
+    const f = handler && handler[method];
+    if (__sbIsFn(f)) await f.call(handler, arg);
+  }
+  // Text and comment handlers run for content anywhere inside a matched element.
+  inside(steps) {
+    for (let i = 0; i < this.stack.length; i++) if (steps.some((s) => __sbSelectorMatches(s, this.stack.slice(0, i + 1)))) return true;
+    return false;
+  }
+  // A text node arrives as its text, then an empty chunk with lastInTextNode, as lol-html does.
+  async text(raw) {
+    if (!raw.length || this.skipBelow >= 0) return;
+    for (const [text, last] of [[raw, false], ["", true]]) {
+      const chunk = new __sbTextChunk(text, last);
+      for (const h of this.documentHandlers) await this.call(h, "text", chunk);
+      for (const [steps, h] of this.handlers) if (this.inside(steps)) await this.call(h, "text", chunk);
+      this.emit(chunk._e.removed ? chunk._e.before + (chunk._e.replaced ?? "") + chunk._e.after : chunk._e.before + text + chunk._e.after);
+    }
+  }
+  async comment(raw) {
+    if (this.skipBelow >= 0) return;
+    const c = new __sbComment(raw);
+    for (const h of this.documentHandlers) await this.call(h, "comments", c);
+    for (const [steps, h] of this.handlers) if (this.inside(steps)) await this.call(h, "comments", c);
+    this.emit(c._e.removed ? c._e.before + (c._e.replaced ?? "") + c._e.after : c._e.before + "<!--" + c.text + "-->" + c._e.after);
+  }
+  async doctype(raw) {
+    const m = /^<!doctype\s+([^\s>]+)?/i.exec(raw);
+    const d = { name: m && m[1] ? m[1].toLowerCase() : null, publicId: null, systemId: null };
+    for (const h of this.documentHandlers) await this.call(h, "doctype", d);
+    this.emit(raw);
+  }
+  startTag(state) {
+    let s = "<" + (state.renamed ? state.tag : state.rawName);
+    for (const [n, v, raw] of state.attrs) s += raw != null ? " " + raw : " " + n + '="' + __sbEscapeAttr(v) + '"';
+    return s + (state.selfClosing ? " />" : ">");
+  }
+  async element(tag, rawName, attrs, selfClosing, rawStart) {
+    const state = {
+      tag, rawName, attrs, selfClosing, rawStart,
+      attr(name) { const a = this.attrs.find((x) => x[0] == name); return a ? a[1] : null; },
+      edits: new __sbEdits(), prepend: "", append: "", inner: null, keepContent: false, renamed: false, attrsChanged: false,
+      endHandlers: [], endBefore: "", endAfter: "", endRemoved: false,
+    };
+    const skipped = this.skipBelow >= 0;
+    this.stack.push(state);
+    if (!skipped) {
+      const el = new __sbElement(state);
+      for (const [steps, h] of this.handlers) if (steps.some((s) => __sbSelectorMatches(s, this.stack))) await this.call(h, "element", el);
+    }
+    const e = state.edits;
+    this.emit(e.before);
+    const unchanged = !state.renamed && !state.attrsChanged;
+    if (!e.removed || state.keepContent) {
+      if (!e.removed) this.emit(unchanged ? rawStart : this.startTag(state));
+    } else this.emit(e.replaced ?? "");
+    const isVoid = __sbVoidTags.has(tag) || selfClosing;
+    if (isVoid) {
+      this.stack.pop();
+      this.emit(e.after);
+      return null;
+    }
+    if (!e.removed || state.keepContent) this.emit(state.prepend);
+    if (state.inner != null) { this.emit(state.inner); if (this.skipBelow < 0) this.skipBelow = this.stack.length; }
+    else if (e.removed && !state.keepContent && this.skipBelow < 0) this.skipBelow = this.stack.length;
+    return state;
+  }
+  async endTag(state, rawEnd) {
+    if (this.skipBelow == this.stack.length) this.skipBelow = -1;
+    this.stack.pop();
+    const e = state.edits;
+    if (!e.removed || state.keepContent) this.emit(state.append);
+    if (!e.removed) {
+      const end = new __sbEndTag(state);
+      for (const handler of state.endHandlers) await handler(end);
+      this.emit(state.endBefore);
+      if (!state.endRemoved) this.emit(state.renamed || end.name != state.tag ? "</" + state.tag + ">" : rawEnd);
+      this.emit(state.endAfter);
+    }
+    this.emit(e.after);
+  }
+  async run() {
+    const html = this.html;
+    let i = 0, textStart = 0;
+    const flushText = async (to) => { if (to > textStart) await this.text(html.slice(textStart, to)); };
+    const open = [];
+    while (i < html.length) {
+      const lt = html.indexOf("<", i);
+      if (lt < 0) break;
+      const next = html[lt + 1];
+      if (html.startsWith("<!--", lt)) {
+        await flushText(lt);
+        const end = html.indexOf("-->", lt + 4);
+        const stop = end < 0 ? html.length : end;
+        await this.comment(html.slice(lt + 4, stop));
+        i = textStart = end < 0 ? html.length : end + 3;
+        continue;
+      }
+      if (next == "!" || next == "?") {
+        await flushText(lt);
+        const end = html.indexOf(">", lt);
+        const raw = html.slice(lt, end < 0 ? html.length : end + 1);
+        if (/^<!doctype/i.test(raw)) await this.doctype(raw); else this.emit(raw);
+        i = textStart = lt + raw.length;
+        continue;
+      }
+      if (next == "/" && /[a-zA-Z]/.test(html[lt + 2] || "")) {
+        await flushText(lt);
+        const end = html.indexOf(">", lt);
+        const raw = html.slice(lt, end < 0 ? html.length : end + 1);
+        const name = /^<\/([^\s/>]+)/.exec(raw)[1].toLowerCase();
+        // Close up to the matching open element; unmatched end tags pass through.
+        let at = -1;
+        for (let k = open.length - 1; k >= 0; k--) if (open[k].rawName.toLowerCase() == name) { at = k; break; }
+        if (at < 0) this.emit(raw);
+        else {
+          while (open.length > at + 1) { const inner = open.pop(); await this.endTag(inner, ""); }
+          await this.endTag(open.pop(), raw);
+        }
+        i = textStart = lt + raw.length;
+        continue;
+      }
+      if (!/[a-zA-Z]/.test(next || "")) { i = lt + 1; continue; }
+      await flushText(lt);
+      // A start tag: name, then attributes (quoted, unquoted or bare) up to > or />.
+      let p = lt + 1;
+      while (p < html.length && !/[\s/>]/.test(html[p])) p++;
+      const rawName = html.slice(lt + 1, p);
+      const tag = rawName.toLowerCase();
+      const attrs = [];
+      let selfClosing = false;
+      for (;;) {
+        while (p < html.length && /\s/.test(html[p])) p++;
+        if (p >= html.length) break;
+        if (html[p] == ">") { p++; break; }
+        if (html[p] == "/" && html[p + 1] == ">") { selfClosing = true; p += 2; break; }
+        if (html[p] == "/") { p++; continue; }
+        const start = p;
+        let q = p;
+        while (q < html.length && !/[\s=/>]/.test(html[q])) q++;
+        const name = html.slice(p, q).toLowerCase();
+        p = q;
+        while (p < html.length && /\s/.test(html[p])) p++;
+        if (html[p] == "=") {
+          p++;
+          while (p < html.length && /\s/.test(html[p])) p++;
+          let value;
+          if (html[p] == '"' || html[p] == "'") {
+            const quote = html[p], close = html.indexOf(quote, p + 1);
+            value = html.slice(p + 1, close < 0 ? html.length : close);
+            p = close < 0 ? html.length : close + 1;
+          } else {
+            let r = p;
+            while (r < html.length && !/[\s>]/.test(html[r])) r++;
+            value = html.slice(p, r);
+            p = r;
+          }
+          attrs.push([name, value.replace(/&amp;/g, "&").replace(/&quot;/g, '"'), html.slice(start, p)]);
+        } else attrs.push([name, "", html.slice(start, p)]);
+      }
+      const rawStart = html.slice(lt, p);
+      const state = await this.element(tag, rawName, attrs, selfClosing && !__sbVoidTags.has(tag) ? false : selfClosing, rawStart);
+      if (state) open.push(state);
+      i = textStart = p;
+      // Raw text elements hold their content verbatim up to their own end tag.
+      if (state && __sbRawTextTags.has(tag)) {
+        const close = html.toLowerCase().indexOf("</" + tag, p);
+        const stop = close < 0 ? html.length : close;
+        await this.text(html.slice(p, stop));
+        i = textStart = stop;
+      }
+    }
+    await flushText(html.length);
+    // An element whose end tag never came has not ended: nothing appended to it is written
+    // (lol-html does not imply end tags).
+    open.length = 0;
+    const tail = [];
+    for (const h of this.documentHandlers) if (__sbIsFn(h.end)) await h.end(new __sbDocEnd(tail));
+    return this.out.join("") + tail.join("");
+  }
+}
+
+class HTMLRewriter {
+  constructor() { this._handlers = []; this._documentHandlers = []; }
+  on(selector, handlers) { this._handlers.push([__sbParseSelector(selector), handlers]); return this; }
+  onDocument(handlers) { this._documentHandlers.push(handlers); return this; }
+  transform(response) {
+    const handlers = this._handlers, documentHandlers = this._documentHandlers;
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    const body = new ReadableStream({
+      async start(controller) {
+        try {
+          const html = await response.text();
+          const out = await new __sbRewriteRun(handlers, documentHandlers, html).run();
+          controller.enqueue(new TextEncoder().encode(out));
+          controller.close();
+        } catch (error) {
+          controller.error(error);
+        }
+      },
+    });
+    return new Response(body, { status: response.status, statusText: response.statusText, headers });
+  }
+}
+// A static install, so app code sees the name when it is compiled apart (see streams-entry.js).
+if (globalThis.HTMLRewriter == null) globalThis.HTMLRewriter = HTMLRewriter;
+// END HTML REWRITER
+
 // Porffor exposes native timers lexically. Libraries also access them through
 // globalThis, including noble hashes 2.4's host-task yields.
 if (globalThis.setTimeout == null) globalThis.setTimeout = setTimeout;

package/test/native-bodies.ts

@@ -18,6 +18,31 @@ const handler = `export default {async fetch(request) {
   if (path === "/stream-strings") return new Response(new ReadableStream({ start(c) { c.enqueue("text"); c.close(); } }));
   if (path === "/form") { const f = new FormData(); f.append("a", "1"); f.append("f", new Blob(["xy"]), "n.txt"); return new Response(f); }
   const cases = [
+    // HTMLRewriter, against Bun's (lol-html, as in workerd): the W2 cases and more.
+    () => typeof HTMLRewriter,
+    () => new HTMLRewriter().on("h1", { element(e) { e.setInnerContent("x"); } }).transform(new Response("<h1>a</h1><p>b</p>")).text(),
+    () => new HTMLRewriter().on("a", { element(e) { e.setAttribute("href", "/n"); } }).transform(new Response('<a href="/o" data-x=1>l</a>')).text(),
+    () => new HTMLRewriter().on("script", { element(e) { e.remove(); } }).transform(new Response("<p>a</p><script>if (a < b) x()</script>")).text(),
+    async () => { let t = ""; await new HTMLRewriter().on("p", { text(c) { t += c.text + (c.lastInTextNode ? "|" : ""); } }).transform(new Response("<p>hi <b>there</b></p>")).text(); return t; },
+    () => new HTMLRewriter().on("body", { element(e) { e.append("<i>z</i>", { html: true }).prepend("<&>"); } }).transform(new Response("<body>a</body>")).text(),
+    () => new HTMLRewriter().on("div > span.k, #m", { element(e) { e.replace("R"); } }).on("p", { comments(c) { c.remove(); } }).transform(new Response('<div><span class="k">1</span><p><!--c-->2<span class="k">3</span></p></div><i id="m">4</i>')).text(),
+    () => new HTMLRewriter().on("li", { async element(e) { await null; e.removeAndKeepContent(); } }).onDocument({ end(d) { d.append("<!--e-->", { html: true }); } }).transform(new Response("<ul><li>a</li><li>b</li></ul>")).text(),
+    // CompressionStream and DecompressionStream: our output round-trips, and zlib's decodes.
+    async () => { const out = []; for (const f of ["gzip", "deflate", "deflate-raw"]) out.push(await new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("hello ".repeat(200))); c.close(); } }).pipeThrough(new CompressionStream(f)).pipeThrough(new DecompressionStream(f))).text() === "hello ".repeat(200)); return out.join(","); },
+    async () => new Response(new ReadableStream({ start(c) { c.enqueue(Uint8Array.from(atob("H4sIAAAAAAACEysuKMovLUnKTyxRKB5uTACdCbks3AAAAA=="), (ch) => ch.charCodeAt(0))); c.close(); } }).pipeThrough(new DecompressionStream("gzip"))).text(),
+    async () => new Response(new ReadableStream({ start(c) { c.enqueue(Uint8Array.from(atob("eJxLqcxLzM1MVsgoTUvLTcxTSBnlj4ZHJv3SQ2peCgCxCfLI"), (ch) => ch.charCodeAt(0))); c.close(); } }).pipeThrough(new DecompressionStream("deflate"))).text(),
+    async () => { const s = new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("hello hello")); c.close(); } }).pipeThrough(new CompressionStream("gzip")).pipeThrough(new DecompressionStream("gzip")).pipeThrough(new TextDecoderStream()); let t = ""; for (const r = s.getReader(); ;) { const { value, done } = await r.read(); if (done) break; t += value; } return t; },
+    // workerd knows gzip, deflate and deflate-raw; Bun (the reference) also brotli.
+    () => { try { new CompressionStream("brotli"); return "workerd:no throw"; } catch (e) { return "workerd:" + e.name; } },
+    // A ReadableStream body is read to its end by text(), arrayBuffer(), json() and blob().
+    async () => new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("hé")); c.enqueue(new Uint8Array([33])); c.close(); } })).text(),
+    async () => Array.from(new Uint8Array(await new Response(new ReadableStream({ start(c) { c.enqueue(new Uint8Array([1, 2])); c.close(); } })).arrayBuffer())).join(","),
+    async () => JSON.stringify(await new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode('{"a":[1]}')); c.close(); } })).json()),
+    async () => (await new Response(new ReadableStream({ start(c) { c.enqueue(new Uint8Array([120])); c.close(); } })).blob()).size,
+    async () => new Request("http://a.test", { method: "POST", body: new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode("req")); c.close(); } }), duplex: "half" }).text(),
+    // Chunks must be bytes: workerd throws a TypeError, where Bun (the reference below) reads a
+    // string chunk as text. "workerd:" marks the answer to expect from workerd instead.
+    async () => { try { await new Response(new ReadableStream({ start(c) { c.enqueue("s"); c.close(); } })).text(); return "workerd:no throw"; } catch (e) { return "workerd:" + e.name; } },
     () => new Request("http://a.test/a/../b?x=1#f").url,
     async () => { const r = new Request("http://a.test", { method: "POST", body: "x" }); await r.text(); try { await r.text(); return "no throw"; } catch (e) { return r.bodyUsed + ":" + e.name; } },
     () => new Request("http://a.test").redirect,
@@ -125,7 +150,7 @@ try {
   for (const run of reference) {
     try { want.push(String(await run())); } catch (e) { want.push("THROWS " + (e instanceof Error ? e.name : String(e))); }
   }
-  assert.deepEqual(got, want);
+  assert.deepEqual(got, want.map((w) => (w.startsWith("workerd:") ? "workerd:TypeError" : w)));
   console.log(`Native bodies are sent as bytes and ${want.length} Fetch class cases match Bun`);
 } finally {
   if (server) {

package/test/native-json.ts

@@ -17,6 +17,11 @@ const CASES = [
   `JSON.stringify({ n: { toJSON() { return 42; } } })`,
   `JSON.stringify({ nested: { at: new Date(0), list: [new Date(0)] } })`,
   `JSON.stringify({ plain: { x: 1 } })`,
+  // The reviver: children first, undefined deletes, `this` is the holder, arrays by index.
+  `JSON.stringify(JSON.parse('{"a":1,"b":{"c":2}}', (k, v) => (typeof v === "number" ? v * 10 : v)))`,
+  `JSON.stringify(JSON.parse('{"a":1,"drop":2,"l":[1,2,3]}', (k, v) => (k === "drop" ? undefined : v)))`,
+  `JSON.stringify(JSON.parse('[5,6]', function (k, v) { return k === "" ? v : k + ":" + v + ":" + Array.isArray(this); }))`,
+  `JSON.stringify(JSON.parse('{"x":1}', (k, v) => (k === "" ? "root:" + typeof v : v)))`,
 ];
 const handler = `export default {fetch() {
   const U = URL;