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

package/cpp/quickjs/DOMBindingsInternal.cpp

@@ -8,8 +8,9 @@
 
 namespace margelo::nitro::nitrojsdom {
 
-JSClassID js_element_class_id = 0;
-JSClassID js_node_class_id    = 0;
+JSClassID js_element_class_id     = 0;
+JSClassID js_node_class_id        = 0;
+JSClassID js_shadow_root_class_id = 0;
 
 namespace {
 JSClassDef js_element_class = { "Element", .finalizer = nullptr };
@@ -59,6 +60,22 @@ void invalidate_node_cache_batch(JSContext* ctx, RuntimeContext* rctx, const std
   for (void* n : nodes) invalidate_node_cache(ctx, rctx, n);
 }
 
+namespace {
+void invalidate_node_cache_deep(JSContext* ctx, RuntimeContext* rctx, void* node_ptr) {
+  if (!node_ptr) return;
+  invalidate_node_cache(ctx, rctx, node_ptr);
+  for (lxb_dom_node_t* child = static_cast<lxb_dom_node_t*>(node_ptr)->first_child;
+       child; child = child->next) {
+    invalidate_node_cache_deep(ctx, rctx, child);
+  }
+}
+} // namespace
+
+void invalidate_node_cache_deep_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& roots) {
+  if (!rctx) return;
+  for (void* root : roots) invalidate_node_cache_deep(ctx, rctx, root);
+}
+
 void clear_node_cache(JSContext* ctx, RuntimeContext* rctx) {
   if (!rctx) return;
   for (auto& kv : rctx->node_wrapper_cache) {
@@ -85,6 +102,8 @@ lxb_dom_node_t* unwrap_node(JSContext* ctx, JSValue val) {
   void* p = JS_GetOpaque(val, js_element_class_id);
   if (p) return static_cast<lxb_dom_node_t*>(p);
   p = JS_GetOpaque(val, js_node_class_id);
+  if (p) return static_cast<lxb_dom_node_t*>(p);
+  p = JS_GetOpaque(val, js_shadow_root_class_id);
   return static_cast<lxb_dom_node_t*>(p);
 }
 
@@ -107,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);
@@ -117,6 +170,52 @@ 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");
+}
+
+JSValue define_global_constructor(JSContext* ctx, const char* name, JSValue proto) {
+  JSValue ctor = JS_NewCFunction2(ctx, js_illegal_constructor, name, 0, JS_CFUNC_constructor, 0);
+  JS_SetConstructor(ctx, ctor, proto);
+  JSValue global = JS_GetGlobalObject(ctx);
+  JS_SetPropertyStr(ctx, global, name, JS_DupValue(ctx, ctor));
+  JS_FreeValue(ctx, global);
+  return ctor;
+}
+
 bool get_bool_prop(JSContext* ctx, JSValue obj, const char* name) {
   JSValue v = JS_GetPropertyStr(ctx, obj, name);
   bool b = JS_ToBool(ctx, v) > 0;

package/cpp/quickjs/DOMBindingsInternal.hpp

@@ -34,11 +34,16 @@ class LexborDocument;
 // node class (Node traversal only). This prevents non-element nodes from
 // reaching lxb_dom_element_* calls.
 //
+// js_shadow_root_class_id wraps lxb_dom_shadow_root_t* (see ShadowRootBindings).
+//
 // unwrap_element() returns non-null only for element-class objects.
-// unwrap_node()    returns non-null for either class (shared Node methods).
+// unwrap_node()    returns non-null for any of the three (shared Node methods
+//                  like appendChild/childNodes work the same way on a
+//                  ShadowRoot, since it embeds a document fragment's layout).
 
 extern JSClassID js_element_class_id;
 extern JSClassID js_node_class_id;
+extern JSClassID js_shadow_root_class_id;
 
 JSValue make_element(JSContext* ctx, void* node_or_el);
 JSValue make_element_array(JSContext* ctx, const std::vector<void*>& elements);
@@ -51,12 +56,46 @@ 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);
 void invalidate_node_cache_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& nodes);
 void clear_node_cache(JSContext* ctx, RuntimeContext* rctx);
 
+// Same as invalidate_node_cache_batch, but also invalidates every descendant
+// of each given node. Use before destroying a subtree with
+// lxb_dom_node_destroy_deep(): that frees descendants too, and a JS wrapper
+// left pointing at a freed descendant is a use-after-free waiting to happen.
+void invalidate_node_cache_deep_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& roots);
+
 // ── Accessor property helper ──────────────────────────────────────────────────
 
 using GetterFn = JSValue (*)(JSContext*, JSValue);
@@ -64,6 +103,22 @@ 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);
+JSValue define_global_constructor(JSContext* ctx, const char* name, JSValue proto);
+
 // ── Misc shared helpers ───────────────────────────────────────────────────────
 
 // Reads a boolean-ish property off any JS object (used by Event dispatch to read

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>
@@ -90,6 +91,22 @@ QuickJSRuntime::~QuickJSRuntime() {
 
     // Free node wrapper cache
     clear_node_cache(ctx, _ctxState.get());
+
+    // Free the cached document.doctype wrapper
+    if (_ctxState->doctype_wrapper) {
+      JSValue* stored = static_cast<JSValue*>(_ctxState->doctype_wrapper);
+      JS_FreeValue(ctx, *stored);
+      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));
@@ -137,7 +154,7 @@ void QuickJSRuntime::cleanupTimers() {
 
 // ── initialize ─────────────────────────────────────────────────────────────────
 
-void QuickJSRuntime::initialize(const std::string& url) {
+void QuickJSRuntime::initialize(const std::string& url, bool pretendToBeVisual) {
   JSRuntime* rt = JS_NewRuntime();
   if (!rt) throw std::runtime_error("QuickJS: failed to create runtime");
   JSContext* ctx = JS_NewContext(rt);
@@ -151,6 +168,7 @@ void QuickJSRuntime::initialize(const std::string& url) {
   // Create RuntimeContext and attach to QuickJS context opaque
   _ctxState = std::make_unique<RuntimeContext>();
   _ctxState->runtime = this;
+  _ctxState->pretend_to_be_visual = pretendToBeVisual;
   _ctxState->mutation_observers = std::make_unique<MutationObservers>();
   JS_SetContextOpaque(ctx, _ctxState.get());
 
@@ -234,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);
       }
@@ -257,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;
@@ -385,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);
   }
@@ -396,10 +417,16 @@ void QuickJSRuntime::fireTimer(Timer* t) {
 std::string QuickJSRuntime::evaluate(const std::string& script) {
   JSRuntime* rt  = reinterpret_cast<JSRuntime*>(_runtime);
   JSContext* ctx = reinterpret_cast<JSContext*>(_context);
-  std::lock_guard<std::mutex> lock(_mutex);
 
-  // Update the stack reference so QuickJS doesn't false-positive overflow
-  // when evaluate() runs on a different thread than initialize().
+  std::unique_lock<std::mutex> lock(_mutex, std::try_to_lock);
+  if (!lock.owns_lock()) {
+    throw std::runtime_error(
+      "QuickJSRuntime: evaluate() called reentrantly. A callback (onFetch/onAlert/onConfirm/onPrompt) "
+      "attempted to call dom.evaluate() again while an evaluate() call was already in progress on this "
+      "instance. QuickJS is not re-entrant."
+    );
+  }
+
   JS_UpdateStackTop(rt);
 
   JSValue result = JS_Eval(ctx, script.data(), script.size(), "<eval>", JS_EVAL_TYPE_GLOBAL);
@@ -425,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 ─────────────────────────────────────────────────────────────
@@ -66,10 +67,58 @@ struct RuntimeContext {
   Storage local_storage;
   Storage session_storage;
 
+  // In-memory document.cookie jar (name -> value). No real navigation/origin
+  // model exists in this sandbox, so cookie attributes (expires/path/domain/
+  // secure/samesite) are parsed off the setter's input and discarded rather
+  // than enforced — see CookieBindings.
+  Storage cookie_jar;
+
+  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;
 
+  // document.doctype's plain-object wrapper (heap-allocated JSValue*,
+  // DupValue'd strong ref) — not routed through node_wrapper_cache since
+  // it isn't keyed by a native node pointer (see DocumentBindings.cpp).
+  // Built lazily on first access and reused after that, so repeated
+  // `document.doctype` reads return the same JS object (identity-stable).
+  void* doctype_wrapper { nullptr };
+
+  // host element pointer (lxb_dom_element_t*) → its shadow root
+  // (lxb_dom_shadow_root_t*). Lexbor's element struct has no built-in
+  // 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;
 };
 
@@ -80,7 +129,7 @@ public:
   QuickJSRuntime();
   ~QuickJSRuntime();
 
-  void initialize(const std::string& url);
+  void initialize(const std::string& url, bool pretendToBeVisual);
   void bindDocument(LexborDocument* document);
   std::string evaluate(const std::string& script);
 

package/cpp/quickjs/bindings/AbortBindings.cpp

@@ -0,0 +1,128 @@
+#include "AbortBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kAbortBootstrapScript = R"JS(
+(function() {
+  function makeAbortError() {
+    var e = new Error('signal is aborted without reason');
+    e.name = 'AbortError';
+    return e;
+  }
+  function makeTimeoutError() {
+    var e = new Error('signal timed out');
+    e.name = 'TimeoutError';
+    return e;
+  }
+
+  function AbortSignal() {
+    this.aborted = false;
+    this.reason = undefined;
+    this._listeners = [];
+    this._onabort = null;
+    this._onabortListener = null;
+  }
+
+  Object.defineProperty(AbortSignal.prototype, 'onabort', {
+    get: function() { return this._onabort; },
+    set: function(fn) {
+      if (this._onabortListener) {
+        var idx = this._listeners.indexOf(this._onabortListener);
+        if (idx !== -1) this._listeners.splice(idx, 1);
+      }
+      this._onabort = typeof fn === 'function' ? fn : null;
+      if (this._onabort) {
+        var self = this;
+        this._onabortListener = function(evt) { self._onabort(evt); };
+        this._listeners.push(this._onabortListener);
+      } else {
+        this._onabortListener = null;
+      }
+    },
+    enumerable: true,
+    configurable: true,
+  });
+
+  AbortSignal.prototype.addEventListener = function(type, cb) {
+    if (type !== 'abort' || typeof cb !== 'function') return;
+    if (this._listeners.indexOf(cb) === -1) this._listeners.push(cb);
+  };
+  AbortSignal.prototype.removeEventListener = function(type, cb) {
+    if (type !== 'abort') return;
+    var idx = this._listeners.indexOf(cb);
+    if (idx !== -1) this._listeners.splice(idx, 1);
+  };
+  AbortSignal.prototype.dispatchEvent = function(evt) {
+    if (evt && evt.type === 'abort') this._fire();
+    return true;
+  };
+  AbortSignal.prototype.throwIfAborted = function() {
+    if (this.aborted) throw this.reason;
+  };
+  AbortSignal.prototype._fire = function() {
+    var evt = new Event('abort');
+    evt.target = this;
+    this._listeners.slice().forEach(function(cb) {
+      try { cb(evt); } catch (e) {}
+    });
+  };
+  AbortSignal.prototype._abort = function(reason) {
+    if (this.aborted) return;
+    this.aborted = true;
+    this.reason = reason !== undefined ? reason : makeAbortError();
+    this._fire();
+  };
+
+  AbortSignal.abort = function(reason) {
+    var s = new AbortSignal();
+    s._abort(reason);
+    return s;
+  };
+  AbortSignal.timeout = function(ms) {
+    var s = new AbortSignal();
+    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;
+
+  function AbortController() {
+    this.signal = new AbortSignal();
+  }
+  AbortController.prototype.abort = function(reason) {
+    this.signal._abort(reason);
+  };
+
+  globalThis.AbortController = AbortController;
+})();
+)JS";
+
+} // namespace
+
+void AbortBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kAbortBootstrapScript, strlen(kAbortBootstrapScript),
+                            "<abort-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/AbortBindings.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+class AbortBindings {
+public:
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom