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

package/android/CMakeLists.txt

@@ -52,6 +52,7 @@ add_library(${PACKAGE_NAME} SHARED
   ../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
@@ -69,6 +70,9 @@ add_library(${PACKAGE_NAME} SHARED
   ../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

@@ -55,10 +55,14 @@ void HybridHtmlSandbox::initialize(const std::string& html, bool runScripts, con
   // 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, cancelable: true }));"
-        "document.dispatchEvent(new Event('load'));");
+    _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/lexbor/LexborDocument.cpp

@@ -6,6 +6,9 @@
 #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>
@@ -230,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));

package/cpp/lexbor/LexborDocument.hpp

@@ -38,6 +38,20 @@ 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);

package/cpp/quickjs/DOMBindings.cpp

@@ -7,6 +7,7 @@
 #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"
@@ -24,6 +25,9 @@
 #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>
 
@@ -36,13 +40,14 @@ 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
@@ -58,6 +63,9 @@ void DOMBindings::install(QuickJSRuntime* runtime, LexborDocument* document) {
   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 ──────────────────────────────────────────
   {

package/cpp/quickjs/DOMBindingsInternal.cpp

@@ -126,6 +126,40 @@ LexborDocument* get_doc(JSContext* ctx) {
   return rctx ? rctx->document : nullptr;
 }
 
+LexborDocument* doc_for_node(JSContext* ctx, void* node) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx) return nullptr;
+  if (node) {
+    auto* dom_node = static_cast<lxb_dom_node_t*>(node);
+    auto it = rctx->document_registry.find(dom_node->owner_document);
+    if (it != rctx->document_registry.end()) return it->second;
+  }
+  return rctx->document;
+}
+
+void register_document(JSContext* ctx, LexborDocument* doc) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx || !doc) return;
+  auto* html_doc = static_cast<lxb_html_document_t*>(doc->documentHtmlPtr());
+  if (!html_doc) return;
+  void* dom_doc = lxb_dom_interface_document(html_doc);
+  rctx->document_registry[dom_doc] = doc;
+}
+
+void register_document_wrapper(JSContext* ctx, LexborDocument* doc, JSValue wrapper) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx || !doc) return;
+  rctx->document_wrappers[doc] = new JSValue(JS_DupValue(ctx, wrapper));
+}
+
+JSValue get_document_wrapper(JSContext* ctx, LexborDocument* doc) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx || !doc) return JS_UNDEFINED;
+  auto it = rctx->document_wrappers.find(doc);
+  if (it == rctx->document_wrappers.end()) return JS_UNDEFINED;
+  return JS_DupValue(ctx, *static_cast<JSValue*>(it->second));
+}
+
 void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter, SetterFn setter) {
   JSAtom atom = JS_NewAtom(ctx, name);
   JSValue get_fn = JS_NewCFunction2(ctx, (JSCFunction*)getter, name, 0, JS_CFUNC_getter, 0);
@@ -136,6 +170,39 @@ void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter,
   JS_FreeAtom(ctx, atom);
 }
 
+void define_node_type_constants(JSContext* ctx, JSValue obj) {
+  static const struct { const char* name; int32_t value; } kNodeTypeConstants[] = {
+    { "ELEMENT_NODE",                1  },
+    { "ATTRIBUTE_NODE",              2  },
+    { "TEXT_NODE",                   3  },
+    { "CDATA_SECTION_NODE",          4  },
+    { "ENTITY_REFERENCE_NODE",       5  },
+    { "ENTITY_NODE",                 6  },
+    { "PROCESSING_INSTRUCTION_NODE", 7  },
+    { "COMMENT_NODE",                8  },
+    { "DOCUMENT_NODE",               9  },
+    { "DOCUMENT_TYPE_NODE",          10 },
+    { "DOCUMENT_FRAGMENT_NODE",      11 },
+    { "NOTATION_NODE",               12 },
+  };
+  for (const auto& c : kNodeTypeConstants) {
+    JS_DefinePropertyValueStr(ctx, obj, c.name, JS_NewInt32(ctx, c.value), JS_PROP_ENUMERABLE);
+  }
+}
+
+JSValue build_doctype_object(JSContext* ctx, LexborDocument* doc, void* doctype) {
+  JSValue obj = JS_NewObject(ctx);
+  std::string name = doc->doctypeName(doctype);
+  JS_SetPropertyStr(ctx, obj, "name", JS_NewStringLen(ctx, name.data(), name.size()));
+  std::string publicId = doc->doctypePublicId(doctype);
+  JS_SetPropertyStr(ctx, obj, "publicId", JS_NewStringLen(ctx, publicId.data(), publicId.size()));
+  std::string systemId = doc->doctypeSystemId(doctype);
+  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()));
+  return obj;
+}
+
 JSValue js_illegal_constructor(JSContext* ctx, JSValue, int, JSValue*) {
   return JS_ThrowTypeError(ctx, "Illegal constructor");
 }

package/cpp/quickjs/DOMBindingsInternal.hpp

@@ -56,6 +56,34 @@ std::string serialize_node(lxb_dom_node_t* node);
 RuntimeContext* get_ctx(JSContext* ctx);
 LexborDocument* get_doc(JSContext* ctx);
 
+// Resolves the LexborDocument that owns `node`'s tree — the sandbox's
+// primary document, or a secondary document created via
+// DOMParser.parseFromString()/document.implementation.createHTMLDocument()
+// (see DOMParserBindings). Any binding that *creates* a new node relative to
+// an existing one (textContent/innerHTML setters, insertAdjacentHTML,
+// before/after/replaceWith/append/prepend's string-to-text-node coercion,
+// matches()/closest()) must resolve the document this way instead of using
+// get_doc(ctx) directly — otherwise a node from a secondary document would
+// have children created in the *primary* document's memory arena, which is
+// undefined behavior once either document is destroyed. Falls back to the
+// primary document if `node`'s owner isn't registered (shouldn't happen).
+LexborDocument* doc_for_node(JSContext* ctx, void* node);
+
+// Registers `doc` in the runtime's document registry so doc_for_node() can
+// resolve nodes created inside it back to `doc`. Call once, right after the
+// document is constructed/parsed.
+void register_document(JSContext* ctx, LexborDocument* doc);
+
+// Registers `wrapper` (the JS Document object returned to script) as the
+// canonical JS object for `doc`, so get_document_wrapper() can hand back the
+// same reference later (e.g. from node.ownerDocument) instead of building a
+// new, unequal one. Call once, alongside register_document().
+void register_document_wrapper(JSContext* ctx, LexborDocument* doc, JSValue wrapper);
+
+// Returns the JSValue registered via register_document_wrapper() for `doc`,
+// or JS_UNDEFINED if none was registered.
+JSValue get_document_wrapper(JSContext* ctx, LexborDocument* doc);
+
 // ── Node wrapper cache ────────────────────────────────────────────────────────
 
 void invalidate_node_cache(JSContext* ctx, RuntimeContext* rctx, void* node);
@@ -75,6 +103,17 @@ using SetterFn = JSValue (*)(JSContext*, JSValue, JSValue);
 
 void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter, SetterFn setter = nullptr);
 
+// Sets the WHATWG DOM Node.ELEMENT_NODE-style numeric constants (ELEMENT_NODE,
+// TEXT_NODE, COMMENT_NODE, ...) as read-only enumerable properties on `obj`.
+// Values match lxb_dom_node_type_t, which already mirrors the DOM spec numbering.
+void define_node_type_constants(JSContext* ctx, JSValue obj);
+
+// Builds the plain {name, publicId, systemId, nodeType, nodeName} object used
+// to represent a document's DocumentType node (see doc->doctype()). Shared by
+// DocumentBindings (which layers its own identity cache on top) and
+// DOMParserBindings (which doesn't cache — see its call site).
+JSValue build_doctype_object(JSContext* ctx, LexborDocument* doc, void* doctype);
+
 // ── Global constructor helper (instanceof support) ────────────────────────────
 
 JSValue js_illegal_constructor(JSContext* ctx, JSValue this_val, int argc, JSValue* argv);

package/cpp/quickjs/QuickJSRuntime.cpp

@@ -2,6 +2,7 @@
 #include "DOMBindings.hpp"
 #include "DOMBindingsInternal.hpp"
 #include "MutationObservers.hpp"
+#include "bindings/EventBindings.hpp"
 #include "../lexbor/LexborDocument.hpp"
 #include "quickjs.h"
 #include <stdexcept>
@@ -98,6 +99,14 @@ QuickJSRuntime::~QuickJSRuntime() {
       delete stored;
       _ctxState->doctype_wrapper = nullptr;
     }
+
+    // Free cached secondary-document wrappers
+    for (auto& kv : _ctxState->document_wrappers) {
+      JSValue* stored = static_cast<JSValue*>(kv.second);
+      JS_FreeValue(ctx, *stored);
+      delete stored;
+    }
+    _ctxState->document_wrappers.clear();
   }
 
   if (_context) JS_FreeContext(reinterpret_cast<JSContext*>(_context));
@@ -243,6 +252,7 @@ void QuickJSRuntime::drainEventLoop() {
           }
           JS_FreeValue(ctx, str_val);
         }
+        EventBindings::dispatchErrorEvent(ctx, err, ex);
         JS_FreeValue(ctx, ex);
         throw std::runtime_error(err);
       }
@@ -266,6 +276,7 @@ void QuickJSRuntime::drainEventLoop() {
         }
         JS_FreeValue(ctx, str_val);
       }
+      EventBindings::dispatchUnhandledRejectionEvent(ctx, *stored);
       JS_FreeValue(ctx, *stored);
       delete stored;
       _ctxState->pending_rejection = nullptr;
@@ -394,6 +405,7 @@ void QuickJSRuntime::fireTimer(Timer* t) {
       }
       JS_FreeValue(ctx, str_val);
     }
+    EventBindings::dispatchErrorEvent(ctx, err, ex);
     JS_FreeValue(ctx, ex);
     throw std::runtime_error(err);
   }
@@ -440,6 +452,7 @@ std::string QuickJSRuntime::evaluate(const std::string& script) {
       JS_FreeValue(ctx, str_val);
     }
 
+    EventBindings::dispatchErrorEvent(ctx, err, ex);
     JS_FreeValue(ctx, ex);
     QJS_LOG("QuickJS exception: %s", err.c_str());
     throw std::runtime_error(err);

package/cpp/quickjs/QuickJSRuntime.hpp

@@ -39,6 +39,7 @@ struct EventListener {
   void* node;              // lxb_dom_node_t*
   std::string event_type;
   void* callback;          // JSValue* (heap-allocated, owned)
+  bool is_handler_property { false };
 };
 
 // ── RuntimeContext ─────────────────────────────────────────────────────────────
@@ -75,6 +76,9 @@ struct RuntimeContext {
   bool pretend_to_be_visual { false };
   double time_origin_ms { 0 };
 
+  void* active_element { nullptr };
+  std::string ready_state { "loading" };
+
   // node pointer → heap-allocated JSValue* (DupValue'd strong ref)
   // Ensures the same native node always returns the same JS wrapper object.
   std::unordered_map<void*, void*> node_wrapper_cache;
@@ -91,6 +95,30 @@ struct RuntimeContext {
   // back-pointer to an attached shadow root, so we track it ourselves.
   std::unordered_map<void*, void*> element_shadow_roots;
 
+  // Secondary documents created via DOMParser.parseFromString() /
+  // document.implementation.createHTMLDocument() (see DOMParserBindings).
+  // Owned here rather than by their JS wrapper's finalizer: QuickJS class
+  // finalizers only receive a JSRuntime*, not the JSContext needed to safely
+  // touch document_registry below, so they're freed together with the rest
+  // of the sandbox instead of individually via GC.
+  std::vector<std::unique_ptr<LexborDocument>> extra_documents;
+
+  // Raw lexbor document pointer (lxb_dom_document_t*) -> the LexborDocument
+  // wrapper that owns it (primary sandbox document, or one of
+  // extra_documents). Lets node-scoped bindings that create new nodes
+  // (textContent/innerHTML setters, insertAdjacentHTML, matches()/closest())
+  // resolve the *correct* owning document instead of assuming the sandbox's
+  // primary `document` — which would otherwise create nodes in the wrong
+  // document's memory arena when called on a DOMParser-produced element.
+  // See doc_for_node() in DOMBindingsInternal.
+  std::unordered_map<void*, LexborDocument*> document_registry;
+
+  // LexborDocument* -> its JS wrapper (JSValue*, heap-allocated, owned).
+  // Lets node.ownerDocument return the same JS object DOMParser.
+  // parseFromString()/createHTMLDocument() already handed the caller,
+  // instead of building a second, unequal wrapper for the same document.
+  std::unordered_map<LexborDocument*, void*> document_wrappers;
+
   ~RuntimeContext() = default;
 };
 

package/cpp/quickjs/bindings/AbortBindings.cpp

@@ -86,6 +86,20 @@ const char* kAbortBootstrapScript = R"JS(
     setTimeout(function() { s._abort(makeTimeoutError()); }, ms);
     return s;
   };
+  AbortSignal.any = function(signals) {
+    var s = new AbortSignal();
+    var list = [];
+    for (var i = 0; i < signals.length; i++) list.push(signals[i]);
+    for (var j = 0; j < list.length; j++) {
+      if (list[j].aborted) { s._abort(list[j].reason); break; }
+    }
+    if (!s.aborted) {
+      list.forEach(function(signal) {
+        signal.addEventListener('abort', function() { s._abort(signal.reason); });
+      });
+    }
+    return s;
+  };
 
   globalThis.AbortSignal = AbortSignal;
 

package/cpp/quickjs/bindings/BlobBindings.cpp

@@ -20,6 +20,16 @@ const char* kBlobBootstrapScript = R"JS(
     return Array.prototype.slice.call(new TextEncoder().encode(String(part)));
   }
 
+  function normalizeBlobType(type) {
+    if (type === undefined || type === null) return '';
+    var s = String(type);
+    for (var i = 0; i < s.length; i++) {
+      var code = s.charCodeAt(i);
+      if (code < 0x20 || code > 0x7e) return '';
+    }
+    return s.toLowerCase();
+  }
+
   function Blob(parts, options) {
     var bytes = [];
     if (parts) {
@@ -29,7 +39,7 @@ const char* kBlobBootstrapScript = R"JS(
     }
     this._bytes = bytes;
     this.size = bytes.length;
-    this.type = (options && options.type) ? String(options.type) : '';
+    this.type = normalizeBlobType(options && options.type);
   }
   Blob.prototype.slice = function(start, end, contentType) {
     var sliced = this._bytes.slice(start, end);
@@ -55,6 +65,23 @@ const char* kBlobBootstrapScript = R"JS(
   };
   globalThis.Blob = Blob;
 
+  function File(parts, name, options) {
+    Blob.call(this, parts, options);
+    var lastModified;
+    if (options && options.lastModified !== undefined) {
+      var n = Number(options.lastModified);
+      lastModified = (isNaN(n) || !isFinite(n)) ? 0 : Math.trunc(n);
+    } else {
+      lastModified = Date.now();
+    }
+
+    Object.defineProperty(this, 'name', { value: String(name), enumerable: true, configurable: true });
+    Object.defineProperty(this, 'lastModified', { value: lastModified, enumerable: true, configurable: true });
+  }
+  File.prototype = Object.create(Blob.prototype);
+  File.prototype.constructor = File;
+  globalThis.File = File;
+
   function FileReader() {
     this.readyState = 0;
     this.result = null;

package/cpp/quickjs/bindings/BlobBindings.hpp

@@ -4,9 +4,9 @@
 
 namespace margelo::nitro::nitrojsdom {
 
-// Registers globalThis.Blob and globalThis.FileReader. Pure JS on top of
-// TextEncoder/TextDecoder and btoa, so must run after TextEncodingBindings
-// and WindowBindings.
+// Registers globalThis.Blob, globalThis.File, and globalThis.FileReader.
+// Pure JS on top of TextEncoder/TextDecoder and btoa, so must run after
+// TextEncodingBindings and WindowBindings.
 struct BlobBindings {
   static void install(JSContext* ctx);
 };

package/cpp/quickjs/bindings/CSSOMBindings.cpp

@@ -227,6 +227,52 @@ const char* kCSSOMBootstrapScript = R"JS(
     },
     configurable: true,
   });
+
+  // ── getComputedStyle ──────────────────────────────────────────────────
+  // No layout/cascade engine backs this sandbox — there is no stylesheet
+  // specificity resolution or inheritance, only the element's own inline
+  // `style` attribute. `display` falls back to a small user-agent-stylesheet
+  // approximation (block/inline/inline-block/none by tag name, or 'none' for
+  // a `hidden` attribute) since "is this element visible" is the one
+  // getComputedStyle check real-world embedded scripts actually make;
+  // `visibility`/`opacity` fall back to their initial values. Every other
+  // unset property returns '', not a computed initial value.
+  var kBlockTags = { ADDRESS: 1, ARTICLE: 1, ASIDE: 1, BLOCKQUOTE: 1, DETAILS: 1, DIALOG: 1, DD: 1, DIV: 1,
+    DL: 1, DT: 1, FIELDSET: 1, FIGCAPTION: 1, FIGURE: 1, FOOTER: 1, FORM: 1, H1: 1, H2: 1, H3: 1, H4: 1,
+    H5: 1, H6: 1, HEADER: 1, HGROUP: 1, HR: 1, LI: 1, MAIN: 1, NAV: 1, OL: 1, P: 1, PRE: 1, SECTION: 1,
+    TABLE: 1, UL: 1, HTML: 1, BODY: 1 };
+  var kNoneTags = { SCRIPT: 1, STYLE: 1, HEAD: 1, TITLE: 1, META: 1, LINK: 1, TEMPLATE: 1 };
+  var kInlineBlockTags = { IMG: 1, BUTTON: 1, INPUT: 1, SELECT: 1, TEXTAREA: 1 };
+
+  function defaultDisplay(tagName) {
+    if (kNoneTags[tagName]) return 'none';
+    if (kInlineBlockTags[tagName]) return 'inline-block';
+    if (kBlockTags[tagName]) return 'block';
+    return 'inline';
+  }
+
+  function resolveProperty(el, kebabName) {
+    var v = el.style.getPropertyValue(kebabName);
+    if (v) return v;
+    if (kebabName === 'display') return el.hasAttribute('hidden') ? 'none' : defaultDisplay(el.tagName);
+    if (kebabName === 'visibility') return 'visible';
+    if (kebabName === 'opacity') return '1';
+    return '';
+  }
+
+  globalThis.getComputedStyle = function(el) {
+    if (!el || typeof el.tagName !== 'string') {
+      throw new TypeError("Failed to execute 'getComputedStyle': parameter 1 is not of type 'Element'.");
+    }
+    return new Proxy({}, {
+      get: function(_target, prop) {
+        if (prop === 'getPropertyValue') return function(name) { return resolveProperty(el, String(name)); };
+        if (prop === 'getPropertyPriority') return function() { return ''; };
+        if (typeof prop !== 'string') return undefined;
+        return resolveProperty(el, camelToKebab(prop));
+      },
+    });
+  };
 })();
 )JS";
 

package/cpp/quickjs/bindings/CSSOMBindings.hpp

@@ -5,7 +5,9 @@
 namespace margelo::nitro::nitrojsdom {
 
 // Registers a minimal CSSOM: globalThis.CSSRule/CSSStyleRule/CSSStyleSheet,
-// Element.prototype.sheet (tag-checked for "style"), and document.styleSheets.
+// Element.prototype.sheet (tag-checked for "style"), document.styleSheets,
+// and globalThis.getComputedStyle (inline-style + tag-default-display only,
+// no real cascade — see the bootstrap script for the exact fallback rules).
 //
 // Rules are split by a hand-rolled top-level brace scanner rather than
 // Lexbor's CSS rule/declaration AST (lxb_css_rule_t) — mirrors how