@salve-software/react-native-nitro-jsdom 1.1.0 → 2.1.0

package/cpp/quickjs/bindings/EventBindings.cpp

@@ -34,9 +34,17 @@ JSValue js_Event_constructor(JSContext* ctx, JSValue, int argc, JSValue* argv) {
     else { cancelable = JS_ToBool(ctx, c) > 0; JS_FreeValue(ctx, c); }
   }
 
+  bool composed = false;
+  if (argc >= 2 && JS_IsObject(argv[1])) {
+    JSValue c = JS_GetPropertyStr(ctx, argv[1], "composed");
+    if (JS_IsException(c)) { JS_FreeValue(ctx, JS_GetException(ctx)); }
+    else { composed = JS_ToBool(ctx, c) > 0; JS_FreeValue(ctx, c); }
+  }
+
   JS_SetPropertyStr(ctx, obj, "defaultPrevented",  JS_NewBool(ctx, false));
   JS_SetPropertyStr(ctx, obj, "bubbles",           JS_NewBool(ctx, bubbles));
   JS_SetPropertyStr(ctx, obj, "cancelable",        JS_NewBool(ctx, cancelable));
+  JS_SetPropertyStr(ctx, obj, "composed",          JS_NewBool(ctx, composed));
   return obj;
 }
 
@@ -64,9 +72,17 @@ JSValue js_CustomEvent_constructor(JSContext* ctx, JSValue, int argc, JSValue* a
     else { cancelable = JS_ToBool(ctx, c) > 0; JS_FreeValue(ctx, c); }
   }
 
+  bool composed = false;
+  if (argc >= 2 && JS_IsObject(argv[1])) {
+    JSValue c = JS_GetPropertyStr(ctx, argv[1], "composed");
+    if (JS_IsException(c)) { JS_FreeValue(ctx, JS_GetException(ctx)); }
+    else { composed = JS_ToBool(ctx, c) > 0; JS_FreeValue(ctx, c); }
+  }
+
   JS_SetPropertyStr(ctx, obj, "detail",           detail);
   JS_SetPropertyStr(ctx, obj, "bubbles",          JS_NewBool(ctx, bubbles));
   JS_SetPropertyStr(ctx, obj, "cancelable",       JS_NewBool(ctx, cancelable));
+  JS_SetPropertyStr(ctx, obj, "composed",         JS_NewBool(ctx, composed));
   JS_SetPropertyStr(ctx, obj, "defaultPrevented", JS_NewBool(ctx, false));
   return obj;
 }
@@ -113,6 +129,7 @@ JSValue js_KeyboardEvent_constructor(JSContext* ctx, JSValue, int argc, JSValue*
   JSValue init = (argc >= 2) ? argv[1] : JS_UNDEFINED;
   JS_SetPropertyStr(ctx, obj, "bubbles",    JS_NewBool(ctx, get_bool_init_field(ctx, init, "bubbles")));
   JS_SetPropertyStr(ctx, obj, "cancelable", JS_NewBool(ctx, get_bool_init_field(ctx, init, "cancelable")));
+  JS_SetPropertyStr(ctx, obj, "composed",   JS_NewBool(ctx, get_bool_init_field(ctx, init, "composed")));
   JS_SetPropertyStr(ctx, obj, "defaultPrevented", JS_NewBool(ctx, false));
 
   std::string key = get_str_init_field(ctx, init, "key", "");
@@ -137,6 +154,7 @@ JSValue js_MouseEvent_constructor(JSContext* ctx, JSValue, int argc, JSValue* ar
   JSValue init = (argc >= 2) ? argv[1] : JS_UNDEFINED;
   JS_SetPropertyStr(ctx, obj, "bubbles",    JS_NewBool(ctx, get_bool_init_field(ctx, init, "bubbles")));
   JS_SetPropertyStr(ctx, obj, "cancelable", JS_NewBool(ctx, get_bool_init_field(ctx, init, "cancelable")));
+  JS_SetPropertyStr(ctx, obj, "composed",   JS_NewBool(ctx, get_bool_init_field(ctx, init, "composed")));
   JS_SetPropertyStr(ctx, obj, "defaultPrevented", JS_NewBool(ctx, false));
 
   JS_SetPropertyStr(ctx, obj, "clientX", JS_NewFloat64(ctx, get_num_init_field(ctx, init, "clientX", 0)));
@@ -173,6 +191,18 @@ JSValue js_event_stopImmediatePropagation(JSContext* ctx, JSValue this_val, int,
   return JS_UNDEFINED;
 }
 
+// __composedPath is populated by dispatch_event_on_target() right before
+// listener invocation begins; an event that was never dispatched (just
+// constructed) has none, matching the spec's "not currently dispatched" case.
+JSValue js_event_composedPath(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  JSValue path = JS_GetPropertyStr(ctx, this_val, "__composedPath");
+  if (JS_IsUndefined(path) || JS_IsException(path)) {
+    if (JS_IsException(path)) JS_FreeValue(ctx, JS_GetException(ctx));
+    return JS_NewArray(ctx);
+  }
+  return path;
+}
+
 // ── addEventListener / removeEventListener (element) ──────────────────────────
 
 JSValue js_el_addEventListener(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
@@ -189,7 +219,7 @@ JSValue js_el_addEventListener(JSContext* ctx, JSValue this_val, int argc, JSVal
 
   void* node = lxb_dom_interface_node(el);
   for (auto& l : rctx->listeners) {
-    if (l.node == node && l.event_type == event_type) {
+    if (l.node == node && l.event_type == event_type && !l.is_handler_property) {
       JSValue* stored = static_cast<JSValue*>(l.callback);
       if (JS_VALUE_GET_TAG(*stored) == JS_VALUE_GET_TAG(argv[1]) &&
           JS_VALUE_GET_PTR(*stored) == JS_VALUE_GET_PTR(argv[1]))
@@ -219,7 +249,7 @@ JSValue js_el_removeEventListener(JSContext* ctx, JSValue this_val, int argc, JS
 
   void* node = lxb_dom_interface_node(el);
   for (auto it = rctx->listeners.begin(); it != rctx->listeners.end(); ) {
-    if (it->node == node && it->event_type == event_type) {
+    if (it->node == node && it->event_type == event_type && !it->is_handler_property) {
       JSValue* stored_cb = static_cast<JSValue*>(it->callback);
       if (JS_VALUE_GET_TAG(*stored_cb) == JS_VALUE_GET_TAG(argv[1]) &&
           JS_VALUE_GET_PTR(*stored_cb) == JS_VALUE_GET_PTR(argv[1])) {
@@ -254,6 +284,7 @@ JSValue dispatch_event_on_target(JSContext* ctx, RuntimeContext* rctx, JSValue e
   JS_FreeCString(ctx, type_str);
 
   bool bubbles = get_bool_prop(ctx, event_obj, "bubbles");
+  bool composed = get_bool_prop(ctx, event_obj, "composed");
 
   lxb_dom_node_t* doc_node = nullptr;
   if (rctx->document) {
@@ -267,7 +298,46 @@ JSValue dispatch_event_on_target(JSContext* ctx, RuntimeContext* rctx, JSValue e
   std::vector<lxb_dom_node_t*> chain;
   chain.push_back(target_node);
   if (bubbles) {
-    for (lxb_dom_node_t* p = target_node->parent; p; p = p->parent) chain.push_back(p);
+    // Climb ancestors; when we reach the top of a shadow tree (a registered
+    // ShadowRoot — it has no `parent` in the node tree, since Lexbor doesn't
+    // link a shadow root into its host's child list) and the event is
+    // composed, retarget through the shadow host (found by reverse-lookup in
+    // element_shadow_roots) and keep climbing into the light tree above it —
+    // this is how a composed event (e.g. 'click') escapes a shadow boundary
+    // while a non-composed one stays contained. The ShadowRoot node itself is
+    // never added to the chain/composedPath (unlike real DOM, which does
+    // include it): this sandbox's ShadowRoot wrapper only exists via
+    // ShadowRootBindings' host-keyed cache, so building one here via the
+    // generic make_element() path (used for every other chain entry) would
+    // produce a broken, non-ShadowRoot-shaped object instead. Simplification:
+    // this sandbox has no separate capture phase, so composedPath()/
+    // retargeting are only computed along the bubble chain — a non-bubbling
+    // event's composedPath() is just [target].
+    lxb_dom_node_t* p = target_node->parent;
+    while (p) {
+      void* host = nullptr;
+      for (auto& kv : rctx->element_shadow_roots) {
+        if (kv.second == static_cast<void*>(p)) { host = kv.first; break; }
+      }
+      if (host) {
+        if (!composed) break;
+        p = static_cast<lxb_dom_node_t*>(host);
+      }
+      chain.push_back(p);
+      p = p->parent;
+    }
+  }
+
+  {
+    JSValue path_arr = JS_NewArray(ctx);
+    for (size_t i = 0; i < chain.size(); i++) {
+      lxb_dom_node_t* level = chain[i];
+      JSValue entry = (level == doc_node)
+          ? ([&]() { JSValue g = JS_GetGlobalObject(ctx); JSValue d = JS_GetPropertyStr(ctx, g, "document"); JS_FreeValue(ctx, g); return d; })()
+          : make_element(ctx, level);
+      JS_SetPropertyUint32(ctx, path_arr, (uint32_t)i, entry);
+    }
+    JS_SetPropertyStr(ctx, event_obj, "__composedPath", path_arr);
   }
 
   for (lxb_dom_node_t* level : chain) {
@@ -287,11 +357,13 @@ JSValue dispatch_event_on_target(JSContext* ctx, RuntimeContext* rctx, JSValue e
 
     std::vector<JSValue> cbs_to_fire;
     std::vector<JSValue*> cb_ptrs;
+    std::vector<bool> cb_is_handler_property;
     for (auto& listener : rctx->listeners) {
       if (listener.node == level && listener.event_type == event_type) {
         JSValue* cb = static_cast<JSValue*>(listener.callback);
         cbs_to_fire.push_back(JS_DupValue(ctx, *cb));
         cb_ptrs.push_back(cb);
+        cb_is_handler_property.push_back(listener.is_handler_property);
       }
     }
 
@@ -314,7 +386,27 @@ JSValue dispatch_event_on_target(JSContext* ctx, RuntimeContext* rctx, JSValue e
         JS_FreeValue(ctx, cbs_to_fire[i]);
         continue;
       }
-      JSValue ret = JS_Call(ctx, cbs_to_fire[i], current_target, 1, &event_obj);
+      JSValue ret;
+      if (cb_is_handler_property[i] && event_type == "error") {
+        JSValue message_val = JS_GetPropertyStr(ctx, event_obj, "message");
+        JSValue error_val = JS_GetPropertyStr(ctx, event_obj, "error");
+        JSValue global = JS_GetGlobalObject(ctx);
+        JSValue location_val = JS_GetPropertyStr(ctx, global, "location");
+        JSValue source_val = JS_GetPropertyStr(ctx, location_val, "href");
+        JS_FreeValue(ctx, location_val);
+        JS_FreeValue(ctx, global);
+        JSValue lineno_val = JS_NewInt32(ctx, 0);
+        JSValue colno_val = JS_NewInt32(ctx, 0);
+        JSValue args[5] = { message_val, source_val, lineno_val, colno_val, error_val };
+        ret = JS_Call(ctx, cbs_to_fire[i], current_target, 5, args);
+        JS_FreeValue(ctx, message_val);
+        JS_FreeValue(ctx, source_val);
+        JS_FreeValue(ctx, lineno_val);
+        JS_FreeValue(ctx, colno_val);
+        JS_FreeValue(ctx, error_val);
+      } else {
+        ret = JS_Call(ctx, cbs_to_fire[i], current_target, 1, &event_obj);
+      }
       JS_FreeValue(ctx, cbs_to_fire[i]);
       if (JS_IsException(ret)) {
         JS_FreeValue(ctx, ret);
@@ -331,14 +423,23 @@ JSValue dispatch_event_on_target(JSContext* ctx, RuntimeContext* rctx, JSValue e
         JS_FreeValue(ctx, msg_prop);
         JS_FreeValue(ctx, ex);
         JS_ThrowInternalError(ctx, "%s", err.c_str());
+        JS_SetPropertyStr(ctx, event_obj, "__composedPath", JS_NewArray(ctx));
         return JS_EXCEPTION;
       }
+      if (cb_is_handler_property[i] && JS_IsBool(ret) && JS_ToBool(ctx, ret) == 0 &&
+          get_bool_prop(ctx, event_obj, "cancelable")) {
+        JS_SetPropertyStr(ctx, event_obj, "defaultPrevented", JS_NewBool(ctx, true));
+      }
       JS_FreeValue(ctx, ret);
     }
     JS_FreeValue(ctx, current_target);
   }
 
   bool defaultPrevented = get_bool_prop(ctx, event_obj, "defaultPrevented");
+  // Per spec, composedPath() only returns a populated path while the event is
+  // actively being dispatched — reset it so a reference to `event` saved by
+  // a listener returns [] if composedPath() is called after dispatch ends.
+  JS_SetPropertyStr(ctx, event_obj, "__composedPath", JS_NewArray(ctx));
   return JS_NewBool(ctx, !defaultPrevented);
 }
 
@@ -367,7 +468,7 @@ JSValue js_doc_addEventListener(JSContext* ctx, JSValue, int argc, JSValue* argv
           static_cast<lxb_html_document_t*>(rctx->document->documentHtmlPtr())));
 
   for (auto& l : rctx->listeners) {
-    if (l.node == doc_node && l.event_type == event_type) {
+    if (l.node == doc_node && l.event_type == event_type && !l.is_handler_property) {
       JSValue* stored = static_cast<JSValue*>(l.callback);
       if (JS_VALUE_GET_TAG(*stored) == JS_VALUE_GET_TAG(argv[1]) &&
           JS_VALUE_GET_PTR(*stored) == JS_VALUE_GET_PTR(argv[1]))
@@ -427,6 +528,130 @@ JSValue js_doc_dispatchEvent(JSContext* ctx, JSValue, int argc, JSValue* argv) {
   return dispatch_event_on_target(ctx, rctx, argv[0], node);
 }
 
+const char* kHandlerEventTypes[] = { "click", "load", "error", "unhandledrejection", "change", "input", "submit", "reset" };
+
+JSValue get_handler_prop_for_node(JSContext* ctx, RuntimeContext* rctx, void* node, const std::string& event_type) {
+  if (!rctx || !node) return JS_NULL;
+  for (auto& l : rctx->listeners) {
+    if (l.node == node && l.event_type == event_type && l.is_handler_property)
+      return JS_DupValue(ctx, *static_cast<JSValue*>(l.callback));
+  }
+  return JS_NULL;
+}
+
+JSValue set_handler_prop_for_node(JSContext* ctx, RuntimeContext* rctx, void* node, const std::string& event_type, JSValue val) {
+  if (!rctx || !node) return JS_UNDEFINED;
+  for (auto it = rctx->listeners.begin(); it != rctx->listeners.end(); ++it) {
+    if (it->node == node && it->event_type == event_type && it->is_handler_property) {
+      JSValue* stored = static_cast<JSValue*>(it->callback);
+      JS_FreeValue(ctx, *stored);
+      delete stored;
+      rctx->listeners.erase(it);
+      break;
+    }
+  }
+  if (JS_IsFunction(ctx, val)) {
+    EventListener listener;
+    listener.node = node;
+    listener.event_type = event_type;
+    listener.callback = new JSValue(JS_DupValue(ctx, val));
+    listener.is_handler_property = true;
+    rctx->listeners.push_back(std::move(listener));
+  }
+  return JS_UNDEFINED;
+}
+
+JSValue js_el_get_handler(JSContext* ctx, JSValue this_val, int magic) {
+  auto* rctx = get_ctx(ctx);
+  auto* node = unwrap_node(ctx, this_val);
+  return get_handler_prop_for_node(ctx, rctx, node, kHandlerEventTypes[magic]);
+}
+
+JSValue js_el_set_handler(JSContext* ctx, JSValue this_val, JSValue val, int magic) {
+  auto* rctx = get_ctx(ctx);
+  auto* node = unwrap_node(ctx, this_val);
+  return set_handler_prop_for_node(ctx, rctx, node, kHandlerEventTypes[magic], val);
+}
+
+void* doc_node_of(RuntimeContext* rctx) {
+  if (!rctx || !rctx->document) return nullptr;
+  return lxb_dom_interface_node(lxb_dom_interface_document(
+      static_cast<lxb_html_document_t*>(rctx->document->documentHtmlPtr())));
+}
+
+JSValue js_doc_get_handler(JSContext* ctx, JSValue, int magic) {
+  auto* rctx = get_ctx(ctx);
+  return get_handler_prop_for_node(ctx, rctx, doc_node_of(rctx), kHandlerEventTypes[magic]);
+}
+
+JSValue js_doc_set_handler(JSContext* ctx, JSValue, JSValue val, int magic) {
+  auto* rctx = get_ctx(ctx);
+  return set_handler_prop_for_node(ctx, rctx, doc_node_of(rctx), kHandlerEventTypes[magic], val);
+}
+
+void define_element_handler(JSContext* ctx, JSValue obj, const char* name, int magic) {
+  JSAtom atom = JS_NewAtom(ctx, name);
+  JSValue get_fn = JS_NewCFunction2(ctx, (JSCFunction*)js_el_get_handler, name, 0, JS_CFUNC_getter_magic, magic);
+  JSValue set_fn = JS_NewCFunction2(ctx, (JSCFunction*)js_el_set_handler, name, 1, JS_CFUNC_setter_magic, magic);
+  JS_DefinePropertyGetSet(ctx, obj, atom, get_fn, set_fn, JS_PROP_CONFIGURABLE);
+  JS_FreeAtom(ctx, atom);
+}
+
+void define_doc_handler(JSContext* ctx, JSValue obj, const char* name, int magic) {
+  JSAtom atom = JS_NewAtom(ctx, name);
+  JSValue get_fn = JS_NewCFunction2(ctx, (JSCFunction*)js_doc_get_handler, name, 0, JS_CFUNC_getter_magic, magic);
+  JSValue set_fn = JS_NewCFunction2(ctx, (JSCFunction*)js_doc_set_handler, name, 1, JS_CFUNC_setter_magic, magic);
+  JS_DefinePropertyGetSet(ctx, obj, atom, get_fn, set_fn, JS_PROP_CONFIGURABLE);
+  JS_FreeAtom(ctx, atom);
+}
+
+JSValue make_simple_event(JSContext* ctx, const char* type, bool bubbles, bool cancelable) {
+  JSValue obj = JS_NewObjectClass(ctx, js_event_class_id);
+  JS_SetPropertyStr(ctx, obj, "type", JS_NewString(ctx, type));
+  JS_SetPropertyStr(ctx, obj, "bubbles", JS_NewBool(ctx, bubbles));
+  JS_SetPropertyStr(ctx, obj, "cancelable", JS_NewBool(ctx, cancelable));
+  JS_SetPropertyStr(ctx, obj, "defaultPrevented", JS_NewBool(ctx, false));
+  return obj;
+}
+
+void fire_simple_event(JSContext* ctx, RuntimeContext* rctx, const char* type, bool bubbles, bool cancelable, lxb_dom_node_t* node) {
+  JSValue evt = make_simple_event(ctx, type, bubbles, cancelable);
+  JSValue r = dispatch_event_on_target(ctx, rctx, evt, node);
+  JS_FreeValue(ctx, evt);
+  if (JS_IsException(r)) JS_FreeValue(ctx, JS_GetException(ctx));
+  else JS_FreeValue(ctx, r);
+}
+
+JSValue js_el_click(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  auto* rctx = get_ctx(ctx);
+  auto* node = unwrap_node(ctx, this_val);
+  if (!rctx || !node) return JS_UNDEFINED;
+  fire_simple_event(ctx, rctx, "click", true, true, node);
+  return JS_UNDEFINED;
+}
+
+JSValue js_el_focus(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  auto* rctx = get_ctx(ctx);
+  auto* node = unwrap_node(ctx, this_val);
+  if (!rctx || !node || rctx->active_element == node) return JS_UNDEFINED;
+
+  void* previous = rctx->active_element;
+  rctx->active_element = node;
+  if (previous) fire_simple_event(ctx, rctx, "blur", false, false, static_cast<lxb_dom_node_t*>(previous));
+  fire_simple_event(ctx, rctx, "focus", false, false, node);
+  return JS_UNDEFINED;
+}
+
+JSValue js_el_blur(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  auto* rctx = get_ctx(ctx);
+  auto* node = unwrap_node(ctx, this_val);
+  if (!rctx || !node || rctx->active_element != node) return JS_UNDEFINED;
+
+  rctx->active_element = nullptr;
+  fire_simple_event(ctx, rctx, "blur", false, false, node);
+  return JS_UNDEFINED;
+}
+
 } // namespace
 
 void EventBindings::install(JSContext* ctx) {
@@ -438,6 +663,7 @@ void EventBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, event_proto, "preventDefault",           JS_NewCFunction(ctx, js_event_preventDefault,           "preventDefault",           0));
   JS_SetPropertyStr(ctx, event_proto, "stopPropagation",          JS_NewCFunction(ctx, js_event_stopPropagation,          "stopPropagation",          0));
   JS_SetPropertyStr(ctx, event_proto, "stopImmediatePropagation", JS_NewCFunction(ctx, js_event_stopImmediatePropagation, "stopImmediatePropagation", 0));
+  JS_SetPropertyStr(ctx, event_proto, "composedPath",             JS_NewCFunction(ctx, js_event_composedPath,             "composedPath",             0));
   JS_SetClassProto(ctx, js_event_class_id, event_proto);
 
   // ── Event / CustomEvent constructors ───────────────────────────────────────
@@ -457,14 +683,32 @@ void EventBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, node_proto, "addEventListener",    JS_NewCFunction(ctx, js_el_addEventListener,    "addEventListener",    2));
   JS_SetPropertyStr(ctx, node_proto, "removeEventListener", JS_NewCFunction(ctx, js_el_removeEventListener, "removeEventListener", 2));
   JS_SetPropertyStr(ctx, node_proto, "dispatchEvent",       JS_NewCFunction(ctx, js_el_dispatchEvent,       "dispatchEvent",       1));
+
+  define_element_handler(ctx, node_proto, "onclick",  0);
+  define_element_handler(ctx, node_proto, "onload",   1);
+  define_element_handler(ctx, node_proto, "onerror",  2);
+  define_element_handler(ctx, node_proto, "onchange", 4);
+  define_element_handler(ctx, node_proto, "oninput",  5);
+  define_element_handler(ctx, node_proto, "onsubmit", 6);
+  define_element_handler(ctx, node_proto, "onreset",  7);
   JS_FreeValue(ctx, node_proto);
 
+  JSValue element_proto = JS_GetClassProto(ctx, js_element_class_id);
+  JS_SetPropertyStr(ctx, element_proto, "click", JS_NewCFunction(ctx, js_el_click, "click", 0));
+  JS_SetPropertyStr(ctx, element_proto, "focus", JS_NewCFunction(ctx, js_el_focus, "focus", 0));
+  JS_SetPropertyStr(ctx, element_proto, "blur",  JS_NewCFunction(ctx, js_el_blur,  "blur",  0));
+  JS_FreeValue(ctx, element_proto);
+
   // ── addEventListener/removeEventListener/dispatchEvent on document ────────
   // DocumentBindings::install() must have already run so globalThis.document exists.
   JSValue doc = JS_GetPropertyStr(ctx, global, "document");
   JS_SetPropertyStr(ctx, doc, "addEventListener",    JS_NewCFunction(ctx, js_doc_addEventListener,    "addEventListener",    2));
   JS_SetPropertyStr(ctx, doc, "removeEventListener", JS_NewCFunction(ctx, js_doc_removeEventListener, "removeEventListener", 2));
   JS_SetPropertyStr(ctx, doc, "dispatchEvent",       JS_NewCFunction(ctx, js_doc_dispatchEvent,       "dispatchEvent",       1));
+
+  define_doc_handler(ctx, doc, "onclick", 0);
+  define_doc_handler(ctx, doc, "onload",  1);
+  define_doc_handler(ctx, doc, "onerror", 2);
   JS_FreeValue(ctx, doc);
 
   // ── addEventListener/removeEventListener/dispatchEvent on window ──────────
@@ -480,7 +724,39 @@ void EventBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, global, "removeEventListener", JS_NewCFunction(ctx, js_doc_removeEventListener, "removeEventListener", 2));
   JS_SetPropertyStr(ctx, global, "dispatchEvent",       JS_NewCFunction(ctx, js_doc_dispatchEvent,       "dispatchEvent",       1));
 
+  define_doc_handler(ctx, global, "onclick", 0);
+  define_doc_handler(ctx, global, "onload",  1);
+  define_doc_handler(ctx, global, "onerror", 2);
+  define_doc_handler(ctx, global, "onunhandledrejection", 3);
+
   JS_FreeValue(ctx, global);
 }
 
+void EventBindings::dispatchErrorEvent(JSContext* ctx, const std::string& message, JSValue error_value) {
+  auto* rctx = get_ctx(ctx);
+  void* node = doc_node_of(rctx);
+  if (!rctx || !node) return;
+
+  JSValue evt = make_simple_event(ctx, "error", false, true);
+  JS_SetPropertyStr(ctx, evt, "message", JS_NewStringLen(ctx, message.data(), message.size()));
+  JS_SetPropertyStr(ctx, evt, "error", JS_DupValue(ctx, error_value));
+  JSValue r = dispatch_event_on_target(ctx, rctx, evt, static_cast<lxb_dom_node_t*>(node));
+  JS_FreeValue(ctx, evt);
+  if (JS_IsException(r)) JS_FreeValue(ctx, JS_GetException(ctx));
+  else JS_FreeValue(ctx, r);
+}
+
+void EventBindings::dispatchUnhandledRejectionEvent(JSContext* ctx, JSValue reason) {
+  auto* rctx = get_ctx(ctx);
+  void* node = doc_node_of(rctx);
+  if (!rctx || !node) return;
+
+  JSValue evt = make_simple_event(ctx, "unhandledrejection", false, true);
+  JS_SetPropertyStr(ctx, evt, "reason", JS_DupValue(ctx, reason));
+  JSValue r = dispatch_event_on_target(ctx, rctx, evt, static_cast<lxb_dom_node_t*>(node));
+  JS_FreeValue(ctx, evt);
+  if (JS_IsException(r)) JS_FreeValue(ctx, JS_GetException(ctx));
+  else JS_FreeValue(ctx, r);
+}
+
 } // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/EventBindings.hpp

@@ -10,12 +10,15 @@
 // attach addEventListener/dispatchEvent there too).
 
 #include "quickjs.h"
+#include <string>
 
 namespace margelo::nitro::nitrojsdom {
 
 class EventBindings {
 public:
   static void install(JSContext* ctx);
+  static void dispatchErrorEvent(JSContext* ctx, const std::string& message, JSValue error_value);
+  static void dispatchUnhandledRejectionEvent(JSContext* ctx, JSValue reason);
 };
 
 } // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/EventTargetBindings.cpp

@@ -0,0 +1,75 @@
+#include "EventTargetBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kEventTargetBootstrapScript = R"JS(
+(function() {
+  function EventTarget() {
+    this._listeners = Object.create(null);
+  }
+
+  EventTarget.prototype.addEventListener = function(type, listener, options) {
+    if (typeof listener !== 'function' && !(listener && typeof listener.handleEvent === 'function')) return;
+    type = String(type);
+    var capture = !!(options === true || (options && options.capture));
+    var once = !!(options && options.once);
+    var list = this._listeners[type] || (this._listeners[type] = []);
+    for (var i = 0; i < list.length; i++) {
+      if (list[i].listener === listener && list[i].capture === capture) return;
+    }
+    list.push({ listener: listener, capture: capture, once: once });
+  };
+
+  EventTarget.prototype.removeEventListener = function(type, listener, options) {
+    var list = this._listeners[String(type)];
+    if (!list) return;
+    var capture = !!(options === true || (options && options.capture));
+    for (var i = 0; i < list.length; i++) {
+      if (list[i].listener === listener && list[i].capture === capture) { list.splice(i, 1); return; }
+    }
+  };
+
+  EventTarget.prototype.dispatchEvent = function(event) {
+    var list = this._listeners[event.type];
+    Object.defineProperty(event, 'target', { value: this, configurable: true });
+    Object.defineProperty(event, 'currentTarget', { value: this, configurable: true });
+    try {
+      if (list) {
+        var snapshot = list.slice();
+        for (var i = 0; i < snapshot.length; i++) {
+          var entry = snapshot[i];
+          if (list.indexOf(entry) === -1) continue;
+          if (entry.once) {
+            var idx = list.indexOf(entry);
+            if (idx !== -1) list.splice(idx, 1);
+          }
+          if (typeof entry.listener === 'function') entry.listener.call(this, event);
+          else entry.listener.handleEvent(event);
+          if (event.__immediatePropagationStopped) break;
+        }
+      }
+    } finally {
+      Object.defineProperty(event, 'currentTarget', { value: null, configurable: true });
+    }
+    return !event.defaultPrevented;
+  };
+
+  globalThis.EventTarget = EventTarget;
+})();
+)JS";
+
+} // namespace
+
+void EventTargetBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kEventTargetBootstrapScript, strlen(kEventTargetBootstrapScript),
+                            "<event-target-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/EventTargetBindings.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+// globalThis.EventTarget — a standalone, constructible EventTarget for
+// scripts that want addEventListener/removeEventListener/dispatchEvent
+// pub-sub semantics without extending an Element/document/window (which
+// already have their own dispatch paths — see EventBindings). Pure JS: its
+// own per-instance listener map, no bubbling (a bare EventTarget has no
+// ancestors to bubble through), reusing the Event/CustomEvent classes
+// EventBindings already installs.
+//
+// Must run after EventBindings (globalThis.Event, DOMException already
+// available for the "listener not a function" TypeError path — actually
+// mirrors native EventTarget, which silently ignores a non-callable
+// listener rather than throwing).
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+struct EventTargetBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/FetchBindings.cpp

@@ -118,7 +118,7 @@ const char* kFetchBootstrapScript = R"JS(
     this.status = init.status !== undefined ? init.status : 200;
     this.statusText = init.statusText !== undefined ? init.statusText : '';
     this.ok = this.status >= 200 && this.status < 300;
-    this.headers = init.headers instanceof Headers ? init.headers : new Headers(init.headers);
+    this.headers = new Headers(init.headers);
     this.bodyUsed = false;
   }
   Response.prototype.text = function() {
@@ -138,19 +138,54 @@ const char* kFetchBootstrapScript = R"JS(
   };
   globalThis.Response = Response;
 
+  function Request(input, init) {
+    init = init || {};
+    var fromRequest = input instanceof Request;
+    if (fromRequest && input.bodyUsed) {
+      throw new TypeError('Cannot construct a Request with a Request object that has already been used.');
+    }
+    this.url = fromRequest ? input.url : String(input);
+    this.method = (init.method || (fromRequest ? input.method : 'GET')).toUpperCase();
+    this.headers = new Headers(init.headers || (fromRequest ? input.headers : undefined));
+    var initBody = (init.body === undefined) ? (fromRequest ? input._body : undefined) : init.body;
+    this._body = (initBody === undefined || initBody === null) ? undefined : initBody;
+    this.signal = init.signal || (fromRequest ? input.signal : undefined);
+    this.bodyUsed = false;
+    if (fromRequest) input.bodyUsed = true;
+  }
+  Request.prototype.text = function() {
+    if (this.bodyUsed) return Promise.reject(new TypeError('Body has already been consumed.'));
+    this.bodyUsed = true;
+    return Promise.resolve(this._body === undefined ? '' : String(this._body));
+  };
+  Request.prototype.json = function() {
+    if (this.bodyUsed) return Promise.reject(new TypeError('Body has already been consumed.'));
+    this.bodyUsed = true;
+    try {
+      return Promise.resolve(JSON.parse(this._body));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  Request.prototype.clone = function() {
+    if (this.bodyUsed) throw new TypeError('Failed to execute clone: body is already used.');
+    return new Request(this.url, { method: this.method, headers: this.headers, body: this._body, signal: this.signal });
+  };
+  globalThis.Request = Request;
+
   globalThis.fetch = function(input, init) {
     return new Promise(function(resolve, reject) {
       try {
-        init = init || {};
-        if (init.signal && init.signal.aborted) {
-          reject(init.signal.reason !== undefined ? init.signal.reason : new Error('The operation was aborted'));
+        var req = new Request(input, init);
+        if (req.signal && req.signal.aborted) {
+          reject(req.signal.reason !== undefined ? req.signal.reason : new Error('The operation was aborted'));
           return;
         }
-        var url = typeof input === 'string' ? input : (input && input.url);
-        var method = (init.method || 'GET').toUpperCase();
-        var headers = normalizeHeaders(init.headers);
+        var url = req.url;
+        var method = req.method;
+        var headers = normalizeHeaders(req.headers);
         var headersJson = JSON.stringify(headers);
-        var body = (init.body === undefined || init.body === null) ? undefined : String(init.body);
+        var body = req._body === undefined ? undefined : String(req._body);
 
         var raw = __nativeFetchSync(url, method, headersJson, body);
         if (raw.error) {