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

package/android/CMakeLists.txt

@@ -48,13 +48,31 @@ 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
+  ../cpp/quickjs/bindings/DOMParserBindings.cpp
   ../cpp/quickjs/bindings/EventBindings.cpp
   ../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
+  ../cpp/quickjs/bindings/LayoutStubBindings.cpp
+  ../cpp/quickjs/bindings/TreeWalkerBindings.cpp
+  ../cpp/quickjs/bindings/EventTargetBindings.cpp
   ${QUICKJS_SOURCES}
 )
 

package/cpp/HybridHtmlSandbox.cpp

@@ -34,20 +34,37 @@ 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.
+  _runtime->contextState()->ready_state = "interactive";
+  try {
+    _runtime->evaluate("document.dispatchEvent(new Event('DOMContentLoaded', { bubbles: true }));");
+  } catch (...) { }
+
+  _runtime->contextState()->ready_state = "complete";
+  try {
+    _runtime->evaluate("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,20 @@
 #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 <lexbor/dom/interfaces/element.h>
+#include <lexbor/ns/ns.h>
+#include <lexbor/tag/tag.h>
 #include <stdexcept>
+#include <cctype>
+#include <cstring>
+#include <unordered_set>
+#include <vector>
+#include <algorithm>
 
 namespace margelo::nitro::nitrojsdom {
 
@@ -22,6 +33,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 +60,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 +160,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 +205,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) {
@@ -199,6 +233,65 @@ void* LexborDocument::createElement(const std::string& tag) {
       reinterpret_cast<const lxb_char_t*>(tag.data()), tag.size(), nullptr);
 }
 
+void* LexborDocument::createElementNS(const std::string& nsUri, const std::string& qualifiedName) {
+  if (!_document) return nullptr;
+  auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));
+
+  std::string prefix;
+  std::string localName = qualifiedName;
+  auto colon = qualifiedName.find(':');
+  if (colon != std::string::npos) {
+    prefix = qualifiedName.substr(0, colon);
+    localName = qualifiedName.substr(colon + 1);
+  }
+
+  bool known_tag = lxb_tag_data_by_name(dom_doc->tags,
+      reinterpret_cast<const lxb_char_t*>(localName.data()), localName.size()) != nullptr;
+
+  if (!known_tag) {
+    return lxb_dom_element_create(dom_doc,
+        reinterpret_cast<const lxb_char_t*>(localName.data()), localName.size(),
+        nsUri.empty() ? nullptr : reinterpret_cast<const lxb_char_t*>(nsUri.data()), nsUri.size(),
+        prefix.empty() ? nullptr : reinterpret_cast<const lxb_char_t*>(prefix.data()), prefix.size(),
+        nullptr, 0, true);
+  }
+
+  // Known tag + arbitrary ns crashes Lexbor's HTML interface dispatch, so
+  // resolve the ns id via a throwaway unknown-tag element first (safe path).
+  static const char* kNsProbeTag = "x-nitrojsdom-ns-probe";
+  lxb_dom_element_t* probe = lxb_dom_element_create(dom_doc,
+      reinterpret_cast<const lxb_char_t*>(kNsProbeTag), strlen(kNsProbeTag),
+      nsUri.empty() ? nullptr : reinterpret_cast<const lxb_char_t*>(nsUri.data()), nsUri.size(),
+      nullptr, 0, nullptr, 0, true);
+  if (!probe) return nullptr;
+  lxb_ns_id_t resolved_ns = probe->node.ns;
+  lxb_dom_element_destroy(probe);
+
+  lxb_dom_element_t* element = lxb_dom_document_create_element(dom_doc,
+      reinterpret_cast<const lxb_char_t*>(localName.data()), localName.size(), nullptr);
+  if (!element) return nullptr;
+  element->node.ns = resolved_ns;
+
+  if (!prefix.empty()) {
+    const lxb_ns_prefix_data_t* ns_prefix = lxb_ns_prefix_append(dom_doc->prefix,
+        reinterpret_cast<const lxb_char_t*>(prefix.data()), prefix.size());
+    if (ns_prefix) element->node.prefix = ns_prefix->prefix_id;
+  }
+
+  return element;
+}
+
+std::string LexborDocument::namespaceURI(void* node) const {
+  if (!_document || !node) return "";
+  auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));
+  auto* n = static_cast<lxb_dom_node_t*>(node);
+  if (n->ns == LXB_NS__UNDEF) return "";
+  size_t len = 0;
+  const lxb_char_t* uri = lxb_ns_by_id(dom_doc->ns, static_cast<lxb_ns_id_t>(n->ns), &len);
+  if (!uri || len == 0) return "";
+  return std::string(reinterpret_cast<const char*>(uri), len);
+}
+
 void* LexborDocument::createTextNode(const std::string& text) {
   if (!_document) return nullptr;
   auto* dom_doc = lxb_dom_interface_document(static_cast<lxb_html_document_t*>(_document));
@@ -219,6 +312,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 +345,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 +423,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,52 @@ public:
   void* createComment(const std::string& text);
   void* createDocumentFragment();
 
+  // ── Namespaces (createElementNS / Element.namespaceURI) ───────────────────
+  // qualifiedName may be "prefix:localName" or a bare "localName". nsUri may be
+  // empty for the null namespace. Lexbor registers arbitrary namespace URIs
+  // dynamically (lxb_ns_append), so any URI works, not just HTML/SVG/MathML.
+  // Note: lxb_tag_append_lower lowercases local_name internally, so
+  // mixed-case foreign tag/attribute names (e.g. SVG's "viewBox",
+  // "linearGradient") come back lowercased — a lexbor limitation, not
+  // something this binding can work around.
+  void* createElementNS(const std::string& nsUri, const std::string& qualifiedName);
+
+  // Returns the namespace URI for a node, or "" if the node has no namespace
+  // (LXB_NS__UNDEF) — callers should map "" to JS null.
+  std::string namespaceURI(void* node) const;
+
+  // ── 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 +92,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,30 @@
 #include "Storage.hpp"
 #include "QuickJSRuntime.hpp"
 #include "../lexbor/LexborDocument.hpp"
+#include "bindings/DOMExceptionBindings.hpp"
 #include "bindings/ElementBindings.hpp"
 #include "bindings/DocumentBindings.hpp"
+#include "bindings/DOMParserBindings.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 "bindings/LayoutStubBindings.hpp"
+#include "bindings/TreeWalkerBindings.hpp"
+#include "bindings/EventTargetBindings.hpp"
 #include <lexbor/html/html.h>
 #include <lexbor/dom/dom.h>
 
@@ -22,14 +40,32 @@ namespace margelo::nitro::nitrojsdom {
 
 void DOMBindings::install(QuickJSRuntime* runtime, LexborDocument* document) {
   JSContext* ctx = static_cast<JSContext*>(runtime->context());
-  (void)document;
+  register_document(ctx, document); // so doc_for_node() resolves nodes back to the primary 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
+  DOMParserBindings::install(ctx); // adds document.implementation + globalThis.DOMParser; needs 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
+  LayoutStubBindings::install(ctx); // needs Element's proto + globalThis.document to exist
+  TreeWalkerBindings::install(ctx); // needs Element's proto (Node traversal props) + globalThis.document to exist
+  EventTargetBindings::install(ctx); // no dependencies
 
   // ── localStorage / sessionStorage ──────────────────────────────────────────
   {