buninu-browser 0.5.0 → 0.5.1

package/lib/happy-dom/inert-link.js

@@ -0,0 +1,26 @@
+import * as PropertySymbol from '../../vendor/happy-dom/packages/happy-dom/src/PropertySymbol.ts';
+
+// Happy DOM shares HTMLLinkElement.prototype between windows. Install one
+// dispatch hook, but bypass its loader only for windows owned by our renderer.
+const inertWindows = new WeakSet();
+let installed = false;
+export function makeLinksInert(window) {
+  inertWindows.add(window);
+  if (installed) return;
+  installed = true;
+  const base = window.HTMLElement.prototype;
+  const prototype = window.HTMLLinkElement.prototype;
+  const connected = prototype[PropertySymbol.connectedToDocument];
+  const setAttribute = prototype[PropertySymbol.onSetAttribute];
+  prototype[PropertySymbol.connectedToDocument] = function() {
+    if (!inertWindows.has(this[PropertySymbol.window])) return connected.call(this);
+    // The renderer owns load/error dispatch; the disabled parser loader must
+    // not emit a premature error when a dynamic stylesheet is connected.
+    base[PropertySymbol.connectedToDocument].call(this);
+    this.ownerDocument[PropertySymbol.clearComputedStyleCache]();
+  };
+  prototype[PropertySymbol.onSetAttribute] = function(attribute, replacedAttribute) {
+    if (!inertWindows.has(this[PropertySymbol.window])) return setAttribute.call(this, attribute, replacedAttribute);
+    base[PropertySymbol.onSetAttribute].call(this, attribute, replacedAttribute);
+  };
+}

package/lib/happy-dom/node-iterator-removal.js

@@ -0,0 +1,36 @@
+import Node from '../../vendor/happy-dom/packages/happy-dom/src/nodes/node/Node.ts';
+import * as PropertySymbol from '../../vendor/happy-dom/packages/happy-dom/src/PropertySymbol.ts';
+
+// NodeIterator's pre-removing steps must run synchronously, including removals
+// by innerHTML, normalize and reparenting. All reach Happy DOM's internal hook.
+const roots = new WeakMap();
+const cleanup = new FinalizationRegistry(({ entries, ref }) => entries.delete(ref));
+let installed = false;
+export function observeIteratorRemoval(root, iterator) {
+  let entries = roots.get(root);
+  if (!entries) roots.set(root, entries = new Set());
+  const ref = new WeakRef(iterator);
+  entries.add(ref);
+  cleanup.register(iterator, { entries, ref });
+  if (installed) return;
+  installed = true;
+  const remove = Node.prototype[PropertySymbol.removeChild];
+  Node.prototype[PropertySymbol.removeChild] = function(node) {
+    node = node?.[PropertySymbol.proxy] ?? node;
+    // select/form methods are bound to the raw target, while parentNode and
+    // iterator roots expose its proxy. Compare and walk the public identity.
+    const parent = this[PropertySymbol.proxy] ?? this;
+    if (node?.parentNode === parent) {
+      for (let ancestor = parent; ancestor; ancestor = ancestor.parentNode) {
+        const entries = roots.get(ancestor);
+        if (!entries) continue;
+        for (const ref of entries) {
+          const iterator = ref.deref();
+          if (iterator) iterator.preRemove(node);
+          else entries.delete(ref);
+        }
+      }
+    }
+    return remove.call(this, node);
+  };
+}

package/lib/happy-dom/node-replacement.js

@@ -0,0 +1,60 @@
+/** DOM replace: validate first, detach the incoming node, remove the outgoing
+ * node, then insert. Happy DOM's insert-then-remove order skips replacements
+ * in live NodeIterators. Keep this on the renderer bindings' mutation path.
+ * https://dom.spec.whatwg.org/#concept-node-replace */
+function validate(parent, node, child) {
+  const fail = (name) => { throw new DOMException('Invalid node replacement', name); };
+  if (![1,9,11].includes(parent.nodeType)) fail('HierarchyRequestError');
+  for (let ancestor = parent; ancestor; ancestor = ancestor.parentNode ?? ancestor.host) {
+    if (ancestor === node) fail('HierarchyRequestError');
+  }
+  if (child.parentNode !== parent) fail('NotFoundError');
+  if (![1,3,4,7,8,10,11].includes(node.nodeType)) fail('HierarchyRequestError');
+  if (node.nodeType === 10 && parent.nodeType !== 9) fail('HierarchyRequestError');
+  if (parent.nodeType !== 9) return;
+  // Validate the final document, allowing the outgoing child and an incoming
+  // sibling to be replaced/moved without counting either twice.
+  const added = node.nodeType === 11 ? [...node.childNodes] : [node];
+  const final = [];
+  for (const current of parent.childNodes) {
+    if (current === child) final.push(...added);
+    else if (current !== node) final.push(current);
+  }
+  let element = false, doctype = false;
+  for (const current of final) {
+    if (current.nodeType === 3 || current.nodeType === 4) fail('HierarchyRequestError');
+    if (current.nodeType === 1) {
+      if (element) fail('HierarchyRequestError');
+      element = true;
+    } else if (current.nodeType === 10) {
+      if (doctype || element) fail('HierarchyRequestError');
+      doctype = true;
+    }
+  }
+}
+
+export function replaceNode(parent, node, child) {
+  validate(parent, node, child);
+  let reference = child.nextSibling;
+  if (reference === node) reference = node.nextSibling;
+  if (node.parentNode) node.parentNode.removeChild(node);
+  if (child.parentNode) child.parentNode.removeChild(child);
+  parent.insertBefore(node, reference);
+  return child;
+}
+
+export function replaceWithNodes(child, nodes) {
+  const parent = child.parentNode;
+  if (!parent) return;
+  let reference = child.nextSibling;
+  while (reference && nodes.includes(reference)) reference = reference.nextSibling;
+  // DOM's convert-nodes algorithm moves multiple arguments into a fragment
+  // first, including the receiver if it occurs among the arguments.
+  let node = nodes[0];
+  if (nodes.length !== 1) {
+    node = child.ownerDocument.createDocumentFragment();
+    for (const item of nodes) node.appendChild(item);
+  }
+  if (child.parentNode === parent) replaceNode(parent, node, child);
+  else parent.insertBefore(node, reference);
+}

package/lib/happy-dom/parser.js

@@ -1,3 +1,4 @@
+import { makeLinksInert } from './inert-link.js';
 import HTMLParser from "../../vendor/happy-dom/packages/happy-dom/src/html-parser/HTMLParser.ts";
 import Window from "../../vendor/happy-dom/packages/happy-dom/src/window/Window.ts";
 import * as PropertySymbol from "../../vendor/happy-dom/packages/happy-dom/src/PropertySymbol.ts";
@@ -26,7 +27,7 @@ export function parseHTMLDocument(html, url = "about:blank", referrer = "") {
 
 /** An isolated parser context: no script execution, resource loads or page custom elements. */
 export function createInertWindow(url = "about:blank") {
-  return new Window({
+  const window = new Window({
     url,
     settings: {
       disableJavaScriptEvaluation: true,
@@ -40,6 +41,8 @@ export function createInertWindow(url = "about:blank") {
       navigation: { disableFallbackToSetURL: true },
     },
   });
+  makeLinksInert(window);
+  return window;
 }
 
 /**

package/lib/layout/text-layout.js

@@ -1858,8 +1858,10 @@ function resolveHorizontal(ctx, box, containingX, containingWidth, shrink, perce
   return { x: containingX + marginLeft, width, marginLeft, marginRight };
 }
 
+// Anonymous flex/grid items share their parent RenderNode, but measure only
+// their own text run. Never reuse the parent's intrinsic width for these boxes.
 function maxContentWidth(ctx, box) {
-  const cacheKey = box.node ?? box;
+  const cacheKey = box.anonymous ? box : box.node ?? box;
   const cached = ctx.maxContent.get(cacheKey);
   if (cached != null) return cached;
   const style = box.style;
@@ -1902,7 +1904,7 @@ function maxContentWidth(ctx, box) {
 }
 
 function minContentWidth(ctx, box) {
-  const cacheKey = box.node ?? box;
+  const cacheKey = box.anonymous ? box : box.node ?? box;
   const cached = ctx.minContent.get(cacheKey);
   if (cached != null) return cached;
   const style = box.style;

package/lib/renderer/bindings.js

@@ -10,6 +10,8 @@
  *
  * Coverage is the commonly used subset of DOM, not the full WebIDL surface.
  */
+import { replaceNode, replaceWithNodes } from '../happy-dom/node-replacement.js';
+import { observeIteratorRemoval } from '../happy-dom/node-iterator-removal.js';
 import { renderedText, setRenderedText } from "./rendered-text.js";
 import { assignedSlot, slotAssignedNodes, assignSlotNodes } from "./slot-assignment.js";
 import { scrollIntoViewOptions, scrollAlignmentDelta } from "./scroll-into-view.js";
@@ -503,7 +505,7 @@ class NodeBinding {
   replaceChild(child, old) {
     const node = requireNode(child);
     const list = insertionList([node]);
-    this.#node.replaceChild(node, requireNode(old));
+    replaceNode(this.#node, node, requireNode(old));
     inserted(this, list);
     return old;
   }
@@ -1053,7 +1055,7 @@ class ElementBinding extends ParentBinding {
   replaceWith(...values) {
     const nodes = values.map((value) => toNode(this, value));
     const list = insertionList(nodes);
-    nodeOf(this).replaceWith(...nodes);
+    replaceWithNodes(nodeOf(this), nodes);
     inserted(this, list);
   }
 
@@ -1690,6 +1692,10 @@ class DocumentBinding extends ParentBinding {
     return realmOf(this).wrap(nodeOf(this).createComment(String(text)));
   }
 
+  createNodeIterator(root, whatToShow = NodeFilter.SHOW_ALL, filter = null) {
+    return new NodeIteratorBinding(CONSTRUCT, realmOf(this), requireNode(root), whatToShow, filter);
+  }
+
   createTreeWalker(root, whatToShow = NodeFilter.SHOW_ALL, filter = null) {
     return new TreeWalkerBinding(CONSTRUCT, realmOf(this), requireNode(root), whatToShow, filter);
   }
@@ -2033,6 +2039,101 @@ export const NodeFilter = Object.freeze({
 });
 const { FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP } = NodeFilter;
 
+/** DOM §6.1: a cursor between nodes, including the root; REJECT skips
+ * only that node, unlike TreeWalker where it also prunes descendants. */
+class NodeIteratorBinding {
+  #realm; #root; #reference; #before = true; #whatToShow; #filter; #active = false;
+  #candidate = null;
+  constructor(key, realm, root, whatToShow, filter) {
+    if (key !== CONSTRUCT) throw new TypeError("Illegal constructor");
+    this.#realm = realm; this.#root = this.#reference = root;
+    this.#whatToShow = +whatToShow >>> 0; this.#filter = filter ?? null;
+    // WebIDL callback interfaces accept objects/functions or null, but no
+    // primitives; validate even when whatToShow would skip every node.
+    if (this.#filter !== null && typeof filter !== "object" && typeof filter !== "function") {
+      throw new TypeError("NodeIterator filter must be an object or null");
+    }
+    // Keep the internal removal callback off the page-visible interface.
+    observeIteratorRemoval(root, this.#removal);
+  }
+  #removal = { preRemove: node => this.#preRemove(node) };
+  get root() { return this.#realm.wrap(this.#root); }
+  get referenceNode() { return this.#realm.wrap(this.#reference); }
+  get pointerBeforeReferenceNode() { return this.#before; }
+  get whatToShow() { return this.#whatToShow; }
+  get filter() { return this.#filter; }
+  detach() {} // Legacy no-op, as required by DOM.
+  nextNode() { return this.#traverse(true); }
+  previousNode() { return this.#traverse(false); }
+  #following(node, children = true) {
+    if (children && node.firstChild) return node.firstChild;
+    while (node && node !== this.#root) {
+      if (node.nextSibling) return node.nextSibling;
+      node = node.parentNode;
+    }
+    return null;
+  }
+  #preceding(node) {
+    if (node === this.#root) return null;
+    if (!node.previousSibling) return node.parentNode;
+    node = node.previousSibling;
+    while (node.lastChild) node = node.lastChild;
+    return node;
+  }
+  #accept(node) {
+    if (this.#active) throw new DOMException("The iterator filter is already active", "InvalidStateError");
+    if (!(this.#whatToShow & (1 << (node.nodeType - 1)))) return FILTER_SKIP;
+    if (this.#filter === null) return FILTER_ACCEPT;
+    this.#active = true;
+    try {
+      const filter = this.#filter, wrapper = this.#realm.wrap(node);
+      return +(typeof filter === "function" ? Reflect.apply(filter, undefined, [wrapper])
+        : Reflect.apply(filter.acceptNode, filter, [wrapper])) & 0xffff;
+    } finally { this.#active = false; }
+  }
+  #traverse(forward) {
+    if (this.#active) throw new DOMException("The iterator filter is already active", "InvalidStateError");
+    // A filter can remove its candidate or an ancestor synchronously. Track
+    // the traversal cursor separately so pre-removal adjusts both positions.
+    const cursor = this.#candidate = { node: this.#reference, before: this.#before };
+    try {
+      for (;;) {
+        if (forward) {
+          if (cursor.before) cursor.before = false;
+          else cursor.node = this.#following(cursor.node);
+        } else {
+          if (!cursor.before) cursor.before = true;
+          else cursor.node = this.#preceding(cursor.node);
+        }
+        const node = cursor.node;
+        if (!node) return null;
+        if (this.#accept(node) === FILTER_ACCEPT) {
+          this.#reference = cursor.node; this.#before = cursor.before;
+          // Return the accepted node even if the filter removed it; the next
+          // traversal resumes at the repaired position in the remaining tree.
+          return this.#realm.wrap(node);
+        }
+      }
+    } finally { this.#candidate = null; }
+  }
+  #preRemove(node) {
+    if (node === this.#root) return;
+    const adjust = cursor => {
+      if (!cursor?.node || !node.contains(cursor.node)) return;
+      if (cursor.before) {
+        const next = this.#following(node, false);
+        if (next) { cursor.node = next; return; }
+        cursor.before = false;
+      }
+      cursor.node = this.#preceding(node);
+    };
+    const reference = { node: this.#reference, before: this.#before };
+    adjust(reference);
+    this.#reference = reference.node; this.#before = reference.before;
+    adjust(this.#candidate);
+  }
+}
+
 /**
  * DOM §6.2 TreeWalker over the real nodes. The page's filter (a function or
  * an object with acceptNode) sees node wrappers, and its exceptions reach the
@@ -2833,7 +2934,7 @@ function cssEscape(value) {
  * Must run after SES lockdown() (which provides `harden`).
  */
 const BINDINGS = [NodeBinding, CharacterDataBinding, TextBinding, ParentBinding, FragmentBinding, ShadowRootBinding, ElementBinding,
-  DocumentBinding, EventBinding, ClassListBinding, TreeWalkerBinding, RangeBinding];
+  DocumentBinding, EventBinding, ClassListBinding, TreeWalkerBinding, NodeIteratorBinding, RangeBinding];
 
 // Members defined with Object.defineProperty({ get() {...} }) are named
 // "get"; Web IDL names an attribute's accessors "get x" / "set x" and an
@@ -2869,5 +2970,6 @@ export const INTERFACES = Object.freeze({
   DocumentFragment: FragmentBinding,
   ShadowRoot: ShadowRootBinding,
   TreeWalker: TreeWalkerBinding,
+  NodeIterator: NodeIteratorBinding,
   DOMTokenList: ClassListBinding,
 });

package/lib/renderer/page-renderer.js

@@ -438,6 +438,8 @@ function buildPageRenderer({
       [...page.renderTree.nodesById.values()].filter(node => node.type === "text"));
   }
 
+  // Keep fractional CSS sizes through measurement and painting. Rounding each
+  // scale independently can widen painted glyphs beyond the measured line.
   function makeParagraph(text, computedStyle = null, fontSize = computedStyle?.fontSize ?? 16, scale = 1, foregroundPaint = null) {
     const color = canvasColor(CanvasKit, computedStyle?.color ?? "rgba(0, 0, 0, 1)");
     const weight = computedStyle?.fontWeight ?? 400;
@@ -460,7 +462,7 @@ function buildPageRenderer({
       textStyle: {
         color,
         fontFamilies: families,
-        fontSize: Math.max(1, Math.round(fontSize * scale)),
+        fontSize: Math.max(1, fontSize) * scale,
         fontStyle: { weight, slant, width },
         // Roboto is a variable font; static fonts ignore the axis and match by weight.
         fontVariations: [{ axis: "wght", value: weight }, { axis: "wdth", value: stretch }],
@@ -475,7 +477,7 @@ function buildPageRenderer({
     const pushTextStyle = foregroundPaint
       ? value => builder.pushPaintStyle(value, foregroundPaint, backgroundPaint) : value => builder.pushStyle(value);
     const textStyle = (fontFamilies) => CanvasKit.TextStyle({ color, ...decoration, fontFamilies,
-      fontSize: Math.max(1, Math.round(fontSize * scale)), fontStyle: { weight, slant, width },
+      fontSize: Math.max(1, fontSize) * scale, fontStyle: { weight, slant, width },
       fontVariations: [{ axis: "wght", value: weight }, { axis: "wdth", value: stretch }] });
     function append(text, fonts) {
       let emojiStyle;
@@ -518,7 +520,7 @@ function buildPageRenderer({
     return paragraph;
   }
 
-  // Text widths depend only on the font (families, rounded size, weight),
+  // Text widths depend only on the font (families, fractional size, weight),
   // not on the element, so they are cached per font across elements,
   // relayouts and documents. The cache is dropped when it grows too large.
   const MAX_MEASURED_TEXTS = 200_000;
@@ -557,7 +559,7 @@ function buildPageRenderer({
     const weight = computedStyle?.fontWeight ?? 400;
     const fontStyle = computedStyle?.fontStyle ?? "normal";
     const stretch = computedStyle?.fontStretch ?? 100;
-    const key = `${Math.max(1, Math.round(computedStyle?.fontSize ?? 16))}/${weight}/${fontStyle}/${stretch}/${
+    const key = `${Math.max(1, computedStyle?.fontSize ?? 16)}/${weight}/${fontStyle}/${stretch}/${
       resolveFontFamilies(computedStyle?.fontFamily, weight, fontStyle, null, stretch).join(",")}`;
     if (computedStyle && typeof computedStyle === "object") fontKeys.set(computedStyle, key);
     return key;
@@ -2786,6 +2788,10 @@ function buildPageRenderer({
         ? deviceScaleFactor
         : 1;
       viewport.resize(width, height);
+      // Viewport dimensions are layout input even when DOM/stylesheets did
+      // not mutate (including CSS resizes that keep the same pixel size by
+      // changing DPR). Bypass retained-layout shortcuts in that case.
+      if (resized) page.resourceLayoutDirty = true;
       rebuildRenderTree();
       // Listeners must observe the new viewport and layout. A repeated metrics
       // request (or DPR-only change) does not resize the CSS viewport.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu-browser",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Buninu Browser is a browser engine written in JavaScript and WebAssembly for Bun.",
   "keywords": [
     "buninu",

package/test/compare-node-iterator.js

@@ -0,0 +1,42 @@
+// Manual black-box reference check (no Chromium source code copied):
+// bun test/compare-node-iterator.js /usr/local/bin/chromium-headless-shell
+// Optional --snapshot writes Chromium's raw results for the regression test.
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { RendererHost } from '../lib/renderer/host.js';
+import { nodeIteratorCases } from './fixtures/node-iterator-cases.js';
+
+const binary = process.argv[2] || Bun.which('chromium-headless-shell');
+if (!binary) throw new Error('Pass the Chromium Headless Shell executable as the first argument');
+const dir = await mkdtemp(join(tmpdir(), 'node-iterator-'));
+const host = new RendererHost({timeout:20000,fetch:async()=>new Response('')});
+let child;
+try {
+  const expression = `JSON.stringify((${nodeIteratorCases})())`;
+  const path = join(dir, 'cases.html');
+  await Bun.write(path, `<body><script>document.body.textContent=${expression}</script>`);
+  child = Bun.spawn([binary,'--no-sandbox','--disable-gpu','--dump-dom',pathToFileURL(path).href],
+    {stdout:'pipe',stderr:'ignore'});
+  const html = await new Response(child.stdout).text();
+  if (await child.exited) throw new Error('Chromium failed');
+  const body = html.match(/<body>(.*?)<\/body>/s)?.[1];
+  const chromium = JSON.parse(body?.replaceAll('&lt;','<').replaceAll('&gt;','>').replaceAll('&amp;','&'));
+  await host.call('loadDocument',{url:'https://iterator.test/',source:'<body></body>',contentType:'text/html',status:200});
+  await host.call('whenLoaded');
+  const browser = JSON.parse(await host.call('evaluate',expression));
+  let differences = 0;
+  for (let i = 0; i < chromium.length; i++) {
+    if (!Bun.deepEquals(browser[i], chromium[i])) { differences++;console.log({browser:browser[i],chromium:chromium[i]}); }
+  }
+  console.log(`${chromium.length} cases; ${differences} differences (see node-iterator.test.js for documented DOM-spec exceptions)`);
+  if (process.argv.includes('--snapshot')) {
+    await Bun.write(new URL('./fixtures/node-iterator-chromium.json',import.meta.url),
+      '[\n'+chromium.map(row=>'  '+JSON.stringify(row)).join(',\n')+'\n]\n');
+  }
+} finally {
+  child?.kill();
+  host.close();
+  await rm(dir,{recursive:true,force:true});
+}

package/test/fixtures/fractional-text-scale.js

@@ -0,0 +1,38 @@
+import {strict as assert} from 'node:assert';
+import {createPageRenderer,loadGraphics} from '../../lib/renderer/page-renderer.js';
+const {CanvasKit}=await loadGraphics();
+const original=CanvasKit.ParagraphBuilder.MakeFromFontCollection;
+let checked=0;const missing=[];
+CanvasKit.ParagraphBuilder.MakeFromFontCollection=function(...args){
+ const builder=original.apply(this,args),add=builder.addText.bind(builder),build=builder.build.bind(builder);
+ let text='';
+ builder.addText=value=>{text+=value;return add(value)};
+ builder.build=()=>{
+  const paragraph=build(),layout=paragraph.layout.bind(paragraph);
+  paragraph.layout=width=>{
+   layout(width);
+   if(width<10000 && text.trim()){
+    const last=text.trimEnd().length-1;
+    const rects=paragraph.getRectsForRange(last,last+1,CanvasKit.RectHeightStyle.Max,CanvasKit.RectWidthStyle.Tight);
+    if(!rects.length)missing.push({text,width});
+    checked++;
+   }
+  };
+  return paragraph;
+ };
+ return builder;
+};
+const r=await createPageRenderer({});
+try{
+ for(const scale of [1,1.125,1.25,1.5,2]){
+  r.resize(900,300,scale);
+  await r.loadDocument({url:'https://text.test/',contentType:'text/html',source:`<body style="margin:0">
+   <div style="display:flex;gap:24px;font-size:15.2px"><span>Contact</span><span>Ecosystem</span><span>Contributors</span></div>
+   <div style="display:flex;gap:24px;font-size:14.4px"><span>Buninu Linux</span><span>Long navigation label</span></div>
+   <button style="font:14.4px monospace">Show email address</button>
+   </body>`});
+  await r.whenLoaded();await r.screenshot();
+ }
+ assert.deepEqual(missing,[],'All painted lines must retain their final character');
+ assert.ok(checked>=30,'All scales must exercise painted paragraphs');
+}finally{r.dispose();CanvasKit.ParagraphBuilder.MakeFromFontCollection=original}

package/test/fixtures/node-iterator-cases.js

@@ -0,0 +1,59 @@
+// Runs unchanged in the renderer and Chromium; keep this function standalone.
+export function nodeIteratorCases() {
+  const results = [];
+  const label = n => n ? n.id || n.nodeName : null;
+  for (const tag of ['div', 'form', 'select'])
+    for (const operation of ['remove', 'replace', 'replaceWith', 'self', 'sibling', 'fragment', 'descendant', 'multiple'])
+      for (const position of [0, 1, 2, 3]) for (const before of [false, true]) {
+        const root = document.createElement(tag);root.id = 'root';
+        for (const id of ['a', 'b']) {
+          const node = document.createElement('option');node.id = id;root.append(node);
+        }
+        const nested = document.createElement('span');nested.id = 'nested';root.firstChild.append(nested);
+        const it = document.createNodeIterator(root, 1);
+        for (let i = 0; i <= position; i++) it.nextNode();
+        if (before) it.previousNode();
+        const old = root.firstChild, x = document.createElement('em');x.id = 'x';
+        if (operation === 'remove') old.remove();
+        if (operation === 'replace') root.replaceChild(x, old);
+        if (operation === 'replaceWith') old.replaceWith(x);
+        if (operation === 'self') root.replaceChild(old, old);
+        if (operation === 'sibling') root.replaceChild(root.lastChild, old);
+        if (operation === 'descendant') root.replaceChild(nested, old);
+        if (operation === 'fragment') {
+          const fragment = document.createDocumentFragment();fragment.append(x);
+          const y = document.createElement('em');y.id = 'y';fragment.append(y);
+          root.replaceChild(fragment, old);
+        }
+        if (operation === 'multiple') old.replaceWith(x, old, root.lastChild);
+        results.push([tag, operation, position, before, label(it.referenceNode),
+          it.pointerBeforeReferenceNode, label(it.nextNode()), label(it.previousNode()),
+          [...root.childNodes].map(label).join(',')]);
+      }
+  for (const whatToShow of [0, 1, -1, 4294967297, NaN, Infinity, '1', null, 1n, Object(1n), Symbol('x')]) {
+    try { results.push(['mask', String(whatToShow), document.createNodeIterator(document.body, whatToShow).whatToShow]); }
+    catch (e) { results.push(['mask', String(whatToShow), e.name]); }
+  }
+  for (const verdict of [1, 65537, -65535, NaN, Infinity, '1', null, 1n, Object(1n), Symbol('x')]) {
+    try { results.push(['filter', String(verdict), !!document.createNodeIterator(document.body, 1, () => verdict).nextNode()]); }
+    catch (e) { results.push(['filter', String(verdict), e.name]); }
+  }
+  // Filtering and root types: rejection must not prune descendants.
+  for (const rootKind of ['element', 'fragment', 'text', 'comment', 'doctype'])
+    for (const mask of [0, 1, 4, 128, 0xffffffff]) for (const mode of ['accept', 'reject', 'skip', 'alternating']) {
+      const root = rootKind === 'fragment' ? document.createDocumentFragment()
+        : rootKind === 'text' ? document.createTextNode('text')
+        : rootKind === 'comment' ? document.createComment('comment')
+        : rootKind === 'doctype' ? document.implementation.createDocumentType('html', '', '') : document.createElement('div');
+      if (rootKind === 'element' || rootKind === 'fragment') {
+        const child = document.createElement('b');child.append('text');root.append(child, document.createComment('comment'));
+      }
+      const it = document.createNodeIterator(root, mask, n => mode === 'accept' ? 1
+        : mode === 'reject' ? 2 : mode === 'skip' ? 3 : n.nodeType === 1 ? 2 : 1);
+      const forward = [], backward = [];
+      for (let n; (n = it.nextNode());) forward.push(n.nodeType);
+      for (let n; (n = it.previousNode());) backward.push(n.nodeType);
+      results.push(['walk', rootKind, mask, mode, forward.join(','), backward.join(',')]);
+    }
+  return results;
+}

package/test/fixtures/node-iterator-chromium.json

@@ -0,0 +1,315 @@
+[
+  ["div","remove",0,false,"root",false,"b","b","b"],
+  ["div","remove",0,true,"root",true,"root","root","b"],
+  ["div","remove",1,false,"root",false,"b","b","b"],
+  ["div","remove",1,true,"b",true,"b","b","b"],
+  ["div","remove",2,false,"root",false,"b","b","b"],
+  ["div","remove",2,true,"b",true,"b","b","b"],
+  ["div","remove",3,false,"b",false,null,"b","b"],
+  ["div","remove",3,true,"b",true,"b","b","b"],
+  ["div","replace",0,false,"root",false,"x","x","x,b"],
+  ["div","replace",0,true,"root",true,"root","root","x,b"],
+  ["div","replace",1,false,"root",false,"x","x","x,b"],
+  ["div","replace",1,true,"b",true,"b","b","x,b"],
+  ["div","replace",2,false,"root",false,"x","x","x,b"],
+  ["div","replace",2,true,"b",true,"b","b","x,b"],
+  ["div","replace",3,false,"b",false,null,"b","x,b"],
+  ["div","replace",3,true,"b",true,"b","b","x,b"],
+  ["div","replaceWith",0,false,"root",false,"x","x","x,b"],
+  ["div","replaceWith",0,true,"root",true,"root","root","x,b"],
+  ["div","replaceWith",1,false,"root",false,"x","x","x,b"],
+  ["div","replaceWith",1,true,"b",true,"b","b","x,b"],
+  ["div","replaceWith",2,false,"root",false,"x","x","x,b"],
+  ["div","replaceWith",2,true,"b",true,"b","b","x,b"],
+  ["div","replaceWith",3,false,"b",false,null,"b","x,b"],
+  ["div","replaceWith",3,true,"b",true,"b","b","x,b"],
+  ["div","self",0,false,"root",false,"a","a","a,b"],
+  ["div","self",0,true,"root",true,"root","root","a,b"],
+  ["div","self",1,false,"root",false,"a","a","a,b"],
+  ["div","self",1,true,"b",true,"b","b","a,b"],
+  ["div","self",2,false,"root",false,"a","a","a,b"],
+  ["div","self",2,true,"b",true,"b","b","a,b"],
+  ["div","self",3,false,"b",false,null,"b","a,b"],
+  ["div","self",3,true,"b",true,"b","b","a,b"],
+  ["div","sibling",0,false,"root",false,"b","b","b"],
+  ["div","sibling",0,true,"root",true,"root","root","b"],
+  ["div","sibling",1,false,"root",false,"b","b","b"],
+  ["div","sibling",1,true,"a",true,"a","a","b"],
+  ["div","sibling",2,false,"root",false,"b","b","b"],
+  ["div","sibling",2,true,"nested",true,"nested","nested","b"],
+  ["div","sibling",3,false,"root",false,"b","b","b"],
+  ["div","sibling",3,true,"root",false,"b","b","b"],
+  ["div","fragment",0,false,"root",false,"x","x","x,y,b"],
+  ["div","fragment",0,true,"root",true,"root","root","x,y,b"],
+  ["div","fragment",1,false,"root",false,"x","x","x,y,b"],
+  ["div","fragment",1,true,"b",true,"b","b","x,y,b"],
+  ["div","fragment",2,false,"root",false,"x","x","x,y,b"],
+  ["div","fragment",2,true,"b",true,"b","b","x,y,b"],
+  ["div","fragment",3,false,"b",false,null,"b","x,y,b"],
+  ["div","fragment",3,true,"b",true,"b","b","x,y,b"],
+  ["div","descendant",0,false,"root",false,"nested","nested","nested,b"],
+  ["div","descendant",0,true,"root",true,"root","root","nested,b"],
+  ["div","descendant",1,false,"root",false,"nested","nested","nested,b"],
+  ["div","descendant",1,true,"b",true,"b","b","nested,b"],
+  ["div","descendant",2,false,"root",false,"nested","nested","nested,b"],
+  ["div","descendant",2,true,"b",true,"b","b","nested,b"],
+  ["div","descendant",3,false,"b",false,null,"b","nested,b"],
+  ["div","descendant",3,true,"b",true,"b","b","nested,b"],
+  ["div","multiple",0,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",0,true,"root",true,"root","root","x,a,b"],
+  ["div","multiple",1,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",1,true,"root",false,"x","x","x,a,b"],
+  ["div","multiple",2,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",2,true,"root",false,"x","x","x,a,b"],
+  ["div","multiple",3,false,"root",false,"x","x","x,a,b"],
+  ["div","multiple",3,true,"root",false,"x","x","x,a,b"],
+  ["form","remove",0,false,"root",false,"b","b","b"],
+  ["form","remove",0,true,"root",true,"root","root","b"],
+  ["form","remove",1,false,"root",false,"b","b","b"],
+  ["form","remove",1,true,"b",true,"b","b","b"],
+  ["form","remove",2,false,"root",false,"b","b","b"],
+  ["form","remove",2,true,"b",true,"b","b","b"],
+  ["form","remove",3,false,"b",false,null,"b","b"],
+  ["form","remove",3,true,"b",true,"b","b","b"],
+  ["form","replace",0,false,"root",false,"x","x","x,b"],
+  ["form","replace",0,true,"root",true,"root","root","x,b"],
+  ["form","replace",1,false,"root",false,"x","x","x,b"],
+  ["form","replace",1,true,"b",true,"b","b","x,b"],
+  ["form","replace",2,false,"root",false,"x","x","x,b"],
+  ["form","replace",2,true,"b",true,"b","b","x,b"],
+  ["form","replace",3,false,"b",false,null,"b","x,b"],
+  ["form","replace",3,true,"b",true,"b","b","x,b"],
+  ["form","replaceWith",0,false,"root",false,"x","x","x,b"],
+  ["form","replaceWith",0,true,"root",true,"root","root","x,b"],
+  ["form","replaceWith",1,false,"root",false,"x","x","x,b"],
+  ["form","replaceWith",1,true,"b",true,"b","b","x,b"],
+  ["form","replaceWith",2,false,"root",false,"x","x","x,b"],
+  ["form","replaceWith",2,true,"b",true,"b","b","x,b"],
+  ["form","replaceWith",3,false,"b",false,null,"b","x,b"],
+  ["form","replaceWith",3,true,"b",true,"b","b","x,b"],
+  ["form","self",0,false,"root",false,"a","a","a,b"],
+  ["form","self",0,true,"root",true,"root","root","a,b"],
+  ["form","self",1,false,"root",false,"a","a","a,b"],
+  ["form","self",1,true,"b",true,"b","b","a,b"],
+  ["form","self",2,false,"root",false,"a","a","a,b"],
+  ["form","self",2,true,"b",true,"b","b","a,b"],
+  ["form","self",3,false,"b",false,null,"b","a,b"],
+  ["form","self",3,true,"b",true,"b","b","a,b"],
+  ["form","sibling",0,false,"root",false,"b","b","b"],
+  ["form","sibling",0,true,"root",true,"root","root","b"],
+  ["form","sibling",1,false,"root",false,"b","b","b"],
+  ["form","sibling",1,true,"a",true,"a","a","b"],
+  ["form","sibling",2,false,"root",false,"b","b","b"],
+  ["form","sibling",2,true,"nested",true,"nested","nested","b"],
+  ["form","sibling",3,false,"root",false,"b","b","b"],
+  ["form","sibling",3,true,"root",false,"b","b","b"],
+  ["form","fragment",0,false,"root",false,"x","x","x,y,b"],
+  ["form","fragment",0,true,"root",true,"root","root","x,y,b"],
+  ["form","fragment",1,false,"root",false,"x","x","x,y,b"],
+  ["form","fragment",1,true,"b",true,"b","b","x,y,b"],
+  ["form","fragment",2,false,"root",false,"x","x","x,y,b"],
+  ["form","fragment",2,true,"b",true,"b","b","x,y,b"],
+  ["form","fragment",3,false,"b",false,null,"b","x,y,b"],
+  ["form","fragment",3,true,"b",true,"b","b","x,y,b"],
+  ["form","descendant",0,false,"root",false,"nested","nested","nested,b"],
+  ["form","descendant",0,true,"root",true,"root","root","nested,b"],
+  ["form","descendant",1,false,"root",false,"nested","nested","nested,b"],
+  ["form","descendant",1,true,"b",true,"b","b","nested,b"],
+  ["form","descendant",2,false,"root",false,"nested","nested","nested,b"],
+  ["form","descendant",2,true,"b",true,"b","b","nested,b"],
+  ["form","descendant",3,false,"b",false,null,"b","nested,b"],
+  ["form","descendant",3,true,"b",true,"b","b","nested,b"],
+  ["form","multiple",0,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",0,true,"root",true,"root","root","x,a,b"],
+  ["form","multiple",1,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",1,true,"root",false,"x","x","x,a,b"],
+  ["form","multiple",2,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",2,true,"root",false,"x","x","x,a,b"],
+  ["form","multiple",3,false,"root",false,"x","x","x,a,b"],
+  ["form","multiple",3,true,"root",false,"x","x","x,a,b"],
+  ["select","remove",0,false,"root",false,"b","b","b"],
+  ["select","remove",0,true,"root",true,"root","root","b"],
+  ["select","remove",1,false,"root",false,"b","b","b"],
+  ["select","remove",1,true,"b",true,"b","b","b"],
+  ["select","remove",2,false,"root",false,"b","b","b"],
+  ["select","remove",2,true,"b",true,"b","b","b"],
+  ["select","remove",3,false,"b",false,null,"b","b"],
+  ["select","remove",3,true,"b",true,"b","b","b"],
+  ["select","replace",0,false,"root",false,"x","x","x,b"],
+  ["select","replace",0,true,"root",true,"root","root","x,b"],
+  ["select","replace",1,false,"root",false,"x","x","x,b"],
+  ["select","replace",1,true,"b",true,"b","b","x,b"],
+  ["select","replace",2,false,"root",false,"x","x","x,b"],
+  ["select","replace",2,true,"b",true,"b","b","x,b"],
+  ["select","replace",3,false,"b",false,null,"b","x,b"],
+  ["select","replace",3,true,"b",true,"b","b","x,b"],
+  ["select","replaceWith",0,false,"root",false,"x","x","x,b"],
+  ["select","replaceWith",0,true,"root",true,"root","root","x,b"],
+  ["select","replaceWith",1,false,"root",false,"x","x","x,b"],
+  ["select","replaceWith",1,true,"b",true,"b","b","x,b"],
+  ["select","replaceWith",2,false,"root",false,"x","x","x,b"],
+  ["select","replaceWith",2,true,"b",true,"b","b","x,b"],
+  ["select","replaceWith",3,false,"b",false,null,"b","x,b"],
+  ["select","replaceWith",3,true,"b",true,"b","b","x,b"],
+  ["select","self",0,false,"root",false,"a","a","a,b"],
+  ["select","self",0,true,"root",true,"root","root","a,b"],
+  ["select","self",1,false,"root",false,"a","a","a,b"],
+  ["select","self",1,true,"b",true,"b","b","a,b"],
+  ["select","self",2,false,"root",false,"a","a","a,b"],
+  ["select","self",2,true,"b",true,"b","b","a,b"],
+  ["select","self",3,false,"b",false,null,"b","a,b"],
+  ["select","self",3,true,"b",true,"b","b","a,b"],
+  ["select","sibling",0,false,"root",false,"b","b","b"],
+  ["select","sibling",0,true,"root",true,"root","root","b"],
+  ["select","sibling",1,false,"root",false,"b","b","b"],
+  ["select","sibling",1,true,"a",true,"a","a","b"],
+  ["select","sibling",2,false,"root",false,"b","b","b"],
+  ["select","sibling",2,true,"nested",true,"nested","nested","b"],
+  ["select","sibling",3,false,"root",false,"b","b","b"],
+  ["select","sibling",3,true,"root",false,"b","b","b"],
+  ["select","fragment",0,false,"root",false,"x","x","x,y,b"],
+  ["select","fragment",0,true,"root",true,"root","root","x,y,b"],
+  ["select","fragment",1,false,"root",false,"x","x","x,y,b"],
+  ["select","fragment",1,true,"b",true,"b","b","x,y,b"],
+  ["select","fragment",2,false,"root",false,"x","x","x,y,b"],
+  ["select","fragment",2,true,"b",true,"b","b","x,y,b"],
+  ["select","fragment",3,false,"b",false,null,"b","x,y,b"],
+  ["select","fragment",3,true,"b",true,"b","b","x,y,b"],
+  ["select","descendant",0,false,"root",false,"nested","nested","nested,b"],
+  ["select","descendant",0,true,"root",true,"root","root","nested,b"],
+  ["select","descendant",1,false,"root",false,"nested","nested","nested,b"],
+  ["select","descendant",1,true,"b",true,"b","b","nested,b"],
+  ["select","descendant",2,false,"root",false,"nested","nested","nested,b"],
+  ["select","descendant",2,true,"b",true,"b","b","nested,b"],
+  ["select","descendant",3,false,"b",false,null,"b","nested,b"],
+  ["select","descendant",3,true,"b",true,"b","b","nested,b"],
+  ["select","multiple",0,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",0,true,"root",true,"root","root","x,a,b"],
+  ["select","multiple",1,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",1,true,"root",false,"x","x","x,a,b"],
+  ["select","multiple",2,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",2,true,"root",false,"x","x","x,a,b"],
+  ["select","multiple",3,false,"root",false,"x","x","x,a,b"],
+  ["select","multiple",3,true,"root",false,"x","x","x,a,b"],
+  ["mask","0",0],
+  ["mask","1",1],
+  ["mask","-1",4294967295],
+  ["mask","4294967297",1],
+  ["mask","NaN",0],
+  ["mask","Infinity",0],
+  ["mask","1",1],
+  ["mask","null",0],
+  ["mask","1","TypeError"],
+  ["mask","1","TypeError"],
+  ["mask","Symbol(x)","TypeError"],
+  ["filter","1",true],
+  ["filter","65537",true],
+  ["filter","-65535",true],
+  ["filter","NaN",false],
+  ["filter","Infinity",false],
+  ["filter","1",true],
+  ["filter","null",false],
+  ["filter","1","TypeError"],
+  ["filter","1","TypeError"],
+  ["filter","Symbol(x)","TypeError"],
+  ["walk","element",0,"accept","",""],
+  ["walk","element",0,"reject","",""],
+  ["walk","element",0,"skip","",""],
+  ["walk","element",0,"alternating","",""],
+  ["walk","element",1,"accept","1,1","1,1"],
+  ["walk","element",1,"reject","",""],
+  ["walk","element",1,"skip","",""],
+  ["walk","element",1,"alternating","",""],
+  ["walk","element",4,"accept","3","3"],
+  ["walk","element",4,"reject","",""],
+  ["walk","element",4,"skip","",""],
+  ["walk","element",4,"alternating","3","3"],
+  ["walk","element",128,"accept","8","8"],
+  ["walk","element",128,"reject","",""],
+  ["walk","element",128,"skip","",""],
+  ["walk","element",128,"alternating","8","8"],
+  ["walk","element",4294967295,"accept","1,1,3,8","8,3,1,1"],
+  ["walk","element",4294967295,"reject","",""],
+  ["walk","element",4294967295,"skip","",""],
+  ["walk","element",4294967295,"alternating","3,8","8,3"],
+  ["walk","fragment",0,"accept","",""],
+  ["walk","fragment",0,"reject","",""],
+  ["walk","fragment",0,"skip","",""],
+  ["walk","fragment",0,"alternating","",""],
+  ["walk","fragment",1,"accept","1","1"],
+  ["walk","fragment",1,"reject","",""],
+  ["walk","fragment",1,"skip","",""],
+  ["walk","fragment",1,"alternating","",""],
+  ["walk","fragment",4,"accept","3","3"],
+  ["walk","fragment",4,"reject","",""],
+  ["walk","fragment",4,"skip","",""],
+  ["walk","fragment",4,"alternating","3","3"],
+  ["walk","fragment",128,"accept","8","8"],
+  ["walk","fragment",128,"reject","",""],
+  ["walk","fragment",128,"skip","",""],
+  ["walk","fragment",128,"alternating","8","8"],
+  ["walk","fragment",4294967295,"accept","11,1,3,8","8,3,1,11"],
+  ["walk","fragment",4294967295,"reject","",""],
+  ["walk","fragment",4294967295,"skip","",""],
+  ["walk","fragment",4294967295,"alternating","11,3,8","8,3,11"],
+  ["walk","text",0,"accept","",""],
+  ["walk","text",0,"reject","",""],
+  ["walk","text",0,"skip","",""],
+  ["walk","text",0,"alternating","",""],
+  ["walk","text",1,"accept","",""],
+  ["walk","text",1,"reject","",""],
+  ["walk","text",1,"skip","",""],
+  ["walk","text",1,"alternating","",""],
+  ["walk","text",4,"accept","3","3"],
+  ["walk","text",4,"reject","",""],
+  ["walk","text",4,"skip","",""],
+  ["walk","text",4,"alternating","3","3"],
+  ["walk","text",128,"accept","",""],
+  ["walk","text",128,"reject","",""],
+  ["walk","text",128,"skip","",""],
+  ["walk","text",128,"alternating","",""],
+  ["walk","text",4294967295,"accept","3","3"],
+  ["walk","text",4294967295,"reject","",""],
+  ["walk","text",4294967295,"skip","",""],
+  ["walk","text",4294967295,"alternating","3","3"],
+  ["walk","comment",0,"accept","",""],
+  ["walk","comment",0,"reject","",""],
+  ["walk","comment",0,"skip","",""],
+  ["walk","comment",0,"alternating","",""],
+  ["walk","comment",1,"accept","",""],
+  ["walk","comment",1,"reject","",""],
+  ["walk","comment",1,"skip","",""],
+  ["walk","comment",1,"alternating","",""],
+  ["walk","comment",4,"accept","",""],
+  ["walk","comment",4,"reject","",""],
+  ["walk","comment",4,"skip","",""],
+  ["walk","comment",4,"alternating","",""],
+  ["walk","comment",128,"accept","8","8"],
+  ["walk","comment",128,"reject","",""],
+  ["walk","comment",128,"skip","",""],
+  ["walk","comment",128,"alternating","8","8"],
+  ["walk","comment",4294967295,"accept","8","8"],
+  ["walk","comment",4294967295,"reject","",""],
+  ["walk","comment",4294967295,"skip","",""],
+  ["walk","comment",4294967295,"alternating","8","8"],
+  ["walk","doctype",0,"accept","",""],
+  ["walk","doctype",0,"reject","",""],
+  ["walk","doctype",0,"skip","",""],
+  ["walk","doctype",0,"alternating","",""],
+  ["walk","doctype",1,"accept","",""],
+  ["walk","doctype",1,"reject","",""],
+  ["walk","doctype",1,"skip","",""],
+  ["walk","doctype",1,"alternating","",""],
+  ["walk","doctype",4,"accept","",""],
+  ["walk","doctype",4,"reject","",""],
+  ["walk","doctype",4,"skip","",""],
+  ["walk","doctype",4,"alternating","",""],
+  ["walk","doctype",128,"accept","",""],
+  ["walk","doctype",128,"reject","",""],
+  ["walk","doctype",128,"skip","",""],
+  ["walk","doctype",128,"alternating","",""],
+  ["walk","doctype",4294967295,"accept","10","10"],
+  ["walk","doctype",4294967295,"reject","",""],
+  ["walk","doctype",4294967295,"skip","",""],
+  ["walk","doctype",4294967295,"alternating","10","10"]
+]

package/test/fractional-text-scale.test.js

@@ -0,0 +1,6 @@
+import {test,expect} from 'bun:test';
+test('fractional font sizes retain the final glyph at different device scales',async()=>{
+ const child=Bun.spawn([process.execPath,new URL('./fixtures/fractional-text-scale.js',import.meta.url).pathname],{stdout:'pipe',stderr:'pipe'});
+ const [exit,stderr]=await Promise.all([child.exited,new Response(child.stderr).text()]);
+ expect({exit,stderr}).toEqual({exit:0,stderr:''});
+},30000);

package/test/inert-link.test.js

@@ -0,0 +1,37 @@
+import {test, expect} from 'bun:test';
+import Window from '../vendor/happy-dom/packages/happy-dom/src/window/Window.ts';
+import {createInertWindow} from '../lib/happy-dom/parser.js';
+
+test('inert links leave existing and subsequent ordinary windows resource loading intact', async () => {
+  const requests=[];
+  const server=Bun.serve({port:0,fetch(req){requests.push(new URL(req.url).pathname);return new Response('body{color:red}',{headers:{'content-type':'text/css'}})}});
+  const windows=[];
+  const ordinary=()=>{const w=new Window({url:server.url.href});windows.push(w);return w};
+  const addLink=(w,path)=>{
+    const link=w.document.createElement('link'),events=[];
+    link.rel='stylesheet';link.href=path;
+    link.onload=()=>events.push('load');link.onerror=()=>events.push('error');
+    w.document.head.append(link);return {link,events};
+  };
+  try {
+    const before=ordinary();
+    const inert=createInertWindow(server.url.href);windows.push(inert);
+    const after=ordinary();
+    // Repeated setup must not replace the saved native hooks with wrappers.
+    windows.push(createInertWindow(server.url.href));
+    for(const [w,path] of [[before,'/before.css'],[after,'/after.css']]){
+      const {link,events}=addLink(w,path);
+      await w.happyDOM.waitUntilComplete();
+      expect(events).toEqual(['load']);expect(link.sheet).not.toBeNull();
+      link.href=path+'?changed';await w.happyDOM.waitUntilComplete();
+      expect(events).toEqual(['load','load']);
+    }
+    const {link,events}=addLink(inert,'/inert.css');
+    link.href='/inert-changed.css';
+    await inert.happyDOM.waitUntilComplete();
+    expect(events).toEqual([]);expect(link.sheet).toBeNull();
+    expect(requests).toEqual(['/before.css','/before.css','/after.css','/after.css']);
+  } finally {
+    await Promise.all(windows.map(w=>w.happyDOM.abort()));server.stop(true);
+  }
+});

package/test/node-iterator.test.js

@@ -0,0 +1,81 @@
+import { afterAll, beforeAll, expect, test } from 'bun:test';
+import { RendererHost } from '../lib/renderer/host.js';
+import { nodeIteratorCases } from './fixtures/node-iterator-cases.js';
+import chromium from './fixtures/node-iterator-chromium.json';
+
+const host = new RendererHost({timeout: 20000, fetch: async () => new Response('')});
+beforeAll(async () => {
+  await host.call('loadDocument', {url:'https://iterator.test/',source:'<body></body>',contentType:'text/html',status:200});
+  await host.call('whenLoaded');
+});
+afterAll(() => host.close());
+const evaluate = async expression => JSON.parse(await host.call('evaluate', `JSON.stringify(${expression})`));
+
+test('NodeIterator traversal, replacement and WebIDL conversion match Chromium and DOM', async () => {
+  const actual = await evaluate(`(${nodeIteratorCases})()`);
+  const expected = chromium.map(row => {
+    // Chromium retains a detached reference when replacing a node with its
+    // following sibling while the pointer is before it. DOM replace adopts
+    // (detaches) that sibling first, then removes the old node: the repaired
+    // reference must be root, not the now-detached old node/descendant.
+    // https://dom.spec.whatwg.org/#concept-node-replace steps 6–7
+    if (row[1] === 'sibling' && [1,2].includes(row[2]) && row[3]) {
+      return [...row.slice(0,4), 'root', false, 'b', 'b', 'b'];
+    }
+    return row;
+  });
+  expect(actual).toEqual(expected);
+});
+
+test('failed replacements leave the tree and iterator position unchanged', async () => {
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const kind of ['ancestor','missing','document','textDocument','twoElements']) {
+      const root=document.createElement('div');root.id='root';root.innerHTML='<b id="a"></b><i id="b"></i>';
+      const doc=document.implementation.createHTMLDocument('');
+      const parent=kind==='textDocument'||kind==='twoElements'?doc:root;
+      const old=parent.firstChild;
+      const it=document.createNodeIterator(parent);it.nextNode();it.nextNode();
+      const reference=it.referenceNode,before=it.pointerBeforeReferenceNode;
+      const children=[...parent.childNodes];
+      let incoming=kind==='ancestor'?root:kind==='document'?document:document.createElement('em');
+      if(kind==='textDocument')incoming=document.createTextNode('invalid');
+      if(kind==='twoElements'){incoming=document.createDocumentFragment();incoming.append(document.createElement('i'),document.createElement('b'));}
+      let error;
+      try{parent.replaceChild(incoming,kind==='missing'?document.createElement('b'):old)}catch(e){error=e.name}
+      results.push([kind,error,it.referenceNode===reference,it.pointerBeforeReferenceNode===before,
+        children.length===parent.childNodes.length&&children.every((n,i)=>n===parent.childNodes[i])]);
+    }
+    return results;
+  })()`)).toEqual([
+    ['ancestor','HierarchyRequestError',true,true,true],['missing','NotFoundError',true,true,true],
+    ['document','HierarchyRequestError',true,true,true],['textDocument','HierarchyRequestError',true,true,true],
+    ['twoElements','HierarchyRequestError',true,true,true]
+  ]);
+});
+
+test('filter replacement repairs both active and stored iterator cursors', async () => {
+  expect(await evaluate(`(() => {
+    const root=document.createElement('div');root.id='root';root.innerHTML='<b id="a"></b><i id="b"></i>';
+    const it=document.createNodeIterator(root,1,n=>{
+      if(n.id==='a'){const replacement=document.createElement('em');replacement.id='x';root.replaceChild(replacement,n)}
+      return 1;
+    });
+    const got=[];for(let n,i=0;i<8&&(n=it.nextNode());i++)got.push(n.id);
+    return got;
+  })()`)).toEqual(['root','a','x','b']);
+});
+
+test('batch removal follows DOM tree order and keeps references attached', async () => {
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const operation of ['replaceChildren','innerHTML','textContent'])for(const before of [false,true]) {
+      const root=document.createElement('div');root.innerHTML='<i>a</i><i>b</i>';
+      const it=document.createNodeIterator(root);it.nextNode();it.nextNode();it.nextNode();
+      if(before)it.previousNode();
+      if(operation==='replaceChildren')root.replaceChildren();else root[operation]='';
+      results.push([it.referenceNode===root,it.pointerBeforeReferenceNode,it.nextNode()]);
+    }
+    return results;
+  })()`)).toEqual(Array.from({length:6},()=>[true,false,null]));
+});

package/test/page-scripts.test.js

@@ -1997,14 +1997,24 @@ test("a click inside an iframe goes to the element under it in the frame's docum
 test("dynamic linked stylesheets fire load after their rules become available", async () => {
   await load(`<div id="target"></div><script>
     window.sheetLoaded = false;
+    window.sheetEvents = [];
     const link = document.createElement('link');
     link.rel = 'stylesheet';
     link.href = '/slow.css';
-    link.onload = () => { window.sheetLoaded = getComputedStyle(document.body).color; };
+    window.styleTestLink = link;
+    link.onerror = () => sheetEvents.push('error');
+    link.onload = () => { sheetEvents.push('load'); window.sheetLoaded = getComputedStyle(document.body).color; };
     document.head.appendChild(link);
   </script>`);
   for (let i = 0; i < 60 && await evaluate('sheetLoaded') === false; i++) await Bun.sleep(25);
   expect(await evaluate('sheetLoaded')).toBe('rgba(255, 0, 0, 1)');
+  expect(await evaluate('sheetEvents.join()')).toBe('load');
+  await evaluate("styleTestLink.href='/missing.css'; window.eventsAfterHref=sheetEvents.join()");
+  expect(await evaluate('eventsAfterHref')).toBe('load');
+  expect(await waitFor("sheetEvents.join() === 'load,error'")).toBe(true);
+  await evaluate("styleTestLink.href='/slow.css'; window.eventsAfterHref=sheetEvents.join()");
+  expect(await evaluate('eventsAfterHref')).toBe('load,error');
+  expect(await waitFor("sheetEvents.join() === 'load,error,load'")).toBe(true);
 });
 
 test("decoded dynamic images report natural dimensions and fire load", async () => {
@@ -2154,3 +2164,108 @@ test("the page scrolls over content that overflows a 100vh layout, not over clip
   expect(await evaluate(`(scrollTo(0, 99999), [scrollY, Math.round(document.getElementById("end").getBoundingClientRect().bottom)])`))
     .toEqual([2090 - 300, 300]);
 });
+
+test("NodeIterator includes its root, preserves direction, and skips rejected nodes without pruning", async () => {
+  await load('<div id="root"><p id="a"><b id="child"></b></p><!--note--><p id="b"></p></div>');
+  expect(await evaluate(`(() => {
+    const root = document.getElementById('root');
+    const filter = {acceptNode(n) {return n.id === 'a' ? NodeFilter.FILTER_REJECT : NodeFilter.FILTER_ACCEPT}};
+    const it = document.createNodeIterator(root, NodeFilter.SHOW_ELEMENT, filter);
+    const initial = [it instanceof NodeIterator,it.root === root,it.referenceNode === root,it.pointerBeforeReferenceNode,it.filter === filter];
+    const forward=[];let n;while(n=it.nextNode())forward.push(n.id);
+    const reverse=[];while(n=it.previousNode())reverse.push(n.id);
+    it.detach();
+    return JSON.stringify([initial,forward,reverse,it.nextNode().id]);
+  })()`)).toBe(JSON.stringify([[true,true,true,true,true],['root','child','b'],['b','child','root'],'root']));
+});
+
+test("NodeIterator survives sanitizer removals, reparenting, and rejected reentrant filters", async () => {
+  await load('<div id="root"><i id="a"><b id="child"></b></i><i id="b"></i><i id="c"></i></div>');
+  expect(await evaluate(`(() => {
+    const root=document.getElementById('root'),it=document.createNodeIterator(root,1);
+    it.nextNode();it.nextNode();it.nextNode();
+    root.firstChild.remove();
+    const removed=[it.referenceNode.id,it.nextNode().id];
+    it.previousNode();root.firstChild.remove();
+    const before=[it.referenceNode.id,it.pointerBeforeReferenceNode,it.nextNode().id];
+    document.body.appendChild(root.firstChild);
+    const moved=[it.referenceNode.id,it.nextNode()];
+    let error;const recur=document.createNodeIterator(root,1,()=>{try{recur.nextNode()}catch(e){error=e.name}return 1});
+    recur.nextNode();
+    const fresh=document.createNodeIterator(root,NodeFilter.SHOW_TEXT);
+    root.innerHTML='hello<b>world</b>';
+    return JSON.stringify([removed,before,moved,error,fresh.nextNode().data,fresh.nextNode().data]);
+  })()`)).toBe(JSON.stringify([['root','b'],['c',true,'c'],['root',null],'InvalidStateError','hello','world']));
+});
+
+// Expectations independently checked against Chromium Headless Shell.
+test("NodeIterator repairs an active filter cursor when the candidate or its ancestor is removed", async () => {
+  await load("<body></body>");
+  expect(await evaluate(`JSON.stringify((()=>{const results=[];for(const direction of ['nextNode','previousNode'])for(const remove of ['self','ancestor'])for(const verdict of [1,3]){
+ const root=document.createElement('div');root.id='root';root.innerHTML='<i id="a"></i><section id="parent"><b id="b"></b><b id="c"></b></section><i id="d"></i>';document.body.append(root);
+ let armed=false,once=false;const seen=[];const it=document.createNodeIterator(root,1,n=>{if(armed)seen.push(n.id);if(armed&&!once&&n.id==='b'){once=true;(remove==='self'?n:n.parentNode).remove();return verdict;}return 1});
+ if(direction==='previousNode')while(it.nextNode());armed=true;
+ const got=[];for(let n,k=0;k<15&&(n=it[direction]());k++)got.push(n.id);
+ results.push({direction,remove,verdict,seen,got,reference:it.referenceNode.id,before:it.pointerBeforeReferenceNode});root.remove();
+}return results.map(r=>[r.direction,r.remove,r.verdict,r.seen.join(','),r.got.join(','),r.reference,r.before])})())`)).toBe(JSON.stringify([
+    ["nextNode", "self", 1, "root,a,parent,b,c,d", "root,a,parent,b,c,d", "d", false],
+    ["nextNode", "self", 3, "root,a,parent,b,c,d", "root,a,parent,c,d", "d", false],
+    ["nextNode", "ancestor", 1, "root,a,parent,b,d", "root,a,parent,b,d", "d", false],
+    ["nextNode", "ancestor", 3, "root,a,parent,b,d", "root,a,parent,d", "d", false],
+    ["previousNode", "self", 1, "d,c,b,parent,a,root", "d,c,b,parent,a,root", "root", true],
+    ["previousNode", "self", 3, "d,c,b,parent,a,root", "d,c,parent,a,root", "root", true],
+    ["previousNode", "ancestor", 1, "d,c,b,a,root", "d,c,b,a,root", "root", true],
+    ["previousNode", "ancestor", 3, "d,c,b,a,root", "d,c,a,root", "root", true]
+  ]));
+});
+
+test("NodeIterator releases its active cursor after a filter throws", async () => {
+  await load('<div id="root"><b id="child"></b></div>');
+  expect(await evaluate(`(() => {
+    const root=document.getElementById('root');let first=true;
+    const it=document.createNodeIterator(root,1,()=>{if(first){first=false;throw Error('filter failed')}return 1});
+    let message;try{it.nextNode()}catch(e){message=e.message}
+    return [message,it.nextNode().id,it.nextNode().id].join(',');
+  })()`)).toBe('filter failed,root,child');
+});
+
+test("NodeIterator repairs removals through proxy-backed select and form parents", async () => {
+  await load('<body></body>');
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const tag of ['div','select','form']) for(const outerRoot of [false,true])
+      for(const operation of ['remove','removeChild','innerHTML','reparent']) {
+        const outer=document.createElement('div'),parent=document.createElement(tag);
+        outer.append(parent);document.body.append(outer);
+        parent.innerHTML='<option id="a"></option><option id="b"></option>';
+        const it=document.createNodeIterator(outerRoot?outer:parent,1);
+        while(it.nextNode()?.id!=='a') {}
+        const child=parent.firstChild;
+        if(operation==='remove')child.remove();
+        else if(operation==='removeChild')parent.removeChild(child);
+        else if(operation==='innerHTML')parent.innerHTML='';
+        else outer.append(child);
+        results.push([it.referenceNode===parent,it.nextNode()?.id??null]);
+        outer.remove();
+      }
+    return JSON.stringify(results);
+  })()`)).toBe(JSON.stringify(Array.from({length:6},()=>[
+    [true,'b'],[true,'b'],[true,null],[true,'b']
+  ]).flat()));
+});
+
+test("NodeIterator validates nullable callback-interface filters at creation", async () => {
+  await load('<body></body>');
+  expect(await evaluate(`(() => {
+    const results=[];
+    for(const filter of [0,1,false,true,'','x',Symbol('filter'),1n]) {
+      try { document.createNodeIterator(document.body,0,filter);results.push('accepted'); }
+      catch(error) { results.push(error.name); }
+    }
+    for(const filter of [null,undefined,()=>1,{acceptNode(){return 1}},{}]) {
+      const it=document.createNodeIterator(document.body,0,filter);
+      results.push(it.filter===(filter??null) && it.nextNode()===null);
+    }
+    return JSON.stringify(results);
+  })()`)).toBe(JSON.stringify([...Array(8).fill('TypeError'),...Array(5).fill(true)]));
+});

package/test/text-layout.test.js

@@ -675,3 +675,18 @@ test("an out-of-flow box keeps its static position when the block around its pla
   (document) => { document.getElementById("edit").textContent = "a longer paragraph that wraps onto two lines"; });
   expect(rankedLayout(retained)).toEqual(rankedLayout(clean));
 });
+
+test("anonymous flex text items do not reuse their parent's intrinsic width", () => {
+  const { document, window } = parseHTMLDocument(`<body style="margin:0"><div style="display:flex">
+    <span style="display:flex"><a>hash</a>·<time>Today</time>!</span><b>History</b>
+  </div></body>`);
+  const tree = new RenderTreeBuilder().build(document, new StyleEngine().compute(document));
+  const engine = new LayoutEngine({ measureText: text => text.length * 10 });
+  for (const width of [500, 180, 500]) {
+    const layout = engine.layout(tree, { x:0, y:0, width });
+    expect(layout.fragments.map(f => [f.text, f.x, f.width])).toEqual([
+      ["hash", 0, 40], ["·", 40, 10], ["Today", 50, 50], ["!", 100, 10], ["History", 110, 70],
+    ]);
+  }
+  window.happyDOM.abort();
+});

package/test/window-resize.test.js

@@ -34,3 +34,32 @@ test('viewport resize notifies window listeners with fresh geometry and repaints
   expect(await host.call('evaluate','propertyEvents')).toBe(2);
  }finally{host.close();}
 },30000);
+
+test('same-pixel-size DPR changes relayout a quiet page and update viewport CSS',async()=>{
+ const host=new RendererHost({timeout:20000});
+ try {
+  await host.call('resize',1920,1035,1);
+  await host.call('loadDocument',{url:'https://resize.test/',contentType:'text/html',source:`
+   <style>body{margin:0}#center{width:1000px;margin:0 auto;height:20px}
+   #units{width:50vw;height:10vh}#media{width:10px}
+   @media(max-width:1400px){#media{width:30px}}</style>
+   <div id="center">Contact — Buninu Linux</div><div id="units"></div><div id="media"></div>`});
+  await host.call('whenLoaded');
+  const geometry=()=>host.call('evaluate',`JSON.stringify(['center','units','media'].map(id=>{
+   const r=document.getElementById(id).getBoundingClientRect();return [r.x,r.width,r.height];
+  }))`);
+  expect(await geometry()).toBe('[[460,1000,20],[0,960,103.5],[0,10,0]]');
+  for(const [width,height,dpr,expected] of [
+   [1280,690,1.5,'[[140,1000,20],[0,640,69],[0,30,0]]'],
+   [1920,1035,1,'[[460,1000,20],[0,960,103.5],[0,10,0]]'],
+   [1280,690,1.5,'[[140,1000,20],[0,640,69],[0,30,0]]'],
+   // DPR-only changes repaint without changing CSS geometry.
+   [1280,690,2,'[[140,1000,20],[0,640,69],[0,30,0]]'],
+  ]) {
+   await host.call('resize',width,height,dpr);
+   expect(await geometry()).toBe(expected);
+   const png=Buffer.from(await host.composite('screenshot',{format:'png'}),'base64');
+   expect([png.readUInt32BE(16),png.readUInt32BE(20)]).toEqual([width*dpr,height*dpr]);
+  }
+ }finally{host.close()}
+},30000);