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

package/android/CMakeLists.txt

@@ -48,6 +48,7 @@ add_library(${PACKAGE_NAME} SHARED
   ../cpp/quickjs/Storage.cpp
   ../cpp/quickjs/bindings/ClassListBindings.cpp
   ../cpp/quickjs/bindings/DatasetBindings.cpp
+  ../cpp/quickjs/bindings/DOMExceptionBindings.cpp
   ../cpp/quickjs/bindings/StyleBindings.cpp
   ../cpp/quickjs/bindings/ElementBindings.cpp
   ../cpp/quickjs/bindings/DocumentBindings.cpp
@@ -55,6 +56,19 @@ add_library(${PACKAGE_NAME} SHARED
   ../cpp/quickjs/bindings/TimerBindings.cpp
   ../cpp/quickjs/bindings/WindowBindings.cpp
   ../cpp/quickjs/bindings/FetchBindings.cpp
+  ../cpp/quickjs/bindings/LiveCollectionBindings.cpp
+  ../cpp/quickjs/bindings/UrlBindings.cpp
+  ../cpp/quickjs/bindings/AbortBindings.cpp
+  ../cpp/quickjs/bindings/TextEncodingBindings.cpp
+  ../cpp/quickjs/bindings/FormBindings.cpp
+  ../cpp/quickjs/bindings/BlobBindings.cpp
+  ../cpp/quickjs/bindings/CSSOMBindings.cpp
+  ../cpp/quickjs/bindings/ShadowRootBindings.cpp
+  ../cpp/quickjs/bindings/CustomElementsBindings.cpp
+  ../cpp/quickjs/bindings/CookieBindings.cpp
+  ../cpp/quickjs/bindings/TemplateBindings.cpp
+  ../cpp/quickjs/bindings/SlotBindings.cpp
+  ../cpp/quickjs/bindings/XmlSerializerBindings.cpp
   ${QUICKJS_SOURCES}
 )
 

package/cpp/HybridHtmlSandbox.cpp

@@ -34,20 +34,33 @@ std::string jsonQuote(const std::string& s) {
 }
 } // namespace
 
-void HybridHtmlSandbox::initialize(const std::string& html, bool runScripts, const std::string& url) {
+void HybridHtmlSandbox::initialize(const std::string& html, bool runScripts, const std::string& url, bool pretendToBeVisual) {
   _document = std::make_unique<LexborDocument>();
   _document->parse(html);
 
   _runtime = std::make_unique<QuickJSRuntime>();
-  _runtime->initialize(url);
+  _runtime->initialize(url, pretendToBeVisual);
   _runtime->bindDocument(_document.get());
 
   if (runScripts) {
     for (const auto& script : _document->getScriptContents()) {
-      _runtime->evaluate(script);
+      try {
+        _runtime->evaluate(script);
+      } catch (...) { }
     }
   }
 
+  // Fire once parsing (and any inline <script> execution above) is done, so
+  // scripts that do document.addEventListener('DOMContentLoaded'/'load', ...)
+  // or window.addEventListener(...) — the common embedded-widget bootstrap
+  // pattern — see them. There's no real subresource loading in this sandbox,
+  // so both fire back-to-back with nothing in between.
+  try {
+    _runtime->evaluate(
+        "document.dispatchEvent(new Event('DOMContentLoaded', { bubbles: true, cancelable: true }));"
+        "document.dispatchEvent(new Event('load'));");
+  } catch (...) { }
+
   _initialized = true;
 }
 

package/cpp/HybridHtmlSandbox.hpp

@@ -18,7 +18,7 @@ public:
   HybridHtmlSandbox() : HybridObject(TAG), HybridHtmlSandboxSpec() {}
   ~HybridHtmlSandbox() override = default;
 
-  void initialize(const std::string& html, bool runScripts, const std::string& url) override;
+  void initialize(const std::string& html, bool runScripts, const std::string& url, bool pretendToBeVisual) override;
 
   std::shared_ptr<Promise<std::string>> evaluate(const std::string& script) override;
 

package/cpp/lexbor/LexborDocument.cpp

@@ -1,9 +1,17 @@
 #include "LexborDocument.hpp"
 #include <lexbor/html/html.h>
+#include <lexbor/html/interfaces/template_element.h>
 #include <lexbor/css/css.h>
 #include <lexbor/selectors/selectors.h>
 #include <lexbor/dom/dom.h>
+#include <lexbor/dom/interfaces/character_data.h>
+#include <lexbor/dom/interfaces/document_type.h>
 #include <stdexcept>
+#include <cctype>
+#include <cstring>
+#include <unordered_set>
+#include <vector>
+#include <algorithm>
 
 namespace margelo::nitro::nitrojsdom {
 
@@ -22,6 +30,26 @@ static std::string serializeNode(lxb_dom_node_t* node) {
   return result;
 }
 
+bool is_javascript_mime_type(const std::string& type) {
+  if (type.empty()) return true;
+  std::string t;
+  t.reserve(type.size());
+  for (char c : type) t += static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  size_t start = t.find_first_not_of(" \t\n\r\f");
+  if (start == std::string::npos) return true;
+  size_t end = t.find_last_not_of(" \t\n\r\f");
+  t = t.substr(start, end - start + 1);
+
+  static const std::unordered_set<std::string> kJsTypes = {
+    "text/javascript", "application/javascript", "application/ecmascript",
+    "application/x-ecmascript", "application/x-javascript", "text/ecmascript",
+    "text/javascript1.0", "text/javascript1.1", "text/javascript1.2",
+    "text/javascript1.3", "text/javascript1.4", "text/javascript1.5",
+    "text/jscript", "text/livescript", "text/x-ecmascript", "text/x-javascript",
+  };
+  return kJsTypes.count(t) > 0;
+}
+
 struct FindFirstCtx { lxb_dom_element_t* result = nullptr; };
 
 static lxb_status_t findFirstCallback(lxb_dom_node_t* node, lxb_css_selector_specificity_t, void* ctx) {
@@ -29,11 +57,6 @@ static lxb_status_t findFirstCallback(lxb_dom_node_t* node, lxb_css_selector_spe
   return LXB_STATUS_STOP;
 }
 
-static lxb_status_t findAllStringCallback(lxb_dom_node_t* node, lxb_css_selector_specificity_t, void* ctx) {
-  static_cast<std::vector<std::string>*>(ctx)->push_back(serializeNode(node));
-  return LXB_STATUS_OK;
-}
-
 static lxb_status_t findAllPtrCallback(lxb_dom_node_t* node, lxb_css_selector_specificity_t, void* ctx) {
   static_cast<std::vector<void*>*>(ctx)->push_back(lxb_dom_interface_element(node));
   return LXB_STATUS_OK;
@@ -134,14 +157,14 @@ std::vector<void*> LexborDocument::querySelectorAll_el(const std::string& sel) c
 
 void* LexborDocument::querySelectorFromEl(void* element, const std::string& sel) const {
   if (!element) return nullptr;
-  return findFirstFrom(lxb_dom_interface_node(static_cast<lxb_dom_element_t*>(element)), sel);
+  return findFirstFrom(static_cast<lxb_dom_node_t*>(element), sel);
 }
 
 std::vector<void*> LexborDocument::querySelectorAllFromEl(void* element, const std::string& sel) const {
   if (!_document || !element) return {};
   auto* parser    = static_cast<lxb_css_parser_t*>(_cssParser);
   auto* selectors = static_cast<lxb_selectors_t*>(_selectors);
-  auto* node      = lxb_dom_interface_node(static_cast<lxb_dom_element_t*>(element));
+  auto* node      = static_cast<lxb_dom_node_t*>(element);
 
   lxb_css_selector_list_t* list = lxb_css_selectors_parse(parser,
       reinterpret_cast<const lxb_char_t*>(sel.data()), sel.size());
@@ -179,7 +202,15 @@ std::vector<std::string> LexborDocument::getScriptContents() const {
   contents.reserve(scriptEls.size());
 
   for (void* el : scriptEls) {
-    auto* node = lxb_dom_interface_node(static_cast<lxb_dom_element_t*>(el));
+    auto* element = static_cast<lxb_dom_element_t*>(el);
+
+    size_t type_len = 0;
+    const lxb_char_t* type_attr = lxb_dom_element_get_attribute(element,
+        reinterpret_cast<const lxb_char_t*>("type"), 4, &type_len);
+    std::string type = type_attr ? std::string(reinterpret_cast<const char*>(type_attr), type_len) : "";
+    if (!is_javascript_mime_type(type)) continue;
+
+    auto* node = lxb_dom_interface_node(element);
     size_t len = 0;
     lxb_char_t* text = lxb_dom_node_text_content(node, &len);
     if (text && len > 0) {
@@ -219,6 +250,16 @@ void* LexborDocument::createDocumentFragment() {
   return lxb_dom_document_create_document_fragment(dom_doc);
 }
 
+void* LexborDocument::createShadowRoot(void* hostElement, int mode) {
+  if (!_document || !hostElement) return nullptr;
+  auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));
+  auto* shadow = lxb_dom_shadow_root_interface_create(dom_doc);
+  if (!shadow) return nullptr;
+  shadow->host = static_cast<lxb_dom_element_t*>(hostElement);
+  shadow->mode = static_cast<lxb_dom_shadow_root_mode_t>(mode);
+  return shadow;
+}
+
 // ── Element content ──────────────────────────────────────────────────────────
 
 void LexborDocument::setTextContentOnEl(void* element, const std::string& text) {
@@ -242,10 +283,40 @@ void LexborDocument::setTextContentOnEl(void* element, const std::string& text)
   }
 }
 
+void LexborDocument::setInnerHTMLOnShadowRoot(void* shadowRoot, void* hostElement, const std::string& html) {
+  auto* host = static_cast<lxb_dom_element_t*>(hostElement);
+  auto* doc  = static_cast<lxb_html_document_t*>(_document);
+  auto* root = static_cast<lxb_dom_node_t*>(shadowRoot);
+
+  lxb_dom_node_t* frag = lxb_html_document_parse_fragment(doc, host,
+      reinterpret_cast<const lxb_char_t*>(html.data()), html.size());
+  if (!frag) return;
+
+  while (root->first_child) lxb_dom_node_destroy_deep(root->first_child);
+
+  while (frag->first_child) {
+    lxb_dom_node_t* child = frag->first_child;
+    lxb_dom_node_remove(child);
+    lxb_dom_node_insert_child(root, child);
+  }
+
+  lxb_dom_node_destroy(frag);
+}
+
 void LexborDocument::setInnerHTMLOnEl(void* element, const std::string& html) {
   auto* el  = static_cast<lxb_dom_element_t*>(element);
   auto* doc = static_cast<lxb_html_document_t*>(_document);
-  auto* root = lxb_dom_interface_node(el);
+
+  // <template>.innerHTML populates .content (a separate inert fragment), not
+  // the template element's own light-DOM children — matches the parser's own
+  // "in template" insertion mode behavior for parsed <template> markup.
+  size_t tag_len = 0;
+  const lxb_char_t* tag_name = lxb_dom_element_local_name(el, &tag_len);
+  bool is_template = tag_len == 8 && memcmp(tag_name, "template", 8) == 0;
+
+  lxb_dom_node_t* root = is_template
+      ? lxb_dom_interface_node(reinterpret_cast<lxb_html_template_element_t*>(el)->content)
+      : lxb_dom_interface_node(el);
 
   lxb_dom_node_t* frag = lxb_html_document_parse_fragment(doc, el,
       reinterpret_cast<const lxb_char_t*>(html.data()), html.size());
@@ -290,76 +361,155 @@ bool LexborDocument::matchesSelector(void* element, const std::string& sel) cons
   return false;
 }
 
-// ── Legacy selector-based API ────────────────────────────────────────────────
+// ── <template> ────────────────────────────────────────────────────────────
 
-std::optional<std::string> LexborDocument::querySelector(const std::string& selector) const {
-  auto* el = static_cast<lxb_dom_element_t*>(findFirst(selector));
-  if (!el) return std::nullopt;
-  return serializeNode(lxb_dom_interface_node(el));
+void* LexborDocument::templateContent(void* templateEl) const {
+  if (!templateEl) return nullptr;
+  auto* tpl = reinterpret_cast<lxb_html_template_element_t*>(templateEl);
+  return tpl->content;
 }
 
-std::vector<std::string> LexborDocument::querySelectorAll(const std::string& selector) const {
-  if (!_document) return {};
-  auto* parser    = static_cast<lxb_css_parser_t*>(_cssParser);
-  auto* selectors = static_cast<lxb_selectors_t*>(_selectors);
-  auto* doc       = static_cast<lxb_html_document_t*>(_document);
+// ── Doctype ──────────────────────────────────────────────────────────────────
 
-  lxb_css_selector_list_t* list = lxb_css_selectors_parse(parser,
-      reinterpret_cast<const lxb_char_t*>(selector.data()), selector.size());
-  std::vector<std::string> results;
-  if (list) {
-    lxb_selectors_find(selectors, lxb_dom_interface_node(doc), list, findAllStringCallback, &results);
-    lxb_css_selector_list_destroy_memory(list);
-  }
-  return results;
+void* LexborDocument::doctype() const {
+  if (!_document) return nullptr;
+  auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));
+  return dom_doc->doctype;
 }
 
-std::optional<std::string> LexborDocument::getAttribute(const std::string& selector, const std::string& attr) const {
-  auto* el = static_cast<lxb_dom_element_t*>(findFirst(selector));
-  if (!el) return std::nullopt;
-  size_t val_len;
-  const lxb_char_t* val = lxb_dom_element_get_attribute(el,
-      reinterpret_cast<const lxb_char_t*>(attr.data()), attr.size(), &val_len);
-  if (!val) return std::nullopt;
-  return std::string(reinterpret_cast<const char*>(val), val_len);
-}
-
-void LexborDocument::setAttribute(const std::string& selector, const std::string& attr, const std::string& value) {
-  auto* el = static_cast<lxb_dom_element_t*>(findFirst(selector));
-  if (!el) return;
-  lxb_dom_element_set_attribute(el,
-      reinterpret_cast<const lxb_char_t*>(attr.data()), attr.size(),
-      reinterpret_cast<const lxb_char_t*>(value.data()), value.size());
-}
-
-std::optional<std::string> LexborDocument::getTextContent(const std::string& selector) const {
-  auto* el = static_cast<lxb_dom_element_t*>(findFirst(selector));
-  if (!el) return std::nullopt;
-  lxb_dom_node_t* node = lxb_dom_interface_node(el);
-  size_t len;
-  lxb_char_t* text = lxb_dom_node_text_content(node, &len);
-  if (!text) return std::nullopt;
-  std::string result(reinterpret_cast<char*>(text), len);
-  lxb_dom_document_destroy_text(node->owner_document, text);
-  return result;
+std::string LexborDocument::doctypeName(void* voidDoctype) const {
+  if (!voidDoctype) return "";
+  size_t len = 0;
+  const lxb_char_t* name = lxb_dom_document_type_name(
+      static_cast<lxb_dom_document_type_t*>(voidDoctype), &len);
+  return name ? std::string(reinterpret_cast<const char*>(name), len) : "";
 }
 
-std::optional<std::string> LexborDocument::getInnerHTML(const std::string& selector) const {
-  auto* el = static_cast<lxb_dom_element_t*>(findFirst(selector));
-  if (!el) return std::nullopt;
-  std::string result;
-  lxb_dom_node_t* child = lxb_dom_interface_node(el)->first_child;
+std::string LexborDocument::doctypePublicId(void* voidDoctype) const {
+  if (!voidDoctype) return "";
+  size_t len = 0;
+  const lxb_char_t* id = lxb_dom_document_type_public_id(
+      static_cast<lxb_dom_document_type_t*>(voidDoctype), &len);
+  return id ? std::string(reinterpret_cast<const char*>(id), len) : "";
+}
+
+std::string LexborDocument::doctypeSystemId(void* voidDoctype) const {
+  if (!voidDoctype) return "";
+  size_t len = 0;
+  const lxb_char_t* id = lxb_dom_document_type_system_id(
+      static_cast<lxb_dom_document_type_t*>(voidDoctype), &len);
+  return id ? std::string(reinterpret_cast<const char*>(id), len) : "";
+}
+
+// ── Node.normalize() ─────────────────────────────────────────────────────────
+
+namespace {
+
+void normalize_children(lxb_dom_node_t* parent) {
+  lxb_dom_node_t* child = parent->first_child;
   while (child) {
-    result += serializeNode(child);
-    child = child->next;
+    lxb_dom_node_t* next = child->next;
+
+    if (child->type == LXB_DOM_NODE_TYPE_TEXT) {
+      auto* cd = reinterpret_cast<lxb_dom_character_data_t*>(child);
+      std::string merged(reinterpret_cast<const char*>(cd->data.data), cd->data.length);
+      size_t old_len = cd->data.length;
+
+      lxb_dom_node_t* sibling = next;
+      while (sibling && sibling->type == LXB_DOM_NODE_TYPE_TEXT) {
+        auto* scd = reinterpret_cast<lxb_dom_character_data_t*>(sibling);
+        merged.append(reinterpret_cast<const char*>(scd->data.data), scd->data.length);
+        lxb_dom_node_t* dead = sibling;
+        sibling = sibling->next;
+        lxb_dom_node_remove(dead);
+        lxb_dom_node_destroy(dead);
+      }
+
+      if (merged.empty()) {
+        lxb_dom_node_remove(child);
+        lxb_dom_node_destroy(child);
+      } else {
+        lxb_dom_character_data_replace(cd,
+            reinterpret_cast<const lxb_char_t*>(merged.data()), merged.size(),
+            0, old_len);
+      }
+      next = sibling;
+    } else if (child->first_child) {
+      normalize_children(child);
+    }
+
+    child = next;
   }
-  return result;
 }
 
-void LexborDocument::setInnerHTML(const std::string& selector, const std::string& html) {
-  auto* el = static_cast<lxb_dom_element_t*>(findFirst(selector));
-  if (!el) return;
-  setInnerHTMLOnEl(el, html);
+} // namespace
+
+void LexborDocument::normalize(void* voidNode) {
+  auto* node = static_cast<lxb_dom_node_t*>(voidNode);
+  if (!node) return;
+  normalize_children(node);
+}
+
+// ── Node.compareDocumentPosition() ──────────────────────────────────────────
+
+namespace {
+
+constexpr int kDocumentPositionDisconnected         = 0x01;
+constexpr int kDocumentPositionPreceding            = 0x02;
+constexpr int kDocumentPositionFollowing            = 0x04;
+constexpr int kDocumentPositionContains             = 0x08;
+constexpr int kDocumentPositionContainedBy           = 0x10;
+constexpr int kDocumentPositionImplementationSpecific = 0x20;
+
+lxb_dom_node_t* root_of(lxb_dom_node_t* n) {
+  while (n->parent) n = n->parent;
+  return n;
+}
+
+bool is_ancestor(lxb_dom_node_t* ancestor, lxb_dom_node_t* node) {
+  for (auto* p = node->parent; p; p = p->parent) {
+    if (p == ancestor) return true;
+  }
+  return false;
+}
+
+} // namespace
+
+int LexborDocument::compareDocumentPosition(void* voidA, void* voidB) const {
+  auto* a = static_cast<lxb_dom_node_t*>(voidA);
+  auto* b = static_cast<lxb_dom_node_t*>(voidB);
+  if (!a || !b || a == b) return 0;
+
+  if (root_of(a) != root_of(b)) {
+    return kDocumentPositionDisconnected | kDocumentPositionImplementationSpecific
+         | kDocumentPositionFollowing;
+  }
+
+  // b is a descendant of a
+  if (is_ancestor(a, b)) return kDocumentPositionContainedBy | kDocumentPositionFollowing;
+  // a is a descendant of b
+  if (is_ancestor(b, a)) return kDocumentPositionContains | kDocumentPositionPreceding;
+
+  std::vector<lxb_dom_node_t*> chainA, chainB;
+  for (auto* p = a; p; p = p->parent) chainA.push_back(p);
+  for (auto* p = b; p; p = p->parent) chainB.push_back(p);
+  std::reverse(chainA.begin(), chainA.end());
+  std::reverse(chainB.begin(), chainB.end());
+
+  size_t i = 0;
+  while (i < chainA.size() && i < chainB.size() && chainA[i] == chainB[i]) i++;
+  // chainA[i-1] == chainB[i-1] is the lowest common ancestor (guaranteed to
+  // exist since both nodes share the same root and neither contains the other).
+  lxb_dom_node_t* lca      = chainA[i - 1];
+  lxb_dom_node_t* branchA  = chainA[i];
+  lxb_dom_node_t* branchB  = chainB[i];
+
+  for (lxb_dom_node_t* c = lca->first_child; c; c = c->next) {
+    if (c == branchA) return kDocumentPositionFollowing;
+    if (c == branchB) return kDocumentPositionPreceding;
+  }
+  return kDocumentPositionDisconnected | kDocumentPositionImplementationSpecific
+       | kDocumentPositionFollowing;
 }
 
 } // namespace margelo::nitro::nitrojsdom

package/cpp/lexbor/LexborDocument.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <string>
-#include <optional>
 #include <vector>
 
 namespace margelo::nitro::nitrojsdom {
@@ -39,9 +38,38 @@ public:
   void* createComment(const std::string& text);
   void* createDocumentFragment();
 
+  // ── Shadow DOM ─────────────────────────────────────────────────────────────
+  // mode: 0 = open, 1 = closed (matches lxb_dom_shadow_root_mode_t).
+  void* createShadowRoot(void* hostElement, int mode);
+
+  // ── <template> ─────────────────────────────────────────────────────────────
+  // Returns the lxb_dom_document_fragment_t* backing a <template> element's
+  // `content`. Lexbor allocates this at element-creation time (both for parsed
+  // and createElement()'d templates), so this is a plain field read.
+  void* templateContent(void* templateEl) const;
+
+  // ── Doctype ────────────────────────────────────────────────────────────────
+  // Returns the lxb_dom_document_type_t* for this document, or nullptr if the
+  // parsed HTML had no doctype.
+  void* doctype() const;
+  std::string doctypeName(void* doctype) const;
+  std::string doctypePublicId(void* doctype) const;
+  std::string doctypeSystemId(void* doctype) const;
+
+  // ── Node.normalize() ───────────────────────────────────────────────────────
+  // Merges adjacent Text node siblings and removes empty ones, recursively
+  // through node's subtree (node itself is not replaced, only its descendants).
+  void normalize(void* node);
+
+  // ── Node.compareDocumentPosition() ────────────────────────────────────────
+  // Returns the DOM DOCUMENT_POSITION_* bitmask describing nodeB's position
+  // relative to nodeA (mirrors `nodeA.compareDocumentPosition(nodeB)`).
+  int compareDocumentPosition(void* nodeA, void* nodeB) const;
+
   // ── Element content ───────────────────────────────────────────────────────
   void setTextContentOnEl(void* element, const std::string& text);
   void setInnerHTMLOnEl(void* element, const std::string& html);
+  void setInnerHTMLOnShadowRoot(void* shadowRoot, void* hostElement, const std::string& html);
 
   // Like setInnerHTMLOnEl, but returns the detached parsed nodes instead of
   // replacing contextElement's children — used by insertAdjacentHTML.
@@ -50,15 +78,6 @@ public:
   // ── Selector matching ─────────────────────────────────────────────────────
   bool matchesSelector(void* element, const std::string& sel) const;
 
-  // ── Legacy selector-based API (kept for backward compat) ─────────────────
-  std::optional<std::string> querySelector(const std::string& selector) const;
-  std::vector<std::string> querySelectorAll(const std::string& selector) const;
-  std::optional<std::string> getAttribute(const std::string& selector, const std::string& attr) const;
-  void setAttribute(const std::string& selector, const std::string& attr, const std::string& value);
-  std::optional<std::string> getTextContent(const std::string& selector) const;
-  std::optional<std::string> getInnerHTML(const std::string& selector) const;
-  void setInnerHTML(const std::string& selector, const std::string& html);
-
 private:
   void* _document  { nullptr };
   void* _cssParser { nullptr };

package/cpp/quickjs/DOMBindings.cpp

@@ -4,12 +4,26 @@
 #include "Storage.hpp"
 #include "QuickJSRuntime.hpp"
 #include "../lexbor/LexborDocument.hpp"
+#include "bindings/DOMExceptionBindings.hpp"
 #include "bindings/ElementBindings.hpp"
 #include "bindings/DocumentBindings.hpp"
 #include "bindings/EventBindings.hpp"
 #include "bindings/TimerBindings.hpp"
 #include "bindings/WindowBindings.hpp"
 #include "bindings/FetchBindings.hpp"
+#include "bindings/LiveCollectionBindings.hpp"
+#include "bindings/UrlBindings.hpp"
+#include "bindings/AbortBindings.hpp"
+#include "bindings/TextEncodingBindings.hpp"
+#include "bindings/FormBindings.hpp"
+#include "bindings/BlobBindings.hpp"
+#include "bindings/CSSOMBindings.hpp"
+#include "bindings/ShadowRootBindings.hpp"
+#include "bindings/CustomElementsBindings.hpp"
+#include "bindings/CookieBindings.hpp"
+#include "bindings/TemplateBindings.hpp"
+#include "bindings/SlotBindings.hpp"
+#include "bindings/XmlSerializerBindings.hpp"
 #include <lexbor/html/html.h>
 #include <lexbor/dom/dom.h>
 
@@ -24,12 +38,26 @@ void DOMBindings::install(QuickJSRuntime* runtime, LexborDocument* document) {
   JSContext* ctx = static_cast<JSContext*>(runtime->context());
   (void)document;
 
+  DOMExceptionBindings::install(ctx); // no dependencies; other modules throw DOMException instances
+  LiveCollectionBindings::install(ctx);
   ElementBindings::install(ctx);   // registers the Element class + proto
+  ShadowRootBindings::install(ctx); // needs Element's proto + js_node_class_id's proto
   DocumentBindings::install(ctx);  // creates globalThis.document
+  CookieBindings::install(ctx);    // needs globalThis.document to exist
+  TemplateBindings::install(ctx);  // needs Element's proto
+  CustomElementsBindings::install(ctx); // needs Element/ShadowRoot protos + globalThis.document
+  CSSOMBindings::install(ctx);     // needs Element's proto + globalThis.document to exist
   EventBindings::install(ctx);     // needs Element's proto + globalThis.document to exist
   TimerBindings::install(ctx);
   WindowBindings::install(ctx);
+  UrlBindings::install(ctx);
+  AbortBindings::install(ctx);
+  TextEncodingBindings::install(ctx);
+  BlobBindings::install(ctx);      // uses TextEncoder/TextDecoder + btoa, so must run after both
   FetchBindings::install(ctx);     // XHR bootstrap uses `new Event(...)`, so must run after EventBindings
+  FormBindings::install(ctx);      // uses globalThis.Element + globalThis.Event, so must run after both
+  SlotBindings::install(ctx);      // uses Event/dispatchEvent + Element/ShadowRoot protos, so must run after EventBindings/ShadowRootBindings
+  XmlSerializerBindings::install(ctx); // pure serialization, no ordering requirement beyond ElementBindings
 
   // ── localStorage / sessionStorage ──────────────────────────────────────────
   {

package/cpp/quickjs/DOMBindingsInternal.cpp

@@ -8,8 +8,9 @@
 
 namespace margelo::nitro::nitrojsdom {
 
-JSClassID js_element_class_id = 0;
-JSClassID js_node_class_id    = 0;
+JSClassID js_element_class_id     = 0;
+JSClassID js_node_class_id        = 0;
+JSClassID js_shadow_root_class_id = 0;
 
 namespace {
 JSClassDef js_element_class = { "Element", .finalizer = nullptr };
@@ -59,6 +60,22 @@ void invalidate_node_cache_batch(JSContext* ctx, RuntimeContext* rctx, const std
   for (void* n : nodes) invalidate_node_cache(ctx, rctx, n);
 }
 
+namespace {
+void invalidate_node_cache_deep(JSContext* ctx, RuntimeContext* rctx, void* node_ptr) {
+  if (!node_ptr) return;
+  invalidate_node_cache(ctx, rctx, node_ptr);
+  for (lxb_dom_node_t* child = static_cast<lxb_dom_node_t*>(node_ptr)->first_child;
+       child; child = child->next) {
+    invalidate_node_cache_deep(ctx, rctx, child);
+  }
+}
+} // namespace
+
+void invalidate_node_cache_deep_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& roots) {
+  if (!rctx) return;
+  for (void* root : roots) invalidate_node_cache_deep(ctx, rctx, root);
+}
+
 void clear_node_cache(JSContext* ctx, RuntimeContext* rctx) {
   if (!rctx) return;
   for (auto& kv : rctx->node_wrapper_cache) {
@@ -85,6 +102,8 @@ lxb_dom_node_t* unwrap_node(JSContext* ctx, JSValue val) {
   void* p = JS_GetOpaque(val, js_element_class_id);
   if (p) return static_cast<lxb_dom_node_t*>(p);
   p = JS_GetOpaque(val, js_node_class_id);
+  if (p) return static_cast<lxb_dom_node_t*>(p);
+  p = JS_GetOpaque(val, js_shadow_root_class_id);
   return static_cast<lxb_dom_node_t*>(p);
 }
 
@@ -117,6 +136,19 @@ void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter,
   JS_FreeAtom(ctx, atom);
 }
 
+JSValue js_illegal_constructor(JSContext* ctx, JSValue, int, JSValue*) {
+  return JS_ThrowTypeError(ctx, "Illegal constructor");
+}
+
+JSValue define_global_constructor(JSContext* ctx, const char* name, JSValue proto) {
+  JSValue ctor = JS_NewCFunction2(ctx, js_illegal_constructor, name, 0, JS_CFUNC_constructor, 0);
+  JS_SetConstructor(ctx, ctor, proto);
+  JSValue global = JS_GetGlobalObject(ctx);
+  JS_SetPropertyStr(ctx, global, name, JS_DupValue(ctx, ctor));
+  JS_FreeValue(ctx, global);
+  return ctor;
+}
+
 bool get_bool_prop(JSContext* ctx, JSValue obj, const char* name) {
   JSValue v = JS_GetPropertyStr(ctx, obj, name);
   bool b = JS_ToBool(ctx, v) > 0;

package/cpp/quickjs/DOMBindingsInternal.hpp

@@ -34,11 +34,16 @@ class LexborDocument;
 // node class (Node traversal only). This prevents non-element nodes from
 // reaching lxb_dom_element_* calls.
 //
+// js_shadow_root_class_id wraps lxb_dom_shadow_root_t* (see ShadowRootBindings).
+//
 // unwrap_element() returns non-null only for element-class objects.
-// unwrap_node()    returns non-null for either class (shared Node methods).
+// unwrap_node()    returns non-null for any of the three (shared Node methods
+//                  like appendChild/childNodes work the same way on a
+//                  ShadowRoot, since it embeds a document fragment's layout).
 
 extern JSClassID js_element_class_id;
 extern JSClassID js_node_class_id;
+extern JSClassID js_shadow_root_class_id;
 
 JSValue make_element(JSContext* ctx, void* node_or_el);
 JSValue make_element_array(JSContext* ctx, const std::vector<void*>& elements);
@@ -57,6 +62,12 @@ void invalidate_node_cache(JSContext* ctx, RuntimeContext* rctx, void* node);
 void invalidate_node_cache_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& nodes);
 void clear_node_cache(JSContext* ctx, RuntimeContext* rctx);
 
+// Same as invalidate_node_cache_batch, but also invalidates every descendant
+// of each given node. Use before destroying a subtree with
+// lxb_dom_node_destroy_deep(): that frees descendants too, and a JS wrapper
+// left pointing at a freed descendant is a use-after-free waiting to happen.
+void invalidate_node_cache_deep_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& roots);
+
 // ── Accessor property helper ──────────────────────────────────────────────────
 
 using GetterFn = JSValue (*)(JSContext*, JSValue);
@@ -64,6 +75,11 @@ using SetterFn = JSValue (*)(JSContext*, JSValue, JSValue);
 
 void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter, SetterFn setter = nullptr);
 
+// ── Global constructor helper (instanceof support) ────────────────────────────
+
+JSValue js_illegal_constructor(JSContext* ctx, JSValue this_val, int argc, JSValue* argv);
+JSValue define_global_constructor(JSContext* ctx, const char* name, JSValue proto);
+
 // ── Misc shared helpers ───────────────────────────────────────────────────────
 
 // Reads a boolean-ish property off any JS object (used by Event dispatch to read