buninu-browser 0.1.0 → 0.2.0

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

@@ -101,3 +101,17 @@ 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();
+});

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/text-layout.test.js

@@ -417,3 +417,25 @@ 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();
+});

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);
 })()
 ,