capybara-simulated 0.1.0 → 0.2.0

data/lib/capybara/simulated/js/bridge.bundle.js

@@ -3061,22 +3061,6 @@
     else n._attrs.checked = "";
   }
   __name(toggleChecked, "toggleChecked");
-  function formNamedAccess(form) {
-    if (form._namedAccessProxy) return form._namedAccessProxy;
-    const proxy = new Proxy(form, {
-      get(target, key) {
-        if (key in target) return target[key];
-        if (typeof key !== "string") return target[key];
-        for (const f of target.elements || []) {
-          if (f._attrs && (f._attrs.name === key || f._attrs.id === key)) return f;
-        }
-        return void 0;
-      }
-    });
-    form._namedAccessProxy = proxy;
-    return proxy;
-  }
-  __name(formNamedAccess, "formNamedAccess");
   function checkedRadioInGroup(n) {
     const name = n._attrs.name;
     if (!name) return n._attrs.checked != null ? n : null;
@@ -3290,7 +3274,7 @@
       event.target = event._csimRetargets.has(node) ? event._csimRetargets.get(node) : event._csimTopRetarget;
     }
     if (!capture && node._attrs && !event._immediatePropagationStopped) {
-      const attrName = "on" + event.type;
+      const attrName = "on" + event.type.toLowerCase();
       const propHandler = typeof node[attrName] === "function" ? node[attrName] : null;
       const attrVal = propHandler ? null : node._attrs[attrName];
       let handler = propHandler;
@@ -3535,6 +3519,18 @@
     });
   }
   __name(fireCEDisconnect, "fireCEDisconnect");
+  function fireCEMoveReactions(subtree) {
+    walk(subtree, (el) => {
+      if (!registry.has(el._tag)) return;
+      if (typeof el.connectedMoveCallback === "function") {
+        fireCEHook(el, "connectedMoveCallback");
+      } else {
+        fireCEHook(el, "disconnectedCallback");
+        fireCEHook(el, "connectedCallback");
+      }
+    });
+  }
+  __name(fireCEMoveReactions, "fireCEMoveReactions");
   globalThis.customElements = customElements;
 
   // lib/capybara/simulated/js/src/html-parser.js
@@ -3681,7 +3677,7 @@
   ]);
   var P_SCOPE_BOUNDARY = /* @__PURE__ */ new Set(["applet", "caption", "html", "table", "td", "th", "marquee", "object", "template", "button"]);
   var DOCTYPE_RE = /^\s*<!doctype\s+([^\s>]+)(?:\s+(?:public\s+("[^"]*"|'[^']*')(?:\s+("[^"]*"|'[^']*'))?|system\s+("[^"]*"|'[^']*')))?[^>]*>/i;
-  function installHtmlParser({ Document: Document2, Element: Element2, Text: Text2, Comment: Comment2, DocumentFragment: DocumentFragment2, DocumentType: DocumentType2 }) {
+  function installHtmlParser({ Document: Document2, Element: Element2, Text: Text2, Comment: Comment2, DocumentFragment: DocumentFragment2, DocumentType: DocumentType2, createHtmlPageDocument: createHtmlPageDocument2, registerNamedAccess: registerNamedAccess2 }) {
     const unquote = /* @__PURE__ */ __name((s) => s == null ? "" : s.slice(1, -1), "unquote");
     const HTML_NS_P = "http://www.w3.org/1999/xhtml";
     const SVG_NS_P = "http://www.w3.org/2000/svg";
@@ -3690,7 +3686,7 @@
     const XML_NS_P = "http://www.w3.org/XML/1998/namespace";
     const XMLNS_NS_P = "http://www.w3.org/2000/xmlns/";
     function parseDocument2(html) {
-      const doc = new Document2();
+      const doc = createHtmlPageDocument2(false);
       const dt = DocumentType2 && DOCTYPE_RE.exec(html);
       if (dt) {
         const node = new DocumentType2(dt[1], unquote(dt[2]), unquote(dt[3] || dt[4]), doc);
@@ -3698,7 +3694,6 @@
         doc._children.push(node);
       }
       const root = new Element2("html");
-      doc.documentElement = root;
       root._parent = doc;
       doc._children.push(root);
       const head = new Element2("head");
@@ -3976,7 +3971,10 @@
           if (fa) (el._attrNS || (el._attrNS = {}))[fa.key] = fa.meta;
           continue;
         }
-        el._attrs[asciiLowerAttr(m[1])] = decodeEntities(v);
+        const k = asciiLowerAttr(m[1]);
+        const dv = decodeEntities(v);
+        el._attrs[k] = dv;
+        if (k === "id" || k === "name") registerNamedAccess2(el, k, dv);
       }
     }
     __name(applyAttributes, "applyAttributes");
@@ -4645,6 +4643,16 @@
     } catch (_) {
       globalThis.document = void 0;
     }
+    try {
+      delete globalThis.open;
+    } catch (_) {
+      globalThis.open = void 0;
+    }
+    try {
+      delete globalThis.opener;
+    } catch (_) {
+      globalThis.opener = void 0;
+    }
     globalThis.WorkerGlobalScope = globalThis.WorkerGlobalScope || /* @__PURE__ */ __name(function WorkerGlobalScope() {
     }, "WorkerGlobalScope");
     globalThis.DedicatedWorkerGlobalScope = globalThis.DedicatedWorkerGlobalScope || /* @__PURE__ */ __name(function DedicatedWorkerGlobalScope() {
@@ -6267,7 +6275,13 @@
   // lib/capybara/simulated/js/src/xml-parser.js
   var XML_NS = "http://www.w3.org/XML/1998/namespace";
   var XMLNS_NS = "http://www.w3.org/2000/xmlns/";
+  var PARSERERROR_NS = "http://www.mozilla.org/newlayout/xml/parsererror.xml";
   var isWs = /* @__PURE__ */ __name((c) => c === " " || c === "	" || c === "\n" || c === "\r" || c === "\f", "isWs");
+  var isNCName = /* @__PURE__ */ __name((s) => /^[A-Za-z_][\w.\-]*$/.test(s), "isNCName");
+  var isQName = /* @__PURE__ */ __name((s) => {
+    const c = s.indexOf(":");
+    return c === -1 ? isNCName(s) : isNCName(s.slice(0, c)) && isNCName(s.slice(c + 1));
+  }, "isQName");
   function findTagEnd(s, lt) {
     let q = null;
     for (let i = lt + 1; i < s.length; i++) {
@@ -6283,6 +6297,7 @@
   function parseTag(inner) {
     let i = 0;
     const n = inner.length;
+    let err = false;
     while (i < n && isWs(inner[i])) i++;
     let nameEnd = i;
     while (nameEnd < n && !isWs(inner[nameEnd])) nameEnd++;
@@ -6292,30 +6307,35 @@
     while (i < n) {
       while (i < n && (isWs(inner[i]) || inner[i] === "/")) i++;
       if (i >= n) break;
+      if (inner[i] === "=") {
+        err = true;
+        break;
+      }
       let ae = i;
       while (ae < n && !isWs(inner[ae]) && inner[ae] !== "=") ae++;
       const aname = inner.slice(i, ae);
       i = ae;
       while (i < n && isWs(inner[i])) i++;
-      let avalue = "";
-      if (inner[i] === "=") {
-        i++;
-        while (i < n && isWs(inner[i])) i++;
-        const q = inner[i];
-        if (q === '"' || q === "'") {
-          const end = inner.indexOf(q, i + 1);
-          avalue = end === -1 ? inner.slice(i + 1) : inner.slice(i + 1, end);
-          i = end === -1 ? n : end + 1;
-        } else {
-          let ve = i;
-          while (ve < n && !isWs(inner[ve])) ve++;
-          avalue = inner.slice(i, ve);
-          i = ve;
-        }
+      if (inner[i] !== "=") {
+        err = true;
+        break;
+      }
+      i++;
+      while (i < n && isWs(inner[i])) i++;
+      const q = inner[i];
+      if (q !== '"' && q !== "'") {
+        err = true;
+        break;
       }
-      if (aname) attrs.push({ name: aname, value: decodeEntities(avalue) });
+      const end = inner.indexOf(q, i + 1);
+      if (end === -1) {
+        err = true;
+        break;
+      }
+      attrs.push({ name: aname, value: decodeEntities(inner.slice(i + 1, end)) });
+      i = end + 1;
     }
-    return { name, attrs };
+    return { name, attrs, err };
   }
   __name(parseTag, "parseTag");
   function installXmlParser({ Element: Element2, Text: Text2, Comment: Comment2, ProcessingInstruction: ProcessingInstruction2, CDATASection: CDATASection2, DocumentType: DocumentType2 }) {
@@ -6342,6 +6362,7 @@
       const stack = [];
       const nsStack = [{ xml: XML_NS }];
       let i = 0;
+      let err = false;
       const append = /* @__PURE__ */ __name((node) => {
         if (stack.length) {
           node._parent = stack[stack.length - 1];
@@ -6381,30 +6402,58 @@
             }
           } else if (s[i + 1] === "/") {
             const end = s.indexOf(">", i);
-            if (stack.length) {
+            const raw = end === -1 ? s.slice(i + 2) : s.slice(i + 2, end);
+            const endName = raw.replace(/\s+$/, "");
+            if (end === -1 || /^\s/.test(raw) || !endName) err = true;
+            if (stack.length === 0) {
+              err = true;
+            } else {
+              const top2 = stack[stack.length - 1];
+              const openName = top2._prefix ? top2._prefix + ":" + top2._localName : top2._localName;
+              if (endName !== openName) err = true;
               stack.pop();
               nsStack.pop();
             }
             i = end === -1 ? n : end + 1;
           } else {
+            if (isWs(s[i + 1])) err = true;
             const end = findTagEnd(s, i);
             if (end === -1) {
+              err = true;
               i = n;
               break;
             }
             let inner = s.slice(i + 1, end);
             const selfClose = /\/\s*$/.test(inner);
             if (selfClose) inner = inner.replace(/\/\s*$/, "");
-            const { name, attrs } = parseTag(inner);
+            const { name, attrs, err: tagErr } = parseTag(inner);
+            if (tagErr || !isQName(name)) err = true;
             i = end + 1;
             const scope = Object.assign({}, nsStack[nsStack.length - 1]);
             for (const a of attrs) {
-              if (a.name === "xmlns") scope[""] = a.value || null;
-              else if (a.name.slice(0, 6) === "xmlns:") scope[a.name.slice(6)] = a.value || null;
+              if (a.name === "xmlns") {
+                scope[""] = a.value || null;
+              } else if (a.name.slice(0, 6) === "xmlns:") {
+                const p = a.name.slice(6);
+                if (!isNCName(p) || p === "xmlns") err = true;
+                else scope[p] = a.value || null;
+              }
+            }
+            for (const a of attrs) {
+              if (a.name === "xmlns" || a.name.slice(0, 6) === "xmlns:") continue;
+              if (!isQName(a.name)) {
+                err = true;
+                continue;
+              }
+              const ac = a.name.indexOf(":");
+              if (ac !== -1 && a.name.slice(0, ac) !== "xml" && !(a.name.slice(0, ac) in scope)) {
+                err = true;
+              }
             }
             const colon = name.indexOf(":");
             const prefix = colon === -1 ? null : name.slice(0, colon);
             const localName = colon === -1 ? name : name.slice(colon + 1);
+            if (prefix && prefix !== "xml" && !(prefix in scope)) err = true;
             const ns = prefix ? scope[prefix] || null : scope[""] || null;
             const el = new Element2(name);
             el._localName = localName;
@@ -6438,6 +6487,16 @@
           i = j;
         }
       }
+      if (stack.length > 0) err = true;
+      if (err) {
+        const pe = new Element2("parsererror");
+        pe._localName = "parsererror";
+        pe._ns = PARSERERROR_NS;
+        const msg = new Text2("XML parsing error");
+        msg._parent = pe;
+        pe._children.push(msg);
+        return [pe];
+      }
       return top;
     }
     __name(parseXml2, "parseXml");
@@ -7071,9 +7130,13 @@
       this.nodeType = NODE_ELEMENT;
       this._ownerDoc = null;
     }
-    getRootNode(_options) {
+    getRootNode(options) {
+      const composed = !!(options && options.composed);
       let cur = this;
-      while (cur._parent) cur = cur._parent;
+      while (cur._parent) {
+        if (!composed && cur._isShadowRoot) break;
+        cur = cur._parent;
+      }
       return cur;
     }
     // Per DOM, `nodeValue` is null for every node type except Attr (its value)
@@ -7430,7 +7493,6 @@
           copy._children.push(cc);
         }
         if (copy.nodeType === NODE_DOC) {
-          copy.documentElement = copy._children.find((c) => c.nodeType === NODE_ELEMENT) || null;
           for (const c of copy._children) walkSubtree(c, (n) => {
             n._ownerDoc = copy;
           });
@@ -7846,12 +7908,14 @@
       const prevSib = idx > 0 ? this._children[idx - 1] : null;
       const nextSib = idx < this._children.length ? this._children[idx] : null;
       this._children.splice(idx, 0, ...moved);
+      liveRangesOnInsert(this, idx, moved.length);
       const connected = isConnected(this);
       for (const c of moved) {
         c._parent = this;
         registerSubtree(c);
       }
       recordChildList(this, moved.slice(), [], prevSib, nextSib);
+      if (this._tag === "script") globalThis.__csimScriptChildrenChanged(this);
       if (connected) for (const c of moved) globalThis.__csimFireCEConnect(c);
       for (const c of moved) askForReset(c);
       return frag;
@@ -7868,9 +7932,11 @@
       const prevSib = i > 0 ? this._children[i - 1] : null;
       const nextSib = i + 1 < this._children.length ? this._children[i + 1] : null;
       for (const c of nodes) adoptIntoParent(this, c);
+      liveRangesOnRemove(this, old, i);
       old._parent = null;
       unregisterSubtree(old);
       this._children.splice(i, 1, ...nodes);
+      liveRangesOnInsert(this, i, nodes.length);
       for (const c of nodes) {
         c._parent = this;
         registerSubtree(c);
@@ -7888,9 +7954,12 @@
       if (child && child.nodeType === NODE_FRAGMENT) return this._insertFragmentChildren(child, null);
       adoptIntoParent(this, child);
       child._parent = this;
+      const insertIndex = this._children.length;
       this._children.push(child);
+      liveRangesOnInsert(this, insertIndex, 1);
       registerSubtree(child);
       recordChildList(this, [child], []);
+      if (this._tag === "script") globalThis.__csimScriptChildrenChanged(this);
       if (isConnected(this)) globalThis.__csimFireCEConnect(child);
       askForReset(child);
       return child;
@@ -7908,9 +7977,14 @@
       const prevSib = i > 0 ? this._children[i - 1] : null;
       const nextSib = i + 1 < this._children.length ? this._children[i + 1] : null;
       const wasConnected = isConnected(this);
+      nodeIteratorPreRemove(child);
+      liveRangesOnRemove(this, child, i);
       this._children.splice(i, 1);
       child._parent = null;
       unregisterSubtree(child);
+      const doc = globalThis.document;
+      const ae = doc && doc._activeElement;
+      if (ae && (ae === child || nodeContains(child, ae))) doc._activeElement = null;
       recordChildList(this, [], [child], prevSib, nextSib);
       if (wasConnected) fireCEDisconnect(child);
       return child;
@@ -7930,8 +8004,10 @@
       if (i < 0) return this.appendChild(child);
       child._parent = this;
       this._children.splice(i, 0, child);
+      liveRangesOnInsert(this, i, 1);
       registerSubtree(child);
       recordChildList(this, [child], []);
+      if (this._tag === "script") globalThis.__csimScriptChildrenChanged(this);
       if (isConnected(this)) globalThis.__csimFireCEConnect(child);
       askForReset(child);
       return child;
@@ -7959,9 +8035,11 @@
       const wasConnected = isConnected(this);
       adoptIntoParent(this, neu);
       const j = this._children.indexOf(old);
+      liveRangesOnRemove(this, old, j);
       neu._parent = this;
       old._parent = null;
       this._children[j] = neu;
+      liveRangesOnInsert(this, j, 1);
       unregisterSubtree(old);
       registerSubtree(neu);
       recordChildList(this, [neu], [old]);
@@ -8056,6 +8134,7 @@
     }
     _setData(next) {
       const prev = this._data;
+      liveRangesOnReplaceData(this, 0, prev.length, next.length);
       if (prev === next) return;
       this._data = next;
       recordCharacterData(this, prev);
@@ -8118,7 +8197,9 @@
       const len = prev.length;
       if (offset > len) throw new globalThis.DOMException("The offset is greater than the data length.", "IndexSizeError");
       if (offset + count > len) count = len - offset;
-      this._data = prev.slice(0, offset) + String(data) + prev.slice(offset + count);
+      const str = String(data);
+      liveRangesOnReplaceData(this, offset, count, str.length);
+      this._data = prev.slice(0, offset) + str + prev.slice(offset + count);
       recordCharacterData(this, prev);
     }
   };
@@ -8146,19 +8227,24 @@
     // install chain on that template (including `{{on "click"}}` on
     // search-result anchors).
     splitText(offset) {
+      offset = offset >>> 0;
       const len = this._data.length;
-      if (offset < 0 || offset > len) {
+      if (offset > len) {
         throw new globalThis.DOMException("Index or size is negative or greater than the allowed amount", "IndexSizeError");
       }
-      const suffix = this._data.substring(offset);
-      const newNode = new this.constructor(suffix);
+      const count = len - offset;
+      const newNode = new this.constructor(this._data.substring(offset));
       newNode._ownerDoc = this._ownerDoc;
-      if (this._parent) {
-        const idx = this._parent._children.indexOf(this);
-        this._parent._children.splice(idx + 1, 0, newNode);
-        newNode._parent = this._parent;
+      const parent = this._parent;
+      if (parent) {
+        const idx = parent._children.indexOf(this);
+        parent._children.splice(idx + 1, 0, newNode);
+        newNode._parent = parent;
+        registerSubtree(newNode);
+        recordChildList(parent, [newNode], []);
+        liveRangesOnSplit(this, offset, newNode, parent, idx);
       }
-      this.data = this._data.substring(0, offset);
+      this._replaceData(offset, count, "");
       return newNode;
     }
     // DOM `Text.wholeText`: the concatenated data of this node and its contiguous
@@ -8465,6 +8551,7 @@
       this._vtGen = -1;
       this._vtCV = -1;
       this._attrsColl = null;
+      if (this._tag === "form") Object.setPrototypeOf(this, FormNamedProto);
     }
     _cloneShell() {
       const e = new _Element(this._tag);
@@ -8473,6 +8560,7 @@
       e._ns = this._ns;
       e._prefix = this._prefix;
       e._localName = this._localName;
+      if (this._tag === "script" && this._csimRan) e._csimRan = true;
       return e;
     }
     // tagName / nodeName: the qualified name, ASCII-uppercased only for an
@@ -8521,6 +8609,61 @@
       }
       Object.defineProperty(this, "content", { value: v, writable: true, configurable: true, enumerable: true });
     }
+    // `HTMLStyleElement.sheet` — the CSSStyleSheet associated with a connected
+    // `<style>` (CSSOM). It exists once the element is in a document and reflects
+    // the element's current text content, so an earlier-inserted script can
+    // observe a later-inserted `<style>` already applied (cssRules track the text
+    // live). Disconnected → null; `<link>` sheets (which need the fetched
+    // resource) are not modelled here. Created lazily and cached for stable identity.
+    get sheet() {
+      if (this._tag === "style") {
+        if (!this.isConnected) {
+          this._sheet = null;
+          return null;
+        }
+        const type = (this._attrs.type || "").toLowerCase();
+        if (type && type !== "text/css") {
+          this._sheet = null;
+          return null;
+        }
+        if (!this._sheet) {
+          this._sheet = new globalThis.CSSStyleSheet();
+          this._sheet.ownerNode = this;
+        }
+        this._sheet.replaceSync(this.textContent || "");
+        return this._sheet;
+      }
+      if (this._tag === "link") {
+        const rel = (this._attrs.rel || "").toLowerCase().split(/\s+/);
+        const href = this._attrs.href;
+        if (!this.isConnected || !rel.includes("stylesheet") || !href) {
+          this._sheet = null;
+          return null;
+        }
+        if (!this._sheet) {
+          this._sheet = new globalThis.CSSStyleSheet();
+          this._sheet.ownerNode = this;
+          this._sheet.href = href;
+          let css = "";
+          const dataCss = /^data:text\/css[^,]*,(.*)$/is.exec(href);
+          if (dataCss) {
+            try {
+              css = decodeURIComponent(dataCss[1]);
+            } catch (_) {
+              css = dataCss[1];
+            }
+          } else {
+            try {
+              css = globalThis.__csimExternalAsset(href) || "";
+            } catch (_) {
+            }
+          }
+          this._sheet.replaceSync(css);
+        }
+        return this._sheet;
+      }
+      return void 0;
+    }
     // `<dialog>` HTML interface — show() / showModal() / close() per
     // HTMLDialogElement. Turbo's confirm flow uses this: opens
     // `<dialog id="turbo-confirm">` via `showModal()`, waits for the
@@ -8589,6 +8732,7 @@
       const old = this._attrs[n];
       const next = String(value);
       this._attrs[n] = next;
+      if ((n === "id" || n === "name") && next) registerNamedAccess(this, n, next);
       if ((n === "src" || n === "srcdoc") && (this._tag === "iframe" || this._tag === "frame") && old !== next) {
         const oldRealmId = this._frameRealmId;
         this._frameWindow = null;
@@ -8621,6 +8765,7 @@
       const old = this._attrs[key];
       const next = String(value);
       this._attrs[key] = next;
+      if (rns === null && (localName === "id" || localName === "name") && next) registerNamedAccess(this, localName, next);
       if (rns !== null || prefix !== null || key !== qn) {
         (this._attrNS || (this._attrNS = {}))[key] = { ns: rns, prefix, localName };
       } else if (this._attrNS) {
@@ -8690,6 +8835,7 @@
     _setAttrNodeValue(key, value) {
       const old = this._attrs[key];
       this._attrs[key] = value;
+      if ((key === "id" || key === "name") && value) registerNamedAccess(this, key, value);
       recordAttrMutation(this, key, old == null ? null : old);
       if (old !== value) fireAttrChangedCallback(this, key, old == null ? null : old, value, _Element);
     }
@@ -8711,6 +8857,7 @@
       const key = hasNs ? this._attrKeyByNS(attr._ns, attr._localName) || freshAttrKey(this, qn) : asciiLower2(qn);
       const old = this._attrs[key];
       this._attrs[key] = attr._value;
+      if (!hasNs && (key === "id" || key === "name") && attr._value) registerNamedAccess(this, key, attr._value);
       if (hasNs) (this._attrNS || (this._attrNS = {}))[key] = { ns: attr._ns, prefix: attr._prefix, localName: attr._localName };
       else if (this._attrNS) delete this._attrNS[key];
       attr._ownerElement = this;
@@ -9100,8 +9247,7 @@
     // `this.form` the onclick threw and the columns never moved.
     get form() {
       if (!FORM_ASSOCIATED_TAGS.has(this._tag)) return void 0;
-      const form = formForControl(this);
-      return form ? formNamedAccess(form) : null;
+      return formForControl(this) || null;
     }
     // Form-control IDL attributes — expose the pair-of-attr-and-IDL
     // shape so JS like `input.value = 'x'` / `input.checked = true`
@@ -10650,6 +10796,93 @@
       return globalThis.customElements || null;
     }
   });
+  var FormNamedProto = Object.create(Element.prototype);
+  var FORM_NAMED_PROPS = /* @__PURE__ */ new Set();
+  var FORM_NAMED_TAGS = /* @__PURE__ */ new Set(["input", "select", "textarea", "button", "fieldset", "object"]);
+  function formNamedLookup(form, name) {
+    if (!form || form._tag !== "form") return void 0;
+    const els = form.elements;
+    if (els) for (const c of els) {
+      if (c._attrs && (c._attrs.name === name || c._attrs.id === name)) return c;
+    }
+    return void 0;
+  }
+  __name(formNamedLookup, "formNamedLookup");
+  function registerFormName(el, value) {
+    if (!value || !FORM_NAMED_TAGS.has(el._tag)) return;
+    if (FORM_NAMED_PROPS.has(value)) return;
+    FORM_NAMED_PROPS.add(value);
+    if (value in FormNamedProto) return;
+    Object.defineProperty(FormNamedProto, value, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        return formNamedLookup(this, value);
+      },
+      // Assigning `form.<name> = x` creates an OWN property that shadows the
+      // named getter — matching browser LegacyPlatformObject semantics (named
+      // properties are configurable). Without a setter, strict-mode assignment
+      // to a getter-only property THROWS; jQuery stores its private-data expando
+      // directly on the element (`form[expando] = cache`) and also parks its
+      // marker on `id`/`name` during scoped queries, so a getter-only named prop
+      // would break every form jQuery binds an event to or calls `.data()` on.
+      set(v) {
+        Object.defineProperty(this, value, { value: v, writable: true, enumerable: true, configurable: true });
+      }
+    });
+  }
+  __name(registerFormName, "registerFormName");
+  var WINDOW_NAMED_PROPS = /* @__PURE__ */ new Set();
+  var WINDOW_NAME_VALUES = /* @__PURE__ */ new Set();
+  var WINDOW_NAME_TAGS = /* @__PURE__ */ new Set(["a", "applet", "area", "embed", "form", "frameset", "frame", "iframe", "img", "object"]);
+  var WindowNamedProps = Object.create(Object.getPrototypeOf(globalThis));
+  if (!globalThis.__csimWindowNamedProps) {
+    globalThis.__csimWindowNamedProps = WindowNamedProps;
+    Object.setPrototypeOf(globalThis, WindowNamedProps);
+  }
+  function windowNamedLookup(name) {
+    const doc = globalThis.document;
+    if (!doc) return void 0;
+    const byId2 = doc.getElementById && doc.getElementById(name);
+    if (byId2) return byId2;
+    if (!WINDOW_NAME_VALUES.has(name)) return void 0;
+    let found;
+    walkSubtree(doc, (el) => {
+      if (found || el.nodeType !== NODE_ELEMENT) return;
+      if (WINDOW_NAME_TAGS.has(el._tag) && el._attrs && el._attrs.name === name) found = el;
+    });
+    return found;
+  }
+  __name(windowNamedLookup, "windowNamedLookup");
+  function registerWindowName(el, attrName, value) {
+    if (!value) return;
+    if (attrName === "name") {
+      if (!WINDOW_NAME_TAGS.has(el._tag)) return;
+      WINDOW_NAME_VALUES.add(value);
+    }
+    if (WINDOW_NAMED_PROPS.has(value)) return;
+    WINDOW_NAMED_PROPS.add(value);
+    if (value in globalThis) return;
+    Object.defineProperty(globalThis.__csimWindowNamedProps, value, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        return windowNamedLookup(value);
+      },
+      // As with form named access, assignment shadows the getter with an own
+      // property (configurable named properties); without a setter, strict-mode
+      // `window.foo = x` for an id-named `foo` would throw.
+      set(v) {
+        Object.defineProperty(globalThis, value, { value: v, writable: true, enumerable: true, configurable: true });
+      }
+    });
+  }
+  __name(registerWindowName, "registerWindowName");
+  function registerNamedAccess(el, attrName, value) {
+    registerFormName(el, value);
+    registerWindowName(el, attrName, value);
+  }
+  __name(registerNamedAccess, "registerNamedAccess");
   var DocumentFragment = class extends Node {
     static {
       __name(this, "DocumentFragment");
@@ -10847,7 +11080,95 @@
   for (const __h of GLOBAL_EVENT_HANDLER_ATTRS) {
     if (!(__h in Element.prototype)) Element.prototype[__h] = null;
   }
-  var Document = class _Document extends Node {
+  var DOMImplementation = class {
+    static {
+      __name(this, "DOMImplementation");
+    }
+    constructor(doc) {
+      this._doc = doc;
+    }
+    // Legacy: `hasFeature` always returns true (DOM §4.5.1).
+    hasFeature() {
+      return true;
+    }
+    // `createHTMLDocument(title)` — DOMParser shims and Turbo Drive's page-
+    // snapshot logic both probe it. Returns a fresh Document with a minimal
+    // `<!DOCTYPE html><html><head><title>X</title></head><body></body></html>`
+    // skeleton; full HTML-spec construction (quirks-mode flag) is out of scope.
+    createHTMLDocument(...args) {
+      const d = new Document();
+      const doctype = new DocumentType("html", "", "", d);
+      doctype._parent = d;
+      const html = new Element("html");
+      const head = new Element("head");
+      const body = new Element("body");
+      html._children = newChildList([head, body]);
+      head._parent = html;
+      body._parent = html;
+      html._parent = d;
+      d._children = newChildList([doctype, html]);
+      if (args.length > 0 && args[0] !== void 0) {
+        const t = new Element("title");
+        t._children = newChildList([Object.assign(new Text(String(args[0])), { _parent: t })]);
+        t._parent = head;
+        head._children.push(t);
+      }
+      d._contentType = "text/html";
+      walkSubtree(d, (n) => {
+        n._ownerDoc = d;
+      });
+      return d;
+    }
+    // createDocumentType(qualifiedName, publicId, systemId) — modern spec
+    // validates only the name (a "valid doctype name"); no namespace checks.
+    createDocumentType(qualifiedName, publicId, systemId) {
+      const name = String(qualifiedName);
+      if (!isValidDoctypeName(name)) {
+        throw new globalThis.DOMException(
+          `The qualified name '${name}' is not a valid doctype name.`,
+          "InvalidCharacterError"
+        );
+      }
+      return new DocumentType(name, publicId, systemId, this._doc);
+    }
+    // createDocument(namespace, qualifiedName, doctype) — a fresh XMLDocument with
+    // an optional root element (from the validated qualifiedName) and an optional
+    // doctype, in [doctype?, element?] order.
+    createDocument(...args) {
+      if (args.length < 2) {
+        throw new TypeError("Failed to execute 'createDocument': 2 arguments required.");
+      }
+      const namespace = args[0], qualifiedName = args[1], doctype = args[2];
+      if (doctype != null && !(doctype instanceof DocumentType)) {
+        throw new TypeError("Failed to execute 'createDocument': parameter 3 is not of type 'DocumentType'.");
+      }
+      const ns = namespace == null || namespace === "" ? null : String(namespace);
+      const qn = qualifiedName === null ? "" : String(qualifiedName);
+      let rns = null, prefix = null, localName = null;
+      if (qn !== "") ({ namespace: rns, prefix, localName } = validateAndExtract(ns, qn, "element"));
+      const d = new XMLDocument();
+      d._contentType = ns === HTML_NS3 ? "application/xhtml+xml" : ns === SVG_NS2 ? "image/svg+xml" : "application/xml";
+      d._children = newChildList();
+      d.readyState = "complete";
+      if (doctype != null) {
+        if (doctype._parent) {
+          const i = doctype._parent._children.indexOf(doctype);
+          if (i >= 0) doctype._parent._children.splice(i, 1);
+        }
+        doctype._parent = d;
+        doctype._ownerDoc = d;
+        d._children.push(doctype);
+      }
+      if (qn !== "") {
+        const el = d._createElement(rns, prefix, localName);
+        el._parent = d;
+        d._children.push(el);
+      }
+      return d;
+    }
+  };
+  globalThis.DOMImplementation = DOMImplementation;
+  var Document = class extends Node {
     static {
       __name(this, "Document");
     }
@@ -10962,27 +11283,37 @@
     constructor() {
       super();
       this.nodeType = NODE_DOC;
-      this.readyState = "loading";
-      const html = new Element("html");
-      const head = new Element("head");
-      const body = new Element("body");
-      html._parent = this;
-      this._children.push(html);
-      head._parent = html;
-      html._children.push(head);
-      body._parent = html;
-      html._children.push(body);
-      this.documentElement = html;
+      this.readyState = "complete";
+      this._contentType = "application/xml";
+      this._url = "about:blank";
+      this._noBrowsingContext = true;
       for (const name of GLOBAL_EVENT_HANDLER_ATTRS) this[name] = null;
     }
+    // The document element is the document's (single) element child — derived
+    // from the tree rather than maintained as a field, so it stays correct after
+    // any insert / remove (e.g. `new Document().appendChild(html)`), not just the
+    // explicit parser / graft paths. A Document's child list is tiny (an optional
+    // doctype + the root), so the scan is effectively free; the manual loop
+    // avoids a per-access closure allocation on this hot getter.
+    get documentElement() {
+      const kids = this._children;
+      for (let i = 0; i < kids.length; i++) {
+        if (kids[i].nodeType === NODE_ELEMENT) return kids[i];
+      }
+      return null;
+    }
     // jQuery's `mc(node)` helper resolves a node back to its window
     // via `doc.defaultView || doc.parentWindow`; without these the
     // offset / scroll path throws "Cannot read properties of
     // undefined (reading 'pageYOffset')".
     // The main document's window is the global; a nested (iframe) document
     // carries its own `_defaultView` (a frame-window proxy) set at load time.
+    // A document with no browsing context (`new Document()`, createHTMLDocument,
+    // createDocument) has no associated window — `defaultView` is null (DOM
+    // §4.5.1). Returning the global here would splice the live window (and its
+    // document) into a detached document's event path, cycling it unbounded.
     get defaultView() {
-      return this._defaultView || globalThis;
+      return this._noBrowsingContext ? null : this._defaultView || globalThis;
     }
     get parentWindow() {
       return this.defaultView;
@@ -11003,15 +11334,14 @@
       return null;
     }
     // Cloning a Document yields a new EMPTY document of the same kind, carrying
-    // the content type — children are copied only on a deep clone (cloneNode
-    // handles that + sets documentElement). The base shell would re-run the
-    // constructor's html/head/body skeleton, leaving a shallow clone non-empty.
+    // the content type and browsing-context-ness — children are copied only on a
+    // deep clone (cloneNode handles that + sets documentElement).
     _cloneShell() {
       const d = new this.constructor();
       d._children = newChildList();
-      d.documentElement = null;
       d._contentType = this._contentType;
-      if (this._url) d._url = this._url;
+      d._noBrowsingContext = this._noBrowsingContext;
+      d._url = this._url;
       d.readyState = "complete";
       return d;
     }
@@ -11019,8 +11349,10 @@
     // searchParams.js reads `document.location.search`; without this
     // getter the call hits `undefined.search` and the whole bundle's
     // top-level module init aborts before the search-feed fetch fires.
+    // A document with no browsing context (createHTMLDocument) has `location`
+    // null; the main / frame documents return the live location object.
     get location() {
-      return globalThis.location;
+      return this._noBrowsingContext ? null : globalThis.location;
     }
     set location(v) {
       globalThis.__locationAssign(String(v));
@@ -11257,7 +11589,9 @@
     // the live tree via `appendChild`. We give it just enough surface
     // for `appendChild` / `childNodes` to work.
     createDocumentFragment() {
-      return new DocumentFragment();
+      const f = new DocumentFragment();
+      f._ownerDoc = this;
+      return f;
     }
     // `Document.createEvent(interfaceName)` — legacy DOM Level 2 API
     // still used by libraries that target older browsers (Trix's
@@ -11302,100 +11636,31 @@
         }
       }
       const dest = this;
+      const oldDoc = node.ownerDocument;
       walkSubtree(node, (n) => {
         n._ownerDoc = dest;
       });
+      const oldReg = oldDoc && oldDoc._liveRanges;
+      if (oldReg && oldReg.size) {
+        for (const r of [...oldReg]) {
+          if (sameTreeContains(node, r.startContainer) || sameTreeContains(node, r.endContainer)) r._track();
+        }
+      }
       return node;
     }
-    // `document.implementation.createHTMLDocument(title)` — DOMParser
-    // shims and Turbo Drive page-snapshot logic both probe it. We
-    // return a fresh Document with a minimal `<html><head><title>X</title>
-    // </head><body></body></html>` skeleton; full HTML-spec
-    // construction (DOCTYPE / quirks-mode flag) is out of scope.
+    // `document.implementation` — a per-document, cached `DOMImplementation`
+    // (createHTMLDocument / createDocument / createDocumentType / hasFeature).
+    // Cached so repeated reads return the same instance, and a real class so
+    // `instanceof DOMImplementation` holds.
     get implementation() {
-      return {
-        createHTMLDocument: /* @__PURE__ */ __name((...args) => {
-          const d = new _Document();
-          const doctype = new DocumentType("html", "", "", d);
-          doctype._parent = d;
-          const html = new Element("html");
-          const head = new Element("head");
-          const body = new Element("body");
-          html._children = newChildList([head, body]);
-          head._parent = html;
-          body._parent = html;
-          d.documentElement = html;
-          html._parent = d;
-          d._children = newChildList([doctype, html]);
-          if (args.length > 0 && args[0] !== void 0) {
-            const t = new Element("title");
-            t._children = newChildList([Object.assign(new Text(String(args[0])), { _parent: t })]);
-            t._parent = head;
-            head._children.push(t);
-          }
-          walkSubtree(d, (n) => {
-            n._ownerDoc = d;
-          });
-          return d;
-        }, "createHTMLDocument"),
-        // createDocumentType(qualifiedName, publicId, systemId) — modern spec
-        // validates only the name (a "valid doctype name"); no namespace checks.
-        createDocumentType: /* @__PURE__ */ __name((qualifiedName, publicId, systemId) => {
-          const name = String(qualifiedName);
-          if (!isValidDoctypeName(name)) {
-            throw new globalThis.DOMException(
-              `The qualified name '${name}' is not a valid doctype name.`,
-              "InvalidCharacterError"
-            );
-          }
-          return new DocumentType(name, publicId, systemId, this);
-        }, "createDocumentType"),
-        // createDocument(namespace, qualifiedName, doctype) — a fresh XMLDocument
-        // with an optional root element (from the validated qualifiedName) and an
-        // optional doctype, in [doctype?, element?] order.
-        createDocument: /* @__PURE__ */ __name((...args) => {
-          if (args.length < 2) {
-            throw new TypeError("Failed to execute 'createDocument': 2 arguments required.");
-          }
-          const namespace = args[0], qualifiedName = args[1], doctype = args[2];
-          if (doctype != null && !(doctype instanceof DocumentType)) {
-            throw new TypeError("Failed to execute 'createDocument': parameter 3 is not of type 'DocumentType'.");
-          }
-          const ns = namespace == null || namespace === "" ? null : String(namespace);
-          const qn = qualifiedName === null ? "" : String(qualifiedName);
-          let rns = null, prefix = null, localName = null;
-          if (qn !== "") ({ namespace: rns, prefix, localName } = validateAndExtract(ns, qn, "element"));
-          const d = new XMLDocument();
-          d._contentType = ns === HTML_NS3 ? "application/xhtml+xml" : ns === SVG_NS2 ? "image/svg+xml" : "application/xml";
-          d._children = newChildList();
-          d.documentElement = null;
-          d.readyState = "complete";
-          if (doctype != null) {
-            if (doctype._parent) {
-              const i = doctype._parent._children.indexOf(doctype);
-              if (i >= 0) doctype._parent._children.splice(i, 1);
-            }
-            doctype._parent = d;
-            doctype._ownerDoc = d;
-            d._children.push(doctype);
-          }
-          if (qn !== "") {
-            const el = d._createElement(rns, prefix, localName);
-            el._parent = d;
-            d._children.push(el);
-            d.documentElement = el;
-          }
-          return d;
-        }, "createDocument"),
-        hasFeature: /* @__PURE__ */ __name(() => true, "hasFeature")
-      };
+      return this._implementation || (this._implementation = new DOMImplementation(this));
     }
     // Minimal Range stub for `document.createRange()`. We don't model
     // partial-range selection (start/end offsets on text nodes etc.);
     // only document-order comparison between two nodes' start containers
     // via `compareBoundaryPoints`, which is all the consumers here drive.
     createRange() {
-      return new DocumentOrderRange();
+      return new DocumentOrderRange(this);
     }
     // Minimal NodeIterator. DOMPurify is the canonical consumer —
     // it walks a freshly-parsed sanitisation fragment via
@@ -11404,49 +11669,58 @@
     // DOMPurify operates on small per-call fragments so the up-front
     // walk is cheaper than the per-step sibling/ancestor traversal.
     createNodeIterator(root, whatToShow, filter) {
-      if (whatToShow == null) whatToShow = 4294967295;
-      const all = [];
-      walkSubtree(root, (n) => all.push(n));
+      if (!isNodeArg(root)) {
+        throw new TypeError("Failed to execute 'createNodeIterator': parameter 1 is not of type 'Node'.");
+      }
+      whatToShow = whatToShow === void 0 ? 4294967295 : whatToShow >>> 0;
+      if (filter === void 0) filter = null;
+      const state2 = { node: root, before: true, active: false };
       const accept = /* @__PURE__ */ __name((n) => {
-        const mask = 1 << n.nodeType - 1;
-        if (!(mask & whatToShow)) return 3;
+        if (!(1 << n.nodeType - 1 & whatToShow)) return 3;
         if (filter) {
           const fn = typeof filter === "function" ? filter : filter && filter.acceptNode;
           if (fn) {
-            const r = fn.call(filter || null, n);
+            if (state2.active) {
+              throw new globalThis.DOMException("Failed to execute 'nextNode' on 'NodeIterator': the iterator's filter is already active.", "InvalidStateError");
+            }
+            state2.active = true;
+            let r;
+            try {
+              r = fn.call(filter || null, n);
+            } finally {
+              state2.active = false;
+            }
             if (r === 2 || r === 3 || r === false) return 3;
           }
         }
         return 1;
       }, "accept");
-      let i = -1;
-      return {
-        root,
-        whatToShow,
-        filter,
-        referenceNode: root,
-        pointerBeforeReferenceNode: true,
+      const it = {
         nextNode() {
-          while (++i < all.length) {
-            if (accept(all[i]) !== 1) continue;
-            this.referenceNode = all[i];
-            this.pointerBeforeReferenceNode = false;
-            return all[i];
-          }
-          return null;
+          return nodeIteratorTraverse(this, true);
         },
         previousNode() {
-          while (--i >= 0) {
-            if (accept(all[i]) !== 1) continue;
-            this.referenceNode = all[i];
-            this.pointerBeforeReferenceNode = false;
-            return all[i];
-          }
-          return null;
+          return nodeIteratorTraverse(this, false);
         },
         detach() {
         }
       };
+      Object.defineProperties(it, {
+        _state: { value: state2, writable: false, enumerable: false },
+        _accept: { value: accept, writable: false, enumerable: false },
+        root: { value: root, enumerable: true },
+        whatToShow: { value: whatToShow, enumerable: true },
+        filter: { value: filter, enumerable: true },
+        referenceNode: { get() {
+          return state2.node;
+        }, enumerable: true },
+        pointerBeforeReferenceNode: { get() {
+          return state2.before;
+        }, enumerable: true },
+        [Symbol.toStringTag]: { value: "NodeIterator" }
+      });
+      LIVE_NODE_ITERATORS.add(it);
+      return it;
     }
     // `Document.createTreeWalker(root, whatToShow, filter)` — Trix
     // builds one to traverse the editable subtree by nodeType (its
@@ -11892,65 +12166,299 @@
     // no browsing context; documentURI follows via this.URL
   };
   globalThis.XMLDocument = XMLDocument;
+  function createHtmlPageDocument(withSkeleton) {
+    const doc = new Document();
+    doc._contentType = void 0;
+    doc._url = void 0;
+    doc._noBrowsingContext = false;
+    doc.readyState = "loading";
+    if (withSkeleton) {
+      const html = new Element("html");
+      const head = new Element("head");
+      const body = new Element("body");
+      html._parent = doc;
+      doc._children.push(html);
+      head._parent = html;
+      html._children.push(head);
+      body._parent = html;
+      html._children.push(body);
+    }
+    return doc;
+  }
+  __name(createHtmlPageDocument, "createHtmlPageDocument");
+  function rangesFor(node) {
+    const d = node && (node.nodeType === NODE_DOC ? node : node.ownerDocument);
+    return d ? d._liveRanges : null;
+  }
+  __name(rangesFor, "rangesFor");
+  function liveRangesOnInsert(parent, index, count) {
+    const reg = rangesFor(parent);
+    if (!reg || reg.size === 0) return;
+    for (const r of reg) {
+      if (r.startContainer === parent && r.startOffset > index) r.startOffset += count;
+      if (r.endContainer === parent && r.endOffset > index) r.endOffset += count;
+    }
+  }
+  __name(liveRangesOnInsert, "liveRangesOnInsert");
+  function sameTreeContains(ancestor, descendant) {
+    for (let n = descendant; n; n = n._parent) {
+      if (n === ancestor) return true;
+      if (n._isShadowRoot) return false;
+    }
+    return false;
+  }
+  __name(sameTreeContains, "sameTreeContains");
+  function liveRangesOnRemove(oldParent, node, index) {
+    const reg = rangesFor(oldParent);
+    if (!reg || reg.size === 0) return;
+    for (const r of reg) {
+      if (sameTreeContains(node, r.startContainer)) {
+        r.startContainer = oldParent;
+        r.startOffset = index;
+      }
+      if (sameTreeContains(node, r.endContainer)) {
+        r.endContainer = oldParent;
+        r.endOffset = index;
+      }
+      if (r.startContainer === oldParent && r.startOffset > index) r.startOffset -= 1;
+      if (r.endContainer === oldParent && r.endOffset > index) r.endOffset -= 1;
+    }
+  }
+  __name(liveRangesOnRemove, "liveRangesOnRemove");
+  function liveRangesOnReplaceData(node, offset, count, dataLen) {
+    const reg = rangesFor(node);
+    if (!reg || reg.size === 0) return;
+    const delta = dataLen - count;
+    for (const r of reg) {
+      if (r.startContainer === node) {
+        if (r.startOffset > offset && r.startOffset <= offset + count) r.startOffset = offset;
+        else if (r.startOffset > offset + count) r.startOffset += delta;
+      }
+      if (r.endContainer === node) {
+        if (r.endOffset > offset && r.endOffset <= offset + count) r.endOffset = offset;
+        else if (r.endOffset > offset + count) r.endOffset += delta;
+      }
+    }
+  }
+  __name(liveRangesOnReplaceData, "liveRangesOnReplaceData");
+  function liveRangesOnSplit(node, offset, newNode, parent, nodeIndex) {
+    const reg = rangesFor(node);
+    if (!reg || reg.size === 0) return;
+    for (const r of reg) {
+      if (r.startContainer === node && r.startOffset > offset) {
+        r.startContainer = newNode;
+        r.startOffset -= offset;
+      }
+      if (r.endContainer === node && r.endOffset > offset) {
+        r.endContainer = newNode;
+        r.endOffset -= offset;
+      }
+      if (parent) {
+        if (r.startContainer === parent && r.startOffset === nodeIndex + 1) r.startOffset += 1;
+        if (r.endContainer === parent && r.endOffset === nodeIndex + 1) r.endOffset += 1;
+      }
+    }
+  }
+  __name(liveRangesOnSplit, "liveRangesOnSplit");
+  var LIVE_NODE_ITERATORS = /* @__PURE__ */ new Set();
+  function followingSkippingSubtree(node, root) {
+    for (let cur = node; cur && cur !== root; cur = cur._parent) {
+      const p = cur._parent;
+      if (p) {
+        const sibs = p._children, i = sibs.indexOf(cur);
+        if (i >= 0 && i + 1 < sibs.length) return sibs[i + 1];
+      }
+    }
+    return null;
+  }
+  __name(followingSkippingSubtree, "followingSkippingSubtree");
+  function followingWithinRoot(node, root) {
+    if (node._children && node._children.length) return node._children[0];
+    return followingSkippingSubtree(node, root);
+  }
+  __name(followingWithinRoot, "followingWithinRoot");
+  function precedingWithinRoot(node, root) {
+    if (node === root || !node._parent) return null;
+    const sibs = node._parent._children, i = sibs.indexOf(node);
+    if (i > 0) {
+      let n = sibs[i - 1];
+      while (n._children && n._children.length) n = n._children[n._children.length - 1];
+      return n;
+    }
+    return node._parent;
+  }
+  __name(precedingWithinRoot, "precedingWithinRoot");
+  function nodeIteratorTraverse(it, forward) {
+    let node = it._state.node;
+    let before = it._state.before;
+    while (true) {
+      if (forward) {
+        if (!before) {
+          const n = followingWithinRoot(node, it.root);
+          if (!n) return null;
+          node = n;
+        } else before = false;
+      } else {
+        if (before) {
+          const n = precedingWithinRoot(node, it.root);
+          if (!n) return null;
+          node = n;
+        } else before = true;
+      }
+      if (it._accept(node) === 1) break;
+    }
+    it._state.node = node;
+    it._state.before = before;
+    return node;
+  }
+  __name(nodeIteratorTraverse, "nodeIteratorTraverse");
+  function nodeIteratorPreRemove(toBeRemoved) {
+    if (LIVE_NODE_ITERATORS.size === 0) return;
+    const removedDoc = toBeRemoved.nodeType === NODE_DOC ? toBeRemoved : toBeRemoved.ownerDocument;
+    for (const it of LIVE_NODE_ITERATORS) {
+      const st = it._state;
+      if (nodeContains(toBeRemoved, it.root)) continue;
+      const itDoc = it.root.nodeType === NODE_DOC ? it.root : it.root.ownerDocument;
+      if (itDoc !== removedDoc) continue;
+      if (!nodeContains(toBeRemoved, st.node)) continue;
+      if (st.before) {
+        const next = followingSkippingSubtree(toBeRemoved, null);
+        if (next) {
+          st.node = next;
+          continue;
+        }
+        st.before = false;
+      }
+      const prevSib = toBeRemoved.previousSibling;
+      if (!prevSib) {
+        st.node = toBeRemoved._parent;
+      } else {
+        let n = prevSib;
+        while (n._children && n._children.length) n = n._children[n._children.length - 1];
+        st.node = n;
+      }
+    }
+  }
+  __name(nodeIteratorPreRemove, "nodeIteratorPreRemove");
+  function nodeLength(node) {
+    const t = node.nodeType;
+    if (t === NODE_DOCTYPE) return 0;
+    if (t === NODE_TEXT || t === NODE_CDATA || t === NODE_COMMENT || t === NODE_PI) {
+      return (node.data || "").length;
+    }
+    return node._children ? node._children.length : 0;
+  }
+  __name(nodeLength, "nodeLength");
+  function setRangeBoundary(range, node, offset, which) {
+    const fn = which === "start" ? "setStart" : "setEnd";
+    if (!isNodeArg(node)) {
+      throw new TypeError(`Failed to execute '${fn}' on 'Range': parameter 1 is not of type 'Node'.`);
+    }
+    if (node.nodeType === NODE_DOCTYPE) {
+      throw new globalThis.DOMException(`Failed to execute '${fn}' on 'Range': the node is a doctype.`, "InvalidNodeTypeError");
+    }
+    offset = offset >>> 0;
+    if (offset > nodeLength(node)) {
+      throw new globalThis.DOMException(`Failed to execute '${fn}' on 'Range': the offset ${offset} is larger than the node's length.`, "IndexSizeError");
+    }
+    const newRoot = ancestorChain(node)[0];
+    if (which === "start") {
+      const endRoot = range.endContainer && ancestorChain(range.endContainer)[0];
+      if (newRoot !== endRoot || compareBoundaryPoint(node, offset, range.endContainer, range.endOffset) > 0) {
+        range.endContainer = node;
+        range.endOffset = offset;
+      }
+      range.startContainer = node;
+      range.startOffset = offset;
+    } else {
+      const startRoot = range.startContainer && ancestorChain(range.startContainer)[0];
+      if (newRoot !== startRoot || compareBoundaryPoint(node, offset, range.startContainer, range.startOffset) < 0) {
+        range.startContainer = node;
+        range.startOffset = offset;
+      }
+      range.endContainer = node;
+      range.endOffset = offset;
+    }
+    range._track();
+  }
+  __name(setRangeBoundary, "setRangeBoundary");
+  function boundaryRelativeToNode(range, node, which, after) {
+    const fn = (which === "start" ? "setStart" : "setEnd") + (after ? "After" : "Before");
+    const parent = node && node._parent;
+    if (!parent) {
+      throw new globalThis.DOMException(`Failed to execute '${fn}' on 'Range': the node has no parent.`, "InvalidNodeTypeError");
+    }
+    const index = parent._children.indexOf(node);
+    setRangeBoundary(range, parent, index + (after ? 1 : 0), which);
+  }
+  __name(boundaryRelativeToNode, "boundaryRelativeToNode");
   var DocumentOrderRange = class _DocumentOrderRange {
     static {
       __name(this, "DocumentOrderRange");
     }
-    constructor() {
-      const doc = globalThis.document || null;
-      this.startContainer = doc;
+    constructor(doc) {
+      const d = doc || globalThis.document || null;
+      this.startContainer = d;
       this.startOffset = 0;
-      this.endContainer = doc;
+      this.endContainer = d;
       this.endOffset = 0;
+      this._reg = null;
+      this._track();
+    }
+    // (Re-)register this range in its current document's live-range set. Called
+    // after every boundary change so a range that moves to another document is
+    // tracked there (the registry hangs off the shared document, not a realm).
+    _track() {
+      const sc = this.startContainer;
+      const d = sc && (sc.nodeType === NODE_DOC ? sc : sc.ownerDocument);
+      const reg = d ? d._liveRanges || (d._liveRanges = /* @__PURE__ */ new Set()) : null;
+      if (reg === this._reg) return;
+      if (this._reg) this._reg.delete(this);
+      this._reg = reg;
+      if (reg) reg.add(this);
     }
     setStart(node, offset) {
-      this.startContainer = node;
-      this.startOffset = offset | 0;
+      setRangeBoundary(this, node, offset, "start");
     }
     setEnd(node, offset) {
-      this.endContainer = node;
-      this.endOffset = offset | 0;
-    }
-    // Boundary helpers — node-relative variants of setStart / setEnd.
-    // `setStartBefore(n)` puts the range start at (n.parentNode,
-    // indexOf(n)); `setStartAfter` adds 1; ditto for end. Per HTML
-    // spec — the offset is the position of `n` among its parent's
-    // children. The old "offset=0" approximation broke partial-quote
-    // tests where the range was supposed to skip past leading
-    // siblings, and quote-reply's cloneContents walked from the
-    // wrong start position.
+      setRangeBoundary(this, node, offset, "end");
+    }
     setStartBefore(node) {
-      const p = node && node._parent;
-      this.startContainer = p || node;
-      this.startOffset = p ? p._children.indexOf(node) : 0;
+      boundaryRelativeToNode(this, node, "start", false);
     }
     setStartAfter(node) {
-      const p = node && node._parent;
-      this.startContainer = p || node;
-      this.startOffset = p ? p._children.indexOf(node) + 1 : 0;
+      boundaryRelativeToNode(this, node, "start", true);
     }
     setEndBefore(node) {
-      const p = node && node._parent;
-      this.endContainer = p || node;
-      this.endOffset = p ? p._children.indexOf(node) : 0;
+      boundaryRelativeToNode(this, node, "end", false);
     }
     setEndAfter(node) {
-      const p = node && node._parent;
-      this.endContainer = p || node;
-      this.endOffset = p ? p._children.indexOf(node) + 1 : 0;
-    }
-    // Real DOM: selectNode sets the range to span the given node
-    // *within* its parent. Collapse moves both endpoints to one side.
-    // Consumers here only care that the start container ends up
-    // referring to the node we passed.
-    selectNode(node) {
-      this.startContainer = this.endContainer = node;
-      this.startOffset = this.endOffset = 0;
+      boundaryRelativeToNode(this, node, "end", true);
     }
+    // selectNode spans `node` within its parent: start (parent, index),
+    // end (parent, index+1). A parentless node → InvalidNodeTypeError.
+    selectNode(node) {
+      const parent = node && node._parent;
+      if (!parent) {
+        throw new globalThis.DOMException("Failed to execute 'selectNode' on 'Range': the node has no parent.", "InvalidNodeTypeError");
+      }
+      const index = parent._children.indexOf(node);
+      this.startContainer = parent;
+      this.startOffset = index;
+      this.endContainer = parent;
+      this.endOffset = index + 1;
+      this._track();
+    }
+    // selectNodeContents spans the whole node: start (node, 0), end (node, length).
+    // A doctype has no contents to select → InvalidNodeTypeError.
     selectNodeContents(node) {
+      if (node.nodeType === NODE_DOCTYPE) {
+        throw new globalThis.DOMException("Failed to execute 'selectNodeContents' on 'Range': the node is a doctype.", "InvalidNodeTypeError");
+      }
       this.startContainer = this.endContainer = node;
       this.startOffset = 0;
-      this.endOffset = node.nodeType === NODE_TEXT ? (node.data || "").length : node._children ? node._children.length : 0;
+      this.endOffset = nodeLength(node);
+      this._track();
     }
     // `Range.createContextualFragment(html)` — parse `html` as a fragment using
     // the range's start node as context, returning a DocumentFragment owned by the
@@ -11992,9 +12500,7 @@
       return cloneRangeContents(this);
     }
     extractContents() {
-      const frag = cloneRangeContents(this);
-      deleteRangeContents(this);
-      return frag;
+      return extractRangeContents(this);
     }
     // Spec: removes everything inside the range from its container.
     // Turbo's `FrameRenderer` calls `selectNodeContents(currentElement);
@@ -12030,6 +12536,7 @@
       r.startOffset = this.startOffset;
       r.endContainer = this.endContainer;
       r.endOffset = this.endOffset;
+      r._track();
       return r;
     }
     // DOM spec Range#toString: concatenates the text of all Text nodes
@@ -12069,35 +12576,50 @@
     // containers, inserts at child index `startOffset`. Tiptap /
     // ProseMirror's text-insertion fallback uses this.
     insertNode(node) {
+      if (!isNodeArg(node)) throw new TypeError("Failed to execute 'insertNode' on 'Range': parameter 1 is not of type 'Node'.");
       const sc = this.startContainer;
-      if (!sc) return;
-      if (sc.nodeType === NODE_TEXT) {
-        const parent = sc._parent;
-        if (!parent) return;
-        const text = sc.data || "";
-        const before = text.slice(0, this.startOffset);
-        const after = text.slice(this.startOffset);
-        sc.data = before;
-        const idx = parent._children.indexOf(sc);
-        if (after.length > 0) {
-          const tail = new Text(after);
-          parent.insertBefore(tail, parent._children[idx + 1] || null);
-        }
-        parent.insertBefore(node, parent._children[idx + 1] || null);
-      } else {
-        const ref = sc._children ? sc._children[this.startOffset] : null;
-        sc.insertBefore(node, ref || null);
+      const startIsText = sc.nodeType === NODE_TEXT || sc.nodeType === NODE_CDATA;
+      if (sc.nodeType === NODE_PI || sc.nodeType === NODE_COMMENT || startIsText && !sc._parent || node === sc || nodeContains(node, sc)) {
+        throw new globalThis.DOMException("Failed to execute 'insertNode' on 'Range': the node may not be inserted here.", "HierarchyRequestError");
+      }
+      let referenceNode = startIsText ? sc : sc._children ? sc._children[this.startOffset] || null : null;
+      const parent = referenceNode == null ? sc : referenceNode._parent;
+      ensurePreInsertionValidity(node, parent, referenceNode);
+      if (startIsText) referenceNode = sc.splitText(this.startOffset);
+      if (node === referenceNode) referenceNode = node.nextSibling;
+      if (node._parent) node._parent.removeChild(node);
+      let newOffset = referenceNode == null ? nodeLength(parent) : parent._children.indexOf(referenceNode);
+      newOffset += node.nodeType === NODE_FRAGMENT ? nodeLength(node) : 1;
+      parent.insertBefore(node, referenceNode);
+      if (this.collapsed) {
+        this.endContainer = parent;
+        this.endOffset = newOffset;
       }
-      this.setStartAfter(node);
-      this.collapse(true);
     }
     // Range#surroundContents(newParent): extract range contents, wrap
     // in `newParent`, insert wrapper at the range's start. Used by
     // highlight / annotate libraries.
     surroundContents(newParent) {
-      const frag = this.extractContents();
-      newParent.appendChild(frag);
+      const common = this.commonAncestorContainer;
+      const partialNonText = /* @__PURE__ */ __name((boundary, other) => {
+        if (nodeContains(boundary, other)) return false;
+        for (let n = boundary; n && n !== common; n = n._parent) {
+          if (n.nodeType !== NODE_TEXT && n.nodeType !== NODE_CDATA) return true;
+        }
+        return false;
+      }, "partialNonText");
+      if (partialNonText(this.startContainer, this.endContainer) || partialNonText(this.endContainer, this.startContainer)) {
+        throw new globalThis.DOMException("Failed to execute 'surroundContents' on 'Range': the range partially selects a non-Text node.", "InvalidStateError");
+      }
+      const nt = newParent.nodeType;
+      if (nt === NODE_DOC || nt === NODE_DOCTYPE || nt === NODE_FRAGMENT) {
+        throw new globalThis.DOMException("Failed to execute 'surroundContents' on 'Range': the new parent is a Document, DocumentType, or DocumentFragment node.", "InvalidNodeTypeError");
+      }
+      const fragment = extractRangeContents(this);
+      if (newParent._children) for (const c of newParent._children.slice()) newParent.removeChild(c);
       this.insertNode(newParent);
+      newParent.appendChild(fragment);
+      this.selectNode(newParent);
     }
     // Range#comparePoint(node, offset) — -1/0/+1 vs the range.
     // Range#isPointInRange(node, offset) — true if inside.
@@ -12106,12 +12628,30 @@
       if (ancestorChain(node)[0] !== ancestorChain(this.startContainer)[0]) {
         throw new globalThis.DOMException("The node provided is in a different tree than this Range.", "WrongDocumentError");
       }
-      if (compareDocOrder(node, this.startContainer) < 0) return -1;
-      if (compareDocOrder(node, this.endContainer) > 0) return 1;
+      if (node.nodeType === NODE_DOCTYPE) {
+        throw new globalThis.DOMException("Failed to execute 'comparePoint' on 'Range': the node is a doctype.", "InvalidNodeTypeError");
+      }
+      offset = offset >>> 0;
+      if (offset > nodeLength(node)) {
+        throw new globalThis.DOMException(`Failed to execute 'comparePoint' on 'Range': the offset ${offset} is larger than the node's length.`, "IndexSizeError");
+      }
+      if (compareBoundaryPoint(node, offset, this.startContainer, this.startOffset) < 0) return -1;
+      if (compareBoundaryPoint(node, offset, this.endContainer, this.endOffset) > 0) return 1;
       return 0;
     }
     isPointInRange(node, offset) {
-      return this.comparePoint(node, offset) === 0;
+      if (!isNodeArg(node)) throw new TypeError("Failed to execute 'isPointInRange' on 'Range': parameter 1 is not of type 'Node'.");
+      if (ancestorChain(node)[0] !== ancestorChain(this.startContainer)[0]) return false;
+      if (node.nodeType === NODE_DOCTYPE) {
+        throw new globalThis.DOMException("Failed to execute 'isPointInRange' on 'Range': the node is a doctype.", "InvalidNodeTypeError");
+      }
+      offset = offset >>> 0;
+      if (offset > nodeLength(node)) {
+        throw new globalThis.DOMException(`Failed to execute 'isPointInRange' on 'Range': the offset ${offset} is larger than the node's length.`, "IndexSizeError");
+      }
+      if (compareBoundaryPoint(node, offset, this.startContainer, this.startOffset) < 0) return false;
+      if (compareBoundaryPoint(node, offset, this.endContainer, this.endOffset) > 0) return false;
+      return true;
     }
     get collapsed() {
       return this.startContainer === this.endContainer && this.startOffset === this.endOffset;
@@ -12125,8 +12665,40 @@
       while (i < a.length && i < b.length && a[i] === b[i]) i++;
       return i > 0 ? a[i - 1] : this.startContainer;
     }
-    compareBoundaryPoints(_how, other) {
-      return compareDocOrder(this.startContainer, other.startContainer);
+    // compareBoundaryPoints(how, sourceRange): compares the two ranges' boundary
+    // points selected by `how`. `how` is a WebIDL unsigned short; a value outside
+    // {0,1,2,3} → NotSupportedError. Different roots → WrongDocumentError.
+    compareBoundaryPoints(how, other) {
+      how = how & 65535;
+      if (how > 3) {
+        throw new globalThis.DOMException("Failed to execute 'compareBoundaryPoints' on 'Range': the comparison method must be 0, 1, 2 or 3.", "NotSupportedError");
+      }
+      if (ancestorChain(this.startContainer)[0] !== ancestorChain(other.startContainer)[0]) {
+        throw new globalThis.DOMException("The two Ranges are not in the same tree.", "WrongDocumentError");
+      }
+      let tn, to, on, oo;
+      if (how === 0) {
+        tn = this.startContainer;
+        to = this.startOffset;
+        on = other.startContainer;
+        oo = other.startOffset;
+      } else if (how === 1) {
+        tn = this.endContainer;
+        to = this.endOffset;
+        on = other.startContainer;
+        oo = other.startOffset;
+      } else if (how === 2) {
+        tn = this.endContainer;
+        to = this.endOffset;
+        on = other.endContainer;
+        oo = other.endOffset;
+      } else {
+        tn = this.startContainer;
+        to = this.startOffset;
+        on = other.endContainer;
+        oo = other.endOffset;
+      }
+      return compareBoundaryPoint(tn, to, on, oo);
     }
   };
   DocumentOrderRange.START_TO_START = 0;
@@ -12176,54 +12748,6 @@
     return cur && cur._parent === ancestor ? cur : null;
   }
   __name(__rangeAncestorChild, "__rangeAncestorChild");
-  function __appendCloned(parent, child) {
-    child._parent = parent;
-    parent._children.push(child);
-  }
-  __name(__appendCloned, "__appendCloned");
-  function __emitSlice(target, subtree, startCut, endCut) {
-    const kids = subtree._children || [];
-    let startIdx = 0, startChild = null;
-    if (startCut) {
-      if (startCut.container === subtree) {
-        startIdx = startCut.offset;
-      } else {
-        startChild = __rangeAncestorChild(subtree, startCut.container);
-        if (startChild) startIdx = kids.indexOf(startChild) + 1;
-      }
-    }
-    let endIdx = kids.length, endChild = null;
-    if (endCut) {
-      if (endCut.container === subtree) {
-        endIdx = endCut.offset;
-      } else {
-        endChild = __rangeAncestorChild(subtree, endCut.container);
-        if (endChild) endIdx = kids.indexOf(endChild);
-      }
-    }
-    if (startChild && startChild === endChild) {
-      __appendCloned(target, __cloneSlice(startChild, startCut, endCut));
-      return;
-    }
-    if (startChild) __appendCloned(target, __cloneSlice(startChild, startCut, null));
-    for (let i = startIdx; i < endIdx; i++) {
-      if (kids[i]) __appendCloned(target, kids[i].cloneNode(true));
-    }
-    if (endChild) __appendCloned(target, __cloneSlice(endChild, null, endCut));
-  }
-  __name(__emitSlice, "__emitSlice");
-  function __cloneSlice(subtree, startCut, endCut) {
-    if (subtree.nodeType === NODE_TEXT) {
-      const data = subtree.data || "";
-      const lo = startCut && startCut.container === subtree ? startCut.offset : 0;
-      const hi = endCut && endCut.container === subtree ? endCut.offset : data.length;
-      return new Text(data.slice(lo, hi));
-    }
-    const shell = subtree.cloneNode(false);
-    __emitSlice(shell, subtree, startCut, endCut);
-    return shell;
-  }
-  __name(__cloneSlice, "__cloneSlice");
   function __csimInsertTextAtSelection(text) {
     const sel = globalThis.getSelection && globalThis.getSelection();
     if (!sel || !sel._ranges.length) return false;
@@ -12294,93 +12818,113 @@
   }
   __name(__csimInsertTextAtSelection, "__csimInsertTextAtSelection");
   globalThis.__csimInsertTextAtSelection = __csimInsertTextAtSelection;
-  function __deleteSlice(subtree, startCut, endCut) {
-    if (subtree.nodeType === NODE_TEXT) {
-      const data = subtree.data || "";
-      const lo = startCut && startCut.container === subtree ? startCut.offset : 0;
-      const hi = endCut && endCut.container === subtree ? endCut.offset : data.length;
-      subtree.data = data.slice(0, lo) + data.slice(hi);
-      return;
-    }
-    __emitSliceDelete(subtree, startCut, endCut);
+  function isCharacterData(n) {
+    return n != null && (n.nodeType === NODE_TEXT || n.nodeType === NODE_CDATA || n.nodeType === NODE_COMMENT || n.nodeType === NODE_PI);
   }
-  __name(__deleteSlice, "__deleteSlice");
-  function __emitSliceDelete(subtree, startCut, endCut) {
-    const kids = subtree._children || [];
-    let startIdx = 0, startChild = null;
-    if (startCut) {
-      if (startCut.container === subtree) {
-        startIdx = startCut.offset;
-      } else {
-        startChild = __rangeAncestorChild(subtree, startCut.container);
-        if (startChild) startIdx = kids.indexOf(startChild) + 1;
-      }
-    }
-    let endIdx = kids.length, endChild = null;
-    if (endCut) {
-      if (endCut.container === subtree) {
-        endIdx = endCut.offset;
-      } else {
-        endChild = __rangeAncestorChild(subtree, endCut.container);
-        if (endChild) endIdx = kids.indexOf(endChild);
-      }
-    }
-    if (startChild && startChild === endChild) {
-      __deleteSlice(startChild, startCut, endCut);
-      return;
+  __name(isCharacterData, "isCharacterData");
+  function processRangeContents(range, mode) {
+    const sc = range.startContainer, so = range.startOffset;
+    const ec = range.endContainer, eo = range.endOffset;
+    const ownerDoc = sc && (sc.nodeType === NODE_DOC ? sc : sc.ownerDocument) || globalThis.document;
+    const frag = mode === "delete" ? null : ownerDoc.createDocumentFragment();
+    if (!sc || !ec) return frag;
+    if (sc === ec && so === eo) return frag;
+    if (sc === ec && isCharacterData(sc)) {
+      if (mode !== "delete") {
+        const clone = sc.cloneNode(false);
+        clone._data = (sc.data || "").slice(so, eo);
+        frag.appendChild(clone);
+      }
+      if (mode !== "clone") sc._replaceData(so, eo - so, "");
+      return frag;
     }
-    if (startChild) __deleteSlice(startChild, startCut, null);
-    if (endChild) __deleteSlice(endChild, null, endCut);
-    for (let i = endIdx - 1; i >= startIdx; i--) {
-      if (kids[i]) subtree.removeChild(kids[i]);
+    const common = range.commonAncestorContainer;
+    const firstPC = nodeContains(sc, ec) ? null : __rangeAncestorChild(common, sc);
+    const lastPC = nodeContains(ec, sc) ? null : __rangeAncestorChild(common, ec);
+    const contained = [];
+    const kids = common._children || [];
+    for (let i = 0; i < kids.length; i++) {
+      if (compareBoundaryPoint(common, i, sc, so) >= 0 && compareBoundaryPoint(common, i + 1, ec, eo) <= 0) {
+        contained.push(kids[i]);
+      }
+    }
+    let newNode = sc, newOffset = so;
+    if (mode !== "clone" && !nodeContains(sc, ec)) {
+      let ref = sc;
+      while (ref._parent && !nodeContains(ref._parent, ec)) ref = ref._parent;
+      newNode = ref._parent;
+      newOffset = newNode._children.indexOf(ref) + 1;
+    }
+    if (isCharacterData(firstPC)) {
+      if (mode !== "delete") {
+        const clone = sc.cloneNode(false);
+        clone._data = (sc.data || "").slice(so);
+        frag.appendChild(clone);
+      }
+      if (mode !== "clone") sc._replaceData(so, nodeLength(sc) - so, "");
+    } else if (firstPC) {
+      let clone = null;
+      if (mode !== "delete") {
+        clone = firstPC.cloneNode(false);
+        frag.appendChild(clone);
+      }
+      const sub = new DocumentOrderRange(ownerDoc);
+      sub.startContainer = sc;
+      sub.startOffset = so;
+      sub.endContainer = firstPC;
+      sub.endOffset = nodeLength(firstPC);
+      const subResult = processRangeContents(sub, mode);
+      if (clone) clone.appendChild(subResult);
+      if (sub._reg) sub._reg.delete(sub);
+    }
+    for (const child of contained) {
+      if (mode === "clone") frag.appendChild(child.cloneNode(true));
+      else if (mode === "extract") frag.appendChild(child);
+      else if (child._parent) child._parent.removeChild(child);
+    }
+    if (isCharacterData(lastPC)) {
+      if (mode !== "delete") {
+        const clone = ec.cloneNode(false);
+        clone._data = (ec.data || "").slice(0, eo);
+        frag.appendChild(clone);
+      }
+      if (mode !== "clone") ec._replaceData(0, eo, "");
+    } else if (lastPC) {
+      let clone = null;
+      if (mode !== "delete") {
+        clone = lastPC.cloneNode(false);
+        frag.appendChild(clone);
+      }
+      const sub = new DocumentOrderRange(ownerDoc);
+      sub.startContainer = lastPC;
+      sub.startOffset = 0;
+      sub.endContainer = ec;
+      sub.endOffset = eo;
+      const subResult = processRangeContents(sub, mode);
+      if (clone) clone.appendChild(subResult);
+      if (sub._reg) sub._reg.delete(sub);
+    }
+    if (mode !== "clone") {
+      range.startContainer = newNode;
+      range.startOffset = newOffset;
+      range.endContainer = newNode;
+      range.endOffset = newOffset;
     }
+    return frag;
   }
-  __name(__emitSliceDelete, "__emitSliceDelete");
+  __name(processRangeContents, "processRangeContents");
   function deleteRangeContents(range) {
-    const sc = range.startContainer, so = range.startOffset | 0;
-    const ec = range.endContainer, eo = range.endOffset | 0;
-    if (sc === ec && sc && sc.nodeType === NODE_TEXT) {
-      const data = sc.data || "";
-      sc.data = data.slice(0, so) + data.slice(eo);
-      range.endOffset = range.startOffset;
-    } else if (sc === ec && sc && sc._children) {
-      const end = Math.min(eo, sc._children.length);
-      const doomed = sc._children.slice(so, end);
-      for (const child of doomed) sc.removeChild(child);
-      range.endOffset = range.startOffset;
-      range.endContainer = range.startContainer;
-    } else if (sc && ec) {
-      const ancestor = range.commonAncestorContainer;
-      if (ancestor) {
-        __deleteSlice(ancestor, { container: sc, offset: so }, { container: ec, offset: eo });
-      }
-      range.endContainer = sc;
-      range.endOffset = so;
-    }
+    processRangeContents(range, "delete");
   }
   __name(deleteRangeContents, "deleteRangeContents");
   function cloneRangeContents(range) {
-    const frag = new DocumentFragment();
-    if (!range.startContainer || !range.endContainer) return frag;
-    const sc = range.startContainer, so = range.startOffset;
-    const ec = range.endContainer, eo = range.endOffset;
-    if (sc === ec) {
-      if (sc.nodeType === NODE_TEXT) {
-        __appendCloned(frag, new Text((sc.data || "").slice(so, eo)));
-      } else if (sc._children) {
-        for (let i = so; i < Math.min(eo, sc._children.length); i++) {
-          __appendCloned(frag, sc._children[i].cloneNode(true));
-        }
-      }
-      return frag;
-    }
-    const ancestor = range.commonAncestorContainer;
-    if (ancestor) {
-      __emitSlice(frag, ancestor, { container: sc, offset: so }, { container: ec, offset: eo });
-    }
-    return frag;
+    return processRangeContents(range, "clone");
   }
   __name(cloneRangeContents, "cloneRangeContents");
+  function extractRangeContents(range) {
+    return processRangeContents(range, "extract");
+  }
+  __name(extractRangeContents, "extractRangeContents");
   DocumentOrderRange.END_TO_START = 3;
   DocumentOrderRange.prototype.START_TO_START = 0;
   DocumentOrderRange.prototype.START_TO_END = 1;
@@ -12510,7 +13054,7 @@
     assertNodeArg(node);
     if (child != null) assertNodeArg(child);
     const parent = this;
-    if (node.getRootNode() !== parent.getRootNode()) {
+    if (node.getRootNode({ composed: true }) !== parent.getRootNode({ composed: true })) {
       throw hierarchyError("moveBefore: node and new parent are not in the same tree");
     }
     if (isInclusiveAncestor(node, parent)) {
@@ -12549,6 +13093,7 @@
     askForReset(node);
     if (oldParent) recordChildList(oldParent, [], [node], prevSib, nextSib);
     recordChildList(parent, [node], []);
+    if (isConnected(node)) fireCEMoveReactions(node);
     return void 0;
   }
   __name(moveBeforeImpl, "moveBeforeImpl");
@@ -12612,7 +13157,7 @@
     return el._attrNodeFor(key);
   }
   __name(makeAttr, "makeAttr");
-  var { parseDocument, parseFragment } = installHtmlParser({ Document, Element, Text, Comment, DocumentFragment, DocumentType });
+  var { parseDocument, parseFragment } = installHtmlParser({ Document, Element, Text, Comment, DocumentFragment, DocumentType, createHtmlPageDocument, registerNamedAccess });
   var { parseXml } = installXmlParser({ Element, Text, Comment, ProcessingInstruction, CDATASection, DocumentType });
 
   // lib/capybara/simulated/js/src/abort.js
@@ -15038,10 +15583,12 @@
     const subAction = submitter && submitter._attrs && submitter._attrs.formaction;
     const subMethod = submitter && submitter._attrs && submitter._attrs.formmethod;
     const subEnctype = submitter && submitter._attrs && submitter._attrs.formenctype;
+    const subTarget = submitter && submitter._attrs && submitter._attrs.formtarget;
     return {
       action: subAction != null ? subAction : form._attrs.action != null ? form._attrs.action : "",
       method: (subMethod || form._attrs.method || "get").toLowerCase(),
       enctype: (subEnctype || form._attrs.enctype || "application/x-www-form-urlencoded").toLowerCase(),
+      target: subTarget != null ? subTarget : form._attrs.target != null ? form._attrs.target : "",
       fields,
       fileInputs
     };
@@ -15342,6 +15889,28 @@
     const n = handles.get(h);
     return n != null && isConnected(n);
   };
+  globalThis.__csimEnsureFrameRealm = function(h) {
+    const el = lookup(h);
+    if (!el || el._tag !== "iframe" && el._tag !== "frame") return 0;
+    if (typeof globalThis.__csimFrameWindow !== "function") return 0;
+    globalThis.__csimFrameWindow(el);
+    return el._frameRealmId != null ? el._frameRealmId : 0;
+  };
+  globalThis.__csimLocationHref = function() {
+    return globalThis.location && globalThis.location.href || "";
+  };
+  globalThis.__csimRebindFrameRealm = function(h, oldId, newId) {
+    const el = lookup(h);
+    if (el) {
+      el._frameRealmId = newId || null;
+      el._frameWindow = null;
+    }
+    const ids = globalThis.__csimChildRealmIds;
+    if (ids) {
+      if (oldId) ids.delete(oldId);
+      if (newId) ids.add(newId);
+    }
+  };
   globalThis.__csimValue = function(h) {
     const n = lookup(h);
     if (!n || n.nodeType !== NODE_ELEMENT) return null;
@@ -17316,6 +17885,101 @@
     }
   };
   globalThis.BroadcastChannel = BroadcastChannel;
+  var __csimWindowProxies = /* @__PURE__ */ new Map();
+  function csimWindowProxy(handle) {
+    if (handle == null || handle === "") return null;
+    let proxy = __csimWindowProxies.get(handle);
+    if (proxy) return proxy;
+    const location = {
+      get href() {
+        return globalThis.__csimWindowLocation(handle);
+      },
+      set href(v) {
+        globalThis.__csimWindowSetLocation(handle, String(v));
+      },
+      assign(v) {
+        globalThis.__csimWindowSetLocation(handle, String(v));
+      },
+      replace(v) {
+        globalThis.__csimWindowSetLocation(handle, String(v));
+      },
+      toString() {
+        return globalThis.__csimWindowLocation(handle);
+      }
+    };
+    proxy = {
+      get closed() {
+        return !!globalThis.__csimWindowClosed(handle);
+      },
+      close() {
+        globalThis.__csimWindowClose(handle);
+      },
+      focus() {
+      },
+      blur() {
+      },
+      // Cross-window postMessage. The data round-trips JS→Ruby→JS through the
+      // host marshaller rather than a true structured-clone: plain
+      // primitives/arrays/objects survive, but `undefined`→null, functions /
+      // symbols drop (no DataCloneError is thrown), and prototypes/identity are
+      // lost — fine for the JSON-ish payloads postMessage carries in practice.
+      // `targetOrigin` is accepted but, like the single-origin model elsewhere,
+      // not enforced.
+      postMessage(data, targetOrigin, _transfer) {
+        globalThis.__csimWindowPostMessage(handle, data, String(targetOrigin == null ? "*" : targetOrigin));
+      },
+      get location() {
+        return location;
+      },
+      set location(v) {
+        location.href = v;
+      },
+      get window() {
+        return proxy;
+      },
+      get self() {
+        return proxy;
+      },
+      get __csimWindowHandle() {
+        return handle;
+      }
+    };
+    __csimWindowProxies.set(handle, proxy);
+    return proxy;
+  }
+  __name(csimWindowProxy, "csimWindowProxy");
+  globalThis.open = function(url, name, _features) {
+    const fn = globalThis.__csimWindowOpen;
+    if (typeof fn !== "function") return null;
+    const handle = fn(url == null ? "" : String(url), name == null ? "" : String(name));
+    return handle ? csimWindowProxy(handle) : null;
+  };
+  var __csimOpenerOverride;
+  Object.defineProperty(globalThis, "opener", {
+    configurable: true,
+    get() {
+      if (__csimOpenerOverride !== void 0) return __csimOpenerOverride;
+      const fn = globalThis.__csimWindowOpener;
+      const handle = typeof fn === "function" ? fn() : null;
+      return handle ? csimWindowProxy(handle) : null;
+    },
+    set(v) {
+      __csimOpenerOverride = v;
+    }
+  });
+  globalThis.__csim_deliverWindowMessages = function(events) {
+    if (!events || !events.length) return;
+    for (const ev of events) {
+      const source = ev && ev.sourceHandle ? csimWindowProxy(ev.sourceHandle) : null;
+      dispatchWithOnHandler(globalThis, new MessageEvent("message", {
+        data: ev ? ev.data : void 0,
+        origin: ev && ev.origin || "",
+        source,
+        lastEventId: "",
+        ports: []
+      }));
+    }
+  };
   globalThis.NodeFilter = {
     SHOW_ALL: 4294967295,
     SHOW_ELEMENT: 1,
@@ -17816,10 +18480,15 @@
       this._url = _url || null;
       if (typeof init === "string") {
         this._parseQuery(init);
+      } else if (Array.isArray(init)) {
+        for (const e of init) {
+          if (e == null || e.length !== 2) {
+            throw new TypeError("Failed to construct 'URLSearchParams': each pair must have exactly two elements.");
+          }
+          this._entries.push([String(e[0]), String(e[1])]);
+        }
       } else if (init && typeof init.forEach === "function") {
         init.forEach((v, k) => this._entries.push([String(k), String(v)]));
-      } else if (Array.isArray(init)) {
-        for (const e of init) this._entries.push([String(e[0]), String(e[1])]);
       } else if (init && typeof init === "object") {
         for (const k of Object.keys(init)) this._entries.push([k, String(init[k])]);
       }
@@ -18347,7 +19016,7 @@
     function fireCEConnect(subtree) {
       walkSubtree(subtree, (el) => {
         if (el.nodeType !== NODE_ELEMENT) return;
-        if (!__inHTMLGrafting && el._tag === "script" && !el._csimRan) maybeRunScript(el);
+        if (!__inHTMLGrafting && el._tag === "script" && !el._csimRan && el.isConnected) maybeRunScript(el);
         if (el._tag === "link") maybeFireLinkLoad(el);
         if (el._tag === "iframe" || el._tag === "frame") maybeFireFrameLoad(el);
         ceTryConnect(el);
@@ -18409,9 +19078,9 @@
     function maybeRunScript(el) {
       const type = (el._attrs.type || "").toLowerCase();
       if (type && type !== "text/javascript" && type !== "application/javascript" && type !== "application/x-javascript" && type !== "text/ecmascript") return;
-      el._csimRan = true;
       let body;
       if (el._attrs.src) {
+        el._csimRan = true;
         try {
           const resp = __rackFetch("GET", el._attrs.src, "", null, "follow");
           if (!resp || resp.status >= 400) {
@@ -18423,12 +19092,14 @@
           dispatchScriptLoad(el, false);
           return;
         }
+        if (!body) {
+          dispatchScriptLoad(el, true);
+          return;
+        }
       } else {
         body = scriptText(el);
-      }
-      if (!body) {
-        dispatchScriptLoad(el, true);
-        return;
+        if (!body) return;
+        el._csimRan = true;
       }
       const label = el._attrs.src || "inline://" + hashStr(body);
       let _ok = true;
@@ -18441,6 +19112,11 @@
       dispatchScriptLoad(el, _ok);
     }
     __name(maybeRunScript, "maybeRunScript");
+    globalThis.__csimScriptChildrenChanged = function(el) {
+      if (!__inHTMLGrafting && el && el._tag === "script" && !el._csimRan && el.isConnected) {
+        maybeRunScript(el);
+      }
+    };
     globalThis.Document = Document;
     globalThis.Element = Element;
     installXPath(Document.prototype);
@@ -18453,7 +19129,7 @@
     installNodeConstants(Node);
     globalThis.Text = Text;
     installDomClassAliases({ Element, Document, Text });
-    globalThis.document = new Document();
+    globalThis.document = createHtmlPageDocument(true);
     globalThis.window = globalThis;
     globalThis.EventTarget = EventTarget;
     globalThis.Blob = Blob;
@@ -18487,17 +19163,19 @@
         });
         const ownerURL = (this._ownerDoc || globalThis.document).URL;
         if (ownerURL) doc._url = ownerURL;
+        doc._noBrowsingContext = true;
         return doc;
       }
     };
     function parseXMLDocument(xml) {
       const doc = new Document();
       doc._children = newChildList();
-      doc.documentElement = null;
+      doc._url = void 0;
+      doc._noBrowsingContext = false;
+      doc.readyState = "loading";
       for (const node of parseXml(String(xml == null ? "" : xml))) {
         node._parent = doc;
         doc._children.push(node);
-        if (node.nodeType === NODE_ELEMENT && !doc.documentElement) doc.documentElement = node;
       }
       return doc;
     }
@@ -18555,7 +19233,8 @@
         }
       }
       if (typeof globalThis.__csim_createFrameRealm === "function" && globalThis.RustyRacer && typeof globalThis.RustyRacer.contextGlobal === "function") {
-        const id = globalThis.__csim_createFrameRealm(frameUrl, body, contentType);
+        const parentId = typeof globalThis.RustyRacer.contextOf === "function" ? globalThis.RustyRacer.contextOf(globalThis) : 0;
+        const id = globalThis.__csim_createFrameRealm(frameUrl, body, contentType, parentId);
         if (id != null) {
           frameEl._frameRealmId = id;
           (globalThis.__csimChildRealmIds || (globalThis.__csimChildRealmIds = /* @__PURE__ */ new Set())).add(id);
@@ -18702,7 +19381,6 @@
           c._parent = null;
         }
         dx._children = newChildList();
-        dx.documentElement = null;
         dx._contentType = __ct;
         for (const c of xmlDoc._children) {
           c._parent = dx;
@@ -18710,7 +19388,6 @@
             n._ownerDoc = dx;
           });
           dx._children.push(c);
-          if (c.nodeType === NODE_ELEMENT && !dx.documentElement) dx.documentElement = c;
         }
         registerSubtree(dx);
         globalThis.__csimFireCEConnect(dx);
@@ -18832,7 +19509,10 @@
         } else {
           body = scriptText(s);
         }
-        if (!body) continue;
+        if (!body) {
+          s._csimRan = false;
+          continue;
+        }
         const label = s._attrs.src || "inline://" + hashStr(body);
         const prevCurrent = globalThis.document && globalThis.document._currentScript;
         if (globalThis.document) globalThis.document._currentScript = s;