buninu-browser 0.1.0 → 0.2.1

package/test/positioning.test.js

@@ -54,6 +54,17 @@ test("left+right and top+bottom stretch an absolute box, percentages use the con
   expect(box(".half")).toMatchObject({ x: 50, y: 50 });
 });
 
+test("absolute percentage width uses the full containing block after a left inset", () => {
+  const { box } = render(
+    `<div class="frame"><div class="first"></div><div class="second"></div></div>`,
+    `.frame { position:relative; width:200px; height:100px }
+     .first, .second { position:absolute; top:0; width:10%; height:20px }
+     .first { left:10% } .second { left:70% }`,
+  );
+  expect(box(".first")).toEqual({ x: 20, y: 0, width: 20, height: 20 });
+  expect(box(".second")).toEqual({ x: 140, y: 0, width: 20, height: 20 });
+});
+
 test("relative offsets and translate move a box and its content without affecting siblings", () => {
   const { box, layout } = render(
     `<div class="moved">text</div><div class="next">after</div><div class="centered"></div>`,

package/test/pulse-client.test.js

@@ -0,0 +1,130 @@
+import { expect, test } from "bun:test";
+import { connect } from "node:net";
+import { floatToS16, PulseClient } from "../lib/audio/pulse-client.js";
+import { splitSamples } from "../lib/audio/pcm.js";
+
+// The playback test needs a PulseAudio native-protocol server (jspulse, or a
+// daemon with module-native-protocol-tcp) on 127.0.0.1:4713; without one it is skipped.
+const serverRunning = await new Promise((resolve) => {
+  const socket = connect({ host: "127.0.0.1", port: 4713 });
+  const done = (running) => {
+    socket.destroy();
+    resolve(running);
+  };
+  socket.once("connect", () => done(true));
+  socket.once("error", () => done(false));
+  setTimeout(() => done(false), 1000);
+});
+
+test("floatToS16 clamps and scales interleaved samples to s16le", () => {
+  const bytes = floatToS16(new Float32Array([0, 1, -1, 2, 0.5]));
+  expect([...new Int16Array(bytes.buffer)]).toEqual([0, 32767, -32768, 32767, 16384]);
+});
+
+test("small audio requests consume only whole frames and preserve the remainder", () => {
+  const original = Float32Array.from({ length: 2048 }, (_, index) => index / 2048);
+  let pending = original;
+  const sent = [];
+  for (const bytes of [4, 80, 3840, 172]) {
+    const [part, rest] = splitSamples(pending, 2, bytes);
+    expect(part.length * 2).toBeLessThanOrEqual(bytes);
+    expect(part.length % 2).toBe(0);
+    sent.push(part);
+    pending = rest;
+  }
+  expect([...sent.flatMap((part) => [...part]), ...pending]).toEqual([...original]);
+});
+
+test.skipIf(!serverRunning)("plays a stream through the PulseAudio server on 127.0.0.1:4713", async () => {
+  const client = await PulseClient.connect();
+  const requests = [];
+  const stream = await client.openPlayback({ rate: 44100, channels: 2, onRequest: (bytes) => requests.push(bytes) });
+  expect(requests[0]).toBeGreaterThan(0);
+  stream.write(floatToS16(new Float32Array(44100 * 2 / 10))); // 0.1 s of stereo silence
+  await stream.finish();
+  expect(stream.killed).toBe(true);
+  client.close();
+});
+
+test.skipIf(!serverRunning)("opens independent playback streams at different sample rates", async () => {
+  const client = await PulseClient.connect();
+  const first = await client.openPlayback({ rate: 48000, channels: 1, name: "first" });
+  const second = await client.openPlayback({ rate: 44100, channels: 2, name: "second" });
+  expect(first.index).not.toBe(second.index);
+  await second.close();
+  await first.close();
+  client.close();
+});
+
+test("connecting without a server fails with an error, not a hang", async () => {
+  await expect(PulseClient.connect({ port: 1 })).rejects.toThrow();
+});
+
+test("audio is sent in whole frames, so stereo channels never swap", async () => {
+  // A minimal server: replies to every command, grants odd-sized requests, records audio frame sizes.
+  const sizes = [];
+  const offsets = [];
+  const flags = [];
+  const bufferAttributes = [];
+  let nextStreamIndex = 1;
+  const { createServer } = await import("node:net");
+  const server = createServer((socket) => {
+    let buffer = Buffer.alloc(0);
+    const reply = (tag, extra = []) => {
+      const body = Buffer.from([0x4c, 0, 0, 0, 2, 0x4c, ...u32(tag), ...extra]);
+      socket.write(Buffer.concat([header(body.length, 0xffffffff), body]));
+    };
+    socket.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      while (buffer.length >= 20 && buffer.length >= 20 + buffer.readUInt32BE(0)) {
+        const length = buffer.readUInt32BE(0);
+        const channel = buffer.readUInt32BE(4);
+        const offset = buffer.readBigInt64BE(8);
+        const flag = buffer.readUInt32BE(16);
+        const body = buffer.subarray(20, 20 + length);
+        buffer = buffer.subarray(20 + length);
+        if (channel !== 0xffffffff) {
+          sizes.push(length);
+          offsets.push(offset);
+          flags.push(flag);
+          continue;
+        }
+        const command = body.readUInt32BE(1);
+        const tag = body.readUInt32BE(6);
+        if (command === 3) {
+          const nameEnd = body.indexOf(0, 11);
+          const channelCount = body[nameEnd + 3];
+          const attrs = nameEnd + 1 + 7 + 2 + channelCount + 5 + 1 + 5 + 1;
+          bufferAttributes.push([0, 1, 2].map((index) => body.readUInt32BE(attrs + index * 5 + 1)));
+          reply(tag, [0x4c, ...u32(nextStreamIndex++), 0x4c, ...u32(1), 0x4c, ...u32(96003)]); // odd request, enough for several packets
+        }
+        else reply(tag);
+      }
+    });
+  });
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const client = await PulseClient.connect({ port: server.address().port });
+  const stream = await client.openPlayback({ rate: 48000, channels: 2 });
+  stream.write(new Uint8Array(4 * 24000));
+  await Bun.sleep(100);
+  expect(sizes.length).toBeGreaterThan(1);
+  expect(sizes.every((size) => size % 4 === 0)).toBeTrue();
+  expect(offsets.every((offset) => offset === 0n)).toBeTrue();
+  expect(flags.every((flag) => flag === 0)).toBeTrue();
+  expect(bufferAttributes[0]).toEqual([76800, 15360, 7680]); // 400/80/40 ms at 48 kHz stereo
+  await client.openPlayback({ rate: 48000, channels: 1, leadSeconds: 0.12 });
+  expect(bufferAttributes[1]).toEqual([15360, 3840, 3840]); // 160/40/40 ms at 48 kHz mono
+  client.close();
+  server.close();
+});
+
+function u32(value) {
+  return [(value >>> 24) & 255, (value >>> 16) & 255, (value >>> 8) & 255, value & 255];
+}
+
+function header(length, channel) {
+  const out = Buffer.alloc(20);
+  out.writeUInt32BE(length, 0);
+  out.writeUInt32BE(channel, 4);
+  return out;
+}

package/test/render-tree.test.js

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import { parseHTMLDocument } from "../lib/happy-dom/parser.js";
-import { RenderTreeBuilder, renderTreeText } from "../lib/render-tree/index.js";
+import { RenderTreeBuilder, renderTreeText, sameLayoutInput } from "../lib/render-tree/index.js";
 
 test("builds an engine-owned tree and excludes non-rendered DOM nodes", () => {
   const { document, window } = parseHTMLDocument(`<body>
@@ -101,3 +101,38 @@ test("form controls render their live value, placeholder, selection and checked
   expect(renderTreeText(tree)).toContain("bold label");
   window.happyDOM.abort();
 });
+
+test("audio with controls is a 300x32 player painted from its state; without controls it is not rendered", async () => {
+  const { StyleEngine } = await import("../lib/style/computed-style.js");
+  const { document, window } = parseHTMLDocument(`<body><audio id="a" controls src="t.mp3">fallback</audio><audio id="b" src="t.mp3"></audio></body>`);
+  const engine = new StyleEngine().compute(document);
+  const state = { audio: true, playing: false };
+  const tree = new RenderTreeBuilder().build(document, engine, new Map([[document.getElementById("a"), state]]));
+  const node = (id) => [...tree.nodesById.values()].find((candidate) => candidate.domNode.id === id && !candidate.pseudo);
+  expect(node("a")).toMatchObject({ type: "image", tagName: "AUDIO", widthAttribute: 300, heightAttribute: 32 });
+  expect(node("a").resource).toBe(state);
+  expect(node("b")).toBeUndefined();
+  expect(renderTreeText(tree)).not.toContain("fallback");
+  window.happyDOM.abort();
+});
+
+test("detects whether a rebuilt tree changes layout input", async () => {
+  const { StyleEngine } = await import("../lib/style/computed-style.js");
+  const { document, window } = parseHTMLDocument(`<body><p>visible</p><script>old</script></body>`);
+  const builder = new RenderTreeBuilder();
+  const styles = new StyleEngine().compute(document);
+  const first = builder.build(document, styles);
+  const firstParagraph = first.root.children[0];
+
+  document.querySelector("script").textContent = "new metadata";
+  const metadataOnly = builder.build(document, styles);
+  expect(sameLayoutInput(first.root, metadataOnly.root)).toBe(true);
+  expect(metadataOnly.root).toBe(first.root);
+  expect(metadataOnly.root.children[0]).toBe(firstParagraph);
+
+  document.querySelector("p").textContent = "different visible text";
+  const visibleChange = builder.build(document, styles);
+  expect(sameLayoutInput(metadataOnly.root, visibleChange.root)).toBe(false);
+  expect(visibleChange.root.children[0]).not.toBe(firstParagraph);
+  window.happyDOM.abort();
+});

package/test/resolver.test.js

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test";
-import { fetchResolved, HostResolver } from "../lib/network/resolver.js";
+import { fetchResolved, HostResolver, isLocalhostName } from "../lib/network/resolver.js";
 
 const lookupFrom = (table, calls = []) => async (name, { family }) => {
   calls.push(`${name}/${family}`);
@@ -49,3 +49,14 @@ test("connects to the address with the host name in Host and TLS, falling back o
   const failing = async () => { throw Object.assign(new Error("bad cert"), { code: "ERR_TLS_CERT_ALTNAME_INVALID" }); };
   await expect(fetchResolved(failing, resolver, "https://a.test/", {})).rejects.toThrow("bad cert");
 });
+
+test("localhost names are loopback without a lookup (no /etc/hosts needed)", async () => {
+  const resolver = new HostResolver({ lookup: async () => { throw Object.assign(new Error("no hosts"), { code: "ENOTFOUND" }); } });
+  const loopback = [{ address: "127.0.0.1", family: 4 }, { address: "::1", family: 6 }];
+  for (const name of ["localhost", "LocalHost", "localhost.", "app.localhost", "a.b.localhost."]) {
+    expect(await resolver.addresses(name)).toEqual(loopback);
+  }
+  for (const name of ["localhost.com", "notlocalhost", "localhost..", "my-localhost"]) {
+    expect(isLocalhostName(name)).toBe(false);
+  }
+});

package/test/screenshot-cli.test.js

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { screenshotTargetUrl } from "../lib/screenshot-cli.js";
+
+test("screenshot target treats Windows drive and UNC paths as files", () => {
+  const options = {
+    platform: "win32",
+    resolvePath: (path) => path,
+    fileURL: (path) => ({ href: `file:${path}` }),
+  };
+  for (const path of [String.raw`C:\Users\Ada\page.html`, "C:/Users/Ada/page.html", String.raw`\\server\share\page.html`, String.raw`pages\page.html`]) {
+    expect(screenshotTargetUrl(path, options)).toBe(`file:${path}`);
+  }
+});
+
+test("screenshot target preserves URLs and bare hostnames", () => {
+  expect(screenshotTargetUrl("file:///C:/Users/Ada/page.html", { platform: "win32" })).toBe("file:///C:/Users/Ada/page.html");
+  expect(screenshotTargetUrl("https://example.com", { platform: "win32" })).toBe("https://example.com");
+  expect(screenshotTargetUrl("example.com", { platform: "win32" })).toBe("https://example.com");
+});

package/test/selector-keys.test.js

@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test";
+import { selectorKeys } from "../lib/style/selector-keys.js";
+
+test("indexes a selector by its subject's first key and its ancestors' keys", () => {
+  expect(selectorKeys("DIV.Foo > SPAN#Bar.baz[Data-X]")).toEqual({
+    subject: [{ kind: "id", name: "Bar" }],
+    ancestors: ["div", ".Foo"],
+  });
+  // Sibling compounds are not ancestors; attribute and type names are lowercased.
+  expect(selectorKeys("ul [Role] + LI:hover")).toEqual({ subject: [{ kind: "tag", name: "li" }], ancestors: ["ul"] });
+  // :root is the "html" bucket as a subject, but not an ancestor filter key.
+  expect(selectorKeys(":root").subject).toEqual([{ kind: "tag", name: "html" }]);
+  expect(selectorKeys(":ROOT .x")).toEqual({ subject: [{ kind: "class", name: "x" }], ancestors: [] });
+});
+
+test("escapes, quotes and digits in names", () => {
+  expect(selectorKeys(".a\\:hover .b\\.c").ancestors).toEqual([".a:hover"]);
+  expect(selectorKeys(".a\\:hover .b\\.c").subject).toEqual([{ kind: "class", name: "b.c" }]);
+  // A hex escape cannot be resolved here: the name is left out.
+  expect(selectorKeys(".\\31 0").subject).toBeNull();
+  // Class names cannot start with a digit; ids can.
+  expect(selectorKeys(".1a").subject).toBeNull();
+  expect(selectorKeys("#1a").subject).toEqual([{ kind: "id", name: "1a" }]);
+  // Brackets and "." inside a quoted attribute value are not structure.
+  expect(selectorKeys('[data-x="a] .b"] .c')).toEqual({ subject: [{ kind: "class", name: "c" }], ancestors: ["[data-x"] });
+  expect(selectorKeys(".日本 .語")).toEqual({ subject: [{ kind: "class", name: "語" }], ancestors: [".日本"] });
+});
+
+test(":is() and :where() alternatives each need a key; anything not understood is unindexed", () => {
+  expect(selectorKeys(":is(.a, #b, p)").subject).toEqual([
+    { kind: "class", name: "a" }, { kind: "id", name: "b" }, { kind: "tag", name: "p" },
+  ]);
+  expect(selectorKeys(":where(.a .b, .c)").subject).toBeNull();
+  expect(selectorKeys(":is(.a, :not(.b))").subject).toBeNull();
+  expect(selectorKeys("ns|a b").ancestors).toEqual([]);
+  for (const selector of ["", "> a", "a >", "a 'unterminated", ":is(.a"]) {
+    expect(selectorKeys(selector)).toEqual({ subject: null, ancestors: [] });
+  }
+});

package/test/selector-traits.test.js

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { sheetTraits } from "../lib/style/selector-traits.js";
+
+test("finds :has() compounds and sibling-target compounds in a sheet", () => {
+  const traits = sheetTraits(`
+    /* .ignored:has(a) {} */
+    .a:has(> img), .b .c:has(+ .d)::before { color: red }
+    @media (min-width: 1px) { .e { color: blue } }
+    .f:has(.g) .h, .i { color: green }
+    li:first-child + li .x, ul > li:last-child ~ li { color: black }
+    .esc\\:a .y:not([data-z="a b"]) { color: white }
+  `);
+  expect([...traits.hasCompounds]).toEqual([".a:has(> img)", ".c:has(+ .d)", ".f:has(.g)"]);
+  expect(traits.hasSiblings).toBe(true);
+  expect([...traits.siblingTargetCompounds]).toEqual(["li:first-child + li"]);
+  expect([...traits.structuralCompounds]).toEqual(["li:first-child", "li:last-child"]);
+  expect(traits.descendantFeatures.has(".esc:a")).toBe(true);
+  expect(traits.sibling && traits.firstChild && traits.lastChild).toBe(true);
+});

package/test/text-layout.test.js

@@ -1,6 +1,6 @@
 import { expect, test } from "bun:test";
 import { parseHTMLDocument } from "../lib/happy-dom/parser.js";
-import { layoutText } from "../lib/layout/text-layout.js";
+import { LayoutEngine, layoutText } from "../lib/layout/text-layout.js";
 import { RenderTreeBuilder } from "../lib/render-tree/index.js";
 import { StyleEngine } from "../lib/style/computed-style.js";
 
@@ -417,3 +417,93 @@ test("an auto grid track is limited by a min-width: 0 item instead of its conten
   expect(layout.boxes.map((box) => box.width)).toContain(100);
   expect(layout.boxes.map((box) => box.width)).not.toContain(160);
 });
+
+test("a grid body stacks items sharing an area and aligns its content with place-*", () => {
+  const { document, window } = parseHTMLDocument(`<body><i id="icon" style="display:block;width:40px;height:40px"></i>
+    <p id="a">one</p><p id="b">two two</p><p id="c">three</p></body>`);
+  const styles = new StyleEngine().compute(document, [`
+    body { margin:0; display:grid; min-height:300px; place-content:center; place-items:center }
+    p { margin:0; grid-area:2/1 }
+  `]);
+  const tree = new RenderTreeBuilder().build(document, styles);
+  const layout = layoutText(tree, {
+    x: 0, y: 0, width: 400, measureText: (text) => text.length * 10, fontMetrics: () => ({ ascent: 16, height: 20 }),
+  });
+  const boxOf = (id) => layout.boxes.find((box) => tree.nodesById.get(box.nodeId)?.domNode?.id === id);
+  const [icon, a, b, c] = ["icon", "a", "b", "c"].map(boxOf);
+  // One shared row for the paragraphs, centered in 300px under the 40px icon row.
+  expect([a.y, b.y, c.y]).toEqual([a.y, a.y, a.y]);
+  expect(icon.y).toBe((300 - 40 - 20) / 2);
+  expect(a.y).toBe(icon.y + 40);
+  // place-items: center centers each item in the 70px-wide column ("two two").
+  expect([icon.x, a.x, b.x]).toEqual([180, 185, 165]);
+  window.happyDOM.abort();
+});
+
+test("retained block results match a clean layout after a sibling changes", () => {
+  const { document, window } = parseHTMLDocument(`<body><section><p>unchanged subtree</p></section><section id="edit">short</section></body>`);
+  const styles = new StyleEngine().compute(document);
+  const builder = new RenderTreeBuilder();
+  const engine = new LayoutEngine({
+    measureText: (text) => text.length * 10,
+    fontMetrics: () => ({ ascent: 16, height: 20 }),
+  });
+  const options = { x: 0, y: 0, width: 240, measureText: (text) => text.length * 10, fontMetrics: () => ({ ascent: 16, height: 20 }) };
+  engine.layout(builder.build(document, styles), options);
+
+  document.getElementById("edit").textContent = "a changed sibling which wraps onto another line";
+  const tree = builder.build(document, styles);
+  const retained = engine.layout(tree, options);
+  const clean = layoutText(tree, options);
+  expect(retained).toEqual(clean);
+  window.happyDOM.abort();
+});
+
+/** A layout with paint layers as ranks: replays renumber layers, keeping their order. */
+function rankedLayout(layout) {
+  const orders = new Set([0]);
+  for (const entry of [...layout.boxes, ...layout.fragments]) {
+    for (let layer = entry.layer; layer; layer = layer.parent) orders.add(layer.order);
+  }
+  const rank = new Map([...orders].sort((a, b) => a - b).map((order, index) => [order, index]));
+  const layer = (value) => value && { rank: rank.get(value.order), z: value.z, context: value.context, parent: value.parent ? rank.get(value.parent.order) : null };
+  return {
+    height: layout.height,
+    boxes: layout.boxes.map((box) => ({ ...box, layer: layer(box.layer) })),
+    fragments: layout.fragments.map(({ id, ...fragment }) => ({ ...fragment, layer: layer(fragment.layer) })),
+  };
+}
+
+function retainedAndClean(html, change) {
+  const { document, window } = parseHTMLDocument(html);
+  const styles = new StyleEngine().compute(document);
+  const builder = new RenderTreeBuilder();
+  const measure = { measureText: (text) => text.length * 10, fontMetrics: () => ({ ascent: 16, height: 20 }) };
+  const engine = new LayoutEngine(measure);
+  const options = { x: 0, y: 0, width: 240, viewportHeight: 300, ...measure };
+  engine.layout(builder.build(document, styles), options);
+  change(document);
+  const tree = builder.build(document, styles);
+  const result = { retained: engine.layout(tree, options), clean: layoutText(tree, options), document };
+  window.happyDOM.abort();
+  return result;
+}
+
+test("positioned boxes inside a retained block are replayed in their paint layers", () => {
+  const { retained, clean } = retainedAndClean(`<body><p id="edit">short</p>
+    <section><div style="position:relative;z-index:2">raised <span style="position:relative">inner</span></div>
+    <div style="position:relative">auto</div><p style="position:absolute;top:5px;z-index:-1">behind</p></section></body>`,
+  (document) => { document.getElementById("edit").textContent = "a longer paragraph that wraps onto two lines"; });
+  expect(rankedLayout(retained)).toEqual(rankedLayout(clean));
+  // The section moved down with the wrapped paragraph, and its layers came along.
+  expect(new Set(retained.boxes.map((box) => box.layer.order)).size).toBe(new Set(clean.boxes.map((box) => box.layer.order)).size);
+});
+
+test("an out-of-flow box keeps its static position when the block around its placeholder is replayed", () => {
+  // The absolute box's containing block is the positioned div; its placeholder is in the section,
+  // which is replayed (moved down) after the paragraph above it grows.
+  const { retained, clean } = retainedAndClean(`<body><div style="position:relative"><p id="edit">short</p>
+    <section><p>above</p><div style="position:absolute">static</div><p>below</p></section></div></body>`,
+  (document) => { document.getElementById("edit").textContent = "a longer paragraph that wraps onto two lines"; });
+  expect(rankedLayout(retained)).toEqual(rankedLayout(clean));
+});

package/test/user-agent.test.js

@@ -0,0 +1,42 @@
+import { expect, test } from "bun:test";
+import { CdpServer } from "../lib/cdp-server.js";
+import { createBrowser } from "../lib/headless-shell.js";
+import { MOBILE_USER_AGENT } from "../lib/renderer/flags.js";
+import { CHROMIUM_VERSION, DESKTOP_USER_AGENT, desktopUserAgent } from "../lib/user-agent.js";
+
+test("desktop user agent uses the same version on each platform", () => {
+  for (const [platform, arch, system] of [
+    ["linux", "arm64", "X11; Linux aarch64"],
+    ["linux", "x64", "X11; Linux x86_64"],
+    ["win32", "x64", "Windows NT 10.0; Win64; x64"],
+    ["darwin", "arm64", "Macintosh; Intel Mac OS X 10_15_7"],
+  ]) {
+    expect(desktopUserAgent(platform, arch)).toBe(`Mozilla/5.0 (${system}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${CHROMIUM_VERSION} Safari/537.36`);
+  }
+});
+
+test("mobile uses current Chrome for Android rather than WebView", () => {
+  expect(MOBILE_USER_AGENT).toBe(`Mozilla/5.0 (Linux; Android 16; ASUSAI2501C Build/BQ2A.250525.001) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${CHROMIUM_VERSION} Mobile Safari/537.36`);
+});
+
+test("CDP discovery, HTTP requests, and navigator report the same desktop user agent", async () => {
+  let requestUserAgent;
+  const site = Bun.serve({ port: 0, fetch(request) {
+    requestUserAgent = request.headers.get("user-agent");
+    return new Response("<!doctype html><title>UA test</title>", { headers: { "content-type": "text/html" } });
+  } });
+  const browser = await createBrowser({ spareRenderer: false });
+  const cdp = CdpServer.create(browser.context).listen(0, "127.0.0.1");
+  try {
+    const version = await fetch(`http://127.0.0.1:${cdp.port}/json/version`).then((response) => response.json());
+    expect(version.Browser).toBe(`Chrome/${CHROMIUM_VERSION}`);
+    expect(version["User-Agent"]).toBe(DESKTOP_USER_AGENT);
+    await browser.context.navigate(`http://127.0.0.1:${site.port}/`);
+    expect(requestUserAgent).toBe(DESKTOP_USER_AGENT);
+    expect(await browser.context.evaluate("navigator.userAgent")).toBe(DESKTOP_USER_AGENT);
+  } finally {
+    cdp.stop(true);
+    browser.close();
+    site.stop(true);
+  }
+});

package/vendor/happy-dom/packages/happy-dom/src/nodes/element/Element.ts

@@ -706,12 +706,9 @@ export default class Element
 	 * @param text HTML string to insert.
 	 */
 	public insertAdjacentHTML(position: InsertAdjacentPosition, text: string): void {
-		const childNodes = new HTMLParser(this[PropertySymbol.window]).parse(text)[
-			PropertySymbol.nodeArray
-		];
-		while (childNodes.length) {
-			this.insertAdjacentElement(position, childNodes[0]);
-		}
+		// Insert the parsed fragment as a whole: inserting its nodes one at a
+		// time at "afterbegin" or "afterend" reversed their order.
+		this.insertAdjacentElement(position, new HTMLParser(this[PropertySymbol.window]).parse(text));
 	}
 
 	/**

package/vendor/happy-dom/packages/happy-dom/src/nodes/html-script-element/HTMLScriptElement.ts

@@ -566,16 +566,7 @@ export default class HTMLScriptElement extends HTMLElement {
 			browserSettings &&
 			(browserSettings.disableJavaScriptFileLoading || !browserSettings.enableJavaScriptEvaluation)
 		) {
-			if (browserSettings.handleDisabledFileLoadingAsSuccess) {
-				this.dispatchEvent(new Event('load'));
-			} else {
-				const error = new window.DOMException(
-					`Failed to load module "${url}". JavaScript file loading is disabled.`,
-					DOMExceptionNameEnum.notSupportedError
-				);
-				browserFrame.page.console.error(error);
-				this.dispatchEvent(new Event('error'));
-			}
+			// The renderer owns script fetching and dispatches load/error after execution.
 			return;
 		}
 
@@ -647,16 +638,7 @@ export default class HTMLScriptElement extends HTMLElement {
 			browserSettings &&
 			(browserSettings.disableJavaScriptFileLoading || !browserSettings.enableJavaScriptEvaluation)
 		) {
-			if (browserSettings.handleDisabledFileLoadingAsSuccess) {
-				this.dispatchEvent(new Event('load'));
-			} else {
-				const error = new window.DOMException(
-					`Failed to load script "${absoluteURL}". JavaScript file loading is disabled.`,
-					DOMExceptionNameEnum.notSupportedError
-				);
-				browserFrame.page.console.error(error);
-				this.dispatchEvent(new Event('error'));
-			}
+			// The renderer owns script fetching and dispatches load/error after execution.
 			return;
 		}
 

package/vendor/happy-dom/packages/happy-dom/src/query-selector/QuerySelector.ts

@@ -373,7 +373,10 @@ export default class QuerySelector {
 			);
 		}
 
-		const cachedResult = element[PropertySymbol.cache].matches.get(selector);
+		// A :has() match depends on the whole subtree, which no affected-cache
+		// registration covers, so it is not cached.
+		const cacheable = !selector.includes(':has(');
+		const cachedResult = cacheable ? element[PropertySymbol.cache].matches.get(selector) : null;
 
 		if (cachedResult) {
 			if (cachedResult.result !== null) {
@@ -386,9 +389,11 @@ export default class QuerySelector {
 			result: { match: null }
 		};
 
-		element[PropertySymbol.cache].matches.set(selector, cachedItem);
+		if (cacheable) {
+			element[PropertySymbol.cache].matches.set(selector, cachedItem);
+		}
 
-		if (element[PropertySymbol.isConnected]) {
+		if (cacheable && element[PropertySymbol.isConnected]) {
 			// Document is affected for the ":target" selector
 			(element[PropertySymbol.ownerDocument] || element)[PropertySymbol.affectsCache].push(
 				cachedItem
@@ -462,6 +467,13 @@ export default class QuerySelector {
 			return null;
 		}
 
+		// Structural pseudo-classes and sibling combinators read the parent's
+		// child list, whose changes are reported on the parent.
+		const parent = element.parentNode;
+		if (parent) {
+			this.affectsCache(<Element>parent, cachedItem);
+		}
+
 		const result = selectorItem.match(scope, element, ignoreErrors);
 
 		if (result) {

package/vendor/ses/dist/ses.mjs

@@ -8108,6 +8108,8 @@ const methods = {
    * is accepted.
    */
   '%SetPrototype%': '*',
+  // Page scripts may assign an own toString method to a RegExp instance.
+  '%RegExpPrototype%': { toString: true },
 };$h͏_once.severeEnablements(severeEnablements);
 })()
 ,