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

package/cpp/quickjs/bindings/UrlBindings.cpp

@@ -0,0 +1,286 @@
+#include "UrlBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kUrlBootstrapScript = R"JS(
+(function() {
+  function encodeComponent(str) {
+    return encodeURIComponent(str).replace(/%20/g, '+').replace(/[!'()*]/g, function(c) {
+      return '%' + c.charCodeAt(0).toString(16).toUpperCase();
+    });
+  }
+  function decodeComponent(str) {
+    return decodeURIComponent(str.replace(/\+/g, ' '));
+  }
+
+  function parsePairs(search) {
+    var pairs = [];
+    var s = search && search.charAt(0) === '?' ? search.slice(1) : (search || '');
+    if (!s) return pairs;
+    var parts = s.split('&');
+    for (var i = 0; i < parts.length; i++) {
+      var part = parts[i];
+      if (!part) continue;
+      var eq = part.indexOf('=');
+      var k, v;
+      if (eq === -1) { k = part; v = ''; } else { k = part.slice(0, eq); v = part.slice(eq + 1); }
+      pairs.push([decodeComponent(k), decodeComponent(v)]);
+    }
+    return pairs;
+  }
+
+  function URLSearchParams(init) {
+    this._pairs = [];
+    this._onChange = null;
+    if (init === undefined || init === null || init === '') {
+    } else if (typeof init === 'string') {
+      this._pairs = parsePairs(init);
+    } else if (init instanceof URLSearchParams) {
+      for (var i = 0; i < init._pairs.length; i++) this._pairs.push(init._pairs[i].slice());
+    } else if (Array.isArray(init)) {
+      for (var i = 0; i < init.length; i++) this._pairs.push([String(init[i][0]), String(init[i][1])]);
+    } else if (typeof init === 'object') {
+      for (var k in init) {
+        if (Object.prototype.hasOwnProperty.call(init, k)) this._pairs.push([String(k), String(init[k])]);
+      }
+    }
+  }
+
+  URLSearchParams.prototype._notify = function() { if (this._onChange) this._onChange(); };
+
+  URLSearchParams.prototype.append = function(name, value) {
+    this._pairs.push([String(name), String(value)]);
+    this._notify();
+  };
+  URLSearchParams.prototype.delete = function(name, value) {
+    name = String(name);
+    var hasValue = value !== undefined;
+    var v = hasValue ? String(value) : null;
+    var out = [];
+    for (var i = 0; i < this._pairs.length; i++) {
+      var p = this._pairs[i];
+      if (p[0] === name && (!hasValue || p[1] === v)) continue;
+      out.push(p);
+    }
+    this._pairs = out;
+    this._notify();
+  };
+  URLSearchParams.prototype.get = function(name) {
+    name = String(name);
+    for (var i = 0; i < this._pairs.length; i++) if (this._pairs[i][0] === name) return this._pairs[i][1];
+    return null;
+  };
+  URLSearchParams.prototype.getAll = function(name) {
+    name = String(name);
+    var out = [];
+    for (var i = 0; i < this._pairs.length; i++) if (this._pairs[i][0] === name) out.push(this._pairs[i][1]);
+    return out;
+  };
+  URLSearchParams.prototype.has = function(name, value) {
+    name = String(name);
+    var hasValue = value !== undefined;
+    var v = hasValue ? String(value) : null;
+    for (var i = 0; i < this._pairs.length; i++) {
+      if (this._pairs[i][0] === name && (!hasValue || this._pairs[i][1] === v)) return true;
+    }
+    return false;
+  };
+  URLSearchParams.prototype.set = function(name, value) {
+    name = String(name); value = String(value);
+    var found = false;
+    var out = [];
+    for (var i = 0; i < this._pairs.length; i++) {
+      var p = this._pairs[i];
+      if (p[0] !== name) { out.push(p); continue; }
+      if (!found) { out.push([name, value]); found = true; }
+    }
+    if (!found) out.push([name, value]);
+    this._pairs = out;
+    this._notify();
+  };
+  URLSearchParams.prototype.sort = function() {
+    this._pairs.sort(function(a, b) { return a[0] < b[0] ? -1 : (a[0] > b[0] ? 1 : 0); });
+    this._notify();
+  };
+  URLSearchParams.prototype.forEach = function(cb, thisArg) {
+    for (var i = 0; i < this._pairs.length; i++) cb.call(thisArg, this._pairs[i][1], this._pairs[i][0], this);
+  };
+  URLSearchParams.prototype.keys = function() {
+    var out = [];
+    for (var i = 0; i < this._pairs.length; i++) out.push(this._pairs[i][0]);
+    return out[Symbol.iterator]();
+  };
+  URLSearchParams.prototype.values = function() {
+    var out = [];
+    for (var i = 0; i < this._pairs.length; i++) out.push(this._pairs[i][1]);
+    return out[Symbol.iterator]();
+  };
+  URLSearchParams.prototype.entries = function() {
+    var out = [];
+    for (var i = 0; i < this._pairs.length; i++) out.push(this._pairs[i].slice());
+    return out[Symbol.iterator]();
+  };
+  URLSearchParams.prototype[Symbol.iterator] = function() { return this.entries(); };
+  URLSearchParams.prototype.toString = function() {
+    var out = [];
+    for (var i = 0; i < this._pairs.length; i++) out.push(encodeComponent(this._pairs[i][0]) + '=' + encodeComponent(this._pairs[i][1]));
+    return out.join('&');
+  };
+
+  globalThis.URLSearchParams = URLSearchParams;
+
+  function parseUrlFull(str) {
+    str = String(str === undefined || str === null ? '' : str);
+    var m = /^([^:\/?#]+:)(?:\/\/(?:([^\/?#@]*)@)?([^\/?#:]*)(?::(\d+))?)?([^?#]*)(\?[^#]*)?(#.*)?$/.exec(str);
+    if (!m) return null;
+    var protocol = m[1] || '';
+    var userinfo = m[2] || '';
+    var hostname = m[3] || '';
+    var port = m[4] || '';
+    var pathname = m[5] || '';
+    var search = m[6] || '';
+    var hash = m[7] || '';
+    if (!pathname && hostname) pathname = '/';
+    var username = '', password = '';
+    if (userinfo) {
+      var idx = userinfo.indexOf(':');
+      if (idx === -1) { username = userinfo; } else { username = userinfo.slice(0, idx); password = userinfo.slice(idx + 1); }
+    }
+    return {
+      protocol: protocol, username: username, password: password,
+      hostname: hostname, port: port, pathname: pathname, search: search, hash: hash,
+    };
+  }
+
+  function serializeUrl(p) {
+    var auth = '';
+    if (p.username || p.password) auth = p.username + (p.password ? ':' + p.password : '') + '@';
+    var host = p.hostname ? ('//' + auth + p.hostname + (p.port ? ':' + p.port : '')) : '';
+    return (p.protocol || '') + host + (p.pathname || '') + (p.search || '') + (p.hash || '');
+  }
+
+  function resolveUrlFull(base, next) {
+    next = String(next);
+    if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(next)) return next;
+    var p = parseUrlFull(base) || {};
+    var origin = p.hostname
+      ? serializeUrl({ protocol: p.protocol, username: p.username, password: p.password, hostname: p.hostname, port: p.port, pathname: '', search: '', hash: '' })
+      : (p.protocol || '');
+    if (next.charAt(0) === '/') return origin + next;
+    if (next.charAt(0) === '#') return base.split('#')[0] + next;
+    if (next.charAt(0) === '?') return base.split('?')[0].split('#')[0] + next;
+    var dir = (p.pathname || '/').replace(/\/[^\/]*$/, '/');
+    return origin + dir + next;
+  }
+
+  function URL(url, base) {
+    var href = (base !== undefined && base !== null) ? resolveUrlFull(String(base), url) : String(url);
+    if (!/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(href)) {
+      throw new TypeError('Invalid URL: ' + href);
+    }
+    this._href = href;
+    var self = this;
+    var initialSearch = (parseUrlFull(this._href) || {}).search || '';
+    this._searchParams = new URLSearchParams(initialSearch);
+    this._searchParams._onChange = function() { self._syncSearchFromParams(); };
+  }
+
+  URL.prototype._syncSearchFromParams = function() {
+    var s = this._searchParams.toString();
+    this._setPart('search', s ? '?' + s : '');
+  };
+
+  URL.prototype._setPart = function(part, value) {
+    var p = parseUrlFull(this._href) || {};
+    p[part] = value;
+    this._href = serializeUrl(p);
+  };
+
+  URL.prototype._resyncSearchParams = function() {
+    var s = (parseUrlFull(this._href) || {}).search || '';
+    this._searchParams._pairs = parsePairs(s);
+  };
+
+  ['protocol', 'username', 'password', 'hostname', 'port', 'pathname', 'hash'].forEach(function(name) {
+    Object.defineProperty(URL.prototype, name, {
+      get: function() { return (parseUrlFull(this._href) || {})[name] || ''; },
+      set: function(v) { this._setPart(name, String(v)); },
+      enumerable: true,
+      configurable: true,
+    });
+  });
+
+  Object.defineProperty(URL.prototype, 'search', {
+    get: function() { return (parseUrlFull(this._href) || {}).search || ''; },
+    set: function(v) {
+      var s = String(v);
+      this._setPart('search', s ? (s.charAt(0) === '?' ? s : '?' + s) : '');
+      this._resyncSearchParams();
+    },
+    enumerable: true,
+    configurable: true,
+  });
+
+  Object.defineProperty(URL.prototype, 'searchParams', {
+    get: function() { return this._searchParams; },
+    enumerable: true,
+    configurable: true,
+  });
+
+  Object.defineProperty(URL.prototype, 'host', {
+    get: function() {
+      var p = parseUrlFull(this._href) || {};
+      return p.hostname + (p.port ? ':' + p.port : '');
+    },
+    set: function(v) {
+      var s = String(v);
+      var idx = s.indexOf(':');
+      if (idx === -1) { this._setPart('hostname', s); this._setPart('port', ''); }
+      else { this._setPart('hostname', s.slice(0, idx)); this._setPart('port', s.slice(idx + 1)); }
+    },
+    enumerable: true,
+    configurable: true,
+  });
+
+  Object.defineProperty(URL.prototype, 'origin', {
+    get: function() {
+      var p = parseUrlFull(this._href) || {};
+      if (!p.hostname) return 'null';
+      return p.protocol + '//' + p.hostname + (p.port ? ':' + p.port : '');
+    },
+    enumerable: true,
+    configurable: true,
+  });
+
+  Object.defineProperty(URL.prototype, 'href', {
+    get: function() { return this._href; },
+    set: function(v) {
+      this._href = String(v);
+      this._resyncSearchParams();
+    },
+    enumerable: true,
+    configurable: true,
+  });
+
+  URL.prototype.toString = function() { return this._href; };
+  URL.prototype.toJSON = function() { return this._href; };
+
+  globalThis.URL = URL;
+})();
+)JS";
+
+} // namespace
+
+void UrlBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kUrlBootstrapScript, strlen(kUrlBootstrapScript),
+                            "<url-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/UrlBindings.hpp

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

package/cpp/quickjs/bindings/WindowBindings.cpp

@@ -1,8 +1,10 @@
 #include "WindowBindings.hpp"
+#include "DOMExceptionBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
 #include "../QuickJSRuntime.hpp"
 #include <cstring>
 #include <optional>
+#include <random>
 #include <string>
 #include <vector>
 
@@ -10,6 +12,162 @@ namespace margelo::nitro::nitrojsdom {
 
 namespace {
 
+// ── atob / btoa ────────────────────────────────────────────────────────────
+
+const char kBase64Alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+int8_t base64_decode_char(unsigned char c) {
+  if (c >= 'A' && c <= 'Z') return c - 'A';
+  if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+  if (c >= '0' && c <= '9') return c - '0' + 52;
+  if (c == '+') return 62;
+  if (c == '/') return 63;
+  return -1;
+}
+
+bool is_ascii_whitespace(char c) {
+  return c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r';
+}
+
+JSValue js_window_btoa(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 1) return JS_ThrowTypeError(ctx, "btoa() requires 1 argument");
+  JSValue str_val = JS_ToString(ctx, argv[0]);
+  if (JS_IsException(str_val)) return JS_EXCEPTION;
+  size_t len = 0;
+  const char* s = JS_ToCStringLen(ctx, &len, str_val);
+  if (!s) { JS_FreeValue(ctx, str_val); return JS_EXCEPTION; }
+
+  // JS_ToCStringLen yields UTF-8 (length-aware, so embedded NULs survive);
+  // btoa operates on Latin1 code units, so decode the UTF-8 back into code
+  // points and reject anything outside 0x00-0xFF.
+  std::vector<uint8_t> bytes;
+  bytes.reserve(len);
+  bool out_of_range = false;
+  for (size_t i = 0; i < len && !out_of_range;) {
+    unsigned char c = static_cast<unsigned char>(s[i]);
+    uint32_t codepoint;
+    size_t seq_len;
+    if (c < 0x80) { codepoint = c; seq_len = 1; }
+    else if ((c & 0xE0) == 0xC0 && i + 1 < len) { codepoint = c & 0x1F; seq_len = 2; }
+    else if ((c & 0xF0) == 0xE0 && i + 2 < len) { codepoint = c & 0x0F; seq_len = 3; }
+    else { out_of_range = true; break; }
+    for (size_t k = 1; k < seq_len; k++) {
+      codepoint = (codepoint << 6) | (static_cast<unsigned char>(s[i + k]) & 0x3F);
+    }
+    if (codepoint > 0xFF) { out_of_range = true; break; }
+    bytes.push_back(static_cast<uint8_t>(codepoint));
+    i += seq_len;
+  }
+  JS_FreeCString(ctx, s);
+  JS_FreeValue(ctx, str_val);
+
+  if (out_of_range) {
+    return throw_dom_exception(ctx, "InvalidCharacterError",
+        "The string to be encoded contains characters outside of the Latin1 range.");
+  }
+
+  std::string out;
+  out.reserve(((bytes.size() + 2) / 3) * 4);
+  size_t i = 0;
+  while (i + 3 <= bytes.size()) {
+    uint32_t n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+    out += kBase64Alphabet[(n >> 18) & 0x3F];
+    out += kBase64Alphabet[(n >> 12) & 0x3F];
+    out += kBase64Alphabet[(n >> 6) & 0x3F];
+    out += kBase64Alphabet[n & 0x3F];
+    i += 3;
+  }
+  size_t remaining = bytes.size() - i;
+  if (remaining == 1) {
+    uint32_t n = bytes[i] << 16;
+    out += kBase64Alphabet[(n >> 18) & 0x3F];
+    out += kBase64Alphabet[(n >> 12) & 0x3F];
+    out += "==";
+  } else if (remaining == 2) {
+    uint32_t n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+    out += kBase64Alphabet[(n >> 18) & 0x3F];
+    out += kBase64Alphabet[(n >> 12) & 0x3F];
+    out += kBase64Alphabet[(n >> 6) & 0x3F];
+    out += "=";
+  }
+
+  return JS_NewStringLen(ctx, out.c_str(), out.size());
+}
+
+JSValue js_window_atob(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 1) return JS_ThrowTypeError(ctx, "atob() requires 1 argument");
+  JSValue str_val = JS_ToString(ctx, argv[0]);
+  if (JS_IsException(str_val)) return JS_EXCEPTION;
+  size_t len = 0;
+  const char* s = JS_ToCStringLen(ctx, &len, str_val);
+  if (!s) { JS_FreeValue(ctx, str_val); return JS_EXCEPTION; }
+
+  std::string data;
+  data.reserve(len);
+  for (size_t i = 0; i < len; i++) {
+    if (!is_ascii_whitespace(s[i])) data += s[i];
+  }
+  JS_FreeCString(ctx, s);
+  JS_FreeValue(ctx, str_val);
+
+  if (data.size() % 4 == 0) {
+    if (data.size() >= 2 && data[data.size() - 1] == '=' && data[data.size() - 2] == '=') {
+      data.resize(data.size() - 2);
+    } else if (!data.empty() && data.back() == '=') {
+      data.resize(data.size() - 1);
+    }
+  }
+
+  if (data.size() % 4 == 1) {
+    return throw_dom_exception(ctx, "InvalidCharacterError",
+        "The string to be decoded is not correctly encoded.");
+  }
+  for (char c : data) {
+    if (base64_decode_char(static_cast<unsigned char>(c)) < 0) {
+      return throw_dom_exception(ctx, "InvalidCharacterError",
+          "The string to be decoded is not correctly encoded.");
+    }
+  }
+
+  std::string out;
+  out.reserve((data.size() / 4) * 3 + 3);
+  size_t i = 0;
+  while (i + 4 <= data.size()) {
+    uint32_t n = (base64_decode_char(data[i]) << 18) | (base64_decode_char(data[i + 1]) << 12) |
+                 (base64_decode_char(data[i + 2]) << 6) | base64_decode_char(data[i + 3]);
+    out += static_cast<char>((n >> 16) & 0xFF);
+    out += static_cast<char>((n >> 8) & 0xFF);
+    out += static_cast<char>(n & 0xFF);
+    i += 4;
+  }
+  size_t remaining = data.size() - i;
+  if (remaining == 2) {
+    uint32_t n = (base64_decode_char(data[i]) << 18) | (base64_decode_char(data[i + 1]) << 12);
+    out += static_cast<char>((n >> 16) & 0xFF);
+  } else if (remaining == 3) {
+    uint32_t n = (base64_decode_char(data[i]) << 18) | (base64_decode_char(data[i + 1]) << 12) |
+                 (base64_decode_char(data[i + 2]) << 6);
+    out += static_cast<char>((n >> 16) & 0xFF);
+    out += static_cast<char>((n >> 8) & 0xFF);
+  }
+
+  // atob's result is a "binary string" — each output char code is one decoded
+  // byte (0x00-0xFF). JS_NewStringLen expects UTF-8 input, so each byte must
+  // be re-encoded as the UTF-8 sequence for that same code point (1 byte for
+  // 0x00-0x7F, 2 bytes for 0x80-0xFF) to round-trip through QuickJS correctly.
+  std::string utf8;
+  utf8.reserve(out.size() * 2);
+  for (unsigned char byte : out) {
+    if (byte < 0x80) {
+      utf8 += static_cast<char>(byte);
+    } else {
+      utf8 += static_cast<char>(0xC0 | (byte >> 6));
+      utf8 += static_cast<char>(0x80 | (byte & 0x3F));
+    }
+  }
+  return JS_NewStringLen(ctx, utf8.c_str(), utf8.size());
+}
+
 // ── console ────────────────────────────────────────────────────────────────
 
 JSValue js_console_method(JSContext* ctx, JSValue, int argc, JSValue* argv, int magic) {
@@ -181,6 +339,94 @@ const char* kLocationBootstrapScript = R"JS(
 })();
 )JS";
 
+// ── crypto.getRandomValues ────────────────────────────────────────────────────
+
+JSValue js_native_random_bytes(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  int32_t count = 0;
+  if (argc >= 1) JS_ToInt32(ctx, &count, argv[0]);
+  if (count < 0) count = 0;
+
+  static thread_local std::mt19937 gen{std::random_device{}()};
+  std::uniform_int_distribution<int> dist(0, 255);
+
+  JSValue arr = JS_NewArray(ctx);
+  for (int32_t i = 0; i < count; i++) {
+    JS_SetPropertyUint32(ctx, arr, static_cast<uint32_t>(i), JS_NewInt32(ctx, dist(gen)));
+  }
+  return arr;
+}
+
+const char* kCryptoBootstrapScript = R"JS(
+(function() {
+  globalThis.crypto = globalThis.crypto || {};
+  globalThis.crypto.getRandomValues = function(typedArray) {
+    if (!typedArray || typeof typedArray.byteLength !== 'number' || typedArray instanceof BigInt64Array || typedArray instanceof BigUint64Array) {
+      throw new TypeError('crypto.getRandomValues() requires an integer TypedArray argument');
+    }
+    if (typedArray.byteLength > 65536) {
+      var err = new Error('crypto.getRandomValues() can only fill up to 65536 bytes at a time');
+      err.name = 'QuotaExceededError';
+      throw err;
+    }
+    var bytes = __nativeRandomBytes(typedArray.byteLength);
+    var view = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength);
+    for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
+    return typedArray;
+  };
+})();
+)JS";
+
+// ── navigator ──────────────────────────────────────────────────────────────
+
+const char* kNavigatorBootstrapScript = R"JS(
+(function() {
+  var navigator = {
+    userAgent: 'Mozilla/5.0 (ReactNative) react-native-nitro-jsdom',
+    platform: 'ReactNative',
+    language: 'en-US',
+    languages: ['en-US'],
+    onLine: true,
+    cookieEnabled: false,
+    hardwareConcurrency: 1,
+  };
+  globalThis.navigator = navigator;
+})();
+)JS";
+
+// ── matchMedia ─────────────────────────────────────────────────────────────
+// No layout engine backs this sandbox, so every query reports "no match" —
+// mirrors jsdom's own stance that layout-dependent APIs return inert defaults
+// rather than throwing.
+
+const char* kMatchMediaBootstrapScript = R"JS(
+(function() {
+  function MediaQueryList(media) {
+    this.media = String(media === undefined ? '' : media);
+    this.matches = false;
+    this.onchange = null;
+    this._listeners = [];
+  }
+  MediaQueryList.prototype.addListener = function(cb) {
+    if (typeof cb === 'function' && this._listeners.indexOf(cb) === -1) this._listeners.push(cb);
+  };
+  MediaQueryList.prototype.removeListener = function(cb) {
+    var idx = this._listeners.indexOf(cb);
+    if (idx !== -1) this._listeners.splice(idx, 1);
+  };
+  MediaQueryList.prototype.addEventListener = function(type, cb) {
+    if (type === 'change') this.addListener(cb);
+  };
+  MediaQueryList.prototype.removeEventListener = function(type, cb) {
+    if (type === 'change') this.removeListener(cb);
+  };
+  MediaQueryList.prototype.dispatchEvent = function() { return true; };
+
+  globalThis.matchMedia = function(query) {
+    return new MediaQueryList(query);
+  };
+})();
+)JS";
+
 } // namespace
 
 void WindowBindings::install(JSContext* ctx) {
@@ -189,6 +435,8 @@ void WindowBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, global, "alert",   JS_NewCFunction(ctx, js_window_alert,   "alert",   1));
   JS_SetPropertyStr(ctx, global, "confirm", JS_NewCFunction(ctx, js_window_confirm, "confirm", 1));
   JS_SetPropertyStr(ctx, global, "prompt",  JS_NewCFunction(ctx, js_window_prompt,  "prompt",  2));
+  JS_SetPropertyStr(ctx, global, "atob",    JS_NewCFunction(ctx, js_window_atob,    "atob",    1));
+  JS_SetPropertyStr(ctx, global, "btoa",    JS_NewCFunction(ctx, js_window_btoa,    "btoa",    1));
 
   JSValue console_obj = JS_NewObject(ctx);
   JS_SetPropertyStr(ctx, console_obj, "log",   JS_NewCFunctionMagic(ctx, js_console_method, "log",   0, JS_CFUNC_generic_magic, 0));
@@ -197,6 +445,7 @@ void WindowBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, console_obj, "info",  JS_NewCFunctionMagic(ctx, js_console_method, "info",  0, JS_CFUNC_generic_magic, 3));
   JS_SetPropertyStr(ctx, console_obj, "debug", JS_NewCFunctionMagic(ctx, js_console_method, "debug", 0, JS_CFUNC_generic_magic, 4));
   JS_SetPropertyStr(ctx, global, "console", console_obj);
+  JS_SetPropertyStr(ctx, global, "__nativeRandomBytes", JS_NewCFunction(ctx, js_native_random_bytes, "__nativeRandomBytes", 1));
 
   JS_FreeValue(ctx, global);
 
@@ -206,6 +455,27 @@ void WindowBindings::install(JSContext* ctx) {
     JS_FreeValue(ctx, JS_GetException(ctx));
   }
   JS_FreeValue(ctx, location_result);
+
+  JSValue crypto_result = JS_Eval(ctx, kCryptoBootstrapScript, strlen(kCryptoBootstrapScript),
+                                   "<crypto-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(crypto_result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, crypto_result);
+
+  JSValue navigator_result = JS_Eval(ctx, kNavigatorBootstrapScript, strlen(kNavigatorBootstrapScript),
+                                      "<navigator-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(navigator_result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, navigator_result);
+
+  JSValue match_media_result = JS_Eval(ctx, kMatchMediaBootstrapScript, strlen(kMatchMediaBootstrapScript),
+                                        "<match-media-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(match_media_result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, match_media_result);
 }
 
 } // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/XmlSerializerBindings.cpp

@@ -0,0 +1,44 @@
+#include "XmlSerializerBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include <string>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+JSClassID js_xml_serializer_class_id = 0;
+JSClassDef js_xml_serializer_class = { "XMLSerializer", .finalizer = nullptr };
+
+JSValue js_xmlserializer_constructor(JSContext* ctx, JSValue, int, JSValue*) {
+  return JS_NewObjectClass(ctx, js_xml_serializer_class_id);
+}
+
+JSValue js_xmlserializer_serializeToString(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 1) return JS_NewString(ctx, "");
+  auto* node = unwrap_node(ctx, argv[0]);
+  if (!node) return JS_NewString(ctx, "");
+  std::string result = serialize_node(node);
+  return JS_NewStringLen(ctx, result.data(), result.size());
+}
+
+} // namespace
+
+void XmlSerializerBindings::install(JSContext* ctx) {
+  if (js_xml_serializer_class_id == 0) JS_NewClassID(&js_xml_serializer_class_id);
+  JS_NewClass(JS_GetRuntime(ctx), js_xml_serializer_class_id, &js_xml_serializer_class);
+
+  JSValue proto = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, proto, "serializeToString",
+      JS_NewCFunction(ctx, js_xmlserializer_serializeToString, "serializeToString", 1));
+  JS_SetClassProto(ctx, js_xml_serializer_class_id, JS_DupValue(ctx, proto));
+
+  JSValue ctor = JS_NewCFunction2(ctx, js_xmlserializer_constructor, "XMLSerializer", 0, JS_CFUNC_constructor, 0);
+  JS_SetConstructor(ctx, ctor, proto);
+  JS_FreeValue(ctx, proto);
+
+  JSValue global = JS_GetGlobalObject(ctx);
+  JS_SetPropertyStr(ctx, global, "XMLSerializer", ctor);
+  JS_FreeValue(ctx, global);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/XmlSerializerBindings.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers globalThis.XMLSerializer with serializeToString(node), backed by
+// the same serialize_node() helper Element.prototype.outerHTML already uses
+// (DOMBindingsInternal.hpp) — serializes the given node and its subtree.
+//
+// Scope: only serializeToString(node) is implemented (DOMParser.parseFromString
+// is out of scope — see docs/overview.md's v0.10 notes, it would need a real
+// second Document). `node` must be a wrapped Element/Node/ShadowRoot (i.e. not
+// `document` itself, which is a plain JS object with no native node behind
+// it) — pass document.documentElement instead, same as any other subtree
+// serialization in this sandbox.
+//
+// Must run after ElementBindings (unwrap_node/serialize_node need
+// js_element_class_id/js_node_class_id to exist).
+struct XmlSerializerBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/lib/commonjs/classes/JSDOM/JSDOM.class.js

@@ -39,7 +39,7 @@ class JSDOM {
    */
   static create(html, options) {
     const sandbox = _reactNativeNitroModules.NitroModules.createHybridObject('HtmlSandbox');
-    sandbox.initialize(html, options?.runScripts ?? true, options?.url ?? 'about:blank');
+    sandbox.initialize(html, options?.runScripts ?? true, options?.url ?? 'about:blank', options?.pretendToBeVisual ?? false);
     if (options?.onConsole) {
       const cb = options.onConsole;
       sandbox.setConsoleCallback((level, args) => cb(level, args));