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

package/cpp/quickjs/bindings/CookieBindings.cpp

@@ -0,0 +1,118 @@
+#include "CookieBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
+#include "../Storage.hpp"
+#include <string>
+#include <cctype>
+#include <cstdlib>
+#include <ctime>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+std::string trim(const std::string& s) {
+  size_t start = s.find_first_not_of(" \t\n\r");
+  if (start == std::string::npos) return "";
+  size_t end = s.find_last_not_of(" \t\n\r");
+  return s.substr(start, end - start + 1);
+}
+
+std::string to_lower(std::string s) {
+  for (auto& c : s) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  return s;
+}
+
+// Best-effort: accepts the date formats real cookie strings actually use
+// (RFC 1123, RFC 850, asctime) — not a full HTTP-date parser.
+bool is_past_date(const std::string& value) {
+  static const char* kFormats[] = {
+    "%a, %d %b %Y %H:%M:%S", // RFC 1123: "Thu, 01 Jan 1970 00:00:00 GMT"
+    "%A, %d-%b-%y %H:%M:%S", // RFC 850
+    "%a %b %d %H:%M:%S %Y",  // asctime
+  };
+  for (const char* fmt : kFormats) {
+    struct tm parsed{};
+    if (strptime(value.c_str(), fmt, &parsed)) {
+      return timegm(&parsed) <= time(nullptr);
+    }
+  }
+  return false;
+}
+
+// A cookie write is a deletion when `max-age` is <= 0 or `expires` names a
+// date in the past — the two idioms real-world scripts use to clear a
+// cookie (most commonly `expires=Thu, 01 Jan 1970 00:00:00 GMT`).
+bool is_deletion(const std::string& attrs) {
+  size_t pos = 0;
+  while (pos < attrs.size()) {
+    size_t semi = attrs.find(';', pos);
+    std::string attr = attrs.substr(pos, semi == std::string::npos ? std::string::npos : semi - pos);
+    pos = semi == std::string::npos ? attrs.size() : semi + 1;
+
+    size_t eq = attr.find('=');
+    if (eq == std::string::npos) continue;
+    std::string key = to_lower(trim(attr.substr(0, eq)));
+    std::string value = trim(attr.substr(eq + 1));
+
+    if (key == "max-age") {
+      if (std::atol(value.c_str()) <= 0) return true;
+    } else if (key == "expires") {
+      if (is_past_date(value)) return true;
+    }
+  }
+  return false;
+}
+
+JSValue js_doc_get_cookie(JSContext* ctx, JSValue) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx) return JS_NewString(ctx, "");
+
+  std::string result;
+  for (size_t i = 0; i < rctx->cookie_jar.length(); i++) {
+    auto key = rctx->cookie_jar.key(i);
+    if (!key) continue;
+    auto value = rctx->cookie_jar.getItem(*key);
+    if (!value) continue;
+    if (!result.empty()) result += "; ";
+    result += *key + "=" + *value;
+  }
+  return JS_NewStringLen(ctx, result.data(), result.size());
+}
+
+JSValue js_doc_set_cookie(JSContext* ctx, JSValue, JSValue val) {
+  auto* rctx = get_ctx(ctx);
+  const char* str = JS_ToCString(ctx, val);
+  if (str && rctx) {
+    std::string input(str);
+    size_t semi = input.find(';');
+    std::string pair = semi == std::string::npos ? input : input.substr(0, semi);
+    std::string attrs = semi == std::string::npos ? "" : input.substr(semi + 1);
+    size_t eq = pair.find('=');
+    if (eq != std::string::npos) {
+      std::string name = trim(pair.substr(0, eq));
+      std::string value = trim(pair.substr(eq + 1));
+      if (!name.empty()) {
+        if (is_deletion(attrs)) {
+          rctx->cookie_jar.removeItem(name);
+        } else {
+          rctx->cookie_jar.setItem(name, value);
+        }
+      }
+    }
+  }
+  if (str) JS_FreeCString(ctx, str);
+  return JS_UNDEFINED;
+}
+
+} // namespace
+
+void CookieBindings::install(JSContext* ctx) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue doc = JS_GetPropertyStr(ctx, global, "document");
+  define_prop(ctx, doc, "cookie", js_doc_get_cookie, js_doc_set_cookie);
+  JS_FreeValue(ctx, doc);
+  JS_FreeValue(ctx, global);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/CookieBindings.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers document.cookie (get/set), backed by an in-memory per-runtime
+// cookie jar (RuntimeContext::cookie_jar — a name -> value map preserving
+// insertion order). jsdom backs this with a real tough-cookie CookieJar
+// scoped by domain/path/expiry; this sandbox has no navigation or multiple
+// origins, so scoping attributes (path/domain/secure/samesite) are parsed
+// off and discarded rather than enforced. `expires`/`max-age` are the
+// exception: a value in the past (or max-age <= 0) is treated as the
+// deletion idiom real-world scripts use it for, and removes the cookie
+// instead of leaving a stray "name=" entry in the jar. `expires` parsing is
+// best-effort (RFC 1123/850/asctime formats only, not a full HTTP-date parser).
+//
+// Must run after DocumentBindings (needs globalThis.document to exist).
+struct CookieBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/CustomElementsBindings.cpp

@@ -0,0 +1,341 @@
+#include "CustomElementsBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kCustomElementsBootstrapScript = R"JS(
+(function() {
+  var RESERVED_NAMES = [
+    'annotation-xml', 'color-profile', 'font-face', 'font-face-src',
+    'font-face-uri', 'font-face-format', 'font-face-name', 'missing-glyph',
+  ];
+  var NAME_RE = /^[a-z][a-z0-9._-]*-[a-z0-9._-]*$/;
+
+  function isValidName(name) {
+    if (typeof name !== 'string' || name === '') return false;
+    if (RESERVED_NAMES.indexOf(name) !== -1) return false;
+    return NAME_RE.test(name);
+  }
+
+  // Elements/ShadowRoots don't naturally track their own document, so
+  // connectivity is derived by walking parentNode (crossing shadow
+  // boundaries via .host) until documentElement is reached.
+  function isConnected(node) {
+    var docEl = document.documentElement;
+    var n = node;
+    while (n) {
+      if (n === docEl) return true;
+      n = ('host' in n) ? n.host : n.parentNode;
+    }
+    return false;
+  }
+
+  // No global registry of upgraded elements: every hook below scopes itself
+  // to the subtree it actually touched (via a local, naturally
+  // garbage-collectible JS array), so nothing here can leak memory or grow
+  // unbounded, and no hook costs more than the size of the DOM it mutated.
+
+  function fireConnectivityChange(el, connected) {
+    el.__ceConnected = connected;
+    if (connected) {
+      if (typeof el.connectedCallback === 'function') {
+        try { el.connectedCallback(); } catch (e) {}
+      }
+    } else {
+      if (typeof el.disconnectedCallback === 'function') {
+        try { el.disconnectedCallback(); } catch (e) {}
+      }
+    }
+  }
+
+  function upgradeElement(el) {
+    if (!el || el.__ceUpgraded) return;
+    var tag = el.tagName ? el.tagName.toLowerCase() : null;
+    if (!tag) return;
+    var def = customElements._defs[tag];
+    if (!def) return;
+
+    Object.setPrototypeOf(el, def.ctor.prototype);
+    Object.defineProperty(el, '__ceUpgraded', { value: true, configurable: true });
+    Object.defineProperty(el, '__ceConnected', { value: false, writable: true, configurable: true });
+
+    def.observedAttributes.forEach(function(attr) {
+      if (el.hasAttribute(attr) && typeof el.attributeChangedCallback === 'function') {
+        try { el.attributeChangedCallback(attr, null, el.getAttribute(attr), null); } catch (e) {}
+      }
+    });
+
+    if (isConnected(el)) fireConnectivityChange(el, true);
+  }
+
+  function upgradeAllMatching(name) {
+    var found = document.querySelectorAll(name);
+    for (var i = 0; i < found.length; i++) upgradeElement(found[i]);
+  }
+
+  // Returns the shadow root attached to `el`, if any, regardless of mode.
+  // Element.prototype.shadowRoot hides closed-mode roots from user script by
+  // spec, but our own upgrade/connectivity bookkeeping isn't user script —
+  // it needs to see into every shadow tree the same way the UA internally
+  // does. Populated by the attachShadow() patch further down.
+  function shadowRootOf(el) {
+    return el ? el.__ceShadowRoot : null;
+  }
+
+  // Collects every descendant of `root` (light DOM), recursing into root's
+  // OWN attached shadow root (a custom element's shadow content isn't a
+  // light-DOM child of anything — querySelectorAll('*') alone would never
+  // find it) as well as each descendant's shadow root, so custom elements
+  // living inside shadow trees aren't invisible to the subtree-scoped hooks
+  // below. Does not include `root` itself.
+  function collectDescendantsIncludingShadow(root, out) {
+    if (!root) return;
+    var rootSr = shadowRootOf(root);
+    if (rootSr) collectDescendantsIncludingShadow(rootSr, out);
+    if (typeof root.querySelectorAll !== 'function') return;
+    var found = root.querySelectorAll('*');
+    for (var i = 0; i < found.length; i++) {
+      var el = found[i];
+      out.push(el);
+      var sr = shadowRootOf(el);
+      if (sr) collectDescendantsIncludingShadow(sr, out);
+    }
+  }
+
+  function upgradeSubtree(root) {
+    var found = [];
+    collectDescendantsIncludingShadow(root, found);
+    for (var i = 0; i < found.length; i++) upgradeElement(found[i]);
+  }
+
+  // Fires disconnectedCallback for every already-upgraded, already-connected
+  // custom element currently in root's subtree (light DOM + nested shadow
+  // trees). Call this on the OLD content of a node right BEFORE it's
+  // wholesale-replaced (innerHTML assignment unconditionally destroys every
+  // existing child), while it's still walkable.
+  function disconnectSubtree(root) {
+    var found = [];
+    collectDescendantsIncludingShadow(root, found);
+    for (var i = 0; i < found.length; i++) {
+      var el = found[i];
+      if (el.__ceUpgraded && el.__ceConnected) fireConnectivityChange(el, false);
+    }
+  }
+
+  // Re-checks connectivity of `node`, and every descendant across light DOM
+  // and nested shadow trees, firing connectedCallback/disconnectedCallback on
+  // transitions. Used by appendChild/removeChild, which know exactly which
+  // subtree moved, so this stays O(size of that subtree) regardless of how
+  // many custom elements exist elsewhere in the document.
+  function syncConnectedSubtree(node) {
+    if (!node) return;
+    if (node.__ceUpgraded) {
+      var connected = isConnected(node);
+      if (connected !== node.__ceConnected) fireConnectivityChange(node, connected);
+    }
+    var found = [];
+    collectDescendantsIncludingShadow(node, found);
+    for (var i = 0; i < found.length; i++) {
+      var el = found[i];
+      if (!el.__ceUpgraded) continue;
+      var elConnected = isConnected(el);
+      if (elConnected !== el.__ceConnected) fireConnectivityChange(el, elConnected);
+    }
+  }
+
+  // ── CustomElementRegistry ────────────────────────────────────────────────
+
+  function CustomElementRegistry() {
+    this._defs = Object.create(null);
+    this._pending = Object.create(null);
+    this._ctors = [];
+  }
+
+  CustomElementRegistry.prototype.define = function(name, ctor, options) {
+    if (typeof ctor !== 'function') {
+      throw new TypeError("Failed to execute 'define' on 'CustomElementRegistry': " +
+          "the constructor must be a function");
+    }
+    if (!isValidName(name)) {
+      throw new DOMException("'" + name + "' is not a valid custom element name", 'SyntaxError');
+    }
+    if (this._defs[name]) {
+      throw new DOMException(
+          "the name \"" + name + "\" has already been used with this registry", 'NotSupportedError');
+    }
+    if (this._ctors.indexOf(ctor) !== -1) {
+      throw new DOMException(
+          'this constructor has already been used with this registry', 'NotSupportedError');
+    }
+
+    var observed = ctor.observedAttributes;
+    this._defs[name] = {
+      ctor: ctor,
+      observedAttributes: Array.isArray(observed) ? observed : [],
+    };
+    this._ctors.push(ctor);
+
+    upgradeAllMatching(name);
+
+    if (this._pending[name]) {
+      this._pending[name].resolve();
+      delete this._pending[name];
+    }
+  };
+
+  CustomElementRegistry.prototype.get = function(name) {
+    var def = this._defs[name];
+    return def ? def.ctor : undefined;
+  };
+
+  CustomElementRegistry.prototype.whenDefined = function(name) {
+    if (!isValidName(name)) {
+      return Promise.reject(new DOMException("'" + name + "' is not a valid custom element name", 'SyntaxError'));
+    }
+    if (this._defs[name]) return Promise.resolve();
+    if (!this._pending[name]) {
+      var resolveFn;
+      var promise = new Promise(function(resolve) { resolveFn = resolve; });
+      this._pending[name] = { promise: promise, resolve: resolveFn };
+    }
+    return this._pending[name].promise;
+  };
+
+  // upgrade(root): shadow-including INCLUSIVE descendants — root itself (if
+  // it's an element) plus everything upgradeSubtree already walks (which is
+  // exclusive of root, since its other callers — innerHTML/insertAdjacentHTML
+  // patches below — always pass a pre-existing container that was never
+  // itself a fresh upgrade candidate).
+  CustomElementRegistry.prototype.upgrade = function(root) {
+    if (!(root instanceof Node)) {
+      throw new TypeError(
+          "Failed to execute 'upgrade' on 'CustomElementRegistry': parameter 1 is not of type 'Node'");
+    }
+    var ELEMENT_NODE = 1;
+    if (root.nodeType === ELEMENT_NODE) upgradeElement(root);
+    upgradeSubtree(root);
+  };
+
+  globalThis.CustomElementRegistry = CustomElementRegistry;
+  globalThis.customElements = new CustomElementRegistry();
+
+  // ── Upgrade hooks: document.createElement ────────────────────────────────
+
+  var origCreateElement = document.createElement;
+  document.createElement = function(tag) {
+    var el = origCreateElement.call(document, tag);
+    upgradeElement(el);
+    return el;
+  };
+
+  // ── Upgrade hooks: Element.prototype.innerHTML / ShadowRoot.prototype.innerHTML ──
+
+  function patchInnerHTML(proto) {
+    var desc = Object.getOwnPropertyDescriptor(proto, 'innerHTML');
+    if (!desc || !desc.set) return;
+    var origSet = desc.set;
+    Object.defineProperty(proto, 'innerHTML', {
+      get: desc.get,
+      set: function(html) {
+        disconnectSubtree(this); // walk the OLD content before it's replaced
+        origSet.call(this, html);
+        upgradeSubtree(this); // upgrade/connect the NEW content
+      },
+      enumerable: desc.enumerable,
+      configurable: true,
+    });
+  }
+  patchInnerHTML(Element.prototype);
+  patchInnerHTML(ShadowRoot.prototype);
+
+  // ── Track attached shadow roots for internal (mode-agnostic) traversal ───
+
+  var origAttachShadow = Element.prototype.attachShadow;
+  Element.prototype.attachShadow = function(options) {
+    var root = origAttachShadow.call(this, options);
+    Object.defineProperty(this, '__ceShadowRoot', { value: root, configurable: true });
+    return root;
+  };
+
+  // ── Upgrade hooks: Element.prototype.insertAdjacentHTML ──────────────────
+
+  // insertAdjacentHTML only ever adds content, never removes any — no
+  // existing element can be disconnected by it, so there's nothing to sync
+  // beyond upgrading (and, via upgradeElement, connecting) what's new.
+  var origInsertAdjacentHTML = Element.prototype.insertAdjacentHTML;
+  Element.prototype.insertAdjacentHTML = function(position, html) {
+    origInsertAdjacentHTML.call(this, position, html);
+    upgradeSubtree(this);
+    var pos = String(position).toLowerCase();
+    if ((pos === 'beforebegin' || pos === 'afterend') && this.parentNode) {
+      upgradeSubtree(this.parentNode);
+    }
+  };
+
+  // ── Connect/disconnect hooks: Node.prototype.appendChild / removeChild ───
+
+  var DOCUMENT_FRAGMENT_NODE = 11;
+
+  var origAppendChild = Node.prototype.appendChild;
+  Node.prototype.appendChild = function(child) {
+    var moved = (child && child.nodeType === DOCUMENT_FRAGMENT_NODE)
+        ? Array.prototype.slice.call(child.childNodes)
+        : [child];
+    var result = origAppendChild.call(this, child);
+    moved.forEach(syncConnectedSubtree);
+    return result;
+  };
+
+  var origRemoveChild = Node.prototype.removeChild;
+  Node.prototype.removeChild = function(child) {
+    var result = origRemoveChild.call(this, child);
+    syncConnectedSubtree(child);
+    return result;
+  };
+
+  // ── attributeChangedCallback hooks: setAttribute / removeAttribute ───────
+
+  function observedDefFor(el) {
+    if (!el.__ceUpgraded) return null;
+    var tag = el.tagName ? el.tagName.toLowerCase() : null;
+    return tag ? customElements._defs[tag] : null;
+  }
+
+  var origSetAttribute = Element.prototype.setAttribute;
+  Element.prototype.setAttribute = function(name, value) {
+    var def = observedDefFor(this);
+    var oldValue = def ? this.getAttribute(name) : null;
+    origSetAttribute.call(this, name, value);
+    if (def && def.observedAttributes.indexOf(name) !== -1 &&
+        typeof this.attributeChangedCallback === 'function') {
+      try { this.attributeChangedCallback(name, oldValue, this.getAttribute(name), null); } catch (e) {}
+    }
+  };
+
+  var origRemoveAttribute = Element.prototype.removeAttribute;
+  Element.prototype.removeAttribute = function(name) {
+    var def = observedDefFor(this);
+    var oldValue = def ? this.getAttribute(name) : null;
+    origRemoveAttribute.call(this, name);
+    if (def && def.observedAttributes.indexOf(name) !== -1 &&
+        typeof this.attributeChangedCallback === 'function') {
+      try { this.attributeChangedCallback(name, oldValue, null, null); } catch (e) {}
+    }
+  };
+})();
+)JS";
+
+} // namespace
+
+void CustomElementsBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kCustomElementsBootstrapScript, strlen(kCustomElementsBootstrapScript),
+                            "<custom-elements-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/CustomElementsBindings.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers globalThis.customElements (CustomElementRegistry: define/get/
+// whenDefined/upgrade) plus upgrade hooks. Pure JS, built entirely on top of
+// already-exposed primitives (querySelectorAll, createElement, innerHTML,
+// appendChild, removeChild, setAttribute/removeAttribute, attachShadow) via
+// monkey-patching — no new native bindings.
+//
+// Scope/limitations (documented rather than silently wrong):
+// - Elements are "upgraded" by reassigning their prototype to the registered
+//   class's prototype (Object.setPrototypeOf) rather than by invoking the
+//   class's constructor with the element as `this`. Real custom element
+//   upgrade requires cooperation from the JS engine's class-construction
+//   protocol (a real `new.target`-aware HTMLElement constructor) that this
+//   sandbox doesn't implement, so constructor logic never runs — only
+//   connectedCallback/disconnectedCallback/attributeChangedCallback do.
+// - Upgrade triggers: document.createElement(), a customElements.define()
+//   call rescanning the current document (covers elements already present
+//   from the initial HTML), Element/ShadowRoot.innerHTML assignment, and
+//   insertAdjacentHTML. Other insertion paths (before/after/replaceWith/
+//   append/prepend) are not hooked.
+// - The define()-time rescan walks document.querySelectorAll(name) only, so
+//   it does not cross shadow boundaries: elements already sitting inside an
+//   existing shadow root are not retroactively upgraded when a matching tag
+//   is define()'d afterward. (Populating that shadow root's innerHTML after
+//   the define() call still upgrades them, per the innerHTML trigger above.)
+//   Calling customElements.upgrade(root) manually on that shadow root (or any
+//   ancestor whose shadow-including subtree contains it) covers this case.
+// - customElements.upgrade(root) walks root's shadow-including INCLUSIVE
+//   descendants (root itself, if an element, plus everything reachable via
+//   the same light-DOM + shadow traversal the other hooks use). Throws
+//   TypeError if root isn't a Node (matches the spec: null/undefined/plain
+//   objects are rejected, not silently no-op'd).
+// - attachShadow() is wrapped purely to tag the host element with an
+//   internal, mode-agnostic reference to its shadow root (bypassing the
+//   closed-mode privacy Element.prototype.shadowRoot enforces for user
+//   script), so appendChild/removeChild/innerHTML connectivity bookkeeping
+//   can descend into shadow trees the same way it walks light-DOM children.
+//
+// Must run after ElementBindings, DocumentBindings, and ShadowRootBindings
+// (wraps their innerHTML/createElement/appendChild/removeChild/attachShadow).
+struct CustomElementsBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/DOMExceptionBindings.cpp

@@ -0,0 +1,111 @@
+#include "DOMExceptionBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kDOMExceptionBootstrapScript = R"JS(
+(function() {
+  var LEGACY_CODES = {
+    IndexSizeError: 1,
+    HierarchyRequestError: 3,
+    WrongDocumentError: 4,
+    InvalidCharacterError: 5,
+    NoModificationAllowedError: 7,
+    NotFoundError: 8,
+    NotSupportedError: 9,
+    InUseAttributeError: 10,
+    InvalidStateError: 11,
+    SyntaxError: 12,
+    InvalidModificationError: 13,
+    NamespaceError: 14,
+    InvalidAccessError: 15,
+    TypeMismatchError: 17,
+    SecurityError: 18,
+    NetworkError: 19,
+    AbortError: 20,
+    URLMismatchError: 21,
+    QuotaExceededError: 22,
+    TimeoutError: 23,
+    InvalidNodeTypeError: 24,
+    DataCloneError: 25,
+  };
+
+  function DOMException(message, name) {
+    this.message = message !== undefined ? String(message) : '';
+    this.name = name !== undefined ? String(name) : 'Error';
+    this.code = LEGACY_CODES[this.name] || 0;
+    this.stack = new Error(this.message).stack;
+  }
+  DOMException.prototype = Object.create(Error.prototype);
+  DOMException.prototype.constructor = DOMException;
+  DOMException.prototype.toString = function() {
+    return this.name + ': ' + this.message;
+  };
+
+  // Legacy static/instance numeric constants, e.g. DOMException.NOT_FOUND_ERR.
+  var STATIC_CONST_NAMES = {
+    IndexSizeError: 'INDEX_SIZE_ERR',
+    HierarchyRequestError: 'HIERARCHY_REQUEST_ERR',
+    WrongDocumentError: 'WRONG_DOCUMENT_ERR',
+    InvalidCharacterError: 'INVALID_CHARACTER_ERR',
+    NoModificationAllowedError: 'NO_MODIFICATION_ALLOWED_ERR',
+    NotFoundError: 'NOT_FOUND_ERR',
+    NotSupportedError: 'NOT_SUPPORTED_ERR',
+    InUseAttributeError: 'INUSE_ATTRIBUTE_ERR',
+    InvalidStateError: 'INVALID_STATE_ERR',
+    SyntaxError: 'SYNTAX_ERR',
+    InvalidModificationError: 'INVALID_MODIFICATION_ERR',
+    NamespaceError: 'NAMESPACE_ERR',
+    InvalidAccessError: 'INVALID_ACCESS_ERR',
+    TypeMismatchError: 'TYPE_MISMATCH_ERR',
+    SecurityError: 'SECURITY_ERR',
+    NetworkError: 'NETWORK_ERR',
+    InvalidNodeTypeError: 'INVALID_NODE_TYPE_ERR',
+    DataCloneError: 'DATA_CLONE_ERR',
+  };
+  Object.keys(STATIC_CONST_NAMES).forEach(function(name) {
+    var constName = STATIC_CONST_NAMES[name];
+    var code = LEGACY_CODES[name];
+    Object.defineProperty(DOMException, constName, { value: code, enumerable: true });
+    Object.defineProperty(DOMException.prototype, constName, { value: code, enumerable: true });
+  });
+
+  globalThis.DOMException = DOMException;
+})();
+)JS";
+
+} // namespace
+
+void DOMExceptionBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kDOMExceptionBootstrapScript, strlen(kDOMExceptionBootstrapScript),
+                            "<dom-exception-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
+}
+
+JSValue throw_dom_exception(JSContext* ctx, const char* name, const char* message) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue ctor = JS_GetPropertyStr(ctx, global, "DOMException");
+  JS_FreeValue(ctx, global);
+
+  if (!JS_IsFunction(ctx, ctor)) {
+    JS_FreeValue(ctx, ctor);
+    return JS_ThrowTypeError(ctx, "%s: %s", name, message);
+  }
+
+  JSValue args[2] = { JS_NewString(ctx, message), JS_NewString(ctx, name) };
+  JSValue exc = JS_CallConstructor(ctx, ctor, 2, args);
+  JS_FreeValue(ctx, args[0]);
+  JS_FreeValue(ctx, args[1]);
+  JS_FreeValue(ctx, ctor);
+
+  if (JS_IsException(exc)) return JS_EXCEPTION;
+  JS_Throw(ctx, exc);
+  return JS_EXCEPTION;
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/DOMExceptionBindings.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers globalThis.DOMException (extends Error, with the legacy numeric
+// `.code` field). Installed first since every other binding module that
+// throws a named DOM error (NotFoundError, SyntaxError, InvalidCharacterError,
+// ...) depends on the constructor already existing on globalThis.
+struct DOMExceptionBindings {
+  static void install(JSContext* ctx);
+};
+
+// Constructs `new DOMException(message, name)` via the globalThis constructor
+// and throws it (mirrors JS_ThrowTypeError's calling convention: always
+// returns JS_EXCEPTION so call sites can `return throw_dom_exception(...)`).
+JSValue throw_dom_exception(JSContext* ctx, const char* name, const char* message);
+
+} // namespace margelo::nitro::nitrojsdom