@miaskiewicz/turbo-dom 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miaskiewicz/turbo-dom",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Faster, more spec-correct DOM for test runners — native html5ever (Rust/WASM) parser + lazy copy-on-write DOM. A drop-in-style alternative to jsdom/happy-dom for vitest & jest.",
   "license": "MIT",
   "main": "index.js",

package/src/runtime/dom.mjs

@@ -845,6 +845,13 @@ export class Element extends Node {
   hasAttributeNS(_ns, name) { return this.hasAttribute(name); }
   removeAttributeNS(_ns, name) { this.removeAttribute(name); }
   getAttributeNode(name) { const a = (this.__attrs ?? (this.__attrs = this.__buildAttrs())).find((x) => x.name === name); return a ? { name: a.name, value: a.value, ownerElement: this } : null; }
+  getAttributeNodeNS(_ns, name) { return this.getAttributeNode(name); }
+  // Attr-node methods are thin shims over the name-based API (no real Attr/NamedNodeMap).
+  // React 19's releaseSingletonInstance reads node.attributes (a detached array copy) then
+  // removeAttributeNode(attr)s each — safe because the iterated copy isn't __attrs.
+  setAttributeNode(attr) { const prev = this.getAttributeNode(attr.name); this.setAttribute(attr.name, attr.value); return prev; }
+  setAttributeNodeNS(attr) { return this.setAttributeNode(attr); }
+  removeAttributeNode(attr) { const removed = this.getAttributeNode(attr && attr.name); if (attr && attr.name != null) this.removeAttribute(attr.name); return removed; }
 
   // adjacency
   insertAdjacentElement(position, el) {

package/src/runtime/window.mjs

@@ -201,10 +201,49 @@ export function createWindow(document, { url = 'http://localhost/' } = {}) {
   };
 }
 
-import { performance as nodePerformance } from 'node:perf_hooks';
-function performanceNow() {
-  return nodePerformance.now();
-}
+// No static `node:` import — the runtime must load in a bare V8 isolate (no Node,
+// no web-platform globals). Capture the HOST `performance` at module load, BEFORE
+// turbo-dom installs its own `performance` global (else performanceNow → installed
+// performance.now → performanceNow → ∞). Falls back to Date.now() in a bare V8.
+const hostPerformance = globalThis.performance;
+const performanceNow = typeof hostPerformance?.now === 'function'
+  ? () => hostPerformance.now()
+  : () => Date.now();
+
+// base64 without depending on the Node `Buffer` global — prefer the platform
+// btoa/atob, then Buffer (Node), then a pure-JS fallback so a bare-isolate page
+// that calls btoa/atob doesn't throw.
+const B64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const turboBtoa = typeof globalThis.btoa === 'function'
+  ? (s) => globalThis.btoa(s)
+  : typeof Buffer !== 'undefined'
+    ? (s) => Buffer.from(String(s), 'binary').toString('base64')
+    : (s) => {
+        const str = String(s); let out = '';
+        for (let i = 0; i < str.length;) {
+          const c1 = str.charCodeAt(i++), c2 = str.charCodeAt(i++), c3 = str.charCodeAt(i++);
+          const e1 = c1 >> 2, e2 = ((c1 & 3) << 4) | (c2 >> 4);
+          let e3 = ((c2 & 15) << 2) | (c3 >> 6), e4 = c3 & 63;
+          if (isNaN(c2)) { e3 = e4 = 64; } else if (isNaN(c3)) { e4 = 64; }
+          out += B64[e1] + B64[e2] + (e3 === 64 ? '=' : B64[e3]) + (e4 === 64 ? '=' : B64[e4]);
+        }
+        return out;
+      };
+const turboAtob = typeof globalThis.atob === 'function'
+  ? (s) => globalThis.atob(s)
+  : typeof Buffer !== 'undefined'
+    ? (s) => Buffer.from(String(s), 'base64').toString('binary')
+    : (s) => {
+        const str = String(s).replace(/[^A-Za-z0-9+/]/g, ''); let out = '';
+        for (let i = 0; i < str.length;) {
+          const e1 = B64.indexOf(str[i++]), e2 = B64.indexOf(str[i++]);
+          const e3 = B64.indexOf(str[i++]), e4 = B64.indexOf(str[i++]);
+          out += String.fromCharCode((e1 << 2) | (e2 >> 4));
+          if (e3 !== -1 && e3 !== 64) out += String.fromCharCode(((e2 & 15) << 4) | (e3 >> 2));
+          if (e4 !== -1 && e4 !== 64) out += String.fromCharCode(((e3 & 3) << 6) | e4);
+        }
+        return out;
+      };
 
 // Resolve the host base classes ONCE, with minimal fallbacks so turbo-dom loads &
 // runs in a bare V8 lacking web-platform globals. Where the platform provides the
@@ -344,8 +383,8 @@ const STATIC_BASE = {
   Headers: globalThis.Headers, Request: globalThis.Request, Response: globalThis.Response,
   FormData: TurboFormData, ReadableStream: globalThis.ReadableStream,
   crypto: globalThis.crypto, Crypto: globalThis.Crypto, SubtleCrypto: globalThis.SubtleCrypto,
-  btoa: (s) => Buffer.from(String(s), 'binary').toString('base64'),
-  atob: (s) => Buffer.from(String(s), 'base64').toString('binary'),
+  btoa: (s) => turboBtoa(String(s)),
+  atob: (s) => turboAtob(String(s)),
   MessageChannel: globalThis.MessageChannel, MessagePort: globalThis.MessagePort,
   BroadcastChannel: globalThis.BroadcastChannel, EventSource: globalThis.EventSource,
   reportError: (e) => { void e; },