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

package/cpp/quickjs/bindings/IntlBindings.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers a pure-JS globalThis.Intl.NumberFormat/DateTimeFormat/
+// PluralRules/RelativeTimeFormat (no ICU — QuickJS ships none). Locale data
+// is a small hand-built table (en + pt, the two this project's users
+// actually need), not real CLDR data. Also rewires Number.prototype.
+// toLocaleString and Date.prototype.toLocaleString/toLocaleDateString/
+// toLocaleTimeString to go through these instead of QuickJS's own
+// locale-blind built-ins.
+//
+// RelativeTimeFormat's `style` option ('long'/'short'/'narrow') is accepted
+// but 'short'/'narrow' render identically to 'long' — there's no abbreviated
+// unit-name table, same trade-off DateTimeFormat already made collapsing
+// timeStyle 'long'/'full'. `numeric: 'auto'` only has special phrasing
+// ("yesterday", "next week", ..., plus "now"/"agora" for second: 0) for
+// day/week/month/year/second — hour/minute/quarter always render
+// numerically, matching real Intl's own behavior for units without a
+// natural auto phrase. Auto phrasing only ever applies to exact supported
+// integer values (e.g. -1/0/1) — a fractional value like 1.2 always falls
+// through to numeric formatting rather than rounding into a phrase.
+struct IntlBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/LayoutStubBindings.cpp

@@ -0,0 +1,104 @@
+#include "LayoutStubBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kLayoutStubBootstrapScript = R"JS(
+(function() {
+  function definePositiveInt(proto, name) {
+    Object.defineProperty(proto, name, { get: function() { return 0; }, configurable: true });
+  }
+
+  // ── offset*/client*/scroll* dimensions ────────────────────────────────
+  ['offsetWidth', 'offsetHeight', 'offsetTop', 'offsetLeft',
+   'clientWidth', 'clientHeight', 'clientTop', 'clientLeft',
+   'scrollWidth', 'scrollHeight'].forEach(function(name) {
+    definePositiveInt(Element.prototype, name);
+  });
+  Object.defineProperty(Element.prototype, 'offsetParent', {
+    get: function() { return null; },
+    configurable: true,
+  });
+
+  // scrollTop/scrollLeft are real per-element state (jsdom does the same) —
+  // nothing reads them back to affect layout, but round-tripping a value a
+  // script just set is more useful than hardcoding 0.
+  Object.defineProperty(Element.prototype, 'scrollTop', {
+    get: function() { return this._scrollTop || 0; },
+    set: function(v) { this._scrollTop = Number(v) || 0; },
+    configurable: true,
+  });
+  Object.defineProperty(Element.prototype, 'scrollLeft', {
+    get: function() { return this._scrollLeft || 0; },
+    set: function(v) { this._scrollLeft = Number(v) || 0; },
+    configurable: true,
+  });
+
+  // ── scrollIntoView / scrollTo / scrollBy / scroll ─────────────────────
+  Element.prototype.scrollIntoView = function() {};
+  Element.prototype.scrollTo = function() {};
+  Element.prototype.scrollBy = function() {};
+  Element.prototype.scroll = function() {};
+
+  globalThis.scrollX = 0;
+  globalThis.scrollY = 0;
+  globalThis.pageXOffset = 0;
+  globalThis.pageYOffset = 0;
+  globalThis.scrollTo = function() {};
+  globalThis.scrollBy = function() {};
+  globalThis.scroll = function() {};
+
+  // ── document.elementFromPoint / elementsFromPoint ─────────────────────
+  document.elementFromPoint = function() { return null; };
+  document.elementsFromPoint = function() { return []; };
+
+  // ── ResizeObserver / IntersectionObserver ─────────────────────────────
+  function ResizeObserver(callback) {
+    if (typeof callback !== 'function') {
+      throw new TypeError("Failed to construct 'ResizeObserver': parameter 1 is not a function.");
+    }
+    this._callback = callback;
+  }
+  ResizeObserver.prototype.observe = function() {};
+  ResizeObserver.prototype.unobserve = function() {};
+  ResizeObserver.prototype.disconnect = function() {};
+  globalThis.ResizeObserver = ResizeObserver;
+
+  function normalizeThreshold(threshold) {
+    if (threshold === undefined) return [0];
+    var arr = Array.isArray(threshold) ? threshold.slice() : [threshold];
+    return arr.length ? arr : [0];
+  }
+
+  function IntersectionObserver(callback, options) {
+    if (typeof callback !== 'function') {
+      throw new TypeError("Failed to construct 'IntersectionObserver': parameter 1 is not a function.");
+    }
+    options = options || {};
+    this._callback = callback;
+    this.root = options.root || null;
+    this.rootMargin = options.rootMargin || '0px';
+    this.thresholds = normalizeThreshold(options.threshold);
+  }
+  IntersectionObserver.prototype.observe = function() {};
+  IntersectionObserver.prototype.unobserve = function() {};
+  IntersectionObserver.prototype.disconnect = function() {};
+  IntersectionObserver.prototype.takeRecords = function() { return []; };
+  globalThis.IntersectionObserver = IntersectionObserver;
+})();
+)JS";
+
+} // namespace
+
+void LayoutStubBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kLayoutStubBootstrapScript, strlen(kLayoutStubBootstrapScript),
+                            "<layout-stub-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/LayoutStubBindings.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+// No layout/rendering engine backs this sandbox, so every geometry- and
+// scroll-related API here is an inert stub rather than a real computation —
+// same stance as CSSOMBindings' getComputedStyle and ElementBindings'
+// getBoundingClientRect (both already all-zero without a cascade/layout
+// pass). This file covers the rest of that surface: scrollIntoView/scrollTo/
+// scrollBy/scroll (no-ops), offset*/client*/scroll* dimensions (0, except
+// scrollTop/scrollLeft which are real per-element state — jsdom does the
+// same), document.elementFromPoint/elementsFromPoint (null/[]), and
+// ResizeObserver/IntersectionObserver (constructible, observe()/unobserve()/
+// disconnect() no-op, callback never fires). jsdom itself doesn't expose
+// Resize/IntersectionObserver at all; this project adds them as defensive
+// "don't throw ReferenceError" stubs instead, matching the precedent set by
+// window.history/window.getSelection().
+//
+// Must run after ElementBindings (globalThis.Element) and DocumentBindings
+// (globalThis.document).
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+struct LayoutStubBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/LiveCollectionBindings.cpp

@@ -138,6 +138,51 @@ const char* kIteratorBootstrapScript = R"JS(
       }
     };
   };
+
+  proto.forEach = function(callback, thisArg) {
+    for (var i = 0; i < this.length; i++) callback.call(thisArg, this[i], i, this);
+  };
+
+  function arrayLikeIterator(self, mapEntry) {
+    var i = 0;
+    return {
+      next: function() {
+        if (i >= self.length) return { value: undefined, done: true };
+        var value = mapEntry(i, self[i]);
+        i++;
+        return { value: value, done: false };
+      },
+      [Symbol.iterator]: function() { return this; },
+    };
+  }
+
+  proto.entries = function() {
+    return arrayLikeIterator(this, function(i, v) { return [i, v]; });
+  };
+  proto.keys = function() {
+    return arrayLikeIterator(this, function(i) { return i; });
+  };
+  proto.values = function() {
+    return arrayLikeIterator(this, function(i, v) { return v; });
+  };
+
+  proto.item = function(index) {
+    return index >= 0 && index < this.length ? this[index] : null;
+  };
+
+  // namedItem() is spec'd on HTMLCollection only (matches by id, then by
+  // name), not NodeList — but both share this one LiveCollection class (see
+  // the forEach() comment above), so this stays a no-op-safe lookup for
+  // NodeLists of non-Elements (text/comment nodes have no getAttribute).
+  proto.namedItem = function(name) {
+    for (var i = 0; i < this.length; i++) {
+      var item = this[i];
+      if (typeof item.getAttribute !== 'function') continue;
+      if (item.getAttribute('id') === name || item.getAttribute('name') === name) return item;
+    }
+    return null;
+  };
+
   delete globalThis.__LiveCollectionProto;
 })();
 )JS";

package/cpp/quickjs/bindings/TimerBindings.cpp

@@ -107,6 +107,85 @@ const char* kTimerBootstrapScript = R"JS(
   globalThis.queueMicrotask = function(callback) {
     Promise.resolve().then(function() { callback(); });
   };
+
+  globalThis.requestIdleCallback = function(callback, options) {
+    var timeout = options && options.timeout;
+    return setTimeout(function() {
+      callback({
+        didTimeout: false,
+        timeRemaining: function() { return 50; },
+      });
+    }, typeof timeout === 'number' ? Math.min(timeout, 1) : 1);
+  };
+  globalThis.cancelIdleCallback = function(id) {
+    clearTimeout(id);
+  };
+
+  var __perfEntries = [];
+  function __perfFindMark(name) {
+    for (var i = __perfEntries.length - 1; i >= 0; i--) {
+      if (__perfEntries[i].name === name && __perfEntries[i].entryType === 'mark') return __perfEntries[i];
+    }
+    return null;
+  }
+  function __perfRequireMark(name) {
+    var entry = __perfFindMark(name);
+    if (!entry) {
+      throw new DOMException(
+        "Failed to execute 'measure' on 'Performance': The mark '" + name + "' does not exist.", 'SyntaxError');
+    }
+    return entry.startTime;
+  }
+  performance.mark = function(name, options) {
+    var entry = {
+      name: String(name),
+      entryType: 'mark',
+      startTime: (options && options.startTime !== undefined) ? options.startTime : performance.now(),
+      duration: 0,
+      detail: (options && options.detail !== undefined) ? options.detail : null,
+    };
+    __perfEntries.push(entry);
+    return entry;
+  };
+  performance.measure = function(name, startOrOptions, endMark) {
+    var startTime = 0;
+    var endTime = performance.now();
+    var detail = null;
+    if (typeof startOrOptions === 'string') {
+      startTime = __perfRequireMark(startOrOptions);
+      if (endMark !== undefined) endTime = __perfRequireMark(endMark);
+    } else if (startOrOptions && typeof startOrOptions === 'object') {
+      if (startOrOptions.detail !== undefined) detail = startOrOptions.detail;
+      if (startOrOptions.start !== undefined) {
+        startTime = typeof startOrOptions.start === 'string' ? __perfRequireMark(startOrOptions.start) : startOrOptions.start;
+      }
+      if (startOrOptions.end !== undefined) {
+        endTime = typeof startOrOptions.end === 'string' ? __perfRequireMark(startOrOptions.end) : startOrOptions.end;
+      } else if (startOrOptions.duration !== undefined) {
+        endTime = startTime + startOrOptions.duration;
+      }
+    }
+    var entry = { name: String(name), entryType: 'measure', startTime: startTime, duration: endTime - startTime, detail: detail };
+    __perfEntries.push(entry);
+    return entry;
+  };
+  performance.getEntries = function() { return __perfEntries.slice(); };
+  performance.getEntriesByType = function(type) {
+    return __perfEntries.filter(function(e) { return e.entryType === type; });
+  };
+  performance.getEntriesByName = function(name, type) {
+    return __perfEntries.filter(function(e) { return e.name === name && (!type || e.entryType === type); });
+  };
+  performance.clearMarks = function(name) {
+    __perfEntries = __perfEntries.filter(function(e) {
+      return e.entryType !== 'mark' || (name !== undefined && e.name !== name);
+    });
+  };
+  performance.clearMeasures = function(name) {
+    __perfEntries = __perfEntries.filter(function(e) {
+      return e.entryType !== 'measure' || (name !== undefined && e.name !== name);
+    });
+  };
 })();
 )JS";
 

package/cpp/quickjs/bindings/TreeWalkerBindings.cpp

@@ -0,0 +1,306 @@
+#include "TreeWalkerBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kTreeWalkerBootstrapScript = R"JS(
+(function() {
+  var FILTER_ACCEPT = 1, FILTER_REJECT = 2, FILTER_SKIP = 3;
+
+  var NodeFilter = {
+    FILTER_ACCEPT: FILTER_ACCEPT,
+    FILTER_REJECT: FILTER_REJECT,
+    FILTER_SKIP: FILTER_SKIP,
+    SHOW_ALL: 0xFFFFFFFF,
+    SHOW_ELEMENT: 0x1,
+    SHOW_ATTRIBUTE: 0x2,
+    SHOW_TEXT: 0x4,
+    SHOW_CDATA_SECTION: 0x8,
+    SHOW_ENTITY_REFERENCE: 0x10,
+    SHOW_ENTITY: 0x20,
+    SHOW_PROCESSING_INSTRUCTION: 0x40,
+    SHOW_COMMENT: 0x80,
+    SHOW_DOCUMENT: 0x100,
+    SHOW_DOCUMENT_TYPE: 0x200,
+    SHOW_DOCUMENT_FRAGMENT: 0x400,
+    SHOW_NOTATION: 0x800,
+  };
+  globalThis.NodeFilter = NodeFilter;
+
+  function normalizeFilter(filter) {
+    if (filter === undefined || filter === null) return null;
+    if (typeof filter === 'function') return filter;
+    if (typeof filter.acceptNode === 'function') {
+      return function(node) { return filter.acceptNode(node); };
+    }
+    return null;
+  }
+
+  // Shared by TreeWalker and NodeIterator — both store whatToShow/_filterFn/
+  // _active the same way, so this reads `this` structurally rather than
+  // needing a common base class.
+  function applyFilter(walker, node) {
+    if (walker._active) {
+      throw new DOMException('Recursive node filtering', 'InvalidStateError');
+    }
+    var n = node.nodeType - 1;
+    if (!((1 << n) & walker.whatToShow)) return FILTER_SKIP;
+    if (walker._filterFn === null) return FILTER_ACCEPT;
+    walker._active = true;
+    var result;
+    try {
+      result = walker._filterFn(node);
+    } finally {
+      walker._active = false;
+    }
+    return result;
+  }
+
+  // ── TreeWalker ───────────────────────────────────────────────────────
+  // Ported from jsdom's TreeWalker-impl.js — see header comment.
+
+  function TreeWalker(root, whatToShow, filter) {
+    this.root = root;
+    this.whatToShow = whatToShow === undefined ? NodeFilter.SHOW_ALL : (whatToShow >>> 0);
+    this.filter = filter === undefined ? null : filter;
+    this._filterFn = normalizeFilter(filter);
+    this._active = false;
+    this._currentNode = root;
+  }
+  Object.defineProperty(TreeWalker.prototype, 'currentNode', {
+    get: function() { return this._currentNode; },
+    set: function(node) {
+      if (node === null || node === undefined) {
+        throw new DOMException('Cannot set currentNode to null', 'NotSupportedError');
+      }
+      this._currentNode = node;
+    },
+    enumerable: true,
+  });
+
+  TreeWalker.prototype.parentNode = function() {
+    var node = this._currentNode;
+    while (node !== null && node !== this.root) {
+      node = node.parentNode;
+      if (node !== null && applyFilter(this, node) === FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+    }
+    return null;
+  };
+
+  function traverseChildren(walker, forward) {
+    var node = walker._currentNode;
+    node = forward ? node.firstChild : node.lastChild;
+    if (node === null) return null;
+
+    mainLoop:
+    for (;;) {
+      var result = applyFilter(walker, node);
+      if (result === FILTER_ACCEPT) {
+        walker._currentNode = node;
+        return node;
+      }
+      if (result === FILTER_SKIP) {
+        var child = forward ? node.firstChild : node.lastChild;
+        if (child !== null) { node = child; continue mainLoop; }
+      }
+      for (;;) {
+        var sibling = forward ? node.nextSibling : node.previousSibling;
+        if (sibling !== null) { node = sibling; continue mainLoop; }
+        var parent = node.parentNode;
+        if (parent === null || parent === walker.root || parent === walker._currentNode) return null;
+        node = parent;
+      }
+    }
+  }
+  TreeWalker.prototype.firstChild = function() { return traverseChildren(this, true); };
+  TreeWalker.prototype.lastChild = function() { return traverseChildren(this, false); };
+
+  function traverseSiblings(walker, forward) {
+    var node = walker._currentNode;
+    if (node === walker.root) return null;
+
+    for (;;) {
+      var sibling = forward ? node.nextSibling : node.previousSibling;
+      while (sibling !== null) {
+        node = sibling;
+        var result = applyFilter(walker, node);
+        if (result === FILTER_ACCEPT) {
+          walker._currentNode = node;
+          return node;
+        }
+        sibling = forward ? node.firstChild : node.lastChild;
+        if (result === FILTER_REJECT || sibling === null) {
+          sibling = forward ? node.nextSibling : node.previousSibling;
+        }
+      }
+      node = node.parentNode;
+      if (node === null || node === walker.root) return null;
+      if (applyFilter(walker, node) === FILTER_ACCEPT) return null;
+    }
+  }
+  TreeWalker.prototype.previousSibling = function() { return traverseSiblings(this, false); };
+  TreeWalker.prototype.nextSibling = function() { return traverseSiblings(this, true); };
+
+  TreeWalker.prototype.previousNode = function() {
+    var node = this._currentNode;
+    while (node !== this.root) {
+      var sibling = node.previousSibling;
+      while (sibling !== null) {
+        node = sibling;
+        var result = applyFilter(this, node);
+        while (result !== FILTER_REJECT && node.firstChild !== null) {
+          node = node.lastChild;
+          result = applyFilter(this, node);
+        }
+        if (result === FILTER_ACCEPT) {
+          this._currentNode = node;
+          return node;
+        }
+        sibling = node.previousSibling;
+      }
+      if (node === this.root || node.parentNode === null) return null;
+      node = node.parentNode;
+      if (applyFilter(this, node) === FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+    }
+    return null;
+  };
+
+  TreeWalker.prototype.nextNode = function() {
+    var node = this._currentNode;
+    var result = FILTER_ACCEPT;
+    for (;;) {
+      while (result !== FILTER_REJECT && node.firstChild !== null) {
+        node = node.firstChild;
+        result = applyFilter(this, node);
+        if (result === FILTER_ACCEPT) {
+          this._currentNode = node;
+          return node;
+        }
+      }
+      var sibling = null;
+      do {
+        if (node === this.root) return null;
+        sibling = node.nextSibling;
+        if (sibling !== null) { node = sibling; break; }
+        node = node.parentNode;
+      } while (node !== null);
+      if (node === null) return null;
+      result = applyFilter(this, node);
+      if (result === FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+    }
+  };
+
+  globalThis.TreeWalker = TreeWalker;
+
+  // ── NodeIterator ─────────────────────────────────────────────────────
+  // Ported from jsdom's NodeIterator-impl.js, with domSymbolTree.following()/
+  // preceding() replaced by direct tree-order walks over the same node
+  // properties TreeWalker uses.
+
+  function followingNode(node, root) {
+    if (node.firstChild !== null) return node.firstChild;
+    var cur = node;
+    while (cur !== null && cur !== root) {
+      if (cur.nextSibling !== null) return cur.nextSibling;
+      cur = cur.parentNode;
+    }
+    return null;
+  }
+  function lastInclusiveDescendant(node) {
+    while (node.lastChild !== null) node = node.lastChild;
+    return node;
+  }
+  function precedingNode(node, root) {
+    if (node === root) return null;
+    var sibling = node.previousSibling;
+    if (sibling !== null) return lastInclusiveDescendant(sibling);
+    return node.parentNode;
+  }
+
+  function NodeIterator(root, whatToShow, filter) {
+    this.root = root;
+    this.whatToShow = whatToShow === undefined ? NodeFilter.SHOW_ALL : (whatToShow >>> 0);
+    this.filter = filter === undefined ? null : filter;
+    this._filterFn = normalizeFilter(filter);
+    this._active = false;
+    this._referenceNode = root;
+    this._pointerBeforeReferenceNode = true;
+  }
+  Object.defineProperty(NodeIterator.prototype, 'referenceNode', {
+    get: function() { return this._referenceNode; },
+    enumerable: true,
+  });
+  Object.defineProperty(NodeIterator.prototype, 'pointerBeforeReferenceNode', {
+    get: function() { return this._pointerBeforeReferenceNode; },
+    enumerable: true,
+  });
+
+  function iteratorTraverse(it, forward) {
+    var node = it._referenceNode;
+    var beforeNode = it._pointerBeforeReferenceNode;
+    for (;;) {
+      if (forward) {
+        if (!beforeNode) {
+          node = followingNode(node, it.root);
+          if (node === null) return null;
+        }
+        beforeNode = false;
+      } else {
+        if (beforeNode) {
+          node = precedingNode(node, it.root);
+          if (node === null) return null;
+        }
+        beforeNode = true;
+      }
+      if (applyFilter(it, node) === FILTER_ACCEPT) break;
+    }
+    it._referenceNode = node;
+    it._pointerBeforeReferenceNode = beforeNode;
+    return node;
+  }
+
+  NodeIterator.prototype.nextNode = function() { return iteratorTraverse(this, true); };
+  NodeIterator.prototype.previousNode = function() { return iteratorTraverse(this, false); };
+  NodeIterator.prototype.detach = function() {};
+
+  globalThis.NodeIterator = NodeIterator;
+
+  // ── document.createTreeWalker / createNodeIterator ──────────────────
+  document.createTreeWalker = function(root, whatToShow, filter) {
+    if (!(root instanceof Node)) {
+      throw new TypeError("Failed to execute 'createTreeWalker' on 'Document': parameter 1 is not of type 'Node'.");
+    }
+    return new TreeWalker(root, whatToShow, filter);
+  };
+  document.createNodeIterator = function(root, whatToShow, filter) {
+    if (!(root instanceof Node)) {
+      throw new TypeError("Failed to execute 'createNodeIterator' on 'Document': parameter 1 is not of type 'Node'.");
+    }
+    return new NodeIterator(root, whatToShow, filter);
+  };
+})();
+)JS";
+
+} // namespace
+
+void TreeWalkerBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kTreeWalkerBootstrapScript, strlen(kTreeWalkerBootstrapScript),
+                            "<tree-walker-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/TreeWalkerBindings.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+// NodeFilter, TreeWalker, NodeIterator, and document.createTreeWalker() /
+// createNodeIterator(). Pure JS on top of the Node traversal properties
+// ElementBindings already exposes (firstChild/lastChild/nextSibling/
+// previousSibling/parentNode/nodeType) — no Lexbor access needed.
+//
+// The traversal algorithms (TreeWalker.previousSibling()/nextSibling() in
+// particular — they can descend into an accepted-skip subtree looking for a
+// matching descendant, then ascend) are subtle enough that this is a direct
+// port of jsdom's TreeWalker-impl.js/NodeIterator-impl.js/helpers.js, not a
+// from-scratch implementation, to avoid a plausible-looking-but-wrong
+// backtracking bug. NodeIterator's `_referenceNode`/`_pointerBeforeReferenceNode`
+// walk uses simple tree-order successor/predecessor helpers here in place of
+// jsdom's domSymbolTree.following()/preceding() dependency.
+//
+// Must run after ElementBindings (globalThis.Element/Node) and
+// DocumentBindings (globalThis.document).
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+struct TreeWalkerBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/UrlBindings.cpp

@@ -268,7 +268,50 @@ const char* kUrlBootstrapScript = R"JS(
   URL.prototype.toString = function() { return this._href; };
   URL.prototype.toJSON = function() { return this._href; };
 
+  URL.canParse = function(url, base) {
+    try {
+      new URL(url, base);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  };
+
   globalThis.URL = URL;
+
+  function isAnchorElement(el) {
+    return !!el && (el.tagName === 'A' || el.tagName === 'AREA');
+  }
+
+  function anchorUrl(el) {
+    var raw = el.getAttribute('href');
+    if (raw === null) return null;
+    try { return new URL(raw, document.baseURI); } catch (e) { return null; }
+  }
+
+  Object.defineProperty(Element.prototype, 'href', {
+    configurable: true,
+    get: function() {
+      if (!isAnchorElement(this)) return undefined;
+      var u = anchorUrl(this);
+      return u ? u.href : '';
+    },
+    set: function(value) {
+      if (!isAnchorElement(this)) return;
+      this.setAttribute('href', String(value));
+    },
+  });
+
+  ['protocol', 'username', 'password', 'hostname', 'port', 'pathname', 'search', 'hash', 'host', 'origin'].forEach(function(part) {
+    Object.defineProperty(Element.prototype, part, {
+      configurable: true,
+      get: function() {
+        if (!isAnchorElement(this)) return undefined;
+        var u = anchorUrl(this);
+        return u ? u[part] : '';
+      },
+    });
+  });
 })();
 )JS";