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

package/cpp/quickjs/bindings/DOMParserBindings.cpp

@@ -0,0 +1,299 @@
+#include "DOMParserBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
+#include "../../lexbor/LexborDocument.hpp"
+#include <cstring>
+#include <string>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+JSClassID js_parsed_document_class_id = 0;
+JSClassDef js_parsed_document_class = { "Document", .finalizer = nullptr };
+
+LexborDocument* unwrap_parsed_doc(JSContext* ctx, JSValue val) {
+  return static_cast<LexborDocument*>(JS_GetOpaque(val, js_parsed_document_class_id));
+}
+
+JSValue make_parsed_document(JSContext* ctx, LexborDocument* doc) {
+  register_document(ctx, doc);
+  JSValue obj = JS_NewObjectClass(ctx, js_parsed_document_class_id);
+  JS_SetOpaque(obj, doc);
+  register_document_wrapper(ctx, doc, obj);
+  return obj;
+}
+
+// ── Document-scoped query/creation methods (mirror DocumentBindings.cpp's
+// js_doc_* functions, but resolve `this`'s own LexborDocument instead of
+// always reading the sandbox's primary get_doc(ctx)) ────────────────────────
+
+JSValue js_pdoc_getElementById(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* id = JS_ToCString(ctx, argv[0]);
+  if (!id) return JS_NULL;
+  void* el = doc->getElementById(id);
+  JS_FreeCString(ctx, id);
+  return make_element(ctx, el);
+}
+
+JSValue js_pdoc_querySelector(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* sel = JS_ToCString(ctx, argv[0]);
+  if (!sel) return JS_NULL;
+  void* el = doc->querySelector_el(sel);
+  JS_FreeCString(ctx, sel);
+  return make_element(ctx, el);
+}
+
+JSValue js_pdoc_querySelectorAll(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NewArray(ctx);
+  const char* sel = JS_ToCString(ctx, argv[0]);
+  if (!sel) return JS_NewArray(ctx);
+  auto results = doc->querySelectorAll_el(sel);
+  JS_FreeCString(ctx, sel);
+  return make_element_array(ctx, results);
+}
+
+// Static snapshot, not a live HTMLCollection — see header comment.
+JSValue js_pdoc_getElementsByClassName(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NewArray(ctx);
+  const char* names = JS_ToCString(ctx, argv[0]);
+  if (!names) return JS_NewArray(ctx);
+  auto results = doc->querySelectorAll_el(classNames_to_selector(names));
+  JS_FreeCString(ctx, names);
+  return make_element_array(ctx, results);
+}
+
+// Static snapshot, not a live HTMLCollection — see header comment.
+JSValue js_pdoc_getElementsByTagName(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NewArray(ctx);
+  const char* tag = JS_ToCString(ctx, argv[0]);
+  if (!tag) return JS_NewArray(ctx);
+  auto results = doc->querySelectorAll_el(tag);
+  JS_FreeCString(ctx, tag);
+  return make_element_array(ctx, results);
+}
+
+JSValue js_pdoc_createElement(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* tag = JS_ToCString(ctx, argv[0]);
+  if (!tag) return JS_NULL;
+  void* el = doc->createElement(tag);
+  JS_FreeCString(ctx, tag);
+  return make_element(ctx, el);
+}
+
+JSValue js_pdoc_createTextNode(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* text = JS_ToCString(ctx, argv[0]);
+  if (!text) return JS_NULL;
+  void* node = doc->createTextNode(text);
+  JS_FreeCString(ctx, text);
+  return make_element(ctx, node);
+}
+
+JSValue js_pdoc_createComment(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* text = JS_ToCString(ctx, argv[0]);
+  if (!text) return JS_NULL;
+  void* node = doc->createComment(text);
+  JS_FreeCString(ctx, text);
+  return make_element(ctx, node);
+}
+
+JSValue js_pdoc_createDocumentFragment(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc) return JS_NULL;
+  return make_element(ctx, doc->createDocumentFragment());
+}
+
+JSValue js_pdoc_get_body(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  return doc ? make_element(ctx, doc->body()) : JS_NULL;
+}
+
+JSValue js_pdoc_get_head(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  return doc ? make_element(ctx, doc->head()) : JS_NULL;
+}
+
+JSValue js_pdoc_get_documentElement(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  return doc ? make_element(ctx, doc->documentElement()) : JS_NULL;
+}
+
+// Unlike document.doctype (DocumentBindings.cpp), this isn't cached: a
+// secondary document is far less likely to have `.doctype` read repeatedly,
+// so a fresh plain object per access keeps this file simpler.
+JSValue js_pdoc_get_doctype(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc) return JS_NULL;
+  void* dt = doc->doctype();
+  if (!dt) return JS_NULL;
+  return build_doctype_object(ctx, doc, dt);
+}
+
+// ── DOMParser.parseFromString() / document.implementation.createHTMLDocument() ─
+
+JSValue js_native_parse_from_string(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 2) return JS_ThrowTypeError(ctx, "parseFromString requires 2 arguments");
+  const char* html = JS_ToCString(ctx, argv[0]);
+  if (!html) return JS_EXCEPTION;
+  const char* type = JS_ToCString(ctx, argv[1]);
+  if (!type) { JS_FreeCString(ctx, html); return JS_EXCEPTION; }
+
+  static const char* kSupportedTypes[] = {
+    "text/html", "text/xml", "application/xml", "application/xhtml+xml", "image/svg+xml",
+  };
+  bool supported = false;
+  for (const char* t : kSupportedTypes) {
+    if (std::strcmp(type, t) == 0) { supported = true; break; }
+  }
+  if (!supported) {
+    std::string msg = "Invalid DOMParser type: " + std::string(type);
+    JS_FreeCString(ctx, html);
+    JS_FreeCString(ctx, type);
+    return JS_ThrowTypeError(ctx, "%s", msg.c_str());
+  }
+  // Every supported type is parsed with the HTML parser regardless of MIME
+  // type — this sandbox has no separate XML parser wired up. Good enough for
+  // the common case (parsing HTML/XHTML/SVG markup); genuine XML-specific
+  // syntax (e.g. CDATA sections, processing instructions) is not modeled.
+  JS_FreeCString(ctx, type);
+
+  auto* doc = new LexborDocument();
+  doc->parse(html);
+  JS_FreeCString(ctx, html);
+
+  auto* rctx = get_ctx(ctx);
+  JSValue result = make_parsed_document(ctx, doc);
+  if (rctx) rctx->extra_documents.emplace_back(doc);
+  return result;
+}
+
+JSValue js_native_create_html_document(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  std::string title;
+  if (argc >= 1 && !JS_IsUndefined(argv[0])) {
+    const char* t = JS_ToCString(ctx, argv[0]);
+    if (t) { title = t; JS_FreeCString(ctx, t); }
+  }
+  std::string escaped;
+  escaped.reserve(title.size());
+  for (char c : title) {
+    if (c == '<') escaped += "&lt;";
+    else if (c == '>') escaped += "&gt;";
+    else if (c == '&') escaped += "&amp;";
+    else escaped += c;
+  }
+
+  auto* doc = new LexborDocument();
+  doc->parse("<!doctype html><html><head><title>" + escaped + "</title></head><body></body></html>");
+
+  auto* rctx = get_ctx(ctx);
+  JSValue result = make_parsed_document(ctx, doc);
+  if (rctx) rctx->extra_documents.emplace_back(doc);
+  return result;
+}
+
+const char* kDOMParserBootstrapScript = R"JS(
+(function() {
+  function DOMParser() {}
+  DOMParser.prototype.parseFromString = function(str, type) {
+    return __nativeParseFromString(String(str), String(type));
+  };
+  globalThis.DOMParser = DOMParser;
+
+  document.implementation = {
+    createHTMLDocument: function(title) {
+      return __nativeCreateHTMLDocument(title === undefined ? undefined : String(title));
+    },
+  };
+
+  function definePDocTitle(proto) {
+    Object.defineProperty(proto, 'title', {
+      configurable: true,
+      get: function() {
+        var head = this.head;
+        if (!head) return '';
+        var titleEl = head.querySelector('title');
+        return titleEl ? titleEl.textContent : '';
+      },
+      set: function(value) {
+        var head = this.head;
+        if (!head) return;
+        var titleEl = head.querySelector('title');
+        if (!titleEl) {
+          titleEl = this.createElement('title');
+          head.appendChild(titleEl);
+        }
+        titleEl.textContent = String(value);
+      },
+    });
+  }
+  definePDocTitle(globalThis.__parsedDocumentProto);
+  delete globalThis.__parsedDocumentProto;
+})();
+)JS";
+
+} // namespace
+
+void DOMParserBindings::install(JSContext* ctx) {
+  JS_NewClassID(&js_parsed_document_class_id);
+  JS_NewClass(JS_GetRuntime(ctx), js_parsed_document_class_id, &js_parsed_document_class);
+
+  JSValue proto = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, proto, "getElementById", JS_NewCFunction(ctx, js_pdoc_getElementById, "getElementById", 1));
+  JS_SetPropertyStr(ctx, proto, "querySelector", JS_NewCFunction(ctx, js_pdoc_querySelector, "querySelector", 1));
+  JS_SetPropertyStr(ctx, proto, "querySelectorAll", JS_NewCFunction(ctx, js_pdoc_querySelectorAll, "querySelectorAll", 1));
+  JS_SetPropertyStr(ctx, proto, "getElementsByClassName", JS_NewCFunction(ctx, js_pdoc_getElementsByClassName, "getElementsByClassName", 1));
+  JS_SetPropertyStr(ctx, proto, "getElementsByTagName", JS_NewCFunction(ctx, js_pdoc_getElementsByTagName, "getElementsByTagName", 1));
+  JS_SetPropertyStr(ctx, proto, "createElement", JS_NewCFunction(ctx, js_pdoc_createElement, "createElement", 1));
+  JS_SetPropertyStr(ctx, proto, "createTextNode", JS_NewCFunction(ctx, js_pdoc_createTextNode, "createTextNode", 1));
+  JS_SetPropertyStr(ctx, proto, "createComment", JS_NewCFunction(ctx, js_pdoc_createComment, "createComment", 1));
+  JS_SetPropertyStr(ctx, proto, "createDocumentFragment", JS_NewCFunction(ctx, js_pdoc_createDocumentFragment, "createDocumentFragment", 0));
+
+  define_prop(ctx, proto, "body", js_pdoc_get_body, nullptr);
+  define_prop(ctx, proto, "head", js_pdoc_get_head, nullptr);
+  define_prop(ctx, proto, "documentElement", js_pdoc_get_documentElement, nullptr);
+  define_prop(ctx, proto, "doctype", js_pdoc_get_doctype, nullptr);
+
+  JS_SetPropertyStr(ctx, proto, "nodeType", JS_NewInt32(ctx, 9 /* DOCUMENT_NODE */));
+  JS_SetPropertyStr(ctx, proto, "nodeName", JS_NewString(ctx, "#document"));
+  JS_SetPropertyStr(ctx, proto, "ownerDocument", JS_NULL);
+  define_node_type_constants(ctx, proto);
+
+  JSValue global = JS_GetGlobalObject(ctx);
+
+  // Chain onto Document.prototype (set up by DocumentBindings.cpp) purely so
+  // `parsedDoc instanceof Document` holds, matching real jsdom/browsers.
+  JSValue document_ctor = JS_GetPropertyStr(ctx, global, "Document");
+  JSValue document_proto_val = JS_GetPropertyStr(ctx, document_ctor, "prototype");
+  JS_SetPrototype(ctx, proto, document_proto_val);
+  JS_FreeValue(ctx, document_proto_val);
+  JS_FreeValue(ctx, document_ctor);
+
+  JS_SetClassProto(ctx, js_parsed_document_class_id, JS_DupValue(ctx, proto));
+
+  JS_SetPropertyStr(ctx, global, "__parsedDocumentProto", proto);
+  JS_SetPropertyStr(ctx, global, "__nativeParseFromString", JS_NewCFunction(ctx, js_native_parse_from_string, "__nativeParseFromString", 2));
+  JS_SetPropertyStr(ctx, global, "__nativeCreateHTMLDocument", JS_NewCFunction(ctx, js_native_create_html_document, "__nativeCreateHTMLDocument", 1));
+  JS_FreeValue(ctx, global);
+
+  JSValue result = JS_Eval(ctx, kDOMParserBootstrapScript, strlen(kDOMParserBootstrapScript),
+                            "<domparser-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/DOMParserBindings.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+// Registers globalThis.DOMParser (`.parseFromString()`) and
+// document.implementation.createHTMLDocument(), each of which produces a
+// genuinely separate, inert Document backed by its own LexborDocument
+// instance (see doc_for_node()/register_document() in DOMBindingsInternal —
+// that's what makes mutating a second document safe rather than corrupting
+// the primary document's memory arena).
+//
+// Scope, matching real-world DOMParser usage (parsing a fetched/embedded
+// HTML string and reading it back, occasionally assembling a few new nodes):
+//   - Full read/query support: querySelector(All), getElementById,
+//     getElementsBy{ClassName,TagName} (as static snapshots, not live
+//     HTMLCollections — see below), all generic Node traversal/attribute
+//     methods (those are shared with the primary document's Element/Node
+//     prototypes and don't need document-specific wiring).
+//   - createElement/createTextNode/createComment/createDocumentFragment,
+//     appendChild/removeChild/insertBefore/replaceChild, and the
+//     textContent/innerHTML setters/insertAdjacentHTML/matches()/closest()
+//     inherited from Element.prototype — all resolve the correct owning
+//     document dynamically, so building up a secondary document is fully
+//     safe, not just read-only.
+//   - title get/set (mirrors document.title's head/<title> shim).
+// Not supported on secondary documents (their bindings are hardwired to the
+// primary document — see ShadowRootBindings/CustomElementsBindings/
+// TemplateBindings/LiveCollectionBindings): Shadow DOM (attachShadow),
+// Custom Elements, <template>.content, MutationObserver, live
+// HTMLCollections (.forms/.images/.scripts/.links, and
+// getElementsBy{ClassName,TagName} return static arrays here instead).
+// Scripts inside parsed HTML never execute (per spec, these documents are
+// inert) — no script pipeline is wired to them.
+//
+// Must run after ElementBindings (shares its Element/Node classes/protos)
+// and DocumentBindings (adds .implementation onto globalThis.document).
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+class DOMParserBindings {
+public:
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/DocumentBindings.cpp

@@ -1,7 +1,13 @@
 #include "DocumentBindings.hpp"
+#include "LiveCollectionBindings.hpp"
+#include "DOMExceptionBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
 #include "../../lexbor/LexborDocument.hpp"
+#include <lexbor/html/html.h>
+#include <lexbor/dom/dom.h>
 #include <cstring>
+#include <string>
 
 namespace margelo::nitro::nitrojsdom {
 
@@ -38,18 +44,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) {
@@ -71,6 +106,92 @@ JSValue js_doc_createTextNode(JSContext* ctx, JSValue, int argc, JSValue* argv)
   return make_element(ctx, node);
 }
 
+// Implements the WHATWG "validate and extract a namespace and qualified name"
+// algorithm (https://dom.spec.whatwg.org/#validate-and-extract): splits
+// qualifiedName into prefix/localName and checks the namespace/prefix
+// consistency rules, throwing the spec-mandated DOMException on failure.
+// Full XML Name-production character validation (which characters are legal
+// in a Name) is not implemented — only structural checks (empty name, colon
+// placement, xml/xmlns reservations) — deliberately narrower than real
+// jsdom, since that character-class check is a much larger, separate lift.
+JSValue validate_and_extract_qname(JSContext* ctx, const std::string& ns,
+                                    const std::string& qualifiedName, bool ns_is_null,
+                                    std::string& out_prefix, std::string& out_local) {
+  if (qualifiedName.empty()) {
+    return throw_dom_exception(ctx, "InvalidCharacterError",
+        "The qualified name provided is empty.");
+  }
+
+  auto colon = qualifiedName.find(':');
+  auto last_colon = qualifiedName.rfind(':');
+  if (colon != last_colon) {
+    return throw_dom_exception(ctx, "InvalidCharacterError",
+        "The qualified name provided has more than one ':'.");
+  }
+
+  std::string prefix;
+  std::string local = qualifiedName;
+  if (colon != std::string::npos) {
+    prefix = qualifiedName.substr(0, colon);
+    local = qualifiedName.substr(colon + 1);
+    if (prefix.empty() || local.empty()) {
+      return throw_dom_exception(ctx, "InvalidCharacterError",
+          "The qualified name provided is malformed.");
+    }
+  }
+
+  if (!prefix.empty() && ns_is_null) {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "A namespace is required for a prefixed qualified name.");
+  }
+  if (prefix == "xml" && ns != "http://www.w3.org/XML/1998/namespace") {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "The 'xml' prefix requires the XML namespace.");
+  }
+  bool is_xmlns = (qualifiedName == "xmlns" || prefix == "xmlns");
+  if (is_xmlns && ns != "http://www.w3.org/2000/xmlns/") {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "The 'xmlns' prefix/qualified name requires the XMLNS namespace.");
+  }
+  if (!is_xmlns && ns == "http://www.w3.org/2000/xmlns/") {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "The XMLNS namespace requires the 'xmlns' prefix or qualified name.");
+  }
+
+  out_prefix = prefix;
+  out_local = local;
+  return JS_UNDEFINED;
+}
+
+JSValue js_doc_createElementNS(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 2) {
+    return JS_ThrowTypeError(ctx,
+        "Failed to execute 'createElementNS' on 'Document': 2 arguments required.");
+  }
+  // Per WebIDL, a nullable DOMString? argument only maps to the null
+  // namespace when explicitly `null` — `undefined` stringifies to "undefined"
+  // like any other DOMString argument, it is not treated as null.
+  bool ns_is_null = JS_IsNull(argv[0]);
+  std::string ns;
+  if (!ns_is_null) {
+    const char* ns_c = JS_ToCString(ctx, argv[0]);
+    if (!ns_c) return JS_EXCEPTION;
+    ns = ns_c;
+    JS_FreeCString(ctx, ns_c);
+  }
+  const char* qname = JS_ToCString(ctx, argv[1]);
+  if (!qname) return JS_EXCEPTION;
+  std::string qualifiedName = qname;
+  JS_FreeCString(ctx, qname);
+
+  std::string prefix, local;
+  JSValue validation_error = validate_and_extract_qname(ctx, ns, qualifiedName, ns_is_null, prefix, local);
+  if (JS_IsException(validation_error)) return validation_error;
+
+  void* el = get_doc(ctx)->createElementNS(ns, qualifiedName);
+  return make_element(ctx, el);
+}
+
 JSValue js_doc_createComment(JSContext* ctx, JSValue, int argc, JSValue* argv) {
   if (argc < 1) return JS_NULL;
   const char* text = JS_ToCString(ctx, argv[0]);
@@ -84,6 +205,28 @@ JSValue js_doc_createDocumentFragment(JSContext* ctx, JSValue, int, JSValue*) {
   return make_element(ctx, get_doc(ctx)->createDocumentFragment());
 }
 
+JSValue js_doc_importNode(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 1) {
+    return JS_ThrowTypeError(ctx,
+        "Failed to execute 'importNode' on 'Document': 1 argument required, but only 0 present.");
+  }
+  auto* node = unwrap_node(ctx, argv[0]);
+  if (!node) {
+    return JS_ThrowTypeError(ctx,
+        "Failed to execute 'importNode' on 'Document': parameter 1 is not of type 'Node'.");
+  }
+  if (node->type == LXB_DOM_NODE_TYPE_DOCUMENT) {
+    return throw_dom_exception(ctx, "NotSupportedError",
+        "Failed to execute 'importNode' on 'Document': The node provided is a document, which may not be imported.");
+  }
+  bool deep = argc >= 2 && JS_ToBool(ctx, argv[1]) > 0;
+
+  lxb_dom_document_t* target_doc = lxb_dom_interface_document(
+      static_cast<lxb_html_document_t*>(get_doc(ctx)->documentHtmlPtr()));
+  lxb_dom_node_t* imported = lxb_dom_document_import_node(target_doc, node, deep);
+  return make_element(ctx, imported);
+}
+
 JSValue js_doc_get_body(JSContext* ctx, JSValue) {
   return make_element(ctx, get_doc(ctx)->body());
 }
@@ -96,6 +239,64 @@ 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 = build_doctype_object(ctx, get_doc(ctx), dt);
+  if (rctx) rctx->doctype_wrapper = new JSValue(JS_DupValue(ctx, obj));
+  return obj;
+}
+
+JSValue js_doc_get_activeElement(JSContext* ctx, JSValue) {
+  auto* rctx = get_ctx(ctx);
+  if (rctx && rctx->active_element) return make_element(ctx, rctx->active_element);
+  return make_element(ctx, get_doc(ctx)->body());
+}
+
+JSValue js_doc_get_readyState(JSContext* ctx, JSValue) {
+  auto* rctx = get_ctx(ctx);
+  const std::string& state = rctx ? rctx->ready_state : "loading";
+  return JS_NewStringLen(ctx, state.data(), state.size());
+}
+
+// A doctype-less document renders in quirks mode in every real browser (and
+// jsdom mirrors that), so this is a real, if approximate, signal rather than
+// a hardcoded stub — no actual quirks-mode CSS behavior differs here since
+// there's no layout engine to diverge.
+JSValue js_doc_get_compatMode(JSContext* ctx, JSValue) {
+  bool has_doctype = get_doc(ctx)->doctype() != nullptr;
+  const char* mode = has_doctype ? "CSS1Compat" : "BackCompat";
+  return JS_NewString(ctx, mode);
+}
+
+// document uses its own object/prototype (not node_proto), so it doesn't
+// inherit the Node-level baseURI getter — mirrors js_el_get_baseURI in
+// ElementBindings.cpp (always location.href; no <base> element support).
+JSValue js_doc_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;
+}
+
 const char* kDocumentTitleBootstrapScript = R"JS(
 (function() {
   Object.defineProperty(document, 'title', {
@@ -132,14 +333,48 @@ 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, "createElementNS",        JS_NewCFunction(ctx, js_doc_createElementNS,        "createElementNS",        2));
   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));
   JS_SetPropertyStr(ctx, doc, "createDocumentFragment", JS_NewCFunction(ctx, js_doc_createDocumentFragment, "createDocumentFragment", 0));
+  JS_SetPropertyStr(ctx, doc, "importNode",             JS_NewCFunction(ctx, js_doc_importNode,             "importNode",             2));
 
   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);
+  define_prop(ctx, doc, "activeElement",   js_doc_get_activeElement,   nullptr);
+  define_prop(ctx, doc, "readyState",      js_doc_get_readyState,      nullptr);
+  define_prop(ctx, doc, "compatMode",      js_doc_get_compatMode,      nullptr);
+  define_prop(ctx, doc, "baseURI",         js_doc_get_baseURI,         nullptr);
+
+  JS_SetPropertyStr(ctx, doc, "characterSet", JS_NewString(ctx, "UTF-8"));
+  JS_SetPropertyStr(ctx, doc, "contentType",  JS_NewString(ctx, "text/html"));
+
+  RuntimeContext* rctx = get_ctx(ctx);
+  bool hidden = !(rctx && rctx->pretend_to_be_visual);
+  JS_SetPropertyStr(ctx, doc, "hidden", JS_NewBool(ctx, hidden));
+  JS_SetPropertyStr(ctx, doc, "nodeType", JS_NewInt32(ctx, 9 /* DOCUMENT_NODE */));
+  JS_SetPropertyStr(ctx, doc, "nodeName", JS_NewString(ctx, "#document"));
+  JS_SetPropertyStr(ctx, doc, "ownerDocument", JS_NULL);
+  // document uses its own object/prototype (not node_proto), so it doesn't
+  // inherit js_el_get_namespaceURI — set explicitly rather than leaving this
+  // undefined, matching real jsdom (a Document node has no namespace).
+  JS_SetPropertyStr(ctx, doc, "namespaceURI", JS_NULL);
+
+  JSValue document_proto = JS_NewObject(ctx);
+  JS_SetPrototype(ctx, doc, document_proto);
+  define_node_type_constants(ctx, document_proto);
+  JSValue document_ctor = define_global_constructor(ctx, "Document", document_proto);
+  define_node_type_constants(ctx, document_ctor);
+  JS_FreeValue(ctx, document_ctor);
+  JS_FreeValue(ctx, document_proto);
 
   JS_SetPropertyStr(ctx, global, "document", doc);
   JS_FreeValue(ctx, global);