capybara-simulated 0.1.0 → 0.1.1

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

@@ -3681,7 +3681,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 }) {
     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 +3690,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 +3698,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");
@@ -7071,9 +7070,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 +7433,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,6 +7848,7 @@
       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;
@@ -7868,9 +7871,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,7 +7893,9 @@
       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 (isConnected(this)) globalThis.__csimFireCEConnect(child);
@@ -7908,6 +7915,8 @@
       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);
@@ -7930,6 +7939,7 @@
       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 (isConnected(this)) globalThis.__csimFireCEConnect(child);
@@ -7959,9 +7969,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 +8068,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 +8131,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 +8161,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
@@ -8473,6 +8493,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
@@ -10847,7 +10868,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 +11071,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 +11122,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 +11137,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 +11377,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
@@ -11307,95 +11429,19 @@
       });
       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 +11450,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 +11947,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 +12281,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 +12317,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 +12357,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 +12409,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 +12446,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 +12529,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 +12599,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 +12835,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)) {
@@ -12612,7 +12937,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 });
   var { parseXml } = installXmlParser({ Element, Text, Comment, ProcessingInstruction, CDATASection, DocumentType });
 
   // lib/capybara/simulated/js/src/abort.js
@@ -17816,10 +18141,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])]);
       }
@@ -18453,7 +18783,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;
@@ -18493,11 +18823,12 @@
     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;
     }
@@ -18702,7 +19033,6 @@
           c._parent = null;
         }
         dx._children = newChildList();
-        dx.documentElement = null;
         dx._contentType = __ct;
         for (const c of xmlDoc._children) {
           c._parent = dx;
@@ -18710,7 +19040,6 @@
             n._ownerDoc = dx;
           });
           dx._children.push(c);
-          if (c.nodeType === NODE_ELEMENT && !dx.documentElement) dx.documentElement = c;
         }
         registerSubtree(dx);
         globalThis.__csimFireCEConnect(dx);