buninu-browser 0.2.1 → 0.2.3

package/lib/renderer/piano-input.js

@@ -0,0 +1,22 @@
+import { pianoNote } from "../audio/piano.js";
+
+// Keep a real editable input so mobile keyboards can open, but consume piano
+// input before text editing. Terminals and IMEs may commit several keys at once.
+export function handlePianoInput(element, input, play) {
+  if (element?.getAttribute?.("id") !== "buninu-piano-input" || element.disabled || element.readOnly) return false;
+  // CDP key events also carry text (often "" on rawKeyDown). Only a text-only
+  // commit belongs here; otherwise use key/code, including Space and F1–F12.
+  if (input.key === undefined && input.text !== undefined) {
+    for (const key of String(input.text)) {
+      const note = pianoNote(key);
+      if (note !== null) play?.(note);
+    }
+    return true;
+  }
+  const note = pianoNote(String(input.key), String(input.code ?? ""));
+  if (note === null) return false;
+  // Suppressing text insertion must not depend on whether a note is retriggered
+  // or an audio backend is available. Shift still selects a physical piano key.
+  if (!input.repeat && !(Number(input.modifiers) & 7)) play?.(note);
+  return true;
+}

package/lib/renderer/pointer-move.js

@@ -0,0 +1,29 @@
+const previousTargets = new WeakMap();
+
+/** Deliver pointer/mouse boundary events before movement, as a real pointer does. */
+export function dispatchPointerMove(window, realm, target, x, y) {
+  const document = window.document;
+  const previous = previousTargets.get(document) ?? null;
+  previousTargets.set(document, target);
+  const ancestors = node => { const list = []; for (; node?.nodeType === 1; node = node.parentElement) list.push(node); return list; };
+  const before = ancestors(previous), after = ancestors(target);
+  const send = (node, type, relatedTarget, bubbles = true) => {
+    if (!node) return;
+    const pointer = type.startsWith('pointer');
+    const Constructor = pointer ? window.PointerEvent : window.MouseEvent;
+    const event = new Constructor(type, { clientX: x, clientY: y, relatedTarget, bubbles,
+      composed: bubbles, cancelable: bubbles, button: pointer ? -1 : 0, buttons: 0,
+      pointerId: 1, pointerType: 'mouse', isPrimary: true });
+    if (realm) realm.dispatch(node, event); else node.dispatchEvent(event);
+  };
+  if (previous !== target) {
+    for (const prefix of ['pointer', 'mouse']) {
+      send(previous, `${prefix}out`, target);
+      for (const node of before) if (!after.includes(node)) send(node, `${prefix}leave`, target, false);
+      send(target, `${prefix}over`, previous);
+      for (const node of after.toReversed()) if (!before.includes(node)) send(node, `${prefix}enter`, previous, false);
+    }
+  }
+  send(target, 'pointermove', null);
+  send(target, 'mousemove', null);
+}

package/lib/renderer/rejections.js

@@ -0,0 +1,31 @@
+/**
+ * Promise rejections the renderer's JavaScript engine reports (HTML §8.1.5.7
+ * "unhandled promise rejections"): the page realm turns them into
+ * unhandledrejection and rejectionhandled events on its window. Bun reports
+ * them after the microtask queue drains, where HTML notifies about rejected
+ * promises.
+ */
+const listeners = new Set();
+
+/**
+ * @param {{ unhandled(reason: unknown, promise: Promise<unknown>): boolean, handled(promise: Promise<unknown>): void }} listener
+ *   `unhandled` returns true when the page handled the rejection (its event was canceled).
+ * @returns {() => void} removes the listener
+ */
+export function onPromiseRejection(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/** True when a page canceled the unhandledrejection event, so nothing is logged. */
+export function notifyUnhandledRejection(reason, promise) {
+  let handled = false;
+  for (const listener of listeners) {
+    if (listener.unhandled(reason, promise)) handled = true;
+  }
+  return handled;
+}
+
+export function notifyRejectionHandled(promise) {
+  for (const listener of listeners) listener.handled(promise);
+}

package/lib/renderer/rewrite-worker.js

@@ -0,0 +1,22 @@
+/**
+ * Prepares classic scripts for the page realm off the renderer's main
+ * thread: the rewrites parse the whole script (YouTube's bundles are
+ * megabytes), which would otherwise block page tasks, animation frames and
+ * media for seconds while the scripts are still downloading in parallel.
+ *
+ * Messages: { id, source } → { id, result: { code, parsed, strict } } or
+ * { id, error }. The worker only transforms strings; page code never runs here.
+ */
+import { escapeSesHtmlComments, rewriteClassicScriptSource } from "./script-rewrite.js";
+
+self.addEventListener("message", ({ data }) => {
+  const { id, source } = data ?? {};
+  try {
+    const classic = rewriteClassicScriptSource(String(source));
+    self.postMessage({ id, result: { code: escapeSesHtmlComments(classic.code), parsed: classic.parsed, strict: classic.strict } });
+  } catch (error) {
+    self.postMessage({ id, error: String(error?.message ?? error) });
+  }
+});
+
+self.postMessage({ type: "ready" });