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

package/cpp/quickjs/bindings/ElementBindings.cpp

@@ -11,6 +11,9 @@
 #include <lexbor/html/html.h>
 #include <lexbor/dom/dom.h>
 #include <lexbor/dom/interfaces/character_data.h>
+#include <lexbor/dom/interfaces/attr.h>
+#include <lexbor/ns/const.h>
+#include <lexbor/ns/ns.h>
 #include <cctype>
 #include <cstring>
 #include <optional>
@@ -29,10 +32,18 @@ JSValue js_el_get_tagName(JSContext* ctx, JSValue this_val) {
   auto* el = unwrap_element(ctx, this_val);
   if (!el) return JS_NewString(ctx, "");
   size_t len = 0;
-  const lxb_char_t* name = lxb_dom_element_local_name(el, &len);
+  // qualified_name (prefix:localName) when the element has a namespace
+  // prefix (createElementNS('...', 'prefix:name')), falling back to the
+  // plain local name otherwise.
+  const lxb_char_t* name = lxb_dom_element_qualified_name(el, &len);
   if (!name || len == 0) return JS_NewString(ctx, "");
   std::string r(reinterpret_cast<const char*>(name), len);
-  for (auto& c : r) c = (char)std::toupper((unsigned char)c);
+  // Only HTML-namespace elements are uppercased (per spec); SVG/MathML/custom
+  // namespace elements keep their (lexbor-lowercased) local name as-is.
+  auto* node = reinterpret_cast<lxb_dom_node_t*>(el);
+  if (node->ns == LXB_NS_HTML) {
+    for (auto& c : r) c = (char)std::toupper((unsigned char)c);
+  }
   return JS_NewStringLen(ctx, r.c_str(), r.size());
 }
 
@@ -223,7 +234,7 @@ JSValue js_el_set_value(JSContext* ctx, JSValue this_val, JSValue val) {
       if (has_obs) rctx->mutation_observers->disconnectDetachedTargets(old_children);
     }
 
-    get_doc(ctx)->setTextContentOnEl(el, str);
+    doc_for_node(ctx, el)->setTextContentOnEl(el, str);
 
     if (has_obs) {
       std::vector<void*> new_children;
@@ -340,7 +351,7 @@ JSValue js_el_set_textContent(JSContext* ctx, JSValue this_val, JSValue val) {
         if (has_observers) rctx->mutation_observers->disconnectDetachedTargets(old_children);
       }
     }
-    get_doc(ctx)->setTextContentOnEl(el, str);
+    doc_for_node(ctx, node)->setTextContentOnEl(el, str);
     if (has_observers) {
       std::vector<void*> new_children;
       lxb_dom_node_t* child = node->first_child;
@@ -385,7 +396,7 @@ JSValue js_el_set_innerHTML(JSContext* ctx, JSValue this_val, JSValue val) {
     if (has_observers) rctx->mutation_observers->disconnectDetachedTargets(old_children);
   }
 
-  get_doc(ctx)->setInnerHTMLOnEl(el, html);
+  doc_for_node(ctx, el)->setInnerHTMLOnEl(el, html);
   JS_FreeCString(ctx, html);
 
   if (has_observers) {
@@ -530,6 +541,16 @@ JSValue js_el_set_nodeValue(JSContext* ctx, JSValue this_val, JSValue val) {
   return JS_UNDEFINED;
 }
 
+JSValue js_el_get_data_length(JSContext* ctx, JSValue this_val) {
+  auto* node = unwrap_node(ctx, this_val);
+  if (!node) return JS_UNDEFINED;
+  if (node->type != LXB_DOM_NODE_TYPE_TEXT && node->type != LXB_DOM_NODE_TYPE_COMMENT) return JS_UNDEFINED;
+  JSValue str_val = js_el_get_nodeValue(ctx, this_val);
+  JSValue len_val = JS_GetPropertyStr(ctx, str_val, "length");
+  JS_FreeValue(ctx, str_val);
+  return len_val;
+}
+
 JSValue js_el_get_childNodes(JSContext* ctx, JSValue this_val) {
   auto* node = unwrap_node(ctx, this_val);
   if (!node) return JS_NewArray(ctx);
@@ -651,6 +672,93 @@ JSValue js_el_hasAttribute(JSContext* ctx, JSValue this_val, int argc, JSValue*
   return JS_NewBool(ctx, has);
 }
 
+// ── Namespaced attribute methods (getAttributeNS/setAttributeNS/...) ─────────
+// Simplification: this sandbox doesn't track a real (namespace, localName)
+// identity per attribute the way createElementNS()/namespaceURI() do for
+// elements — building that would mean hand-constructing lxb_dom_attr_t nodes
+// with their own ns/prefix fields, a much larger and riskier lift than the
+// element side. Instead, attributes are matched by local name only (the
+// qualified name with any "prefix:" stripped), which is spec-accurate for
+// the common real-world case (a single xlink:href-style attribute) but not
+// for two attributes sharing a local name across different namespaces — a
+// case that essentially never comes up in embedded-widget scripts.
+lxb_dom_attr_t* find_attr_by_local_name(lxb_dom_element_t* el, const std::string& localName) {
+  for (lxb_dom_attr_t* attr = lxb_dom_element_first_attribute(el); attr; attr = lxb_dom_element_next_attribute(attr)) {
+    size_t len = 0;
+    const lxb_char_t* qname = lxb_dom_attr_qualified_name(attr, &len);
+    if (!qname) continue;
+    std::string q(reinterpret_cast<const char*>(qname), len);
+    auto colon = q.find(':');
+    std::string local = (colon == std::string::npos) ? q : q.substr(colon + 1);
+    if (local == localName) return attr;
+  }
+  return nullptr;
+}
+
+JSValue js_el_getAttributeNS(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el || argc < 2) return JS_NULL;
+  const char* local = JS_ToCString(ctx, argv[1]);
+  if (!local) return JS_NULL;
+  auto* attr = find_attr_by_local_name(el, local);
+  JS_FreeCString(ctx, local);
+  if (!attr) return JS_NULL;
+  size_t len = 0;
+  const lxb_char_t* val = lxb_dom_attr_value(attr, &len);
+  return val ? JS_NewStringLen(ctx, reinterpret_cast<const char*>(val), len) : JS_NewString(ctx, "");
+}
+
+JSValue js_el_hasAttributeNS(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el || argc < 2) return JS_FALSE;
+  const char* local = JS_ToCString(ctx, argv[1]);
+  if (!local) return JS_FALSE;
+  bool has = find_attr_by_local_name(el, local) != nullptr;
+  JS_FreeCString(ctx, local);
+  return JS_NewBool(ctx, has);
+}
+
+JSValue js_el_setAttributeNS(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el || argc < 3) return JS_UNDEFINED;
+  const char* qualified_name = JS_ToCString(ctx, argv[1]);
+  const char* value = JS_ToCString(ctx, argv[2]);
+  if (qualified_name && value) {
+    std::string qn(qualified_name);
+    auto colon = qn.find(':');
+    std::string local = (colon == std::string::npos) ? qn : qn.substr(colon + 1);
+
+    auto* existing = find_attr_by_local_name(el, local);
+    if (existing) {
+      lxb_dom_attr_set_existing_value(existing,
+          reinterpret_cast<const lxb_char_t*>(value), strlen(value));
+    } else {
+      lxb_dom_element_set_attribute(el,
+          reinterpret_cast<const lxb_char_t*>(qualified_name), qn.size(),
+          reinterpret_cast<const lxb_char_t*>(value), strlen(value));
+    }
+  }
+  if (qualified_name) JS_FreeCString(ctx, qualified_name);
+  if (value) JS_FreeCString(ctx, value);
+  return JS_UNDEFINED;
+}
+
+JSValue js_el_removeAttributeNS(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el || argc < 2) return JS_UNDEFINED;
+  const char* local = JS_ToCString(ctx, argv[1]);
+  if (local) {
+    auto* attr = find_attr_by_local_name(el, local);
+    if (attr) {
+      size_t qlen = 0;
+      const lxb_char_t* qname = lxb_dom_attr_qualified_name(attr, &qlen);
+      if (qname) lxb_dom_element_remove_attribute(el, qname, qlen);
+    }
+    JS_FreeCString(ctx, local);
+  }
+  return JS_UNDEFINED;
+}
+
 // Inserts `node` via `insert_one`, expanding DocumentFragments into their
 // children first (per the DOM's "insert a node" algorithm — a fragment is
 // never itself part of the resulting tree, only its children are moved in).
@@ -821,12 +929,15 @@ JSValue js_el_replaceChild(JSContext* ctx, JSValue this_val, int argc, JSValue*
   return JS_DupValue(ctx, argv[1]); // returns the replaced (old) child, per spec
 }
 
-lxb_dom_node_t* js_to_node_or_text(JSContext* ctx, JSValue val) {
+// `context_node` supplies the owning document for a string argument coerced
+// into a new text node (see doc_for_node()) — irrelevant when `val` is
+// already a node.
+lxb_dom_node_t* js_to_node_or_text(JSContext* ctx, JSValue val, lxb_dom_node_t* context_node) {
   auto* node = unwrap_node(ctx, val);
   if (node) return node;
   const char* str = JS_ToCString(ctx, val);
   if (!str) return nullptr;
-  void* text = get_doc(ctx)->createTextNode(str);
+  void* text = doc_for_node(ctx, context_node)->createTextNode(str);
   JS_FreeCString(ctx, str);
   return static_cast<lxb_dom_node_t*>(text);
 }
@@ -838,7 +949,7 @@ JSValue js_el_before(JSContext* ctx, JSValue this_val, int argc, JSValue* argv)
 
   std::vector<void*> inserted;
   for (int i = 0; i < argc; i++) {
-    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i]);
+    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i], node);
     if (!n) continue;
     auto batch = expand_and_insert(n, [&](lxb_dom_node_t* one) { lxb_dom_node_insert_before(node, one); });
     inserted.insert(inserted.end(), batch.begin(), batch.end());
@@ -860,7 +971,7 @@ JSValue js_el_after(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
 
   std::vector<void*> inserted;
   for (int i = 0; i < argc; i++) {
-    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i]);
+    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i], node);
     if (!n) continue;
     auto batch = expand_and_insert(n, [&](lxb_dom_node_t* one) {
       if (ref) lxb_dom_node_insert_before(ref, one); else lxb_dom_node_insert_child(parent, one);
@@ -884,7 +995,7 @@ JSValue js_el_replaceWith(JSContext* ctx, JSValue this_val, int argc, JSValue* a
 
   std::vector<void*> inserted;
   for (int i = 0; i < argc; i++) {
-    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i]);
+    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i], node);
     if (!n) continue;
     auto batch = expand_and_insert(n, [&](lxb_dom_node_t* one) { lxb_dom_node_insert_before(node, one); });
     inserted.insert(inserted.end(), batch.begin(), batch.end());
@@ -906,7 +1017,7 @@ JSValue js_el_append(JSContext* ctx, JSValue this_val, int argc, JSValue* argv)
 
   std::vector<void*> inserted;
   for (int i = 0; i < argc; i++) {
-    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i]);
+    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i], parent_node);
     if (!n) continue;
     auto batch = expand_and_insert(n, [&](lxb_dom_node_t* one) { lxb_dom_node_insert_child(parent_node, one); });
     inserted.insert(inserted.end(), batch.begin(), batch.end());
@@ -927,7 +1038,7 @@ JSValue js_el_prepend(JSContext* ctx, JSValue this_val, int argc, JSValue* argv)
 
   std::vector<void*> inserted;
   for (int i = 0; i < argc; i++) {
-    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i]);
+    lxb_dom_node_t* n = js_to_node_or_text(ctx, argv[i], parent_node);
     if (!n) continue;
     auto batch = expand_and_insert(n, [&](lxb_dom_node_t* one) {
       if (ref) lxb_dom_node_insert_before(ref, one); else lxb_dom_node_insert_child(parent_node, one);
@@ -948,11 +1059,12 @@ JSValue js_el_closest(JSContext* ctx, JSValue this_val, int argc, JSValue* argv)
   const char* sel = JS_ToCString(ctx, argv[0]);
   if (!sel) return JS_NULL;
 
+  auto* doc = doc_for_node(ctx, lxb_dom_interface_node(el));
   JSValue result = JS_NULL;
   for (lxb_dom_node_t* node = lxb_dom_interface_node(el);
        node && node->type == LXB_DOM_NODE_TYPE_ELEMENT;
        node = node->parent) {
-    if (get_doc(ctx)->matchesSelector(lxb_dom_interface_element(node), sel)) {
+    if (doc->matchesSelector(lxb_dom_interface_element(node), sel)) {
       result = make_element(ctx, node);
       break;
     }
@@ -975,7 +1087,7 @@ JSValue js_el_insertAdjacentHTML(JSContext* ctx, JSValue this_val, int argc, JSV
   JS_FreeCString(ctx, position);
 
   lxb_dom_node_t* node = lxb_dom_interface_node(el);
-  auto parsed = get_doc(ctx)->parseFragmentNodes(el, html);
+  auto parsed = doc_for_node(ctx, node)->parseFragmentNodes(el, html);
   JS_FreeCString(ctx, html);
   if (parsed.empty()) return JS_UNDEFINED;
 
@@ -1028,7 +1140,7 @@ JSValue js_el_matches(JSContext* ctx, JSValue this_val, int argc, JSValue* argv)
   if (!el || argc < 1) return JS_FALSE;
   const char* sel = JS_ToCString(ctx, argv[0]);
   if (!sel) return JS_FALSE;
-  bool result = get_doc(ctx)->matchesSelector(el, sel);
+  bool result = doc_for_node(ctx, el)->matchesSelector(el, sel);
   JS_FreeCString(ctx, sel);
   return JS_NewBool(ctx, result);
 }
@@ -1038,7 +1150,7 @@ JSValue js_el_querySelector(JSContext* ctx, JSValue this_val, int argc, JSValue*
   if (!el || argc < 1) return JS_NULL;
   const char* sel = JS_ToCString(ctx, argv[0]);
   if (!sel) return JS_NULL;
-  void* found = get_doc(ctx)->querySelectorFromEl(el, sel);
+  void* found = doc_for_node(ctx, el)->querySelectorFromEl(el, sel);
   JS_FreeCString(ctx, sel);
   return make_element(ctx, found);
 }
@@ -1048,7 +1160,7 @@ JSValue js_el_querySelectorAll(JSContext* ctx, JSValue this_val, int argc, JSVal
   if (!el || argc < 1) return JS_NewArray(ctx);
   const char* sel = JS_ToCString(ctx, argv[0]);
   if (!sel) return JS_NewArray(ctx);
-  auto results = get_doc(ctx)->querySelectorAllFromEl(el, sel);
+  auto results = doc_for_node(ctx, el)->querySelectorAllFromEl(el, sel);
   JS_FreeCString(ctx, sel);
   return make_element_array(ctx, results);
 }
@@ -1154,6 +1266,14 @@ JSValue js_el_getBoundingClientRect(JSContext* ctx, JSValue this_val, int, JSVal
   return rect;
 }
 
+JSValue js_el_getClientRects(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_NewArray(ctx);
+  JSValue arr = JS_NewArray(ctx);
+  JS_SetPropertyUint32(ctx, arr, 0, js_el_getBoundingClientRect(ctx, this_val, argc, argv));
+  return arr;
+}
+
 JSValue js_el_isSameNode(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
   auto* node = unwrap_node(ctx, this_val);
   if (!node || argc < 1) return JS_FALSE;
@@ -1229,7 +1349,7 @@ JSValue js_el_normalize(JSContext* ctx, JSValue this_val, int, JSValue*) {
     invalidate_node_cache_batch(ctx, get_ctx(ctx), text_nodes);
   }
 
-  get_doc(ctx)->normalize(node);
+  doc_for_node(ctx, node)->normalize(node);
   return JS_UNDEFINED;
 }
 
@@ -1238,7 +1358,75 @@ JSValue js_el_compareDocumentPosition(JSContext* ctx, JSValue this_val, int argc
   if (!node || argc < 1) return JS_NewInt32(ctx, 0);
   auto* other = unwrap_node(ctx, argv[0]);
   if (!other) return JS_NewInt32(ctx, 0);
-  return JS_NewInt32(ctx, get_doc(ctx)->compareDocumentPosition(node, other));
+  return JS_NewInt32(ctx, doc_for_node(ctx, node)->compareDocumentPosition(node, other));
+}
+
+JSValue js_canonicalize_root_node(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 1) return JS_UNDEFINED;
+  auto* node = unwrap_node(ctx, argv[0]);
+  if (node && node->type == LXB_DOM_NODE_TYPE_DOCUMENT && doc_for_node(ctx, node) == get_doc(ctx)) {
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue doc_val = JS_GetPropertyStr(ctx, global, "document");
+    JS_FreeValue(ctx, global);
+    return doc_val;
+  }
+  return JS_DupValue(ctx, argv[0]);
+}
+
+JSValue js_el_get_ownerDocument(JSContext* ctx, JSValue this_val) {
+  auto* node = unwrap_node(ctx, this_val);
+  if (!node) return JS_NULL;
+  if (node->type == LXB_DOM_NODE_TYPE_DOCUMENT) return JS_NULL;
+
+  LexborDocument* owner = doc_for_node(ctx, node);
+  if (owner == get_doc(ctx)) {
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue doc_val = JS_GetPropertyStr(ctx, global, "document");
+    JS_FreeValue(ctx, global);
+    return doc_val;
+  }
+
+  JSValue wrapper = get_document_wrapper(ctx, owner);
+  if (!JS_IsUndefined(wrapper)) return wrapper;
+
+  void* html_doc = owner->documentHtmlPtr();
+  void* doc_node = lxb_dom_interface_node(
+      lxb_dom_interface_document(static_cast<lxb_html_document_t*>(html_doc)));
+  return make_element(ctx, doc_node);
+}
+
+JSValue js_el_get_namespaceURI(JSContext* ctx, JSValue this_val) {
+  auto* node = unwrap_node(ctx, this_val);
+  if (!node) return JS_NULL;
+  LexborDocument* owner = doc_for_node(ctx, node);
+  std::string uri = owner ? owner->namespaceURI(node) : "";
+  if (uri.empty()) return JS_NULL;
+  return JS_NewStringLen(ctx, uri.data(), uri.size());
+}
+
+// Element.prefix — the namespace prefix set via createElementNS('ns', 'prefix:local'),
+// or null for an element with no prefix (the overwhelmingly common case).
+JSValue js_el_get_prefix(JSContext* ctx, JSValue this_val) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_NULL;
+  auto* node = reinterpret_cast<lxb_dom_node_t*>(el);
+  if (node->prefix == 0) return JS_NULL;
+  const lxb_ns_prefix_data_t* data = lxb_ns_prefix_data_by_id(node->owner_document->prefix, node->prefix);
+  if (!data) return JS_NULL;
+  const lxb_char_t* str = lexbor_hash_entry_str(&data->entry);
+  if (!str) return JS_NULL;
+  return JS_NewStringLen(ctx, reinterpret_cast<const char*>(str), data->entry.length);
+}
+
+// Node.baseURI — always the document's URL in this sandbox (no <base> element
+// support/per-node override), so this just forwards to location.href.
+JSValue js_el_get_baseURI(JSContext* ctx, JSValue) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue location = JS_GetPropertyStr(ctx, global, "location");
+  JS_FreeValue(ctx, global);
+  JSValue href = JS_GetPropertyStr(ctx, location, "href");
+  JS_FreeValue(ctx, location);
+  return href;
 }
 
 } // namespace
@@ -1273,7 +1461,12 @@ void ElementBindings::install(JSContext* ctx) {
   define_prop(ctx, node_proto, "nodeType",         js_el_get_nodeType,        nullptr);
   define_prop(ctx, node_proto, "nodeName",         js_el_get_nodeName,        nullptr);
   define_prop(ctx, node_proto, "nodeValue",        js_el_get_nodeValue,       js_el_set_nodeValue);
+  define_prop(ctx, node_proto, "data",             js_el_get_nodeValue,       js_el_set_nodeValue);
+  define_prop(ctx, node_proto, "length",           js_el_get_data_length,     nullptr);
   define_prop(ctx, node_proto, "textContent",      js_el_get_textContent,     js_el_set_textContent);
+  define_prop(ctx, node_proto, "ownerDocument",    js_el_get_ownerDocument,   nullptr);
+  define_prop(ctx, node_proto, "namespaceURI",     js_el_get_namespaceURI,    nullptr);
+  define_prop(ctx, node_proto, "baseURI",          js_el_get_baseURI,         nullptr);
   define_prop(ctx, node_proto, "childNodes",       js_el_get_childNodes,      nullptr);
   define_prop(ctx, node_proto, "firstChild",       js_el_get_firstChild,      nullptr);
   define_prop(ctx, node_proto, "lastChild",        js_el_get_lastChild,       nullptr);
@@ -1282,6 +1475,8 @@ void ElementBindings::install(JSContext* ctx) {
   define_prop(ctx, node_proto, "parentNode",       js_el_get_parentNode,      nullptr);
   define_prop(ctx, node_proto, "parentElement",    js_el_get_parentElement,   nullptr);
 
+  define_node_type_constants(ctx, node_proto);
+
   JS_SetClassProto(ctx, js_node_class_id, JS_DupValue(ctx, node_proto));
 
   // ── Element proto: inherits Node, adds Element-specific APIs ─────────────
@@ -1292,10 +1487,15 @@ void ElementBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, proto, "setAttribute",           JS_NewCFunction(ctx, js_el_setAttribute,           "setAttribute",           2));
   JS_SetPropertyStr(ctx, proto, "removeAttribute",        JS_NewCFunction(ctx, js_el_removeAttribute,        "removeAttribute",        1));
   JS_SetPropertyStr(ctx, proto, "hasAttribute",           JS_NewCFunction(ctx, js_el_hasAttribute,           "hasAttribute",           1));
+  JS_SetPropertyStr(ctx, proto, "getAttributeNS",         JS_NewCFunction(ctx, js_el_getAttributeNS,         "getAttributeNS",         2));
+  JS_SetPropertyStr(ctx, proto, "setAttributeNS",         JS_NewCFunction(ctx, js_el_setAttributeNS,         "setAttributeNS",         3));
+  JS_SetPropertyStr(ctx, proto, "removeAttributeNS",      JS_NewCFunction(ctx, js_el_removeAttributeNS,      "removeAttributeNS",      2));
+  JS_SetPropertyStr(ctx, proto, "hasAttributeNS",         JS_NewCFunction(ctx, js_el_hasAttributeNS,         "hasAttributeNS",         2));
   JS_SetPropertyStr(ctx, proto, "toggleAttribute",        JS_NewCFunction(ctx, js_el_toggleAttribute,        "toggleAttribute",        2));
   JS_SetPropertyStr(ctx, proto, "getAttributeNames",      JS_NewCFunction(ctx, js_el_getAttributeNames,      "getAttributeNames",      0));
   JS_SetPropertyStr(ctx, proto, "remove",                 JS_NewCFunction(ctx, js_el_remove,                 "remove",                 0));
   JS_SetPropertyStr(ctx, proto, "matches",                JS_NewCFunction(ctx, js_el_matches,                "matches",                1));
+  JS_SetPropertyStr(ctx, proto, "webkitMatchesSelector",  JS_NewCFunction(ctx, js_el_matches,                "webkitMatchesSelector",  1));
   JS_SetPropertyStr(ctx, proto, "querySelector",          JS_NewCFunction(ctx, js_el_querySelector,          "querySelector",          1));
   JS_SetPropertyStr(ctx, proto, "querySelectorAll",       JS_NewCFunction(ctx, js_el_querySelectorAll,       "querySelectorAll",       1));
   JS_SetPropertyStr(ctx, proto, "getElementsByClassName", JS_NewCFunction(ctx, js_el_getElementsByClassName, "getElementsByClassName", 1));
@@ -1305,14 +1505,17 @@ void ElementBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, proto, "append",                 JS_NewCFunction(ctx, js_el_append,                 "append",                 0));
   JS_SetPropertyStr(ctx, proto, "prepend",                JS_NewCFunction(ctx, js_el_prepend,                "prepend",                0));
   JS_SetPropertyStr(ctx, proto, "getBoundingClientRect",  JS_NewCFunction(ctx, js_el_getBoundingClientRect,  "getBoundingClientRect",  0));
+  JS_SetPropertyStr(ctx, proto, "getClientRects",         JS_NewCFunction(ctx, js_el_getClientRects,         "getClientRects",         0));
 
   define_prop(ctx, proto, "tagName",                js_el_get_tagName,             nullptr);
+  define_prop(ctx, proto, "prefix",                 js_el_get_prefix,              nullptr);
   define_prop(ctx, proto, "id",                     js_el_get_id,                  js_el_set_id);
   define_prop(ctx, proto, "className",              js_el_get_className,           js_el_set_className);
   define_prop(ctx, proto, "value",                  js_el_get_value,               js_el_set_value);
   define_prop(ctx, proto, "checked",                js_el_get_checked,             js_el_set_checked);
   define_prop(ctx, proto, "innerHTML",              js_el_get_innerHTML,           js_el_set_innerHTML);
   define_prop(ctx, proto, "outerHTML",              js_el_get_outerHTML,           nullptr);
+  define_prop(ctx, proto, "innerText",              js_el_get_textContent,         js_el_set_textContent);
   define_prop(ctx, proto, "children",               js_el_get_children,            nullptr);
   define_prop(ctx, proto, "firstElementChild",      js_el_get_firstElementChild,   nullptr);
   define_prop(ctx, proto, "lastElementChild",       js_el_get_lastElementChild,    nullptr);
@@ -1329,14 +1532,87 @@ void ElementBindings::install(JSContext* ctx) {
   JSValue node_proto_ref    = JS_GetClassProto(ctx, js_node_class_id);
   JSValue element_proto_ref = JS_GetClassProto(ctx, js_element_class_id);
 
-  JS_FreeValue(ctx, define_global_constructor(ctx, "Node", node_proto_ref));
+  JSValue node_ctor = define_global_constructor(ctx, "Node", node_proto_ref);
+  define_node_type_constants(ctx, node_ctor);
+  JS_FreeValue(ctx, node_ctor);
   JSValue element_ctor = define_global_constructor(ctx, "Element", element_proto_ref);
   JSValue global = JS_GetGlobalObject(ctx);
   JS_SetPropertyStr(ctx, global, "HTMLElement", element_ctor);
+  JS_SetPropertyStr(ctx, global, "__nativeCanonicalizeRootNode",
+                     JS_NewCFunction(ctx, js_canonicalize_root_node, "__nativeCanonicalizeRootNode", 1));
   JS_FreeValue(ctx, global);
 
   JS_FreeValue(ctx, node_proto_ref);
   JS_FreeValue(ctx, element_proto_ref);
+
+  static const char* kGetRootNodeScript = R"JS(
+  (function() {
+    Node.prototype.getRootNode = function(options) {
+      var composed = !!(options && options.composed);
+      var node = this;
+      while (true) {
+        var parent = node.parentNode;
+        if (parent) { node = parent; continue; }
+        if (composed && node.host) { node = node.host; continue; }
+        return __nativeCanonicalizeRootNode(node);
+      }
+    };
+
+    Object.defineProperty(Node.prototype, 'isConnected', {
+      get: function() { return this.getRootNode() === document; },
+      enumerable: true,
+      configurable: true,
+    });
+
+    function locateNamespace(node, prefix) {
+      if (!node) return null;
+      if (node.nodeType === 1) {
+        if (node.namespaceURI !== null && node.prefix === prefix) return node.namespaceURI;
+        var attrs = node.attributes;
+        for (var i = 0; i < attrs.length; i++) {
+          var a = attrs[i];
+          if (prefix === null && a.name === 'xmlns') return a.value || null;
+          if (prefix !== null && a.name === 'xmlns:' + prefix) return a.value || null;
+        }
+        return locateNamespace(node.parentElement, prefix);
+      }
+      if (node.nodeType === 9) {
+        return node.documentElement ? locateNamespace(node.documentElement, prefix) : null;
+      }
+      if (node.nodeType === 10 || node.nodeType === 11) return null;
+      return locateNamespace(node.parentElement, prefix);
+    }
+
+    Node.prototype.lookupNamespaceURI = function(prefix) {
+      if (prefix === undefined || prefix === '') prefix = null;
+      return locateNamespace(this, prefix);
+    };
+
+    Node.prototype.isDefaultNamespace = function(namespace) {
+      if (namespace === undefined || namespace === '') namespace = null;
+      return this.lookupNamespaceURI(null) === namespace;
+    };
+
+    Node.prototype.lookupPrefix = function(namespace) {
+      if (!namespace) return null;
+      var node = this.nodeType === 9 ? this.documentElement : this;
+      while (node && node.nodeType === 1) {
+        if (node.namespaceURI === namespace && node.prefix !== null) return node.prefix;
+        var attrs = node.attributes;
+        for (var i = 0; i < attrs.length; i++) {
+          var a = attrs[i];
+          if (a.name.indexOf('xmlns:') === 0 && a.value === namespace) return a.name.slice(6);
+        }
+        node = node.parentElement;
+      }
+      return null;
+    };
+  })();
+  )JS";
+  JSValue root_node_result = JS_Eval(ctx, kGetRootNodeScript, strlen(kGetRootNodeScript),
+                                      "<get-root-node-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(root_node_result)) JS_FreeValue(ctx, JS_GetException(ctx));
+  JS_FreeValue(ctx, root_node_result);
 }
 
 } // namespace margelo::nitro::nitrojsdom