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

package/cpp/quickjs/QuickJSRuntime.cpp

@@ -90,6 +90,14 @@ 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;
+    }
   }
 
   if (_context) JS_FreeContext(reinterpret_cast<JSContext*>(_context));
@@ -137,7 +145,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 +159,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());
 
@@ -396,10 +405,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);

package/cpp/quickjs/QuickJSRuntime.hpp

@@ -66,10 +66,31 @@ 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 };
+
   // 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;
+
   ~RuntimeContext() = default;
 };
 
@@ -80,7 +101,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,114 @@
+#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;
+  };
+
+  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

package/cpp/quickjs/bindings/BlobBindings.cpp

@@ -0,0 +1,137 @@
+#include "BlobBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kBlobBootstrapScript = R"JS(
+(function() {
+  function partToBytes(part) {
+    if (part instanceof ArrayBuffer) {
+      return Array.prototype.slice.call(new Uint8Array(part));
+    }
+    if (part && typeof part.byteLength === 'number' && part.buffer !== undefined) {
+      return Array.prototype.slice.call(new Uint8Array(part.buffer, part.byteOffset, part.byteLength));
+    }
+    if (part instanceof Blob) {
+      return part._bytes.slice();
+    }
+    return Array.prototype.slice.call(new TextEncoder().encode(String(part)));
+  }
+
+  function Blob(parts, options) {
+    var bytes = [];
+    if (parts) {
+      for (var i = 0; i < parts.length; i++) {
+        bytes = bytes.concat(partToBytes(parts[i]));
+      }
+    }
+    this._bytes = bytes;
+    this.size = bytes.length;
+    this.type = (options && options.type) ? String(options.type) : '';
+  }
+  Blob.prototype.slice = function(start, end, contentType) {
+    var sliced = this._bytes.slice(start, end);
+    var result = new Blob([]);
+    result._bytes = sliced;
+    result.size = sliced.length;
+    result.type = contentType ? String(contentType) : '';
+    return result;
+  };
+  Blob.prototype.text = function() {
+    var bytes = this._bytes;
+    var buf = new ArrayBuffer(bytes.length);
+    var view = new Uint8Array(buf);
+    for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
+    return Promise.resolve(new TextDecoder().decode(buf));
+  };
+  Blob.prototype.arrayBuffer = function() {
+    var bytes = this._bytes;
+    var buf = new ArrayBuffer(bytes.length);
+    var view = new Uint8Array(buf);
+    for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
+    return Promise.resolve(buf);
+  };
+  globalThis.Blob = Blob;
+
+  function FileReader() {
+    this.readyState = 0;
+    this.result = null;
+    this.error = null;
+    this.onload = null;
+    this.onloadend = null;
+    this.onerror = null;
+    this._listeners = {};
+  }
+  FileReader.EMPTY = 0;
+  FileReader.LOADING = 1;
+  FileReader.DONE = 2;
+  FileReader.prototype.addEventListener = function(type, cb) {
+    if (!this._listeners[type]) this._listeners[type] = [];
+    if (this._listeners[type].indexOf(cb) === -1) this._listeners[type].push(cb);
+  };
+  FileReader.prototype.removeEventListener = function(type, cb) {
+    var list = this._listeners[type];
+    if (!list) return;
+    var idx = list.indexOf(cb);
+    if (idx !== -1) list.splice(idx, 1);
+  };
+  FileReader.prototype._fire = function(type) {
+    var evt = { type: type, target: this };
+    var handlerProp = 'on' + type;
+    if (typeof this[handlerProp] === 'function') this[handlerProp](evt);
+    var list = this._listeners[type];
+    if (list) list.slice().forEach(function(cb) { cb(evt); });
+  };
+  FileReader.prototype._read = function(blob, mode) {
+    var self = this;
+    self.readyState = 1;
+    setTimeout(function() {
+      if (!blob) {
+        self.error = new Error('FileReader was given no blob to read');
+        self.readyState = 2;
+        self._fire('error');
+        self._fire('loadend');
+        return;
+      }
+      var bytes = blob._bytes || [];
+      if (mode === 'text') {
+        var buf = new ArrayBuffer(bytes.length);
+        var view = new Uint8Array(buf);
+        for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
+        self.result = new TextDecoder().decode(buf);
+      } else if (mode === 'dataurl') {
+        var binary = '';
+        for (var j = 0; j < bytes.length; j++) binary += String.fromCharCode(bytes[j]);
+        self.result = 'data:' + (blob.type || '') + ';base64,' + btoa(binary);
+      } else if (mode === 'arraybuffer') {
+        var arrBuf = new ArrayBuffer(bytes.length);
+        var arrView = new Uint8Array(arrBuf);
+        for (var k = 0; k < bytes.length; k++) arrView[k] = bytes[k];
+        self.result = arrBuf;
+      }
+      self.readyState = 2;
+      self._fire('load');
+      self._fire('loadend');
+    }, 0);
+  };
+  FileReader.prototype.readAsText = function(blob) { this._read(blob, 'text'); };
+  FileReader.prototype.readAsDataURL = function(blob) { this._read(blob, 'dataurl'); };
+  FileReader.prototype.readAsArrayBuffer = function(blob) { this._read(blob, 'arraybuffer'); };
+  globalThis.FileReader = FileReader;
+})();
+)JS";
+
+} // namespace
+
+void BlobBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kBlobBootstrapScript, strlen(kBlobBootstrapScript),
+                            "<blob-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/BlobBindings.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "quickjs.h"
+
+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.
+struct BlobBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/CSSOMBindings.cpp

@@ -0,0 +1,244 @@
+#include "CSSOMBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kCSSOMBootstrapScript = R"JS(
+(function() {
+  function stripComments(text) {
+    return text.replace(/\/\*[\s\S]*?\*\//g, '');
+  }
+
+  function camelToKebab(name) {
+    return name.replace(/[A-Z]/g, function(c) { return '-' + c.toLowerCase(); });
+  }
+
+  // Splits a stylesheet's raw text into top-level rule descriptors, tracking
+  // brace depth so a nested block (e.g. the rules inside @media) is captured
+  // as one opaque chunk rather than mis-parsed as a sibling rule.
+  function splitTopLevelRules(cssText) {
+    var text = stripComments(String(cssText === undefined ? '' : cssText));
+    var descriptors = [];
+    var i = 0;
+    var len = text.length;
+    while (i < len) {
+      while (i < len && /\s/.test(text.charAt(i))) i++;
+      if (i >= len) break;
+      var start = i;
+      var depth = 0;
+      var j = i;
+      while (j < len) {
+        var c = text.charAt(j);
+        if (c === '{') {
+          depth++;
+        } else if (c === '}') {
+          depth--;
+          if (depth <= 0) { j++; break; }
+        } else if (c === ';' && depth === 0) {
+          j++;
+          break;
+        }
+        j++;
+      }
+      var raw = text.slice(start, j);
+      if (raw.trim()) descriptors.push(parseOneRule(raw));
+      i = j;
+    }
+    return descriptors;
+  }
+
+  function parseOneRule(raw) {
+    var trimmed = raw.trim();
+    var braceIdx = trimmed.indexOf('{');
+    if (trimmed.charAt(0) === '@' || braceIdx === -1) {
+      return { kind: 'unknown', cssText: trimmed };
+    }
+    var selectorText = trimmed.slice(0, braceIdx).trim();
+    var body = trimmed.slice(braceIdx + 1, trimmed.length - 1);
+    return { kind: 'style', selectorText: selectorText, declarationText: body.trim() };
+  }
+
+  // Parses "color: red; font-size: 12px" into ordered [name, value] pairs —
+  // same informal model StyleBindings.cpp uses for inline element.style.
+  function parseDeclarations(text) {
+    var pairs = [];
+    var parts = String(text === undefined ? '' : text).split(';');
+    for (var i = 0; i < parts.length; i++) {
+      var part = parts[i].trim();
+      if (!part) continue;
+      var colonIdx = part.indexOf(':');
+      if (colonIdx === -1) continue;
+      var prop = part.slice(0, colonIdx).trim().toLowerCase();
+      var value = part.slice(colonIdx + 1).trim();
+      if (prop) pairs.push([prop, value]);
+    }
+    return pairs;
+  }
+
+  function makeRuleStyle(initialText) {
+    var pairs = parseDeclarations(initialText);
+
+    var target = {
+      getPropertyValue: function(name) {
+        var kebab = camelToKebab(String(name));
+        for (var i = 0; i < pairs.length; i++) if (pairs[i][0] === kebab) return pairs[i][1];
+        return '';
+      },
+      setProperty: function(name, value) {
+        var kebab = camelToKebab(String(name));
+        for (var i = 0; i < pairs.length; i++) {
+          if (pairs[i][0] === kebab) { pairs[i][1] = String(value); return; }
+        }
+        pairs.push([kebab, String(value)]);
+      },
+      removeProperty: function(name) {
+        var kebab = camelToKebab(String(name));
+        var old = '';
+        var next = [];
+        for (var i = 0; i < pairs.length; i++) {
+          if (pairs[i][0] === kebab && !old) { old = pairs[i][1]; continue; }
+          next.push(pairs[i]);
+        }
+        pairs = next;
+        return old;
+      },
+      get cssText() {
+        var out = '';
+        for (var i = 0; i < pairs.length; i++) out += pairs[i][0] + ': ' + pairs[i][1] + '; ';
+        return out.trim();
+      },
+      set cssText(text) {
+        pairs = parseDeclarations(text);
+      },
+    };
+
+    return new Proxy(target, {
+      get: function(t, prop, receiver) {
+        if (typeof prop === 'string' && !(prop in t)) {
+          var kebab = camelToKebab(prop);
+          for (var i = 0; i < pairs.length; i++) if (pairs[i][0] === kebab) return pairs[i][1];
+          return undefined;
+        }
+        return Reflect.get(t, prop, receiver);
+      },
+      set: function(t, prop, value, receiver) {
+        if (typeof prop === 'string' && !(prop in t)) {
+          t.setProperty(prop, value);
+          return true;
+        }
+        return Reflect.set(t, prop, value, receiver);
+      },
+    });
+  }
+
+  function CSSRule() {}
+  CSSRule.STYLE_RULE = 1;
+  CSSRule.MEDIA_RULE = 4;
+  CSSRule.prototype.type = 0;
+
+  function CSSStyleRule(selectorText, declarationText, parentStyleSheet) {
+    this.selectorText = selectorText;
+    this.style = makeRuleStyle(declarationText);
+    this.parentStyleSheet = parentStyleSheet || null;
+    this.type = CSSRule.STYLE_RULE;
+  }
+  CSSStyleRule.prototype = Object.create(CSSRule.prototype);
+  CSSStyleRule.prototype.constructor = CSSStyleRule;
+  Object.defineProperty(CSSStyleRule.prototype, 'cssText', {
+    get: function() { return this.selectorText + ' { ' + this.style.cssText + ' }'; },
+    configurable: true,
+  });
+
+  function makeUnknownRule(cssText, parentStyleSheet) {
+    return { type: 0, cssText: cssText, parentStyleSheet: parentStyleSheet || null };
+  }
+
+  function ruleFromDescriptor(d, sheet) {
+    return d.kind === 'style'
+      ? new CSSStyleRule(d.selectorText, d.declarationText, sheet)
+      : makeUnknownRule(d.cssText, sheet);
+  }
+
+  function makeRuleList(rules) {
+    var arr = rules.slice();
+    arr.item = function(i) { return this[i] !== undefined ? this[i] : null; };
+    return arr;
+  }
+
+  function CSSStyleSheet(ownerNode) {
+    this.ownerNode = ownerNode || null;
+    this.cssRules = makeRuleList([]);
+    this.rules = this.cssRules;
+  }
+  CSSStyleSheet.prototype.insertRule = function(ruleText, index) {
+    var idx = (index === undefined) ? this.cssRules.length : index;
+    if (idx < 0 || idx > this.cssRules.length) {
+      throw new DOMException(
+        'The index provided (' + idx + ') is not in the allowed range.', 'IndexSizeError');
+    }
+    var rule = ruleFromDescriptor(parseOneRule(String(ruleText)), this);
+    Array.prototype.splice.call(this.cssRules, idx, 0, rule);
+    return idx;
+  };
+  CSSStyleSheet.prototype.deleteRule = function(index) {
+    if (index < 0 || index >= this.cssRules.length) {
+      throw new DOMException(
+        'The index provided (' + index + ') is not in the allowed range.', 'IndexSizeError');
+    }
+    Array.prototype.splice.call(this.cssRules, index, 1);
+  };
+
+  function parseStylesheetInto(sheet, cssText) {
+    var descriptors = splitTopLevelRules(cssText);
+    for (var i = 0; i < descriptors.length; i++) {
+      sheet.cssRules.push(ruleFromDescriptor(descriptors[i], sheet));
+    }
+  }
+
+  globalThis.CSSRule = CSSRule;
+  globalThis.CSSStyleRule = CSSStyleRule;
+  globalThis.CSSStyleSheet = CSSStyleSheet;
+
+  Object.defineProperty(Element.prototype, 'sheet', {
+    get: function() {
+      if (this.tagName !== 'STYLE') return null;
+      if (!this._sheet) {
+        var sheet = new CSSStyleSheet(this);
+        parseStylesheetInto(sheet, this.textContent);
+        this._sheet = sheet;
+      }
+      return this._sheet;
+    },
+    configurable: true,
+  });
+
+  Object.defineProperty(document, 'styleSheets', {
+    get: function() {
+      var styleEls = document.querySelectorAll('style');
+      var sheets = [];
+      for (var i = 0; i < styleEls.length; i++) {
+        var sheet = styleEls[i].sheet;
+        if (sheet) sheets.push(sheet);
+      }
+      sheets.item = function(i) { return this[i] !== undefined ? this[i] : null; };
+      return sheets;
+    },
+    configurable: true,
+  });
+})();
+)JS";
+
+} // namespace
+
+void CSSOMBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kCSSOMBootstrapScript, strlen(kCSSOMBootstrapScript),
+                            "<cssom-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/CSSOMBindings.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers a minimal CSSOM: globalThis.CSSRule/CSSStyleRule/CSSStyleSheet,
+// Element.prototype.sheet (tag-checked for "style"), and document.styleSheets.
+//
+// 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
+// StyleBindings.cpp already treats inline "style" text as informally-parsed
+// property:value pairs rather than integrating Lexbor's typed CSS value
+// engine. At-rules (@media, @keyframes, ...) are captured as opaque stub
+// rules (cssText only, no nested-rule access) rather than fully parsed.
+//
+// Must run after ElementBindings (globalThis.Element) and DocumentBindings
+// (globalThis.document).
+struct CSSOMBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/ClassListBindings.cpp

@@ -1,4 +1,5 @@
 #include "ClassListBindings.hpp"
+#include "DOMExceptionBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
 #include "../QuickJSRuntime.hpp"
 #include "../MutationObservers.hpp"
@@ -36,13 +37,13 @@ std::string join_classes(const std::vector<std::string>& v) {
 // Validates a DOMTokenList token: throws on empty or whitespace-containing token.
 bool validate_token(JSContext* ctx, const char* token) {
   if (!token || token[0] == '\0') {
-    JS_ThrowTypeError(ctx, "The token provided must not be empty.");
+    throw_dom_exception(ctx, "SyntaxError", "The token provided must not be empty.");
     return false;
   }
   for (const char* p = token; *p; p++) {
     unsigned char c = (unsigned char)*p;
     if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f') {
-      JS_ThrowTypeError(ctx, "The token provided contains HTML space characters, which are not valid in tokens.");
+      throw_dom_exception(ctx, "InvalidCharacterError", "The token provided contains HTML space characters, which are not valid in tokens.");
       return false;
     }
   }