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

package/cpp/quickjs/bindings/ShadowRootBindings.cpp

@@ -0,0 +1,171 @@
+#include "ShadowRootBindings.hpp"
+#include "DOMExceptionBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
+#include "../../lexbor/LexborDocument.hpp"
+#include <lexbor/html/html.h>
+#include <lexbor/dom/dom.h>
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+JSClassDef js_shadow_root_class = { "ShadowRoot", .finalizer = nullptr };
+
+lxb_dom_shadow_root_t* unwrap_shadow_root(JSValue val) {
+  return static_cast<lxb_dom_shadow_root_t*>(JS_GetOpaque(val, js_shadow_root_class_id));
+}
+
+JSValue make_shadow_root(JSContext* ctx, void* shadow_ptr) {
+  if (!shadow_ptr) return JS_NULL;
+
+  RuntimeContext* rctx = get_ctx(ctx);
+  if (rctx) {
+    auto it = rctx->node_wrapper_cache.find(shadow_ptr);
+    if (it != rctx->node_wrapper_cache.end()) {
+      return JS_DupValue(ctx, *static_cast<JSValue*>(it->second));
+    }
+  }
+
+  JSValue obj = JS_NewObjectClass(ctx, js_shadow_root_class_id);
+  JS_SetOpaque(obj, shadow_ptr);
+  if (rctx) rctx->node_wrapper_cache[shadow_ptr] = new JSValue(JS_DupValue(ctx, obj));
+  return obj;
+}
+
+JSValue js_shadow_get_host(JSContext* ctx, JSValue this_val) {
+  auto* shadow = unwrap_shadow_root(this_val);
+  if (!shadow) return JS_NULL;
+  return make_element(ctx, shadow->host);
+}
+
+JSValue js_shadow_get_mode(JSContext* ctx, JSValue this_val) {
+  auto* shadow = unwrap_shadow_root(this_val);
+  if (!shadow) return JS_NewString(ctx, "open");
+  return JS_NewString(ctx, shadow->mode == LXB_DOM_SHADOW_ROOT_MODE_CLOSED ? "closed" : "open");
+}
+
+JSValue js_shadow_get_innerHTML(JSContext* ctx, JSValue this_val) {
+  auto* shadow = unwrap_shadow_root(this_val);
+  if (!shadow) return JS_NewString(ctx, "");
+  std::string result;
+  lxb_dom_node_t* child = lxb_dom_interface_node(shadow)->first_child;
+  while (child) { result += serialize_node(child); child = child->next; }
+  return JS_NewString(ctx, result.c_str());
+}
+
+JSValue js_shadow_set_innerHTML(JSContext* ctx, JSValue this_val, JSValue val) {
+  auto* shadow = unwrap_shadow_root(this_val);
+  if (!shadow) return JS_UNDEFINED;
+  const char* html = JS_ToCString(ctx, val);
+  if (!html) return JS_UNDEFINED;
+
+  lxb_dom_node_t* node = lxb_dom_interface_node(shadow);
+  auto* rctx = get_ctx(ctx);
+  std::vector<void*> old_children;
+  lxb_dom_node_t* child = node->first_child;
+  while (child) { old_children.push_back(child); child = child->next; }
+  if (!old_children.empty()) invalidate_node_cache_deep_batch(ctx, rctx, old_children);
+
+  get_doc(ctx)->setInnerHTMLOnShadowRoot(shadow, shadow->host, html);
+  JS_FreeCString(ctx, html);
+  return JS_UNDEFINED;
+}
+
+JSValue js_shadow_querySelector(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* shadow = unwrap_shadow_root(this_val);
+  if (!shadow || argc < 1) return JS_NULL;
+  const char* sel = JS_ToCString(ctx, argv[0]);
+  if (!sel) return JS_NULL;
+  void* found = get_doc(ctx)->querySelectorFromEl(shadow, sel);
+  JS_FreeCString(ctx, sel);
+  return make_element(ctx, found);
+}
+
+JSValue js_shadow_querySelectorAll(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* shadow = unwrap_shadow_root(this_val);
+  if (!shadow || argc < 1) return JS_NewArray(ctx);
+  const char* sel = JS_ToCString(ctx, argv[0]);
+  if (!sel) return JS_NewArray(ctx);
+  auto found = get_doc(ctx)->querySelectorAllFromEl(shadow, sel);
+  JS_FreeCString(ctx, sel);
+  return make_element_array(ctx, found);
+}
+
+// ── Element.prototype.attachShadow() / .shadowRoot ────────────────────────────
+
+JSValue js_el_attachShadow(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_UNDEFINED;
+
+  if (argc < 1 || !JS_IsObject(argv[0])) {
+    return JS_ThrowTypeError(ctx, "attachShadow() requires an options object with a 'mode' property");
+  }
+  JSValue mode_val = JS_GetPropertyStr(ctx, argv[0], "mode");
+  if (JS_IsException(mode_val)) return JS_EXCEPTION;
+  const char* mode_str = JS_ToCString(ctx, mode_val);
+  JS_FreeValue(ctx, mode_val);
+  if (!mode_str) return JS_EXCEPTION;
+  bool is_open = strcmp(mode_str, "open") == 0;
+  bool is_closed = strcmp(mode_str, "closed") == 0;
+  JS_FreeCString(ctx, mode_str);
+  if (!is_open && !is_closed) {
+    return JS_ThrowTypeError(ctx, "attachShadow() options.mode must be 'open' or 'closed'");
+  }
+
+  auto* rctx = get_ctx(ctx);
+  if (rctx && rctx->element_shadow_roots.count(el)) {
+    return throw_dom_exception(ctx, "NotSupportedError", "This element already has an attached shadow root.");
+  }
+
+  void* shadow = get_doc(ctx)->createShadowRoot(el, is_closed ? 1 : 0);
+  if (!shadow) return JS_NULL;
+  if (rctx) rctx->element_shadow_roots[el] = shadow;
+
+  return make_shadow_root(ctx, shadow);
+}
+
+JSValue js_el_get_shadowRoot(JSContext* ctx, JSValue this_val) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el) return JS_NULL;
+  auto* rctx = get_ctx(ctx);
+  if (!rctx) return JS_NULL;
+  auto it = rctx->element_shadow_roots.find(el);
+  if (it == rctx->element_shadow_roots.end()) return JS_NULL;
+  auto* shadow = static_cast<lxb_dom_shadow_root_t*>(it->second);
+  if (shadow->mode == LXB_DOM_SHADOW_ROOT_MODE_CLOSED) return JS_NULL;
+  return make_shadow_root(ctx, shadow);
+}
+
+} // namespace
+
+void ShadowRootBindings::install(JSContext* ctx) {
+  if (js_shadow_root_class_id == 0) JS_NewClassID(&js_shadow_root_class_id);
+  JS_NewClass(JS_GetRuntime(ctx), js_shadow_root_class_id, &js_shadow_root_class);
+
+  JSValue node_proto = JS_GetClassProto(ctx, js_node_class_id);
+  JSValue proto = JS_NewObjectProto(ctx, node_proto);
+  JS_FreeValue(ctx, node_proto);
+
+  define_prop(ctx, proto, "host",       js_shadow_get_host,       nullptr);
+  define_prop(ctx, proto, "mode",       js_shadow_get_mode,       nullptr);
+  define_prop(ctx, proto, "innerHTML",  js_shadow_get_innerHTML,  js_shadow_set_innerHTML);
+  JS_SetPropertyStr(ctx, proto, "querySelector",
+      JS_NewCFunction(ctx, js_shadow_querySelector, "querySelector", 1));
+  JS_SetPropertyStr(ctx, proto, "querySelectorAll",
+      JS_NewCFunction(ctx, js_shadow_querySelectorAll, "querySelectorAll", 1));
+
+  JS_SetClassProto(ctx, js_shadow_root_class_id, proto);
+  JSValue shadow_proto_ref = JS_GetClassProto(ctx, js_shadow_root_class_id);
+  JS_FreeValue(ctx, define_global_constructor(ctx, "ShadowRoot", shadow_proto_ref));
+  JS_FreeValue(ctx, shadow_proto_ref);
+
+  JSValue element_proto = JS_GetClassProto(ctx, js_element_class_id);
+  JS_SetPropertyStr(ctx, element_proto, "attachShadow",
+      JS_NewCFunction(ctx, js_el_attachShadow, "attachShadow", 1));
+  define_prop(ctx, element_proto, "shadowRoot", js_el_get_shadowRoot, nullptr);
+  JS_FreeValue(ctx, element_proto);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/ShadowRootBindings.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers the ShadowRoot class (host/mode/innerHTML/querySelector(All),
+// plus Node-proto methods like appendChild/childNodes via prototype chain)
+// and Element.prototype.attachShadow()/shadowRoot.
+//
+// A ShadowRoot wraps a real lxb_dom_shadow_root_t*, which embeds a
+// lxb_dom_document_fragment_t as its first member — so it shares the
+// document fragment's node-tree layout, and generic Node methods work on it
+// unmodified. Lexbor has no attachShadow-equivalent linking a host element
+// to its shadow root, so that association is tracked in
+// RuntimeContext::element_shadow_roots.
+//
+// No slotting/encapsulation/event retargeting — this models just enough of
+// Shadow DOM for scripts that create/query/populate a scoped subtree.
+//
+// Must run after ElementBindings (globalThis.Element, js_node_class_id's
+// proto) and DOMExceptionBindings (NotSupportedError on double-attach).
+struct ShadowRootBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/SlotBindings.cpp

@@ -0,0 +1,161 @@
+#include "SlotBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kSlotBootstrapScript = R"JS(
+(function() {
+  function isSlotElement(el) {
+    return !!el && el.tagName === 'SLOT';
+  }
+
+  // Elements can carry a slot="..." attribute; anything else (text nodes,
+  // elements without the attribute) is assigned to the default slot ("").
+  function effectiveSlotName(node) {
+    if (node && node.nodeType === 1 && typeof node.getAttribute === 'function') {
+      return node.getAttribute('slot') || '';
+    }
+    return '';
+  }
+
+  // Walks up from a node living INSIDE a shadow tree (e.g. a <slot>) to find
+  // its containing ShadowRoot.
+  function containingShadowRoot(node) {
+    var n = node ? node.parentNode : null;
+    while (n) {
+      if (n instanceof ShadowRoot) return n;
+      n = n.parentNode;
+    }
+    return null;
+  }
+
+  // For a light-DOM child of some shadow host, returns that host's shadow
+  // root (or null if its parent has none / it's closed-mode).
+  function hostShadowRootFor(node) {
+    var parent = node ? node.parentNode : null;
+    return (parent && parent.shadowRoot) ? parent.shadowRoot : null;
+  }
+
+  function slotName(slotEl) {
+    return slotEl.getAttribute('name') || '';
+  }
+
+  // Nodes assigned to `slotEl`: light-DOM children of the shadow root's host
+  // whose effective slot name matches this slot's name, in host child order.
+  function computeAssigned(slotEl) {
+    var root = containingShadowRoot(slotEl);
+    if (!root) return [];
+    var host = root.host;
+    if (!host) return [];
+    var name = slotName(slotEl);
+    var result = [];
+    var child = host.firstChild;
+    while (child) {
+      if (effectiveSlotName(child) === name) result.push(child);
+      child = child.nextSibling;
+    }
+    return result;
+  }
+
+  Element.prototype.assignedNodes = function(options) {
+    if (!isSlotElement(this)) return [];
+    var assigned = computeAssigned(this);
+    if (assigned.length === 0 && options && options.flatten) {
+      var fallback = [];
+      var c = this.firstChild;
+      while (c) { fallback.push(c); c = c.nextSibling; }
+      return fallback;
+    }
+    return assigned;
+  };
+
+  Element.prototype.assignedElements = function(options) {
+    return this.assignedNodes(options).filter(function(n) { return n.nodeType === 1; });
+  };
+
+  // ── slotchange (best-effort — see SlotBindings.hpp for exact triggers) ────
+
+  function sameAssignment(a, b) {
+    if (a.length !== b.length) return false;
+    for (var i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+    return true;
+  }
+
+  function notifySlotChange(root) {
+    if (!root || typeof root.querySelectorAll !== 'function') return;
+    var slots = root.querySelectorAll('slot');
+    for (var i = 0; i < slots.length; i++) {
+      var slot = slots[i];
+      var next = computeAssigned(slot);
+      var prev = slot.__slotAssigned || [];
+      if (!sameAssignment(prev, next)) {
+        slot.__slotAssigned = next;
+        slot.dispatchEvent(new Event('slotchange', { bubbles: true }));
+      }
+    }
+  }
+
+  var origAppendChild = Node.prototype.appendChild;
+  Node.prototype.appendChild = function(child) {
+    var result = origAppendChild.call(this, child);
+    if (this.shadowRoot) notifySlotChange(this.shadowRoot);
+    return result;
+  };
+
+  var origRemoveChild = Node.prototype.removeChild;
+  Node.prototype.removeChild = function(child) {
+    var result = origRemoveChild.call(this, child);
+    if (this.shadowRoot) notifySlotChange(this.shadowRoot);
+    return result;
+  };
+
+  var origSetAttribute = Element.prototype.setAttribute;
+  Element.prototype.setAttribute = function(name, value) {
+    var result = origSetAttribute.call(this, name, value);
+    if (String(name).toLowerCase() === 'slot') {
+      var root = hostShadowRootFor(this);
+      if (root) notifySlotChange(root);
+    }
+    return result;
+  };
+
+  var origRemoveAttribute = Element.prototype.removeAttribute;
+  Element.prototype.removeAttribute = function(name) {
+    var result = origRemoveAttribute.call(this, name);
+    if (String(name).toLowerCase() === 'slot') {
+      var root = hostShadowRootFor(this);
+      if (root) notifySlotChange(root);
+    }
+    return result;
+  };
+
+  var shadowInnerHTMLDesc = Object.getOwnPropertyDescriptor(ShadowRoot.prototype, 'innerHTML');
+  if (shadowInnerHTMLDesc && shadowInnerHTMLDesc.set) {
+    var origShadowInnerHTMLSet = shadowInnerHTMLDesc.set;
+    Object.defineProperty(ShadowRoot.prototype, 'innerHTML', {
+      get: shadowInnerHTMLDesc.get,
+      set: function(html) {
+        origShadowInnerHTMLSet.call(this, html);
+        notifySlotChange(this);
+      },
+      enumerable: shadowInnerHTMLDesc.enumerable,
+      configurable: true,
+    });
+  }
+})();
+)JS";
+
+} // namespace
+
+void SlotBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kSlotBootstrapScript, strlen(kSlotBootstrapScript),
+                            "<slot-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/SlotBindings.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers <slot> assignment: Element.prototype.assignedNodes/
+// assignedElements (tag-checked for "slot"), and a best-effort `slotchange`
+// event. Pure JS, built entirely on top of already-exposed primitives
+// (querySelectorAll, childNodes/parentNode, Element.prototype.shadowRoot,
+// setAttribute/removeAttribute, ShadowRoot.prototype.innerHTML) via
+// monkey-patching — Lexbor itself has no slot concept at all.
+//
+// Assignment algorithm: a light-DOM child of a shadow host is assigned to
+// the <slot> (inside that host's shadow tree) whose `name` matches the
+// child's `slot` attribute (or the unnamed/default slot, if the child has
+// none), computed on demand from the live tree — never cached/stale.
+//
+// Scope/limitations (documented rather than silently wrong):
+// - Does not implement the "first slot with a given name wins" tie-break for
+//   shadow trees with duplicate slot names — assumes one slot per name.
+// - assignedNodes({flatten}) falls back to the slot's own light-DOM children
+//   (its fallback content) when it has no real assignment; it does not
+//   recursively flatten nested slots-inside-slots.
+// - slotchange fires (best-effort, comparing each slot's previous vs.
+//   recomputed assignment) on: host.appendChild()/removeChild(), a
+//   light-DOM child's `slot` attribute changing via setAttribute/
+//   removeAttribute, and ShadowRoot.innerHTML assignment (covers newly
+//   added <slot> elements getting their first, non-empty assignment — the
+//   common attachShadow-then-populate pattern). NOT covered: before/after/
+//   replaceWith/append/prepend on the host, or mutating the shadow tree
+//   itself via appendChild/removeChild on the ShadowRoot directly.
+// - Only reaches shadow roots visible via the public (mode-agnostic-for-us)
+//   Element.prototype.shadowRoot getter, so a *closed*-mode shadow host
+//   won't trigger slotchange from its light-DOM child mutations (the getter
+//   returns null for closed mode by spec) — assignedNodes()/assignedElements()
+//   on the <slot> itself are unaffected and still compute correctly.
+//
+// Must run after ElementBindings, EventBindings, and ShadowRootBindings.
+struct SlotBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/TemplateBindings.cpp

@@ -0,0 +1,42 @@
+#include "TemplateBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../../lexbor/LexborDocument.hpp"
+#include <lexbor/dom/dom.h>
+#include <cstring>
+#include <cctype>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+bool is_template_element(lxb_dom_element_t* el) {
+  size_t len = 0;
+  const lxb_char_t* name = lxb_dom_element_local_name(el, &len);
+  if (!name || len != 8) return false;
+  for (size_t i = 0; i < len; i++) {
+    if (std::tolower(name[i]) != "template"[i]) return false;
+  }
+  return true;
+}
+
+JSValue js_el_get_content(JSContext* ctx, JSValue this_val) {
+  auto* el = unwrap_element(ctx, this_val);
+  if (!el || !is_template_element(el)) return JS_UNDEFINED;
+  return make_element(ctx, get_doc(ctx)->templateContent(el));
+}
+
+} // namespace
+
+void TemplateBindings::install(JSContext* ctx) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue element_ctor = JS_GetPropertyStr(ctx, global, "Element");
+  JSValue element_proto = JS_GetPropertyStr(ctx, element_ctor, "prototype");
+
+  define_prop(ctx, element_proto, "content", js_el_get_content, nullptr);
+
+  JS_FreeValue(ctx, element_proto);
+  JS_FreeValue(ctx, element_ctor);
+  JS_FreeValue(ctx, global);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/TemplateBindings.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers a `content` getter on Element.prototype, tag-checked for
+// "template" internally (mirroring FormBindings' tag-check pattern) —
+// returns the lxb_dom_document_fragment_t Lexbor already allocates as
+// lxb_html_template_element_t::content, for both parsed and
+// document.createElement()'d <template> elements. No custom parsing logic:
+// Lexbor's own HTML5 tree constructor already redirects a parsed
+// <template>'s children into that fragment instead of the template's own
+// light-DOM children (see packages/lexbor/.../tree/insertion_mode/in_template.c).
+// LexborDocument::setInnerHTMLOnEl() mirrors that for template.innerHTML=.
+//
+// Scope: the returned fragment is a generic Node wrapper (like
+// document.createDocumentFragment()), so it has childNodes/appendChild/etc.
+// but not querySelector(All) — same limitation createDocumentFragment()
+// already has. cloneNode() on a <template> does not specially deep-clone
+// `.content` (relies on Lexbor's own node clone, not verified against spec
+// for this case) — undocumented/untested edge case, not the golden path.
+//
+// Must run after ElementBindings (globalThis.Element, unwrap_element).
+struct TemplateBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/TextEncodingBindings.cpp

@@ -0,0 +1,117 @@
+#include "TextEncodingBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kTextEncodingBootstrapScript = R"JS(
+(function() {
+  function TextEncoder() {
+    this.encoding = 'utf-8';
+  }
+  TextEncoder.prototype.encode = function(input) {
+    var str = String(input === undefined ? '' : input);
+    var bytes = [];
+    for (var i = 0; i < str.length; i++) {
+      var code = str.charCodeAt(i);
+      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < str.length) {
+        var next = str.charCodeAt(i + 1);
+        if (next >= 0xDC00 && next <= 0xDFFF) {
+          code = ((code - 0xD800) << 10) + (next - 0xDC00) + 0x10000;
+          i++;
+        }
+      }
+      if (code < 0x80) {
+        bytes.push(code);
+      } else if (code < 0x800) {
+        bytes.push(0xC0 | (code >> 6), 0x80 | (code & 0x3F));
+      } else if (code < 0x10000) {
+        bytes.push(0xE0 | (code >> 12), 0x80 | ((code >> 6) & 0x3F), 0x80 | (code & 0x3F));
+      } else {
+        bytes.push(
+          0xF0 | (code >> 18),
+          0x80 | ((code >> 12) & 0x3F),
+          0x80 | ((code >> 6) & 0x3F),
+          0x80 | (code & 0x3F)
+        );
+      }
+    }
+    return new Uint8Array(bytes);
+  };
+  TextEncoder.prototype.encodeInto = function(input, dest) {
+    var encoded = this.encode(input);
+    var written = Math.min(encoded.length, dest.length);
+    for (var i = 0; i < written; i++) dest[i] = encoded[i];
+    return { read: written === encoded.length ? String(input).length : written, written: written };
+  };
+
+  function TextDecoder(label, options) {
+    this.encoding = label ? String(label).toLowerCase() : 'utf-8';
+    this.fatal = !!(options && options.fatal);
+    this.ignoreBOM = !!(options && options.ignoreBOM);
+  }
+  TextDecoder.prototype.decode = function(input) {
+    var bytes;
+    if (input === undefined) {
+      bytes = new Uint8Array(0);
+    } else if (input instanceof ArrayBuffer) {
+      bytes = new Uint8Array(input);
+    } else if (input && input.buffer !== undefined) {
+      bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    } else {
+      bytes = new Uint8Array(0);
+    }
+
+    var result = '';
+    var i = 0;
+    while (i < bytes.length) {
+      var b0 = bytes[i];
+      var codepoint, len;
+      if (b0 < 0x80) { codepoint = b0; len = 1; }
+      else if ((b0 & 0xE0) === 0xC0) { codepoint = b0 & 0x1F; len = 2; }
+      else if ((b0 & 0xF0) === 0xE0) { codepoint = b0 & 0x0F; len = 3; }
+      else if ((b0 & 0xF8) === 0xF0) { codepoint = b0 & 0x07; len = 4; }
+      else {
+        if (this.fatal) throw new TypeError('The encoded data was not valid UTF-8.');
+        result += '�';
+        i++;
+        continue;
+      }
+      if (i + len > bytes.length) {
+        if (this.fatal) throw new TypeError('The encoded data was not valid UTF-8.');
+        result += '�';
+        break;
+      }
+      for (var k = 1; k < len; k++) {
+        codepoint = (codepoint << 6) | (bytes[i + k] & 0x3F);
+      }
+      if (codepoint > 0xFFFF) {
+        codepoint -= 0x10000;
+        result += String.fromCharCode(0xD800 + (codepoint >> 10), 0xDC00 + (codepoint & 0x3FF));
+      } else {
+        result += String.fromCharCode(codepoint);
+      }
+      i += len;
+    }
+    if (!this.ignoreBOM && result.charCodeAt(0) === 0xFEFF) result = result.slice(1);
+    return result;
+  };
+
+  globalThis.TextEncoder = TextEncoder;
+  globalThis.TextDecoder = TextDecoder;
+})();
+)JS";
+
+} // namespace
+
+void TextEncodingBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kTextEncodingBootstrapScript, strlen(kTextEncodingBootstrapScript),
+                            "<text-encoding-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/TextEncodingBindings.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers globalThis.TextEncoder/TextDecoder (UTF-8 only — the vast
+// majority of real-world usage — implemented in pure JS since encoding a
+// JS string's UTF-16 code units to UTF-8 bytes needs no native primitive).
+struct TextEncodingBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/TimerBindings.cpp

@@ -2,6 +2,7 @@
 #include "../DOMBindingsInternal.hpp"
 #include "../QuickJSRuntime.hpp"
 #include <chrono>
+#include <cstring>
 
 namespace margelo::nitro::nitrojsdom {
 
@@ -12,6 +13,17 @@ int64_t dom_now_ms() {
   return duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
 }
 
+double dom_now_high_res_ms() {
+  using namespace std::chrono;
+  return duration<double, std::milli>(steady_clock::now().time_since_epoch()).count();
+}
+
+JSValue js_native_now_ms(JSContext* ctx, JSValue, int, JSValue*) {
+  auto* rctx = get_ctx(ctx);
+  double origin = rctx ? rctx->time_origin_ms : 0.0;
+  return JS_NewFloat64(ctx, dom_now_high_res_ms() - origin);
+}
+
 JSValue js_setTimeout(JSContext* ctx, JSValue, int argc, JSValue* argv) {
   if (argc < 1 || !JS_IsFunction(ctx, argv[0])) return JS_NewInt32(ctx, 0);
   auto* rctx = get_ctx(ctx);
@@ -80,15 +92,44 @@ JSValue js_clearTimer(JSContext* ctx, JSValue, int argc, JSValue* argv) {
   return JS_UNDEFINED;
 }
 
+const char* kTimerBootstrapScript = R"JS(
+(function() {
+  globalThis.performance = globalThis.performance || {};
+  globalThis.performance.now = function() { return __nativeNowMs(); };
+
+  globalThis.requestAnimationFrame = function(callback) {
+    return setTimeout(function() { callback(performance.now()); }, 16);
+  };
+  globalThis.cancelAnimationFrame = function(id) {
+    clearTimeout(id);
+  };
+
+  globalThis.queueMicrotask = function(callback) {
+    Promise.resolve().then(function() { callback(); });
+  };
+})();
+)JS";
+
 } // namespace
 
 void TimerBindings::install(JSContext* ctx) {
+  auto* rctx = get_ctx(ctx);
+  if (rctx) rctx->time_origin_ms = dom_now_high_res_ms();
+
   JSValue global = JS_GetGlobalObject(ctx);
   JS_SetPropertyStr(ctx, global, "setTimeout",    JS_NewCFunction(ctx, js_setTimeout,  "setTimeout",   2));
   JS_SetPropertyStr(ctx, global, "setInterval",   JS_NewCFunction(ctx, js_setInterval, "setInterval",  2));
   JS_SetPropertyStr(ctx, global, "clearTimeout",  JS_NewCFunction(ctx, js_clearTimer,  "clearTimeout", 1));
   JS_SetPropertyStr(ctx, global, "clearInterval", JS_NewCFunction(ctx, js_clearTimer,  "clearInterval",1));
+  JS_SetPropertyStr(ctx, global, "__nativeNowMs", JS_NewCFunction(ctx, js_native_now_ms, "__nativeNowMs", 0));
   JS_FreeValue(ctx, global);
+
+  JSValue result = JS_Eval(ctx, kTimerBootstrapScript, strlen(kTimerBootstrapScript),
+                            "<timer-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
 }
 
 } // namespace margelo::nitro::nitrojsdom