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

package/cpp/quickjs/bindings/DocumentBindings.cpp

@@ -1,7 +1,10 @@
 #include "DocumentBindings.hpp"
+#include "LiveCollectionBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
 #include "../../lexbor/LexborDocument.hpp"
 #include <cstring>
+#include <string>
 
 namespace margelo::nitro::nitrojsdom {
 
@@ -38,18 +41,47 @@ JSValue js_doc_getElementsByClassName(JSContext* ctx, JSValue, int argc, JSValue
   if (argc < 1) return JS_NewArray(ctx);
   const char* names = JS_ToCString(ctx, argv[0]);
   if (!names) return JS_NewArray(ctx);
-  auto results = get_doc(ctx)->querySelectorAll_el(classNames_to_selector(names));
+  JSValue result = LiveCollectionBindings::makeBySelector(ctx, nullptr, classNames_to_selector(names));
   JS_FreeCString(ctx, names);
-  return make_element_array(ctx, results);
+  return result;
 }
 
 JSValue js_doc_getElementsByTagName(JSContext* ctx, JSValue, int argc, JSValue* argv) {
   if (argc < 1) return JS_NewArray(ctx);
   const char* tag = JS_ToCString(ctx, argv[0]);
   if (!tag) return JS_NewArray(ctx);
-  auto results = get_doc(ctx)->querySelectorAll_el(tag);
+  JSValue result = LiveCollectionBindings::makeBySelector(ctx, nullptr, tag);
   JS_FreeCString(ctx, tag);
-  return make_element_array(ctx, results);
+  return result;
+}
+
+JSValue js_doc_getElementsByName(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 1) return JS_NewArray(ctx);
+  const char* name = JS_ToCString(ctx, argv[0]);
+  if (!name) return JS_NewArray(ctx);
+  std::string selector = "[name=\"" + std::string(name) + "\"]";
+  JS_FreeCString(ctx, name);
+  return LiveCollectionBindings::makeBySelector(ctx, nullptr, selector);
+}
+
+// document.forms/.images/.scripts/.links — live HTMLCollections backed by the
+// same LiveCollectionBindings::makeBySelector primitive that already backs
+// getElementsByClassName/getElementsByTagName. .links matches jsdom: any <a>
+// or <area> that actually has an href attribute (bare <a> anchors don't count).
+JSValue js_doc_get_forms(JSContext* ctx, JSValue) {
+  return LiveCollectionBindings::makeBySelector(ctx, nullptr, "form");
+}
+
+JSValue js_doc_get_images(JSContext* ctx, JSValue) {
+  return LiveCollectionBindings::makeBySelector(ctx, nullptr, "img");
+}
+
+JSValue js_doc_get_scripts(JSContext* ctx, JSValue) {
+  return LiveCollectionBindings::makeBySelector(ctx, nullptr, "script");
+}
+
+JSValue js_doc_get_links(JSContext* ctx, JSValue) {
+  return LiveCollectionBindings::makeBySelector(ctx, nullptr, "a[href], area[href]");
 }
 
 JSValue js_doc_createElement(JSContext* ctx, JSValue, int argc, JSValue* argv) {
@@ -96,6 +128,39 @@ JSValue js_doc_get_documentElement(JSContext* ctx, JSValue) {
   return make_element(ctx, get_doc(ctx)->documentElement());
 }
 
+// document.doctype is exposed as a plain {name, publicId, systemId, nodeType,
+// nodeName} object rather than routed through make_element()/the generic
+// Node wrapper: DocumentType's `name` is an interned lxb_dom_attr_id_t (needs
+// LexborDocument::doctypeName(), not the generic nodeName getter), and it has
+// no other Node behavior real-world embedded scripts rely on (no children,
+// not appendChild-able). Since it's a plain object rather than a cached
+// node-pointer-keyed wrapper, the constructed object is cached directly on
+// RuntimeContext (built once, on first access) so repeated `document.doctype`
+// reads return the same JS object — the document itself never gets
+// re-parsed mid-instance, so the cache never needs invalidation.
+JSValue js_doc_get_doctype(JSContext* ctx, JSValue) {
+  void* dt = get_doc(ctx)->doctype();
+  if (!dt) return JS_NULL;
+
+  auto* rctx = get_ctx(ctx);
+  if (rctx && rctx->doctype_wrapper) {
+    return JS_DupValue(ctx, *static_cast<JSValue*>(rctx->doctype_wrapper));
+  }
+
+  JSValue obj = JS_NewObject(ctx);
+  std::string name = get_doc(ctx)->doctypeName(dt);
+  JS_SetPropertyStr(ctx, obj, "name",      JS_NewStringLen(ctx, name.data(), name.size()));
+  std::string publicId = get_doc(ctx)->doctypePublicId(dt);
+  JS_SetPropertyStr(ctx, obj, "publicId",  JS_NewStringLen(ctx, publicId.data(), publicId.size()));
+  std::string systemId = get_doc(ctx)->doctypeSystemId(dt);
+  JS_SetPropertyStr(ctx, obj, "systemId",  JS_NewStringLen(ctx, systemId.data(), systemId.size()));
+  JS_SetPropertyStr(ctx, obj, "nodeType",  JS_NewInt32(ctx, 10));
+  JS_SetPropertyStr(ctx, obj, "nodeName",  JS_NewStringLen(ctx, name.data(), name.size()));
+
+  if (rctx) rctx->doctype_wrapper = new JSValue(JS_DupValue(ctx, obj));
+  return obj;
+}
+
 const char* kDocumentTitleBootstrapScript = R"JS(
 (function() {
   Object.defineProperty(document, 'title', {
@@ -132,6 +197,7 @@ void DocumentBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, doc, "querySelectorAll",       JS_NewCFunction(ctx, js_doc_querySelectorAll,       "querySelectorAll",       1));
   JS_SetPropertyStr(ctx, doc, "getElementsByClassName", JS_NewCFunction(ctx, js_doc_getElementsByClassName, "getElementsByClassName", 1));
   JS_SetPropertyStr(ctx, doc, "getElementsByTagName",   JS_NewCFunction(ctx, js_doc_getElementsByTagName,   "getElementsByTagName",   1));
+  JS_SetPropertyStr(ctx, doc, "getElementsByName",      JS_NewCFunction(ctx, js_doc_getElementsByName,      "getElementsByName",      1));
   JS_SetPropertyStr(ctx, doc, "createElement",          JS_NewCFunction(ctx, js_doc_createElement,          "createElement",          1));
   JS_SetPropertyStr(ctx, doc, "createTextNode",         JS_NewCFunction(ctx, js_doc_createTextNode,         "createTextNode",         1));
   JS_SetPropertyStr(ctx, doc, "createComment",          JS_NewCFunction(ctx, js_doc_createComment,          "createComment",          1));
@@ -140,6 +206,20 @@ void DocumentBindings::install(JSContext* ctx) {
   define_prop(ctx, doc, "body",            js_doc_get_body,            nullptr);
   define_prop(ctx, doc, "head",            js_doc_get_head,            nullptr);
   define_prop(ctx, doc, "documentElement", js_doc_get_documentElement, nullptr);
+  define_prop(ctx, doc, "doctype",         js_doc_get_doctype,         nullptr);
+  define_prop(ctx, doc, "forms",           js_doc_get_forms,           nullptr);
+  define_prop(ctx, doc, "images",          js_doc_get_images,          nullptr);
+  define_prop(ctx, doc, "scripts",         js_doc_get_scripts,         nullptr);
+  define_prop(ctx, doc, "links",           js_doc_get_links,           nullptr);
+
+  RuntimeContext* rctx = get_ctx(ctx);
+  bool hidden = !(rctx && rctx->pretend_to_be_visual);
+  JS_SetPropertyStr(ctx, doc, "hidden", JS_NewBool(ctx, hidden));
+
+  JSValue document_proto = JS_NewObject(ctx);
+  JS_SetPrototype(ctx, doc, document_proto);
+  JS_FreeValue(ctx, define_global_constructor(ctx, "Document", document_proto));
+  JS_FreeValue(ctx, document_proto);
 
   JS_SetPropertyStr(ctx, global, "document", doc);
   JS_FreeValue(ctx, global);

package/cpp/quickjs/bindings/ElementBindings.cpp

@@ -2,6 +2,8 @@
 #include "ClassListBindings.hpp"
 #include "DatasetBindings.hpp"
 #include "StyleBindings.hpp"
+#include "LiveCollectionBindings.hpp"
+#include "DOMExceptionBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
 #include "../QuickJSRuntime.hpp"
 #include "../MutationObservers.hpp"
@@ -100,6 +102,196 @@ JSValue js_el_set_className(JSContext* ctx, JSValue this_val, JSValue val) {
   return JS_UNDEFINED;
 }
 
+// ── Form element properties (value / checked) ────────────────────────────────
+// Simplified attribute-reflection model, matching this file's existing id/
+// className getters: no separate "dirty value" IDL flag like real browsers,
+// just direct reflection so scripts that set then read these back (the
+// common embedded-widget pattern) see consistent results.
+
+JSValue js_el_get_textContent(JSContext* ctx, JSValue this_val);
+
+bool element_tag_is(lxb_dom_element_t* el, const char* tag) {
+  size_t len = 0;
+  const lxb_char_t* name = lxb_dom_element_local_name(el, &len);
+  if (!name || len != strlen(tag)) return false;
+  for (size_t i = 0; i < len; i++) {
+    if (std::tolower(name[i]) != std::tolower((unsigned char)tag[i])) return false;
+  }
+  return true;
+}
+
+// HTMLOptionElement's value: the "value" attribute if present, else the
+// option's text content.
+std::string option_effective_value(lxb_dom_element_t* option) {
+  size_t len = 0;
+  const lxb_char_t* val = lxb_dom_element_get_attribute(option,
+      reinterpret_cast<const lxb_char_t*>("value"), 5, &len);
+  if (val) return std::string(reinterpret_cast<const char*>(val), len);
+  lxb_dom_node_t* node = lxb_dom_interface_node(option);
+  lxb_char_t* text = lxb_dom_node_text_content(node, &len);
+  if (!text) return "";
+  std::string result(reinterpret_cast<char*>(text), len);
+  lxb_dom_document_destroy_text(node->owner_document, text);
+  return result;
+}
+
+JSValue js_select_get_value(JSContext* ctx, lxb_dom_element_t* select_el) {
+  auto options = get_doc(ctx)->querySelectorAllFromEl(select_el, "option");
+  void* chosen = nullptr;
+  for (void* opt : options) {
+    if (lxb_dom_element_has_attribute(static_cast<lxb_dom_element_t*>(opt),
+        reinterpret_cast<const lxb_char_t*>("selected"), 8)) { chosen = opt; break; }
+  }
+  if (!chosen && !options.empty()) chosen = options.front();
+  if (!chosen) return JS_NewString(ctx, "");
+  return JS_NewString(ctx, option_effective_value(static_cast<lxb_dom_element_t*>(chosen)).c_str());
+}
+
+void js_select_set_value(JSContext* ctx, lxb_dom_element_t* select_el, const std::string& value) {
+  auto options = get_doc(ctx)->querySelectorAllFromEl(select_el, "option");
+  auto* rctx = get_ctx(ctx);
+  bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+  auto* attr_name = reinterpret_cast<const lxb_char_t*>("selected");
+
+  for (void* opt : options) {
+    auto* opt_el = static_cast<lxb_dom_element_t*>(opt);
+    bool should_select = option_effective_value(opt_el) == value;
+    bool has_selected = lxb_dom_element_has_attribute(opt_el, attr_name, 8);
+
+    std::optional<std::string> old_val;
+    if (has_obs && has_selected && rctx->mutation_observers->hasAttributeOldValueObserver()) {
+      size_t len = 0;
+      const lxb_char_t* v = lxb_dom_element_get_attribute(opt_el, attr_name, 8, &len);
+      if (v) old_val = std::string(reinterpret_cast<const char*>(v), len);
+    }
+
+    bool changed = false;
+    if (should_select && !has_selected) {
+      lxb_dom_element_set_attribute(opt_el, attr_name, 8, reinterpret_cast<const lxb_char_t*>(""), 0);
+      changed = true;
+    } else if (!should_select && has_selected) {
+      lxb_dom_element_remove_attribute(opt_el, attr_name, 8);
+      changed = true;
+    }
+
+    if (changed && has_obs) {
+      rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(opt_el), "selected", old_val);
+    }
+  }
+}
+
+JSValue js_el_get_value(JSContext* ctx, JSValue this_val) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_NewString(ctx, "");
+  if (element_tag_is(el, "select")) return js_select_get_value(ctx, el);
+  if (element_tag_is(el, "textarea")) return js_el_get_textContent(ctx, this_val);
+  size_t len = 0;
+  const lxb_char_t* val = lxb_dom_element_get_attribute(el,
+      reinterpret_cast<const lxb_char_t*>("value"), 5, &len);
+  if (val) return JS_NewStringLen(ctx, reinterpret_cast<const char*>(val), len);
+
+  // A checkbox/radio with no "value" attribute defaults its value to "on".
+  if (element_tag_is(el, "input")) {
+    size_t type_len = 0;
+    const lxb_char_t* type_val = lxb_dom_element_get_attribute(el,
+        reinterpret_cast<const lxb_char_t*>("type"), 4, &type_len);
+    std::string type_str = type_val ? std::string(reinterpret_cast<const char*>(type_val), type_len) : "";
+    for (auto& c : type_str) c = (char)std::tolower((unsigned char)c);
+    if (type_str == "checkbox" || type_str == "radio") return JS_NewString(ctx, "on");
+  }
+  return JS_NewString(ctx, "");
+}
+
+JSValue js_el_set_value(JSContext* ctx, JSValue this_val, JSValue val) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_UNDEFINED;
+  const char* str = JS_ToCString(ctx, val);
+  if (!str) return JS_UNDEFINED;
+
+  if (element_tag_is(el, "select")) {
+    js_select_set_value(ctx, el, str);
+  } else if (element_tag_is(el, "textarea")) {
+    auto* rctx = get_ctx(ctx);
+    bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+    lxb_dom_node_t* node = lxb_dom_interface_node(el);
+
+    std::vector<void*> old_children;
+    lxb_dom_node_t* child = node->first_child;
+    while (child) { old_children.push_back(child); child = child->next; }
+    if (!old_children.empty()) {
+      invalidate_node_cache_deep_batch(ctx, rctx, old_children);
+      if (has_obs) rctx->mutation_observers->disconnectDetachedTargets(old_children);
+    }
+
+    get_doc(ctx)->setTextContentOnEl(el, str);
+
+    if (has_obs) {
+      std::vector<void*> new_children;
+      child = node->first_child;
+      while (child) { new_children.push_back(child); child = child->next; }
+      rctx->mutation_observers->notifyChildList(ctx, node, new_children, {}, nullptr, nullptr);
+    }
+  } else {
+    auto* rctx = get_ctx(ctx);
+    bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+    std::optional<std::string> old_val;
+    if (has_obs && rctx->mutation_observers->hasAttributeOldValueObserver()) {
+      size_t len = 0;
+      const lxb_char_t* v = lxb_dom_element_get_attribute(el,
+          reinterpret_cast<const lxb_char_t*>("value"), 5, &len);
+      if (v) old_val = std::string(reinterpret_cast<const char*>(v), len);
+    }
+    lxb_dom_element_set_attribute(el,
+        reinterpret_cast<const lxb_char_t*>("value"), 5,
+        reinterpret_cast<const lxb_char_t*>(str), strlen(str));
+    if (has_obs) {
+      rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(el), "value", old_val);
+    }
+  }
+
+  JS_FreeCString(ctx, str);
+  return JS_UNDEFINED;
+}
+
+JSValue js_el_get_checked(JSContext* ctx, JSValue this_val) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_FALSE;
+  bool has = lxb_dom_element_has_attribute(el,
+      reinterpret_cast<const lxb_char_t*>("checked"), 7);
+  return JS_NewBool(ctx, has);
+}
+
+JSValue js_el_set_checked(JSContext* ctx, JSValue this_val, JSValue val) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_UNDEFINED;
+  bool checked = JS_ToBool(ctx, val) > 0;
+  auto* attr_name = reinterpret_cast<const lxb_char_t*>("checked");
+  bool has = lxb_dom_element_has_attribute(el, attr_name, 7);
+
+  auto* rctx = get_ctx(ctx);
+  bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+  std::optional<std::string> old_val;
+  if (has_obs && has && rctx->mutation_observers->hasAttributeOldValueObserver()) {
+    size_t len = 0;
+    const lxb_char_t* v = lxb_dom_element_get_attribute(el, attr_name, 7, &len);
+    if (v) old_val = std::string(reinterpret_cast<const char*>(v), len);
+  }
+
+  if (checked && !has) {
+    lxb_dom_element_set_attribute(el, attr_name, 7, reinterpret_cast<const lxb_char_t*>(""), 0);
+    if (has_obs) {
+      rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(el), "checked", std::nullopt);
+    }
+  } else if (!checked && has) {
+    lxb_dom_element_remove_attribute(el, attr_name, 7);
+    if (has_obs) {
+      rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(el), "checked", old_val);
+    }
+  }
+
+  return JS_UNDEFINED;
+}
+
 JSValue js_el_get_textContent(JSContext* ctx, JSValue this_val) {
   lxb_dom_node_t* node = unwrap_node(ctx, this_val);
   if (!node) return JS_NewString(ctx, "");
@@ -144,7 +336,7 @@ JSValue js_el_set_textContent(JSContext* ctx, JSValue this_val, JSValue val) {
       lxb_dom_node_t* child = node->first_child;
       while (child) { old_children.push_back(child); child = child->next; }
       if (!old_children.empty()) {
-        invalidate_node_cache_batch(ctx, rctx, old_children);
+        invalidate_node_cache_deep_batch(ctx, rctx, old_children);
         if (has_observers) rctx->mutation_observers->disconnectDetachedTargets(old_children);
       }
     }
@@ -189,7 +381,7 @@ JSValue js_el_set_innerHTML(JSContext* ctx, JSValue this_val, JSValue val) {
   }
 
   if (!old_children.empty()) {
-    invalidate_node_cache_batch(ctx, rctx, old_children);
+    invalidate_node_cache_deep_batch(ctx, rctx, old_children);
     if (has_observers) rctx->mutation_observers->disconnectDetachedTargets(old_children);
   }
 
@@ -223,16 +415,8 @@ JSValue js_el_get_parentElement(JSContext* ctx, JSValue this_val) {
 
 JSValue js_el_get_children(JSContext* ctx, JSValue this_val) {
   auto* el = unwrap_element(ctx, this_val);
-  JSValue arr = JS_NewArray(ctx);
-  if (!el) return arr;
-  uint32_t idx = 0;
-  lxb_dom_node_t* child = lxb_dom_interface_node(el)->first_child;
-  while (child) {
-    if (child->type == LXB_DOM_NODE_TYPE_ELEMENT)
-      JS_SetPropertyUint32(ctx, arr, idx++, make_element(ctx, lxb_dom_interface_element(child)));
-    child = child->next;
-  }
-  return arr;
+  if (!el) return JS_NewArray(ctx);
+  return LiveCollectionBindings::makeChildren(ctx, el);
 }
 
 JSValue js_el_get_firstElementChild(JSContext* ctx, JSValue this_val) {
@@ -348,12 +532,8 @@ JSValue js_el_set_nodeValue(JSContext* ctx, JSValue this_val, JSValue val) {
 
 JSValue js_el_get_childNodes(JSContext* ctx, JSValue this_val) {
   auto* node = unwrap_node(ctx, this_val);
-  JSValue arr = JS_NewArray(ctx);
-  if (!node) return arr;
-  uint32_t idx = 0;
-  lxb_dom_node_t* child = node->first_child;
-  while (child) { JS_SetPropertyUint32(ctx, arr, idx++, make_element(ctx, child)); child = child->next; }
-  return arr;
+  if (!node) return JS_NewArray(ctx);
+  return LiveCollectionBindings::makeChildNodes(ctx, node);
 }
 
 JSValue js_el_get_firstChild(JSContext* ctx, JSValue this_val) {
@@ -551,8 +731,7 @@ JSValue js_el_insertBefore(JSContext* ctx, JSValue this_val, int argc, JSValue*
     if (ref) {
       lxb_dom_node_t* receiver_node = unwrap_node(ctx, this_val);
       if (!receiver_node || ref->parent != receiver_node) {
-        JS_ThrowTypeError(ctx, "NotFoundError: reference node is not a child of this node");
-        return JS_EXCEPTION;
+        return throw_dom_exception(ctx, "NotFoundError", "reference node is not a child of this node");
       }
       parent_node = receiver_node;
       inserted = expand_and_insert(new_node, [&](lxb_dom_node_t* n) {
@@ -619,8 +798,7 @@ JSValue js_el_replaceChild(JSContext* ctx, JSValue this_val, int argc, JSValue*
   auto* old_node = unwrap_node(ctx, argv[1]);
   if (!new_node || !old_node) return JS_NULL;
   if (old_node->parent != parent_node) {
-    JS_ThrowTypeError(ctx, "NotFoundError: the node to be replaced is not a child of this node");
-    return JS_EXCEPTION;
+    return throw_dom_exception(ctx, "NotFoundError", "the node to be replaced is not a child of this node");
   }
 
   lxb_dom_node_t* prev_sib = old_node->prev;
@@ -835,8 +1013,7 @@ JSValue js_el_insertAdjacentHTML(JSContext* ctx, JSValue this_val, int argc, JSV
     next_sib = ref;
   } else {
     for (void* n : parsed) lxb_dom_node_destroy_deep(static_cast<lxb_dom_node_t*>(n));
-    JS_ThrowTypeError(ctx, "SyntaxError: invalid insertAdjacentHTML position '%s'", pos.c_str());
-    return JS_EXCEPTION;
+    return throw_dom_exception(ctx, "SyntaxError", ("invalid insertAdjacentHTML position '" + pos + "'").c_str());
   }
 
   auto* rctx = get_ctx(ctx);
@@ -881,9 +1058,9 @@ JSValue js_el_getElementsByClassName(JSContext* ctx, JSValue this_val, int argc,
   if (!el || argc < 1) return JS_NewArray(ctx);
   const char* names = JS_ToCString(ctx, argv[0]);
   if (!names) return JS_NewArray(ctx);
-  auto results = get_doc(ctx)->querySelectorAllFromEl(el, classNames_to_selector(names));
+  JSValue result = LiveCollectionBindings::makeBySelector(ctx, el, classNames_to_selector(names));
   JS_FreeCString(ctx, names);
-  return make_element_array(ctx, results);
+  return result;
 }
 
 JSValue js_el_getElementsByTagName(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
@@ -891,9 +1068,9 @@ JSValue js_el_getElementsByTagName(JSContext* ctx, JSValue this_val, int argc, J
   if (!el || argc < 1) return JS_NewArray(ctx);
   const char* tag = JS_ToCString(ctx, argv[0]);
   if (!tag) return JS_NewArray(ctx);
-  auto results = get_doc(ctx)->querySelectorAllFromEl(el, tag);
+  JSValue result = LiveCollectionBindings::makeBySelector(ctx, el, tag);
   JS_FreeCString(ctx, tag);
-  return make_element_array(ctx, results);
+  return result;
 }
 
 JSValue js_el_getAttributeNames(JSContext* ctx, JSValue this_val, int, JSValue*) {
@@ -966,6 +1143,17 @@ JSValue js_el_toggleAttribute(JSContext* ctx, JSValue this_val, int argc, JSValu
   return JS_NewBool(ctx, force_present);
 }
 
+JSValue js_el_getBoundingClientRect(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_NULL;
+  JSValue rect = JS_NewObject(ctx);
+  static const char* kFields[] = { "x", "y", "width", "height", "top", "right", "bottom", "left" };
+  for (const char* field : kFields) {
+    JS_SetPropertyStr(ctx, rect, field, JS_NewInt32(ctx, 0));
+  }
+  return rect;
+}
+
 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;
@@ -1022,6 +1210,37 @@ JSValue js_el_isEqualNode(JSContext* ctx, JSValue this_val, int argc, JSValue* a
   return JS_NewBool(ctx, nodes_equal(node, other));
 }
 
+void collect_text_descendants(lxb_dom_node_t* node, std::vector<void*>& out) {
+  for (lxb_dom_node_t* child = node->first_child; child; child = child->next) {
+    if (child->type == LXB_DOM_NODE_TYPE_TEXT) out.push_back(child);
+    else if (child->first_child) collect_text_descendants(child, out);
+  }
+}
+
+JSValue js_el_normalize(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  auto* node = unwrap_node(ctx, this_val);
+  if (!node) return JS_UNDEFINED;
+
+  // normalize() only merges/drops Text nodes (leaves, no children of their
+  // own), so a flat invalidate is enough — no need for the *_deep variant.
+  std::vector<void*> text_nodes;
+  collect_text_descendants(node, text_nodes);
+  if (!text_nodes.empty()) {
+    invalidate_node_cache_batch(ctx, get_ctx(ctx), text_nodes);
+  }
+
+  get_doc(ctx)->normalize(node);
+  return JS_UNDEFINED;
+}
+
+JSValue js_el_compareDocumentPosition(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* node = unwrap_node(ctx, this_val);
+  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));
+}
+
 } // namespace
 
 void ElementBindings::install(JSContext* ctx) {
@@ -1048,6 +1267,8 @@ void ElementBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, node_proto, "replaceWith",  JS_NewCFunction(ctx, js_el_replaceWith,  "replaceWith",  0));
   JS_SetPropertyStr(ctx, node_proto, "isSameNode",   JS_NewCFunction(ctx, js_el_isSameNode,   "isSameNode",   1));
   JS_SetPropertyStr(ctx, node_proto, "isEqualNode",  JS_NewCFunction(ctx, js_el_isEqualNode,  "isEqualNode",  1));
+  JS_SetPropertyStr(ctx, node_proto, "normalize",    JS_NewCFunction(ctx, js_el_normalize,    "normalize",    0));
+  JS_SetPropertyStr(ctx, node_proto, "compareDocumentPosition", JS_NewCFunction(ctx, js_el_compareDocumentPosition, "compareDocumentPosition", 1));
 
   define_prop(ctx, node_proto, "nodeType",         js_el_get_nodeType,        nullptr);
   define_prop(ctx, node_proto, "nodeName",         js_el_get_nodeName,        nullptr);
@@ -1083,10 +1304,13 @@ void ElementBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, proto, "insertAdjacentHTML",     JS_NewCFunction(ctx, js_el_insertAdjacentHTML,     "insertAdjacentHTML",     2));
   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));
 
   define_prop(ctx, proto, "tagName",                js_el_get_tagName,             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, "children",               js_el_get_children,            nullptr);
@@ -1101,6 +1325,18 @@ void ElementBindings::install(JSContext* ctx) {
   define_prop(ctx, proto, "attributes",              js_el_get_attributes,          nullptr);
 
   JS_SetClassProto(ctx, js_element_class_id, proto);
+
+  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 element_ctor = define_global_constructor(ctx, "Element", element_proto_ref);
+  JSValue global = JS_GetGlobalObject(ctx);
+  JS_SetPropertyStr(ctx, global, "HTMLElement", element_ctor);
+  JS_FreeValue(ctx, global);
+
+  JS_FreeValue(ctx, node_proto_ref);
+  JS_FreeValue(ctx, element_proto_ref);
 }
 
 } // namespace margelo::nitro::nitrojsdom