diff --git a/dom/nodes/Node-insertBefore.html b/dom/nodes/Node-insertBefore.html
index 6977501501ddf0..ce8b3d8a57bc97 100644
--- a/dom/nodes/Node-insertBefore.html
+++ b/dom/nodes/Node-insertBefore.html
@@ -8,8 +8,11 @@
 <script>
   var insertFunc = Node.prototype.insertBefore;
 </script>
-<script src="pre-insertion-checks.js"></script>
+<script src="pre-insertion-validation-notfound.js"></script>
+<script src="pre-insertion-validation-hierarchy.js"></script>
 <script>
+preInsertionValidateHierarchy("insertBefore");
+
 function testLeafNode(nodeName, createNodeFunction) {
   test(function() {
     var node = createNodeFunction();
@@ -71,30 +74,6 @@
   var doc = document.implementation.createHTMLDocument("title");
   doc.removeChild(doc.documentElement);
 
-  var df = doc.createDocumentFragment();
-  df.appendChild(doc.createElement("a"));
-  df.appendChild(doc.createElement("b"));
-  assert_throws_dom("HierarchyRequestError", function() {
-    doc.insertBefore(df, null);
-  });
-
-  df = doc.createDocumentFragment();
-  df.appendChild(doc.createTextNode("text"));
-  assert_throws_dom("HierarchyRequestError", function() {
-    doc.insertBefore(df, null);
-  });
-
-  df = doc.createDocumentFragment();
-  df.appendChild(doc.createComment("comment"));
-  df.appendChild(doc.createTextNode("text"));
-  assert_throws_dom("HierarchyRequestError", function() {
-    doc.insertBefore(df, null);
-  });
-}, "If the context node is a document, appending a DocumentFragment that contains a text node or too many elements should throw a HierarchyRequestError.")
-test(function() {
-  var doc = document.implementation.createHTMLDocument("title");
-  doc.removeChild(doc.documentElement);
-
   var df = doc.createDocumentFragment();
   df.appendChild(doc.createElement("a"));
   df.appendChild(doc.createElement("b"));
diff --git a/dom/nodes/Node-replaceChild.html b/dom/nodes/Node-replaceChild.html
index e942cfa3ec44c0..74aac67d432af5 100644
--- a/dom/nodes/Node-replaceChild.html
+++ b/dom/nodes/Node-replaceChild.html
@@ -10,7 +10,7 @@
 <script>
   var insertFunc = Node.prototype.replaceChild;
 </script>
-<script src="pre-insertion-checks.js"></script>
+<script src="pre-insertion-validation-notfound.js"></script>
 <script>
 // IDL.
 test(function() {
diff --git a/dom/nodes/ParentNode-append.html b/dom/nodes/ParentNode-append.html
index dcc398f3f586d1..4e101f73a25719 100644
--- a/dom/nodes/ParentNode-append.html
+++ b/dom/nodes/ParentNode-append.html
@@ -4,44 +4,45 @@
 <link rel=help href="https://dom.spec.whatwg.org/#dom-parentnode-append">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
+<script src="pre-insertion-validation-hierarchy.js"></script>
 <script>
+preInsertionValidateHierarchy("append");
 
 function test_append(node, nodeName) {
-
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.append();
         assert_array_equals(parent.childNodes, []);
     }, nodeName + '.append() without any argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.append(null);
         assert_equals(parent.childNodes[0].textContent, 'null');
     }, nodeName + '.append() with null as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.append(undefined);
         assert_equals(parent.childNodes[0].textContent, 'undefined');
     }, nodeName + '.append() with undefined as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.append('text');
         assert_equals(parent.childNodes[0].textContent, 'text');
     }, nodeName + '.append() with only text as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
-        var x = document.createElement('x');
+        const parent = node.cloneNode();
+        const x = document.createElement('x');
         parent.append(x);
         assert_array_equals(parent.childNodes, [x]);
     }, nodeName + '.append() with only one element as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
-        var child = document.createElement('test');
+        const parent = node.cloneNode();
+        const child = document.createElement('test');
         parent.appendChild(child);
         parent.append(null);
         assert_equals(parent.childNodes[0], child);
@@ -49,9 +50,9 @@
     }, nodeName + '.append() with null as an argument, on a parent having a child.');
 
     test(function() {
-        var parent = node.cloneNode();
-        var x = document.createElement('x');
-        var child = document.createElement('test');
+        const parent = node.cloneNode();
+        const x = document.createElement('x');
+        const child = document.createElement('test');
         parent.appendChild(child);
         parent.append(x, 'text');
         assert_equals(parent.childNodes[0], child);
@@ -61,6 +62,6 @@
 }
 
 test_append(document.createElement('div'), 'Element');
-test_append(document.createDocumentFragment(), 'DocumentFrgment');
+test_append(document.createDocumentFragment(), 'DocumentFragment');
 </script>
 </html>
diff --git a/dom/nodes/ParentNode-prepend.html b/dom/nodes/ParentNode-prepend.html
index 644693ffe6d816..f6aa38a2dd58a1 100644
--- a/dom/nodes/ParentNode-prepend.html
+++ b/dom/nodes/ParentNode-prepend.html
@@ -4,44 +4,45 @@
 <link rel=help href="https://dom.spec.whatwg.org/#dom-parentnode-prepend">
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
+<script src="pre-insertion-validation-hierarchy.js"></script>
 <script>
+preInsertionValidateHierarchy("prepend");
 
 function test_prepend(node, nodeName) {
-
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.prepend();
         assert_array_equals(parent.childNodes, []);
     }, nodeName + '.prepend() without any argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.prepend(null);
         assert_equals(parent.childNodes[0].textContent, 'null');
     }, nodeName + '.prepend() with null as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.prepend(undefined);
         assert_equals(parent.childNodes[0].textContent, 'undefined');
     }, nodeName + '.prepend() with undefined as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
+        const parent = node.cloneNode();
         parent.prepend('text');
         assert_equals(parent.childNodes[0].textContent, 'text');
     }, nodeName + '.prepend() with only text as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
-        var x = document.createElement('x');
+        const parent = node.cloneNode();
+        const x = document.createElement('x');
         parent.prepend(x);
         assert_array_equals(parent.childNodes, [x]);
     }, nodeName + '.prepend() with only one element as an argument, on a parent having no child.');
 
     test(function() {
-        var parent = node.cloneNode();
-        var child = document.createElement('test');
+        const parent = node.cloneNode();
+        const child = document.createElement('test');
         parent.appendChild(child);
         parent.prepend(null);
         assert_equals(parent.childNodes[0].textContent, 'null');
@@ -49,9 +50,9 @@
     }, nodeName + '.prepend() with null as an argument, on a parent having a child.');
 
     test(function() {
-        var parent = node.cloneNode();
-        var x = document.createElement('x');
-        var child = document.createElement('test');
+        const parent = node.cloneNode();
+        const x = document.createElement('x');
+        const child = document.createElement('test');
         parent.appendChild(child);
         parent.prepend(x, 'text');
         assert_equals(parent.childNodes[0], x);
@@ -61,6 +62,6 @@
 }
 
 test_prepend(document.createElement('div'), 'Element');
-test_prepend(document.createDocumentFragment(), 'DocumentFrgment');
+test_prepend(document.createDocumentFragment(), 'DocumentFragment');
 </script>
 </html>
diff --git a/dom/nodes/ParentNode-replaceChildren.html b/dom/nodes/ParentNode-replaceChildren.html
new file mode 100644
index 00000000000000..6557db4412847b
--- /dev/null
+++ b/dom/nodes/ParentNode-replaceChildren.html
@@ -0,0 +1,118 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>ParentNode.replaceChildren</title>
+<link rel=help href="https://dom.spec.whatwg.org/#dom-parentnode-replacechildren">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="pre-insertion-validation-hierarchy.js"></script>
+<script>
+  preInsertionValidateHierarchy("replaceChildren");
+
+  function test_replacechildren(node, nodeName) {
+    test(() => {
+      const parent = node.cloneNode();
+      parent.replaceChildren();
+      assert_array_equals(parent.childNodes, []);
+    }, `${nodeName}.replaceChildren() without any argument, on a parent having no child.`);
+
+    test(() => {
+      const parent = node.cloneNode();
+      parent.replaceChildren(null);
+      assert_equals(parent.childNodes[0].textContent, 'null');
+    }, `${nodeName}.replaceChildren() with null as an argument, on a parent having no child.`);
+
+    test(() => {
+      const parent = node.cloneNode();
+      parent.replaceChildren(undefined);
+      assert_equals(parent.childNodes[0].textContent, 'undefined');
+    }, `${nodeName}.replaceChildren() with undefined as an argument, on a parent having no child.`);
+
+    test(() => {
+      const parent = node.cloneNode();
+      parent.replaceChildren('text');
+      assert_equals(parent.childNodes[0].textContent, 'text');
+    }, `${nodeName}.replaceChildren() with only text as an argument, on a parent having no child.`);
+
+    test(() => {
+      const parent = node.cloneNode();
+      const x = document.createElement('x');
+      parent.replaceChildren(x);
+      assert_array_equals(parent.childNodes, [x]);
+    }, `${nodeName}.replaceChildren() with only one element as an argument, on a parent having no child.`);
+
+    test(() => {
+      const parent = node.cloneNode();
+      const child = document.createElement('test');
+      parent.appendChild(child);
+      parent.replaceChildren(null);
+      assert_equals(parent.childNodes.length, 1);
+      assert_equals(parent.childNodes[0].textContent, 'null');
+    }, `${nodeName}.replaceChildren() with null as an argument, on a parent having a child.`);
+
+    test(() => {
+      const parent = node.cloneNode();
+      const x = document.createElement('x');
+      const child = document.createElement('test');
+      parent.appendChild(child);
+      parent.replaceChildren(x, 'text');
+      assert_equals(parent.childNodes.length, 2);
+      assert_equals(parent.childNodes[0], x);
+      assert_equals(parent.childNodes[1].textContent, 'text');
+    }, `${nodeName}.replaceChildren() with one element and text as argument, on a parent having a child.`);
+
+    async_test(t => {
+      let phase = 0;
+
+      const previousParent = node.cloneNode();
+      const insertions = [
+        document.createElement("test1"),
+        document.createElement("test2")
+      ];
+      previousParent.append(...insertions);
+
+      const parent = node.cloneNode();
+      const children = [
+        document.createElement("test3"),
+        document.createElement("test4")
+      ];
+      parent.append(...children);
+
+      const previousObserver = new MutationObserver(mutations => {
+        t.step(() => {
+          assert_equals(phase, 0);
+          assert_equals(mutations.length, 2);
+          for (const [i, mutation] of Object.entries(mutations)) {
+            assert_equals(mutation.type, "childList");
+            assert_equals(mutation.addedNodes.length, 0);
+            assert_equals(mutation.removedNodes.length, 1);
+            assert_equals(mutation.removedNodes[0], insertions[i]);
+          }
+          phase = 1;
+        });
+      });
+      previousObserver.observe(previousParent, { childList: true });
+
+      const observer = new MutationObserver(mutations => {
+        t.step(() => {
+          assert_equals(phase, 1);
+          assert_equals(mutations.length, 1);
+          const mutation = mutations[0];
+          assert_equals(mutation.type, "childList");
+          assert_equals(mutation.addedNodes.length, 2);
+          assert_array_equals([...mutation.addedNodes], insertions);
+          assert_equals(mutation.removedNodes.length, 2);
+          assert_array_equals([...mutation.removedNodes], children);
+        });
+        t.done();
+      });
+      observer.observe(parent, { childList: true });
+
+      parent.replaceChildren(...previousParent.children);
+    }, `${nodeName}.replaceChildren() should move nodes in the right order`);
+  }
+
+  test_replacechildren(document.createElement('div'), 'Element');
+  test_replacechildren(document.createDocumentFragment(), 'DocumentFragment');
+</script>
+
+</html>
diff --git a/dom/nodes/pre-insertion-validation-hierarchy.js b/dom/nodes/pre-insertion-validation-hierarchy.js
new file mode 100644
index 00000000000000..6ef2576df2c70b
--- /dev/null
+++ b/dom/nodes/pre-insertion-validation-hierarchy.js
@@ -0,0 +1,86 @@
+/**
+ * Validations where `child` argument is irrelevant.
+ * @param {Function} methodName
+ */
+function preInsertionValidateHierarchy(methodName) {
+  function insert(parent, node) {
+    if (parent[methodName].length > 1) {
+      // This is for insertBefore(). We can't blindly pass `null` for all methods
+      // as doing so will move nodes before validation.
+      parent[methodName](node, null);
+    } else {
+      parent[methodName](node);
+    }
+  }
+
+  // Step 2
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    assert_throws_dom("HierarchyRequestError", () => insert(doc.body, doc.body));
+    assert_throws_dom("HierarchyRequestError", () => insert(doc.body, doc.documentElement));
+  }, "If node is a host-including inclusive ancestor of parent, then throw a HierarchyRequestError DOMException.");
+
+  // Step 4
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    const doc2 = document.implementation.createHTMLDocument("title2");
+    assert_throws_dom("HierarchyRequestError", () => insert(doc, doc2));
+  }, "If node is not a DocumentFragment, DocumentType, Element, Text, ProcessingInstruction, or Comment node, then throw a HierarchyRequestError DOMException.");
+
+  // Step 5, in case of inserting a text node into a document
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    assert_throws_dom("HierarchyRequestError", () => insert(doc, doc.createTextNode("text")));
+  }, "If node is a Text node and parent is a document, then throw a HierarchyRequestError DOMException.");
+
+  // Step 5, in case of inserting a doctype into a non-document
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    const doctype = doc.childNodes[0];
+    assert_throws_dom("HierarchyRequestError", () => insert(doc.createElement("a"), doctype));
+  }, "If node is a doctype and parent is not a document, then throw a HierarchyRequestError DOMException.")
+
+  // Step 6, in case of DocumentFragment including multiple elements
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    doc.documentElement.remove();
+    const df = doc.createDocumentFragment();
+    df.appendChild(doc.createElement("a"));
+    df.appendChild(doc.createElement("b"));
+    assert_throws_dom("HierarchyRequestError", () => insert(doc, df));
+  }, "If node is a DocumentFragment with multiple elements and parent is a document, then throw a HierarchyRequestError DOMException.");
+
+  // Step 6, in case of DocumentFragment has multiple elements when document already has an element
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    const df = doc.createDocumentFragment();
+    df.appendChild(doc.createElement("a"));
+    assert_throws_dom("HierarchyRequestError", () => insert(doc, df));
+  }, "If node is a DocumentFragment with an element and parent is a document with another element, then throw a HierarchyRequestError DOMException.");
+
+  // Step 6, in case of an element
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    const el = doc.createElement("a");
+    assert_throws_dom("HierarchyRequestError", () => insert(doc, el));
+  }, "If node is an Element and parent is a document with another element, then throw a HierarchyRequestError DOMException.");
+
+  // Step 6, in case of a doctype when document already has another doctype
+  test(() => {
+    const doc = document.implementation.createHTMLDocument("title");
+    const doctype = doc.childNodes[0].cloneNode();
+    doc.documentElement.remove();
+    assert_throws_dom("HierarchyRequestError", () => insert(doc, doctype));
+  }, "If node is a doctype and parent is a document with another doctype, then throw a HierarchyRequestError DOMException.");
+
+  // Step 6, in case of a doctype when document has an element
+  if (methodName !== "prepend") {
+    // Skip `.prepend` as this doesn't throw if `child` is an element
+    test(() => {
+      const doc = document.implementation.createHTMLDocument("title");
+      const doctype = doc.childNodes[0].cloneNode();
+      doc.childNodes[0].remove();
+      assert_throws_dom("HierarchyRequestError", () => insert(doc, doctype));
+    }, "If node is a doctype and parent is a document with an element, then throw a HierarchyRequestError DOMException.");
+  }
+}
diff --git a/dom/nodes/pre-insertion-checks.js b/dom/nodes/pre-insertion-validation-notfound.js
similarity index 100%
rename from dom/nodes/pre-insertion-checks.js
rename to dom/nodes/pre-insertion-validation-notfound.js