buninu-browser 0.2.1 → 0.2.3

package/bunfig.toml

@@ -1,2 +1,3 @@
 [test]
 pathIgnorePatterns = ["vendor/**"]
+preload = ["./test/setup.js"]

package/buninu-browser.js

@@ -45,6 +45,10 @@ Options:
   --mobile                        Present as a phone: mobile user agent and touch media
                                   features (hover: none, pointer: coarse); user agent
                                   overrides over CDP are ignored
+  --webkit                        Use a desktop WebKit/Safari compatibility identity (default)
+                                  for JavaScriptCore; CDP user agent overrides are ignored
+  --chromium                      Use the previous desktop Chromium compatibility identity
+                                  Last desktop identity flag wins; --mobile takes priority
   --screenshot[=FILE]             Capture one PNG and exit (default screenshot.png)
   --window-size=WIDTH,HEIGHT      Viewport size for the screenshot (default 800,600)
   --screenshot-wait=MILLISECONDS  Wait after page load before capturing

package/index.js

@@ -84,6 +84,11 @@ Frontends (first argument only):
   --win32, --gtk, --appkit, --qt
       Native windowed frontends (reserved, not implemented yet)
 
+Browser identity:
+  WebKit/Safari compatibility identity is the engine default (not native WebKit).
+  Pass -- --webkit or -- --chromium through casty; with --headless, omit --.
+  Last desktop identity flag wins; --mobile takes priority.
+
 Information:
   --help, -h, -help
       Show this help & exit

package/lib/audio/piano.js

@@ -46,7 +46,30 @@ export function pianoNote(key, code = "") {
 export function pianoTone(note, rate = 48000) {
   const frames = Math.round(rate * 0.7);
   const samples = new Float32Array(frames);
-  const frequency = 440 * 2 ** ((note - 69) / 12);
+  
+  
+  let frequency = 432
+  
+  if(0)
+  {
+    frequency = 432 * 2 ** ((note - 69) / 12);
+  }
+  else
+  {
+    const note_diff = note - 69
+
+    const ratios = [
+      1, 16/15, 9/8, 6/5, 5/4, 4/3, 
+      45/32, 3/2, 8/5, 5/3, 9/5, 15/8
+    ]
+    const ratio = ratios[
+      (note_diff + 432) % 12
+    ]
+    const octave = Math.floor(note_diff/12)
+    
+    frequency = 432 * ratio * 2**octave ;
+  }
+  
   // The original left-hand register is quiet on small speakers. Raise only
   // its level; leave pitch and relative harmonic balance untouched.
   const gain = 1 + Math.max(0, Math.min(1, (60 - note) / 24));

package/lib/audio/playback-buffer.js

@@ -0,0 +1,27 @@
+// Decoded PCM kept in the controller is independent of the device queue.
+// It can bridge renderer work without increasing pause/seek output latency.
+export class PlaybackBuffer {
+  constructor(bytesPerSecond, frameBytes, leadSeconds) {
+    this.bytesPerSecond = bytesPerSecond;
+    this.frameBytes = frameBytes;
+    this.reserve = leadSeconds <= 0.15 ? 0 : this.align(bytesPerSecond * 2);
+    this.threshold = this.reserve ? this.align(bytesPerSecond * 0.4) : 0;
+    this.buffering = Boolean(this.reserve);
+  }
+
+  align(bytes) {
+    return Math.max(0, Math.floor(bytes / this.frameBytes) * this.frameBytes);
+  }
+
+  ready(queued, inDevice, finishing) {
+    if (!this.reserve || finishing) return true;
+    if (queued < this.frameBytes && inDevice < this.frameBytes) this.buffering = true;
+    if (this.buffering && queued >= this.threshold) this.buffering = false;
+    return !this.buffering;
+  }
+
+  request(queued, outstanding, inDevice, immediateNeed) {
+    // Requests stay bounded even when the producer or network stops replying.
+    return this.align(Math.max(immediateNeed, this.reserve - inDevice) - queued - outstanding);
+  }
+}

package/lib/audio/pulse-client.js

@@ -13,6 +13,7 @@
  * other channels carry a stream's audio. Audio is sent as s16le.
  */
 import { connect } from "node:net";
+import { PlaybackBuffer } from "./playback-buffer.js";
 
 export { floatToS16 } from "./pcm.js";
 
@@ -22,11 +23,11 @@ const PROTOCOL_VERSION = 8;
 const SAMPLE_S16LE = 3;
 const COMMAND = {
   ERROR: 0, REPLY: 2, CREATE_PLAYBACK_STREAM: 3, DELETE_PLAYBACK_STREAM: 4, AUTH: 8, SET_CLIENT_NAME: 9,
-  DRAIN_PLAYBACK_STREAM: 12, REQUEST: 61, UNDERFLOW: 63, PLAYBACK_STREAM_KILLED: 32,
+  DRAIN_PLAYBACK_STREAM: 12, GET_PLAYBACK_LATENCY: 14, REQUEST: 61, UNDERFLOW: 63, PLAYBACK_STREAM_KILLED: 32,
 };
 const TAG = {
   STRING: 0x74, NULL: 0x4e, U32: 0x4c, U8: 0x42, SAMPLE_SPEC: 0x61, ARBITRARY: 0x78, TRUE: 0x31, FALSE: 0x30,
-  CHANNEL_MAP: 0x6d, CVOLUME: 0x76,
+  CHANNEL_MAP: 0x6d, CVOLUME: 0x76, TIMEVAL: 0x54, USEC: 0x55, S64: 0x72,
 };
 // PulseAudio channel positions: mono, front-left, front-right, then aux channels.
 const POSITION = { MONO: 0, FRONT_LEFT: 1, FRONT_RIGHT: 2, AUX0: 12 };
@@ -52,6 +53,11 @@ class TagWriter {
     return this;
   }
 
+  timeval(milliseconds) {
+    this.#bytes.push(TAG.TIMEVAL, ...u32be(Math.floor(milliseconds / 1000)), ...u32be((milliseconds % 1000) * 1000));
+    return this;
+  }
+
   arbitrary(bytes) {
     this.#bytes.push(TAG.ARBITRARY, ...u32be(bytes.length), ...bytes);
     return this;
@@ -95,6 +101,27 @@ class TagReader {
     return this.#rawU32();
   }
 
+  bool() {
+    const tag = this.#data[this.#index++];
+    if (tag !== TAG.TRUE && tag !== TAG.FALSE) throw new Error("pulse: invalid boolean");
+    return tag === TAG.TRUE;
+  }
+
+  timeval() {
+    this.#expect(TAG.TIMEVAL);
+    return this.#rawU32() + this.#rawU32() / 1e6;
+  }
+
+  integer64(tag, signed = false) {
+    this.#expect(tag);
+    if (this.#index + 8 > this.#data.length) throw new Error("pulse: truncated timing value");
+    const view = new DataView(this.#data.buffer, this.#data.byteOffset + this.#index, 8);
+    const value = Number(signed ? view.getBigInt64(0) : view.getBigUint64(0));
+    this.#index += 8;
+    if (!Number.isSafeInteger(value)) throw new Error("pulse: timing value out of range");
+    return value;
+  }
+
   string() {
     if (this.#data[this.#index] === TAG.NULL) {
       this.#index++;
@@ -175,13 +202,17 @@ export class PulseClient {
   }
 
   /** Sends a command packet; resolves with the reply's reader. */
-  #command(command, fill = () => {}) {
+  #command(command, fill = () => {}, timeout = 0) {
     if (this.#closed) return Promise.reject(new Error("pulse: connection closed"));
     const tag = this.#nextTag++;
     const writer = new TagWriter().u32(command).u32(tag);
     fill(writer);
     return new Promise((resolve, reject) => {
-      this.#pending.set(tag, { resolve, reject, command });
+      const timer = timeout ? setTimeout(() => {
+        this.#pending.delete(tag);
+        reject(new Error("pulse: timing request timed out"));
+      }, timeout) : null;
+      this.#pending.set(tag, { resolve, reject, command, timer });
       this.#socket.write(frame(PACKET_CHANNEL, writer.finish()));
     });
   }
@@ -210,6 +241,7 @@ export class PulseClient {
       const pending = this.#pending.get(tag);
       this.#pending.delete(tag);
       if (!pending) return;
+      clearTimeout(pending.timer);
       if (command === COMMAND.REPLY) pending.resolve(reader);
       else pending.reject(new Error(`pulse: command ${pending.command} server error ${reader.u32()}`));
     } else if (command === COMMAND.REQUEST) {
@@ -217,6 +249,8 @@ export class PulseClient {
       stream?.grant(reader.u32());
     } else if (command === COMMAND.PLAYBACK_STREAM_KILLED) {
       this.#streams.get(reader.u32())?.kill();
+    } else if (command === COMMAND.UNDERFLOW) {
+      this.#streams.get(reader.u32())?.updateTiming();
     }
   }
 
@@ -225,7 +259,7 @@ export class PulseClient {
    * `onRequest(bytes)` asks for about that much more audio, paced to real time
    * (see PlaybackStream).
    */
-  async openPlayback({ rate, channels, name = "audio", onRequest = () => {}, leadSeconds = LEAD_SECONDS }) {
+  async openPlayback({ rate, channels, name = "audio", onRequest = () => {}, onTiming = null, onTimingError = null, leadSeconds = LEAD_SECONDS }) {
     const spec = { format: SAMPLE_S16LE, channels, rate };
     const frameBytes = channels * 2;
     const bytesForSeconds = (seconds) => Math.max(frameBytes, Math.round(rate * seconds) * frameBytes);
@@ -245,7 +279,7 @@ export class PulseClient {
     const index = reply.u32();
     reply.u32(); // sink input index
     const requested = reply.u32();
-    const stream = new PlaybackStream(this, index, spec, onRequest, leadSeconds);
+    const stream = new PlaybackStream(this, index, spec, onRequest, leadSeconds, onTiming, onTimingError);
     this.#streams.set(index, stream);
     stream.grant(requested);
     return stream;
@@ -261,6 +295,20 @@ export class PulseClient {
     return this.#command(COMMAND.DRAIN_PLAYBACK_STREAM, (w) => w.u32(index));
   }
 
+  /** Protocol v8 timing: the read cursor minus the sink's measured device queue. */
+  async playbackTiming(index) {
+    const reply = await this.#command(COMMAND.GET_PLAYBACK_LATENCY,
+      (w) => w.u32(index).timeval(Date.now()), 2000);
+    const sinkSeconds = reply.integer64(TAG.USEC) / 1e6;
+    reply.integer64(TAG.USEC); // source latency (recording only)
+    const playing = reply.bool();
+    reply.timeval(); // echoed request time
+    reply.timeval(); // server measurement time; don't assume synchronized wall clocks
+    const writeIndex = reply.integer64(TAG.S64, true);
+    const readIndex = reply.integer64(TAG.S64, true);
+    return { sinkSeconds, playing, writeIndex, readIndex };
+  }
+
   async deleteStream(index) {
     this.#streams.delete(index);
     await this.#command(COMMAND.DELETE_PLAYBACK_STREAM, (w) => w.u32(index)).catch(() => {});
@@ -269,7 +317,10 @@ export class PulseClient {
   close() {
     if (this.#closed) return;
     this.#closed = true;
-    for (const { reject } of this.#pending.values()) reject(new Error("pulse: connection closed"));
+    for (const { reject, timer } of this.#pending.values()) {
+      clearTimeout(timer);
+      reject(new Error("pulse: connection closed"));
+    }
     this.#pending.clear();
     for (const stream of this.#streams.values()) stream.kill();
     this.#streams.clear();
@@ -282,9 +333,9 @@ export class PulseClient {
  * to LEAD_SECONDS ahead of the playback clock, whatever the server asks for.
  * Some servers ask for more at once and queue it themselves (jspulse's
  * OpenSL ES backend requests again as soon as it receives), and then a pause
- * would leave everything already sent still playing. `onRequest(bytes)` asks
- * the producer for about that much more; audio it has not been asked for is
- * never requested twice.
+ * would leave everything already sent still playing. The producer prepares a
+ * separate bounded PCM reserve here so renderer work cannot immediately starve
+ * the output. That reserve is discarded on close, not sent to the device.
  */
 const LEAD_SECONDS = 0.5;
 const PACE_MS = 50;
@@ -305,9 +356,14 @@ class PlaybackStream {
   #started = null;
   #timer = null;
   #leadSeconds;
+  #onTiming;
+  #onTimingError;
+  #timingPending = false;
+  #playedBytes = 0;
+  #producerBuffer;
   killed = false;
 
-  constructor(client, index, { rate, channels }, onRequest, leadSeconds) {
+  constructor(client, index, { rate, channels }, onRequest, leadSeconds, onTiming, onTimingError) {
     this.#client = client;
     this.index = index;
     // Audio is only ever cut at whole frames (one sample of every channel):
@@ -317,7 +373,32 @@ class PlaybackStream {
     this.#bytesPerSecond = rate * this.#frameBytes;
     this.#onRequest = onRequest;
     this.#leadSeconds = leadSeconds;
-    this.#timer = setInterval(() => this.#pace(), PACE_MS);
+    this.#producerBuffer = new PlaybackBuffer(this.#bytesPerSecond, this.#frameBytes, leadSeconds);
+    this.#onTiming = onTiming;
+    this.#onTimingError = onTimingError;
+    this.#timer = setInterval(() => { this.#pace(); void this.updateTiming(); }, PACE_MS);
+  }
+
+  async updateTiming() {
+    if (!this.#onTiming || this.killed || this.#timingPending) return;
+    this.#timingPending = true;
+    try {
+      const timing = await this.#client.playbackTiming(this.index);
+      if (this.killed) return;
+      // Never count queued PCM or underrun silence as played media. No wall
+      // clock extrapolation: an absent/stale report freezes the master clock.
+      const end = Math.min(this.#offset, Math.max(0, timing.writeIndex));
+      const played = Math.min(end, Math.max(0, Math.min(end, timing.readIndex) - timing.sinkSeconds * this.#bytesPerSecond));
+      this.#playedBytes = Math.max(this.#playedBytes, this.#frameAligned(played));
+      this.#onTiming({ seconds: this.#playedBytes / this.#bytesPerSecond,
+        sentSeconds: this.#offset / this.#bytesPerSecond, sinkSeconds: timing.sinkSeconds, playing: timing.playing,
+        bufferedSeconds: this.#queuedBytes / this.#bytesPerSecond });
+      this.#pace();
+    } catch (error) {
+      if (!this.killed) this.#onTimingError?.(error);
+    } finally {
+      this.#timingPending = false;
+    }
   }
 
   /** The server has room for `bytes` more. */
@@ -343,6 +424,11 @@ class PlaybackStream {
   #allowed() {
     const elapsed = this.#started === null ? 0 : (performance.now() - this.#started) / 1000;
     const bytes = Math.floor(this.#bytesPerSecond * (elapsed + this.#leadSeconds));
+    // Device progress is authoritative, with real-time pacing as a second
+    // ceiling: a server incorrectly reporting a zero queue cannot flood the
+    // device faster than real time. This is a queue limit, not an A/V offset.
+    if (this.#onTiming) return this.#frameAligned(Math.min(bytes,
+      this.#playedBytes + this.#bytesPerSecond * this.#leadSeconds));
     return bytes - (bytes % this.#frameBytes);
   }
 
@@ -354,7 +440,11 @@ class PlaybackStream {
     // (a few at a time), so small packets leave them little to play from.
     const minimum = this.#frameAligned(this.#bytesPerSecond * MIN_PACKET_SECONDS);
     const maximum = this.#frameAligned(this.#bytesPerSecond * MAX_PACKET_SECONDS);
-    while (this.#credit > 0 && this.#queuedBytes > 0 && this.#offset < allowed) {
+    const inDevice = this.#onTiming ? Math.max(0, this.#offset - this.#playedBytes)
+      : this.#started === null ? 0 : Math.max(0, this.#offset - (performance.now() - this.#started) / 1000 * this.#bytesPerSecond);
+    const ready = this.#producerBuffer.ready(this.#queuedBytes, inDevice, this.finishing);
+    const previousOffset = this.#offset;
+    while (ready && this.#credit > 0 && this.#queuedBytes > 0 && this.#offset < allowed) {
       const room = this.#frameAligned(Math.min(this.#credit, allowed - this.#offset, maximum, this.#queuedBytes));
       if (room < this.#frameBytes || (room < minimum && !this.finishing && this.#queuedBytes < minimum)) break;
       const packet = new Uint8Array(room);
@@ -372,15 +462,34 @@ class PlaybackStream {
       this.#credit -= room;
       this.#queuedBytes -= room;
     }
-    // Ask for what the clock will allow next that is neither queued nor already asked for.
-    const need = this.#frameAligned(Math.min(this.#offset + this.#credit, allowed + this.#bytesPerSecond * PACE_MS / 1000)
-      - this.#offset - this.#queuedBytes - this.#outstanding);
+    // Predecode independently of server credits; only transmission uses the
+    // small device budget above. Keep outstanding requests in that budget too.
+    const immediateNeed = Math.min(this.#credit, allowed + this.#bytesPerSecond * PACE_MS / 1000 - this.#offset);
+    const sentNow = inDevice + this.#offset - previousOffset;
+    const need = this.#producerBuffer.request(this.#queuedBytes, this.#outstanding, sentNow, immediateNeed);
     if (need >= this.#bytesPerSecond * MIN_REQUEST_SECONDS && !this.finishing) {
       this.#outstanding += need;
       this.#onRequest(need);
     }
   }
 
+  /**
+   * Restarts the pacing clock from what was sent so far. After the writer
+   * paused (the output ran dry), sending resumes at the playback rate
+   * instead of catching up with the time that passed, which would queue
+   * seconds on the server and delay what plays from then on.
+   */
+  resync() {
+    if (this.killed || this.#started === null) return;
+    this.#started = performance.now() - this.#offset / this.#bytesPerSecond * 1000;
+    this.#pace();
+  }
+
+  /** Bytes handed to the server so far: once there, the server may play them even after the stream closes. */
+  get sentBytes() {
+    return this.#offset;
+  }
+
   /** Bytes queued but not yet sent. */
   get queued() {
     return this.#queuedBytes;
@@ -392,9 +501,18 @@ class PlaybackStream {
     while (this.#queue.length && !this.killed) await new Promise((resolve) => setTimeout(resolve, PACE_MS));
     if (!this.killed) {
       await this.#client.drain(this.index).catch(() => {});
-      // A server that queued ahead may answer the drain early: wait for the clock too.
-      const end = (this.#started ?? performance.now()) + this.#offset / this.#bytesPerSecond * 1000;
-      while (!this.killed && performance.now() < end) await new Promise((resolve) => setTimeout(resolve, PACE_MS));
+      if (this.#onTiming) {
+        // Some compatible servers acknowledge drain before their device queue
+        // empties. Only a measured playback cursor may end synchronized media.
+        while (!this.killed && this.#playedBytes < this.#offset) {
+          await this.updateTiming();
+          await new Promise((resolve) => setTimeout(resolve, PACE_MS));
+        }
+      }
+      if (!this.#onTiming) {
+        const end = (this.#started ?? performance.now()) + this.#offset / this.#bytesPerSecond * 1000;
+        while (!this.killed && performance.now() < end) await new Promise((resolve) => setTimeout(resolve, PACE_MS));
+      }
     }
     await this.close();
   }

package/lib/cdp-server.js

@@ -1,4 +1,4 @@
-import { CHROMIUM_VERSION, DESKTOP_USER_AGENT } from "./user-agent.js";
+import { BROWSER_PRODUCT, DESKTOP_USER_AGENT } from "./user-agent.js";
 
 const CDP_DEFAULT_PORT = 9222;
 const CDP_PROTOCOL_VERSION = "1.3";
@@ -124,11 +124,10 @@ export class CdpServer {
 
         if (pathname === "/json/version") {
           return respond(jsonResponse({
-            Browser: `Chrome/${CHROMIUM_VERSION}`,
+            Browser: BROWSER_PRODUCT,
             "Protocol-Version": CDP_PROTOCOL_VERSION,
-            "User-Agent": DESKTOP_USER_AGENT,
-            "V8-Version": Bun.version,
-            "WebKit-Version": "537.36",
+            "User-Agent": context.userAgent ?? DESKTOP_USER_AGENT,
+            "Bun-Version": Bun.version,
             webSocketDebuggerUrl,
           }));
         }
@@ -283,9 +282,9 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
     case "Browser.getVersion":
       return {
         protocolVersion: CDP_PROTOCOL_VERSION,
-        product: `Chrome/${CHROMIUM_VERSION}`,
+        product: BROWSER_PRODUCT,
         revision: "cdp-server",
-        userAgent: DESKTOP_USER_AGENT,
+        userAgent: ctx.userAgent ?? DESKTOP_USER_AGENT,
         jsVersion: Bun.version,
       };
     case "Browser.setDownloadBehavior":
@@ -381,11 +380,14 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
     }
     case "Page.getFrameTree": {
       const target = getSessionTarget(state, sessionId);
+      // Script/form navigations can replace the document without Page.navigate.
+      // Report the committed response, not the last URL requested over CDP.
+      const resource = await ctx.resourceContent?.() ?? await ctx.resourceContent?.(target.url);
       // The document's own type (an image, TOML...), not the page shown for it.
-      const type = (await ctx.resourceContent?.(target.url))?.contentType?.split(";")[0].trim().toLowerCase();
+      const type = resource?.contentType?.split(";")[0].trim().toLowerCase();
       return {
         frameTree: {
-          frame: { ...createFrame(target), ...(type ? { mimeType: type } : {}) },
+          frame: { ...createFrame(resource ? { ...target, url: resource.url ?? target.url } : target), ...(type ? { mimeType: type } : {}) },
         },
       };
     }
@@ -398,8 +400,11 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       return {};
     case "Page.addScriptToEvaluateOnNewDocument":
       return {
-        identifier: `script-${state.nextObjectId++}`,
+        identifier: ctx.addInitScript?.(params.source ?? "") ?? `script-${state.nextObjectId++}`,
       };
+    case "Page.removeScriptToEvaluateOnNewDocument":
+      ctx.removeInitScript?.(params.identifier);
+      return {};
     case "Page.createIsolatedWorld": {
       const target = getSessionTarget(state, sessionId);
       const executionContextId = state.nextExecutionContextId++;
@@ -681,8 +686,12 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       return {};
     case "Input.dispatchMouseEvent": {
       const target = getSessionTarget(state, sessionId);
+      if (params.type === "mouseMoved") {
+        await ctx.move?.(params.x, params.y);
+        return {};
+      }
       if (params.type === "mouseWheel") {
-        await ctx.scroll?.(params.deltaX ?? 0, params.deltaY ?? 0);
+        await ctx.scroll?.(params.deltaX ?? 0, params.deltaY ?? 0, { x: params.x, y: params.y });
         return {};
       }
 
@@ -714,6 +723,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
             text: params.text ?? "",
             code: params.code ?? "",
             repeat: !!params.autoRepeat,
+            windowsVirtualKeyCode: params.windowsVirtualKeyCode,
           });
           target.cdpKeyDown = signature;
         }
@@ -724,6 +734,7 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
             text: params.text ?? "",
             code: params.code ?? "",
             repeat: !!params.autoRepeat,
+            windowsVirtualKeyCode: params.windowsVirtualKeyCode,
           });
         }
       } else if (params.type === "keyUp") {

package/lib/happy-dom/parser.js

@@ -1,5 +1,6 @@
 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 "./selector-pseudo-adapter.js";
 
 const IMPLICIT_HEAD_ELEMENTS = new Set([
   "BASE", "BASEFONT", "BGSOUND", "LINK", "META", "NOFRAMES", "SCRIPT", "STYLE", "TEMPLATE", "TITLE",
@@ -20,25 +21,48 @@ export function parseHTMLDocument(html, url = "about:blank") {
       disableCSSFileLoading: true,
       disableIframePageLoading: true,
       enableImageFileLoading: false,
+      // This DOM is only the tree builder. Link activation must not change
+      // its URL before our controller commits a navigation (downloads never
+      // commit). Otherwise later #links resolve against the download URL.
+      navigation: { disableFallbackToSetURL: true },
     },
   });
 
   new HTMLParser(window).parse(String(html), window.document);
-  normalizeImplicitHead(window.document);
+  normalizeImplicitHead(window.document, implicitHeadCount(String(html)));
   return { window, document: window.document };
 }
 
+/**
+ * How many leading metadata elements belong in the implicit head: with no
+ * <head> tag, those before an explicit <body> tag (all of them without one).
+ * With a <head> tag Happy DOM places them itself. Comments and the contents
+ * of raw-text elements are skipped so that text in them is not counted.
+ */
+function implicitHeadCount(html) {
+  const source = html
+    .replace(/<!--[\s\S]*?-->/g, "")
+    .replace(/<(script|style|textarea|title|template|noframes)\b([^>]*)>[\s\S]*?<\/\1\s*>/gi, "<$1$2></$1>");
+  if (/<head[\s>\/]/i.test(source)) return 0;
+  const bodyAt = source.search(/<body[\s>\/]/i);
+  if (bodyAt < 0) return Infinity;
+  return (source.slice(0, bodyAt).match(/<(base|basefont|bgsound|link|meta|noframes|script|style|template|title)\b/gi) ?? []).length;
+}
+
 /**
  * Happy DOM 20's parser places metadata in body when source omits explicit
  * head/body tags. HTML's "before head" and "in head" insertion modes instead
- * put leading metadata elements into the implicit head.
+ * put leading metadata elements into the implicit head; once the <body> tag
+ * has been seen, metadata stays in body (`limit` counts those before it).
  */
-function normalizeImplicitHead(document) {
+function normalizeImplicitHead(document, limit) {
   const { head, body } = document;
-  if (!head || !body) return;
+  if (!head || !body || limit <= 0) return;
 
+  let moved = 0;
   let bodyContentStarted = false;
   for (const node of [...body.childNodes]) {
+    if (moved >= limit) break;
     if (!bodyContentStarted && node.nodeType === 3 && !node.textContent.trim()) {
       node.remove();
       continue;
@@ -46,6 +70,7 @@ function normalizeImplicitHead(document) {
     if (node.nodeType === 8) continue;
     if (!bodyContentStarted && node.nodeType === 1 && IMPLICIT_HEAD_ELEMENTS.has(node.tagName)) {
       head.appendChild(node);
+      moved++;
       continue;
     }
     bodyContentStarted = true;

package/lib/happy-dom/selector-pseudo-adapter.js

@@ -0,0 +1,14 @@
+import SelectorItem from "../../vendor/happy-dom/packages/happy-dom/src/query-selector/SelectorItem.ts";
+
+// Happy DOM's :empty checks only element children. CSS also excludes elements
+// with nonempty text nodes (including whitespace); comments do not count.
+const original = SelectorItem.prototype.matchPseudoItem;
+SelectorItem.prototype.matchPseudoItem = function (scope, element, siblings, pseudo, ignoreErrors) {
+  if (pseudo.name === "empty") {
+    for (const child of element.childNodes) {
+      if (child.nodeType === 1 || (child.nodeType === 3 || child.nodeType === 4) && child.data.length) return null;
+    }
+    return { priorityWeight: 10 };
+  }
+  return original.call(this, scope, element, siblings, pseudo, ignoreErrors);
+};