diff --git a/src/Xml/Dom/Assert/assert_cdata.php b/src/Xml/Dom/Assert/assert_cdata.php
index 21ca62af..b9c21673 100644
--- a/src/Xml/Dom/Assert/assert_cdata.php
+++ b/src/Xml/Dom/Assert/assert_cdata.php
@@ -4,15 +4,15 @@
 
 namespace VeeWee\Xml\Dom\Assert;
 
-use \DOM\CdataSection;
+use \DOM\CDATASection;
 use Psl\Type\Exception\AssertException;
 use function Psl\Type\instance_of;
 
 /**
- * @psalm-assert \DOM\CdataSection $node
+ * @psalm-assert \DOM\CDATASection $node
  * @throws AssertException
  */
-function assert_cdata(mixed $node): \DOM\CdataSection
+function assert_cdata(mixed $node): \DOM\CDATASection
 {
-    return instance_of(\DOM\CdataSection::class)->assert($node);
+    return instance_of(\DOM\CDATASection::class)->assert($node);
 }
diff --git a/src/Xml/Dom/Builder/cdata.php b/src/Xml/Dom/Builder/cdata.php
index bcfd39bc..a8e20859 100644
--- a/src/Xml/Dom/Builder/cdata.php
+++ b/src/Xml/Dom/Builder/cdata.php
@@ -5,20 +5,20 @@
 namespace VeeWee\Xml\Dom\Builder;
 
 use Closure;
-use \DOM\CdataSection;
+use \DOM\CDATASection;
 use \DOM\Node;
 use function VeeWee\Xml\Dom\Assert\assert_cdata;
 use function VeeWee\Xml\Dom\Locator\Node\detect_document;
 use function VeeWee\Xml\Internal\configure;
 
 /**
- * @param list<callable(\DOM\CdataSection): \DOM\CdataSection> $configurators
+ * @param list<callable(\DOM\CDATASection): \DOM\CDATASection> $configurators
  *
- * @return Closure(\DOM\Node): \DOM\CdataSection
+ * @return Closure(\DOM\Node): \DOM\CDATASection
  */
 function cdata(string $data, ...$configurators): Closure
 {
-    return static function (\DOM\Node $node) use ($data, $configurators): \DOM\CdataSection {
+    return static function (\DOM\Node $node) use ($data, $configurators): \DOM\CDATASection {
         $document = detect_document($node);
 
         return assert_cdata(
diff --git a/src/Xml/Dom/Builder/escaped_value.php b/src/Xml/Dom/Builder/escaped_value.php
index 2d63b835..4f22482d 100644
--- a/src/Xml/Dom/Builder/escaped_value.php
+++ b/src/Xml/Dom/Builder/escaped_value.php
@@ -13,7 +13,8 @@
 function escaped_value(string $value): Closure
 {
     return static function (\DOM\Element $node) use ($value): \DOM\Element {
-        $node->nodeValue = htmlspecialchars($value, ENT_XML1|ENT_QUOTES);
+        // TODO : Add entity subtitution through appendXML ?
+        $node->textContent = htmlspecialchars($value, ENT_XML1|ENT_QUOTES);
 
         return $node;
     };
diff --git a/src/Xml/Dom/Builder/value.php b/src/Xml/Dom/Builder/value.php
index 48c3eb59..b0afa13a 100644
--- a/src/Xml/Dom/Builder/value.php
+++ b/src/Xml/Dom/Builder/value.php
@@ -13,7 +13,8 @@
 function value(string $value): Closure
 {
     return static function (\DOM\Element $node) use ($value): \DOM\Element {
-        $node->nodeValue = $value;
+        // TODO : Add entity subtitution through appendXML ?
+        $node->textContent = $value;
 
         return $node;
     };
diff --git a/src/Xml/Dom/Collection/NodeList.php b/src/Xml/Dom/Collection/NodeList.php
index 8ead96ad..fa8191e1 100644
--- a/src/Xml/Dom/Collection/NodeList.php
+++ b/src/Xml/Dom/Collection/NodeList.php
@@ -59,6 +59,15 @@ public static function empty(): self
         return new self();
     }
 
+    /**
+     * @param \DOM\HTMLCollection $list
+     * @return NodeList<\DOM\Element>
+     */
+    public static function fromDOMHTMLCollection(\DOM\HTMLCollection $list): self
+    {
+        return new self(...values($list->getIterator()));
+    }
+
     /**
      * @template X of \DOM\Node
      * @param DOMNodeList<X> $list
diff --git a/src/Xml/Dom/Configurator/loader.php b/src/Xml/Dom/Configurator/loader.php
deleted file mode 100644
index fe5bb569..00000000
--- a/src/Xml/Dom/Configurator/loader.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace VeeWee\Xml\Dom\Configurator;
-
-use Closure;
-use \DOM\XMLDocument;
-
-/**
- * @param callable(\DOM\XMLDocument): void $loader
- *
- * @return Closure(\DOM\XMLDocument): \DOM\XMLDocument
- */
-function loader(callable $loader): Closure
-{
-    return static function (\DOM\XMLDocument $document) use ($loader): \DOM\XMLDocument {
-        $loader($document);
-        return $document;
-    };
-}
diff --git a/src/Xml/Dom/Configurator/pretty_print.php b/src/Xml/Dom/Configurator/pretty_print.php
index a6977006..71384406 100644
--- a/src/Xml/Dom/Configurator/pretty_print.php
+++ b/src/Xml/Dom/Configurator/pretty_print.php
@@ -13,7 +13,8 @@
 function pretty_print(): Closure
 {
     return static function (\DOM\XMLDocument $document): \DOM\XMLDocument {
-        $document->preserveWhiteSpace = false;
+        // TODO :  not fully implemented yet in the new API
+        //$document->preserveWhiteSpace = false;
         $document->formatOutput = true;
 
         return $document;
diff --git a/src/Xml/Dom/Configurator/trim_spaces.php b/src/Xml/Dom/Configurator/trim_spaces.php
index 60097497..9b23089a 100644
--- a/src/Xml/Dom/Configurator/trim_spaces.php
+++ b/src/Xml/Dom/Configurator/trim_spaces.php
@@ -13,7 +13,8 @@
 function trim_spaces(): Closure
 {
     return static function (\DOM\XMLDocument $document): \DOM\XMLDocument {
-        $document->preserveWhiteSpace = false;
+        // TODO :  not fully implemented yet in the new API
+        //$document->preserveWhiteSpace = false;
         $document->formatOutput = false;
 
         return $document;
diff --git a/src/Xml/Dom/Configurator/utf8.php b/src/Xml/Dom/Configurator/utf8.php
index 688aaf22..afdeaa2d 100644
--- a/src/Xml/Dom/Configurator/utf8.php
+++ b/src/Xml/Dom/Configurator/utf8.php
@@ -13,7 +13,7 @@
 function utf8(): Closure
 {
     return static function (\DOM\XMLDocument $document): \DOM\XMLDocument {
-        $document->encoding = 'UTF-8';
+        $document->charset = 'UTF-8';
 
         return $document;
     };
diff --git a/src/Xml/Dom/Document.php b/src/Xml/Dom/Document.php
index 61786d1c..bb6b0967 100644
--- a/src/Xml/Dom/Document.php
+++ b/src/Xml/Dom/Document.php
@@ -14,10 +14,7 @@
 use VeeWee\Xml\ErrorHandling\Issue\IssueCollection;
 use VeeWee\Xml\Exception\RuntimeException;
 use function Psl\Vec\map;
-use function VeeWee\Xml\Dom\Configurator\loader;
-use function VeeWee\Xml\Dom\Loader\xml_file_loader;
-use function VeeWee\Xml\Dom\Loader\xml_node_loader;
-use function VeeWee\Xml\Dom\Loader\xml_string_loader;
+use function VeeWee\Xml\Dom\Loader;
 use function VeeWee\Xml\Dom\Locator\document_element;
 use function VeeWee\Xml\Dom\Mapper\xml_string;
 use function VeeWee\Xml\Internal\configure;
@@ -47,18 +44,28 @@ public static function configure(callable ... $configurators): self
     }
 
     /**
+     * @param callable(): XMLDocument $loader
      * @param list<callable(XMLDocument): XMLDocument> $configurators
      *
      * @throws RuntimeException
      */
-    public static function fromXmlFile(string $file, callable ...$configurators): self
+    public static function fromLoader(callable $loader, callable ...$configurators): self
     {
         return new self(
-            configure(...$configurators)(XMLDocument::createFromFile($file))
-            // TODO : What with loader(xml_file_loader($file))
+            configure(...$configurators)($loader())
         );
     }
 
+    /**
+     * @param list<callable(XMLDocument): XMLDocument> $configurators
+     *
+     * @throws RuntimeException
+     */
+    public static function fromXmlFile(string $file, callable ...$configurators): self
+    {
+        return self::fromLoader(Loader\xml_file_loader($file), ...$configurators);
+    }
+
     /**
      * @param non-empty-string $xml
      * @param list<callable(XMLDocument): XMLDocument> $configurators
@@ -67,10 +74,7 @@ public static function fromXmlFile(string $file, callable ...$configurators): se
      */
     public static function fromXmlString(string $xml, callable ...$configurators): self
     {
-        return new self(
-            configure(...$configurators)(XMLDocument::createFromString($xml))
-           // TODO : What with loader(xml_string_loader($file))
-        );
+        return self::fromLoader(Loader\xml_string_loader($xml), ...$configurators);
     }
 
     /**
@@ -80,10 +84,7 @@ public static function fromXmlString(string $xml, callable ...$configurators): s
      */
     public static function fromXmlNode(\DOM\Node $node, callable ...$configurators): self
     {
-        return self::configure(
-            loader(xml_node_loader($node)),
-            ...$configurators
-        );
+        return self::fromLoader(Loader\xml_node_loader($node), ...$configurators);
     }
 
     /**
@@ -93,9 +94,7 @@ public static function fromXmlNode(\DOM\Node $node, callable ...$configurators):
      */
     public static function fromUnsafeDocument(XMLDocument $document, callable ...$configurators): self
     {
-        return new self(
-            configure(...$configurators)($document)
-        );
+        return self::fromLoader(static fn () => $document, ...$configurators);
     }
 
     public function toUnsafeDocument(): XMLDocument
diff --git a/src/Xml/Dom/Loader/Loader.php b/src/Xml/Dom/Loader/Loader.php
index 98b1e5e1..f0c34c9a 100644
--- a/src/Xml/Dom/Loader/Loader.php
+++ b/src/Xml/Dom/Loader/Loader.php
@@ -8,5 +8,5 @@
 
 interface Loader
 {
-    public function __invoke(\DOM\XMLDocument $document): void;
+    public function __invoke(): XMLDocument;
 }
diff --git a/src/Xml/Dom/Loader/load.php b/src/Xml/Dom/Loader/load.php
deleted file mode 100644
index 8f1bc645..00000000
--- a/src/Xml/Dom/Loader/load.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace VeeWee\Xml\Dom\Loader;
-
-use VeeWee\Xml\Exception\RuntimeException;
-use function VeeWee\Xml\ErrorHandling\disallow_issues;
-use function VeeWee\Xml\ErrorHandling\disallow_libxml_false_returns;
-
-/**
- * @param callable(): bool $loader
- * @throws RuntimeException
- */
-function load(callable $loader): void
-{
-    disallow_issues(
-        static function () use ($loader) {
-            disallow_libxml_false_returns(
-                $loader(),
-                'Could not load the DOM Document'
-            );
-        }
-    );
-}
diff --git a/src/Xml/Dom/Loader/xml_file_loader.php b/src/Xml/Dom/Loader/xml_file_loader.php
index a7126ca9..4d719110 100644
--- a/src/Xml/Dom/Loader/xml_file_loader.php
+++ b/src/Xml/Dom/Loader/xml_file_loader.php
@@ -5,21 +5,19 @@
 namespace VeeWee\Xml\Dom\Loader;
 
 use Closure;
-use \DOM\XMLDocument;
+use DOM\XMLDocument;
 use Webmozart\Assert\Assert;
+use function VeeWee\Xml\ErrorHandling\disallow_issues;
 
 /**
  * @param int $options - bitmask of LIBXML_* constants https://www.php.net/manual/en/libxml.constants.php
- * @return Closure(\DOM\XMLDocument): void
+ * @return Closure(): XMLDocument
  */
 function xml_file_loader(string $file, int $options = 0): Closure
 {
-    return static function (\DOM\XMLDocument $document) use ($file, $options): void {
-        load(
-            static function () use ($document, $file, $options): bool {
-                Assert::fileExists($file);
-                return $document->load($file, $options);
-            }
-        );
-    };
+    return static fn () => disallow_issues(static function () use ($file, $options): XMLDocument {
+        Assert::fileExists($file);
+
+        return XMLDocument::createFromFile($file, $options);
+    });
 }
diff --git a/src/Xml/Dom/Loader/xml_node_loader.php b/src/Xml/Dom/Loader/xml_node_loader.php
index 7a5f1ef1..9222cd1a 100644
--- a/src/Xml/Dom/Loader/xml_node_loader.php
+++ b/src/Xml/Dom/Loader/xml_node_loader.php
@@ -6,16 +6,20 @@
 
 use Closure;
 use \DOM\XMLDocument;
-
 use \DOM\Node;
 use function VeeWee\Xml\Dom\Manipulator\Node\append_external_node;
+use function VeeWee\Xml\ErrorHandling\disallow_issues;
 
 /**
- * @return Closure(\DOM\XMLDocument): void
+ * @return Closure(): XMLDocument
  */
 function xml_node_loader(\DOM\Node $importedNode): Closure
 {
-    return static function (\DOM\XMLDocument $document) use ($importedNode): void {
-        load(static fn (): bool => (bool) append_external_node($document, $importedNode));
-    };
+    return static fn () => disallow_issues(static function () use ($importedNode): XMLDocument {
+        $document = XMLDocument::createEmpty();
+
+        append_external_node($document, $importedNode);
+
+        return $document;
+    });
 }
diff --git a/src/Xml/Dom/Loader/xml_string_loader.php b/src/Xml/Dom/Loader/xml_string_loader.php
index 8191be2a..c7dd0977 100644
--- a/src/Xml/Dom/Loader/xml_string_loader.php
+++ b/src/Xml/Dom/Loader/xml_string_loader.php
@@ -6,15 +6,16 @@
 
 use Closure;
 use \DOM\XMLDocument;
+use function VeeWee\Xml\ErrorHandling\disallow_issues;
 
 /**
  * @param non-empty-string $xml
  * @param int $options - bitmask of LIBXML_* constants https://www.php.net/manual/en/libxml.constants.php
- * @return Closure(\DOM\XMLDocument): void
+ * @return Closure(): XMLDocument
  */
 function xml_string_loader(string $xml, int $options = 0): Closure
 {
-    return static function (\DOM\XMLDocument $document) use ($xml, $options): void {
-        load(static fn (): bool => $document->loadXML($xml, $options));
-    };
+    return static fn () => disallow_issues(static function () use ($xml, $options): XMLDocument {
+        return XMLDocument::createFromString($xml, $options);
+    });
 }
diff --git a/src/Xml/Dom/Locator/Element/locate_by_namespaced_tag_name.php b/src/Xml/Dom/Locator/Element/locate_by_namespaced_tag_name.php
index 5124bb5f..55dd2218 100644
--- a/src/Xml/Dom/Locator/Element/locate_by_namespaced_tag_name.php
+++ b/src/Xml/Dom/Locator/Element/locate_by_namespaced_tag_name.php
@@ -12,5 +12,5 @@
  */
 function locate_by_namespaced_tag_name(\DOM\Element $node, string $namespace, string $localTagName): NodeList
 {
-    return NodeList::fromDOMNodeList($node->getElementsByTagNameNS($namespace, $localTagName));
+    return NodeList::fromDOMHTMLCollection($node->getElementsByTagNameNS($namespace, $localTagName));
 }
diff --git a/src/Xml/Dom/Locator/Element/locate_by_tag_name.php b/src/Xml/Dom/Locator/Element/locate_by_tag_name.php
index b134ca20..f299118b 100644
--- a/src/Xml/Dom/Locator/Element/locate_by_tag_name.php
+++ b/src/Xml/Dom/Locator/Element/locate_by_tag_name.php
@@ -12,5 +12,5 @@
  */
 function locate_by_tag_name(\DOM\Element $node, string $tag): NodeList
 {
-    return NodeList::fromDOMNodeList($node->getElementsByTagName($tag));
+    return NodeList::fromDOMHTMLCollection($node->getElementsByTagName($tag));
 }
diff --git a/src/Xml/Dom/Locator/Node/detect_document.php b/src/Xml/Dom/Locator/Node/detect_document.php
index 65112509..86a5c7a5 100644
--- a/src/Xml/Dom/Locator/Node/detect_document.php
+++ b/src/Xml/Dom/Locator/Node/detect_document.php
@@ -16,8 +16,5 @@
  */
 function detect_document(\DOM\Node $node): \DOM\XMLDocument
 {
-    $document = is_document($node) ? $node : $node->ownerDocument;
-    Assert::notNull($document, 'Expected to find an ownerDocument on provided \DOM\Node.');
-
-    return $document;
+    return is_document($node) ? $node : $node->ownerDocument;
 }
diff --git a/src/Xml/Dom/Locator/Node/value.php b/src/Xml/Dom/Locator/Node/value.php
index dc51ad80..c82e77d6 100644
--- a/src/Xml/Dom/Locator/Node/value.php
+++ b/src/Xml/Dom/Locator/Node/value.php
@@ -19,5 +19,8 @@
  */
 function value(\DOM\Node $node, TypeInterface $type)
 {
-    return $type->coerce($node->nodeValue);
+    // TODO : nodeValue did entity substitution
+    // TODO : nodeValue returns null for elements
+    // TODO : How to best deal with this?
+    return $type->coerce($node->textContent ?? '');
 }
diff --git a/src/Xml/Dom/Manipulator/Element/rename.php b/src/Xml/Dom/Manipulator/Element/rename.php
index ae6e8aa1..dca0f633 100644
--- a/src/Xml/Dom/Manipulator/Element/rename.php
+++ b/src/Xml/Dom/Manipulator/Element/rename.php
@@ -4,8 +4,6 @@
 
 namespace VeeWee\Xml\Dom\Manipulator\Element;
 
-use \DOM\Attr;
-use \DOM\Element;
 use \DOM\NameSpaceNode;
 use VeeWee\Xml\Exception\RuntimeException;
 use function VeeWee\Xml\Dom\Builder\element;
@@ -44,7 +42,8 @@ static function (\DOM\NameSpaceNode $attribute) use ($target, $newElement): void
     );
 
     attributes_list($target)->forEach(
-        static function (\DOM\Attr $attribute) use ($newElement): void {
+        static function (\DOM\Attr $attribute) use ($target, $newElement): void {
+            $target->removeAttributeNode($attribute);
             $newElement->setAttributeNode($attribute);
         }
     );
diff --git a/src/Xml/Dom/Mapper/xslt_template.php b/src/Xml/Dom/Mapper/xslt_template.php
index 9862e390..8600b182 100644
--- a/src/Xml/Dom/Mapper/xslt_template.php
+++ b/src/Xml/Dom/Mapper/xslt_template.php
@@ -5,19 +5,19 @@
 namespace VeeWee\Xml\Dom\Mapper;
 
 use Closure;
-use DOMDocument as DOMDocument;
-use VeeWee\XmlDOMDocument;
+use VeeWee\Xml\Dom\Document;
+use DOM\XMLDocument;
 use VeeWee\Xml\Xslt\Processor;
 use XSLTProcessor;
 
 /**
  * @param list<callable(XSLTProcessor): XSLTProcessor> $configurators
- * @return Closure(DOMDocument): string
+ * @return Closure(XMLDocument): string
  */
 function xslt_template(Document $template, callable ... $configurators): Closure
 {
-    return static fn (DOMDocument $document): string
-        => Processor::fromTemplateDocument($template, ...$configurators)->transformDocumentToString(
+    return static fn (XMLDocument $document): string =>
+        Processor::fromTemplateDocument($template, ...$configurators)->transformDocumentToString(
             Document::fromUnsafeDocument($document)
         );
 }
diff --git a/src/Xml/Dom/Predicate/is_cdata.php b/src/Xml/Dom/Predicate/is_cdata.php
index 60b7ac29..3fbd1ef6 100644
--- a/src/Xml/Dom/Predicate/is_cdata.php
+++ b/src/Xml/Dom/Predicate/is_cdata.php
@@ -4,13 +4,13 @@
 
 namespace VeeWee\Xml\Dom\Predicate;
 
-use \DOM\CdataSection;
+use \DOM\CDATASection;
 use \DOM\Node;
 
 /**
- * @psalm-assert-if-true \DOM\CdataSection $node
+ * @psalm-assert-if-true \DOM\CDATASection $node
  */
 function is_cdata(\DOM\Node $node): bool
 {
-    return $node instanceof \DOM\CdataSection;
+    return $node instanceof \DOM\CDATASection;
 }
diff --git a/src/Xml/Dom/Traverser/Visitor/SortAttributes.php b/src/Xml/Dom/Traverser/Visitor/SortAttributes.php
index 20b02ce3..4dfa6ca1 100644
--- a/src/Xml/Dom/Traverser/Visitor/SortAttributes.php
+++ b/src/Xml/Dom/Traverser/Visitor/SortAttributes.php
@@ -4,12 +4,10 @@
 
 namespace VeeWee\Xml\Dom\Traverser\Visitor;
 
-use \DOM\Attr;
-use \DOM\Node;
 use VeeWee\Xml\Dom\Traverser\Action;
 use function VeeWee\Xml\Dom\Locator\Attribute\attributes_list;
-use function VeeWee\Xml\Dom\Manipulator\append;
 use function VeeWee\Xml\Dom\Predicate\is_element;
+use function VeeWee\Xml\ErrorHandling\disallow_issues;
 
 final class SortAttributes extends AbstractVisitor
 {
@@ -23,7 +21,8 @@ public function onNodeEnter(\DOM\Node $node): Action
             ->sort(static fn (\DOM\Attr $a, \DOM\Attr $b): int => $a->nodeName <=> $b->nodeName)
             ->forEach(
                 static function (\DOM\Attr $attr) use ($node): void {
-                    append($attr)($node);
+                    // TODO  : move login into Manipulator\append()
+                    disallow_issues(static fn () => $node->setAttributeNode($attr));
                 }
             );
 
diff --git a/src/Xml/Xslt/Configurator/functions.php b/src/Xml/Xslt/Configurator/functions.php
index cb6e1175..210b1705 100644
--- a/src/Xml/Xslt/Configurator/functions.php
+++ b/src/Xml/Xslt/Configurator/functions.php
@@ -8,6 +8,8 @@
 use XSLTProcessor;
 
 /**
+ * TODO : Add support for callables : https://wiki.php.net/rfc/improve_callbacks_dom_and_xsl (either here or through a separate configurator)
+ *
  * @param non-empty-list<string> $functions
  *
  * @return Closure(XSLTProcessor): XSLTProcessor
diff --git a/src/bootstrap.php b/src/bootstrap.php
index a6e0898a..ce099e05 100644
--- a/src/bootstrap.php
+++ b/src/bootstrap.php
@@ -24,7 +24,6 @@
         'Xml\Dom\Configurator\canonicalize' => __DIR__.'/Xml/Dom/Configurator/canonicalize.php',
         'Xml\Dom\Configurator\comparable' => __DIR__.'/Xml/Dom/Configurator/comparable.php',
         'Xml\Dom\Configurator\document_uri' => __DIR__.'/Xml/Dom/Configurator/document_uri.php',
-        'Xml\Dom\Configurator\loader' => __DIR__.'/Xml/Dom/Configurator/loader.php',
         'Xml\Dom\Configurator\normalize' => __DIR__.'/Xml/Dom/Configurator/normalize.php',
         'Xml\Dom\Configurator\optimize_namespaces' => __DIR__.'/Xml/Dom/Configurator/optimize_namespaces.php',
         'Xml\Dom\Configurator\pretty_print' => __DIR__.'/Xml/Dom/Configurator/pretty_print.php',
@@ -32,7 +31,6 @@
         'Xml\Dom\Configurator\trim_spaces' => __DIR__.'/Xml/Dom/Configurator/trim_spaces.php',
         'Xml\Dom\Configurator\utf8' => __DIR__.'/Xml/Dom/Configurator/utf8.php',
         'Xml\Dom\Configurator\validator' => __DIR__.'/Xml/Dom/Configurator/validator.php',
-        'Xml\Dom\Loader\load' => __DIR__.'/Xml/Dom/Loader/load.php',
         'Xml\Dom\Loader\xml_file_loader' => __DIR__.'/Xml/Dom/Loader/xml_file_loader.php',
         'Xml\Dom\Loader\xml_node_loader' => __DIR__.'/Xml/Dom/Loader/xml_node_loader.php',
         'Xml\Dom\Loader\xml_string_loader' => __DIR__.'/Xml/Dom/Loader/xml_string_loader.php',
diff --git a/stubs/DOM.phpstub b/stubs/DOM.phpstub
index 520be9c2..9fe7fc46 100644
--- a/stubs/DOM.phpstub
+++ b/stubs/DOM.phpstub
@@ -1,11 +1,1661 @@
 <?php
 
-class DOMNameSpaceNode extends DOMNode {
-    public string $namespaceURI;
-    public string $nodeName;
-    public string $prefix;
+/** @generate-class-entries */
+
+namespace
+{
+    /**
+     * @var int
+     * @cvalue XML_ELEMENT_NODE
+     */
+    const XML_ELEMENT_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_NODE
+     */
+    const XML_ATTRIBUTE_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_TEXT_NODE
+     */
+    const XML_TEXT_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_CDATA_SECTION_NODE
+     */
+    const XML_CDATA_SECTION_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ENTITY_REF_NODE
+     */
+    const XML_ENTITY_REF_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ENTITY_NODE
+     */
+    const XML_ENTITY_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_PI_NODE
+     */
+    const XML_PI_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_COMMENT_NODE
+     */
+    const XML_COMMENT_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_DOCUMENT_NODE
+     */
+    const XML_DOCUMENT_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_DOCUMENT_TYPE_NODE
+     */
+    const XML_DOCUMENT_TYPE_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_DOCUMENT_FRAG_NODE
+     */
+    const XML_DOCUMENT_FRAG_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_NOTATION_NODE
+     */
+    const XML_NOTATION_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_HTML_DOCUMENT_NODE
+     */
+    const XML_HTML_DOCUMENT_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_DTD_NODE
+     */
+    const XML_DTD_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ELEMENT_DECL
+     */
+    const XML_ELEMENT_DECL_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_DECL
+     */
+    const XML_ATTRIBUTE_DECL_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ENTITY_DECL
+     */
+    const XML_ENTITY_DECL_NODE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_NAMESPACE_DECL
+     */
+    const XML_NAMESPACE_DECL_NODE = UNKNOWN;
+#ifdef XML_GLOBAL_NAMESPACE
+    /**
+     * @var int
+     * @cvalue XML_GLOBAL_NAMESPACE
+     */
+    const XML_GLOBAL_NAMESPACE = UNKNOWN;
+#endif
+
+    /**
+     * @var int
+     * @cvalue XML_LOCAL_NAMESPACE
+     */
+    const XML_LOCAL_NAMESPACE = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_CDATA
+     */
+    const XML_ATTRIBUTE_CDATA = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_ID
+     */
+    const XML_ATTRIBUTE_ID = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_IDREF
+     */
+    const XML_ATTRIBUTE_IDREF = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_IDREFS
+     */
+    const XML_ATTRIBUTE_IDREFS = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_ENTITIES
+     */
+    const XML_ATTRIBUTE_ENTITY = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_NMTOKEN
+     */
+    const XML_ATTRIBUTE_NMTOKEN = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_NMTOKENS
+     */
+    const XML_ATTRIBUTE_NMTOKENS = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_ENUMERATION
+     */
+    const XML_ATTRIBUTE_ENUMERATION = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue XML_ATTRIBUTE_NOTATION
+     */
+    const XML_ATTRIBUTE_NOTATION = UNKNOWN;
+
+    /**
+     * @var int
+     * @cvalue PHP_ERR
+     */
+    const DOM_PHP_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INDEX_SIZE_ERR
+     */
+    const DOM_INDEX_SIZE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue DOMSTRING_SIZE_ERR
+     */
+    const DOMSTRING_SIZE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue HIERARCHY_REQUEST_ERR
+     */
+    const DOM_HIERARCHY_REQUEST_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue WRONG_DOCUMENT_ERR
+     */
+    const DOM_WRONG_DOCUMENT_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INVALID_CHARACTER_ERR
+     */
+    const DOM_INVALID_CHARACTER_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NO_DATA_ALLOWED_ERR
+     */
+    const DOM_NO_DATA_ALLOWED_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NO_MODIFICATION_ALLOWED_ERR
+     */
+    const DOM_NO_MODIFICATION_ALLOWED_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NOT_FOUND_ERR
+     */
+    const DOM_NOT_FOUND_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NOT_SUPPORTED_ERR
+     */
+    const DOM_NOT_SUPPORTED_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INUSE_ATTRIBUTE_ERR
+     */
+    const DOM_INUSE_ATTRIBUTE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INVALID_STATE_ERR
+     */
+    const DOM_INVALID_STATE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue SYNTAX_ERR
+     */
+    const DOM_SYNTAX_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INVALID_MODIFICATION_ERR
+     */
+    const DOM_INVALID_MODIFICATION_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NAMESPACE_ERR
+     */
+    const DOM_NAMESPACE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INVALID_ACCESS_ERR
+     */
+    const DOM_INVALID_ACCESS_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue VALIDATION_ERR
+     */
+    const DOM_VALIDATION_ERR = UNKNOWN;
+
+    class DOMDocumentType extends DOMNode
+    {
+        /** @readonly */
+        public string $name;
+
+        /** @readonly */
+        public DOMNamedNodeMap $entities;
+
+        /** @readonly */
+        public DOMNamedNodeMap $notations;
+
+        /** @readonly */
+        public string $publicId;
+
+        /** @readonly */
+        public string $systemId;
+
+        /** @readonly */
+        public ?string $internalSubset;
+    }
+
+    class DOMCdataSection extends DOMText
+    {
+        public function __construct(string $data) {}
+    }
+
+    class DOMComment extends DOMCharacterData
+    {
+        public function __construct(string $data = "") {}
+    }
+
+    interface DOMParentNode
+    {
+        /** @param DOMNode|string $nodes */
+        public function append(...$nodes): void;
+
+        /** @param DOMNode|string $nodes */
+        public function prepend(...$nodes): void;
+
+        /** @param DOMNode|string $nodes */
+        public function replaceChildren(...$nodes): void;
+    }
+
+    interface DOMChildNode
+    {
+        public function remove(): void;
+
+        /** @param DOMNode|string $nodes */
+        public function before(... $nodes): void;
+
+        /** @param DOMNode|string $nodes */
+        public function after(...$nodes): void;
+
+        /** @param DOMNode|string $nodes */
+        public function replaceWith(...$nodes): void;
+    }
+
+    class DOMNode
+    {
+        public const int DOCUMENT_POSITION_DISCONNECTED = 0x01;
+        public const int DOCUMENT_POSITION_PRECEDING = 0x02;
+        public const int DOCUMENT_POSITION_FOLLOWING = 0x04;
+        public const int DOCUMENT_POSITION_CONTAINS = 0x08;
+        public const int DOCUMENT_POSITION_CONTAINED_BY = 0x10;
+        public const int DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
+
+        /** @readonly */
+        public string $nodeName;
+
+        public ?string $nodeValue;
+
+        /** @readonly */
+        public int $nodeType;
+
+        /** @readonly */
+        public ?DOMNode $parentNode;
+
+        /** @readonly */
+        public ?DOMElement $parentElement;
+
+        /** @readonly */
+        public DOMNodeList $childNodes;
+
+        /** @readonly */
+        public ?DOMNode $firstChild;
+
+        /** @readonly */
+        public ?DOMNode $lastChild;
+
+        /** @readonly */
+        public ?DOMNode $previousSibling;
+
+        /** @readonly */
+        public ?DOMNode $nextSibling;
+
+        /** @readonly */
+        public ?DOMNamedNodeMap $attributes;
+
+        /** @readonly */
+        public bool $isConnected;
+
+        /** @readonly */
+        public ?DOMDocument $ownerDocument;
+
+        /** @readonly */
+        public ?string $namespaceURI;
+
+        public string $prefix;
+
+        /** @readonly */
+        public ?string $localName;
+
+        /** @readonly */
+        public ?string $baseURI;
+
+        public string $textContent;
+
+        /** @return DOMNode|false */
+        public function appendChild(DOMNode $node) {}
+
+        /** @tentative-return-type */
+        public function C14N(bool $exclusive = false, bool $withComments = false, ?array $xpath = null, ?array $nsPrefixes = null): string|false {}
+
+        /** @tentative-return-type */
+        public function C14NFile(string $uri, bool $exclusive = false, bool $withComments = false, ?array $xpath = null, ?array $nsPrefixes = null): int|false {}
+
+        /** @return DOMNode|false */
+        public function cloneNode(bool $deep = false) {}
+
+        /** @tentative-return-type */
+        public function getLineNo(): int {}
+
+        /** @tentative-return-type */
+        public function getNodePath(): ?string {}
+
+        /** @tentative-return-type */
+        public function hasAttributes(): bool {}
+
+        /** @tentative-return-type */
+        public function hasChildNodes(): bool {}
+
+        /** @return DOMNode|false */
+        public function insertBefore(DOMNode $node, ?DOMNode $child = null) {}
+
+        /** @tentative-return-type */
+        public function isDefaultNamespace(string $namespace): bool {}
+
+        /** @tentative-return-type */
+        public function isSameNode(DOMNode $otherNode): bool {}
+
+        public function isEqualNode(?DOMNode $otherNode): bool {}
+
+        /** @tentative-return-type */
+        public function isSupported(string $feature, string $version): bool {}
+
+        /** @tentative-return-type */
+        public function lookupNamespaceURI(?string $prefix): ?string {}
+
+        /** @tentative-return-type */
+        public function lookupPrefix(string $namespace): ?string {}
+
+        /** @tentative-return-type */
+        public function normalize(): void {}
+
+        /** @return DOMNode|false */
+        public function removeChild(DOMNode $child) {}
+
+        /** @return DOMNode|false */
+        public function replaceChild(DOMNode $node, DOMNode $child) {}
+
+        public function contains(DOMNode|DOMNameSpaceNode|null $other): bool {}
+
+        public function getRootNode(?array $options = null): DOMNode {}
+
+        public function compareDocumentPosition(DOMNode $other): int {}
+
+        public function __sleep(): array {}
+
+        public function __wakeup(): void {}
+    }
+
+    class DOMNameSpaceNode
+    {
+        /** @readonly */
+        public string $nodeName;
+
+        /** @readonly */
+        public ?string $nodeValue;
+
+        /** @readonly */
+        public int $nodeType;
+
+        /** @readonly */
+        public string $prefix;
+
+        /** @readonly */
+        public ?string $localName;
+
+        /** @readonly */
+        public ?string $namespaceURI;
+
+        /** @readonly */
+        public bool $isConnected;
+
+        /** @readonly */
+        public ?DOMDocument $ownerDocument;
+
+        /** @readonly */
+        public ?DOMNode $parentNode;
+
+        /** @readonly */
+        public ?DOMElement $parentElement;
+
+        /** @implementation-alias DOMNode::__sleep */
+        public function __sleep(): array {}
+
+        /** @implementation-alias DOMNode::__wakeup */
+        public function __wakeup(): void {}
+    }
+
+    class DOMImplementation
+    {
+        /** @tentative-return-type */
+        public function getFeature(string $feature, string $version): never {}
+
+        /** @tentative-return-type */
+        public function hasFeature(string $feature, string $version): bool {}
+
+        /** @return DOMDocumentType|false */
+        public function createDocumentType(string $qualifiedName, string $publicId = "", string $systemId = "") {}
+
+        /** @tentative-return-type */
+        public function createDocument(?string $namespace = null, string $qualifiedName = "", ?DOMDocumentType $doctype = null): DOMDocument {}
+    }
+
+    class DOMDocumentFragment extends DOMNode implements DOMParentNode
+    {
+        /** @readonly */
+        public ?DOMElement $firstElementChild;
+
+        /** @readonly */
+        public ?DOMElement $lastElementChild;
+
+        /** @readonly */
+        public int $childElementCount;
+
+        public function __construct() {}
+
+        /** @tentative-return-type */
+        public function appendXML(string $data): bool {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMElement::append
+         */
+        public function append(...$nodes): void {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMElement::prepend
+         */
+        public function prepend(...$nodes): void {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMDocument::replaceChildren
+         */
+        public function replaceChildren(...$nodes): void {}
+    }
+
+    class DOMNodeList implements \IteratorAggregate, \Countable
+    {
+        /** @readonly */
+        public int $length;
+
+        /** @tentative-return-type */
+        public function count(): int {}
+
+        public function getIterator(): Iterator {}
+
+        /** @return DOMElement|DOMNode|DOMNameSpaceNode|null */
+        public function item(int $index) {}
+    }
+
+    class DOMCharacterData extends DOMNode implements DOMChildNode
+    {
+        public string $data;
+
+        /** @readonly */
+        public int $length;
+
+        /** @readonly */
+        public ?DOMElement $previousElementSibling;
+
+        /** @readonly */
+        public ?DOMElement $nextElementSibling;
+
+        /** @tentative-return-type */
+        public function appendData(string $data): true {}
+
+        /** @return string|false */
+        public function substringData(int $offset, int $count) {}
+
+        /** @tentative-return-type */
+        public function insertData(int $offset, string $data): bool {}
+
+        /** @tentative-return-type */
+        public function deleteData(int $offset, int $count): bool {}
+
+        /** @tentative-return-type */
+        public function replaceData(int $offset, int $count, string $data): bool {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMElement::replaceWith
+         */
+        public function replaceWith(...$nodes): void {}
+
+        /** @implementation-alias DOMElement::remove */
+        public function remove(): void {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMElement::before
+         */
+        public function before(... $nodes): void {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMElement::after
+         */
+        public function after(...$nodes): void {}
+    }
+
+    class DOMAttr extends DOMNode
+    {
+        /** @readonly */
+        public string $name;
+
+        /** @readonly */
+        public bool $specified = true;
+
+        public string $value;
+
+        /** @readonly */
+        public ?DOMElement $ownerElement;
+
+        /** @readonly */
+        public mixed $schemaTypeInfo = null;
+
+        public function __construct(string $name, string $value = "") {}
+
+        /** @tentative-return-type */
+        public function isId(): bool {}
+    }
+
+    class DOMElement extends DOMNode implements \DOMParentNode, \DOMChildNode
+    {
+        /** @readonly */
+        public string $tagName;
+
+        public string $className;
+
+        public string $id;
+
+        /** @readonly */
+        public mixed $schemaTypeInfo = null;
+
+        /** @readonly */
+        public ?DOMElement $firstElementChild;
+
+        /** @readonly */
+        public ?DOMElement $lastElementChild;
+
+        /** @readonly */
+        public int $childElementCount;
+
+        /** @readonly */
+        public ?DOMElement $previousElementSibling;
+
+        /** @readonly */
+        public ?DOMElement $nextElementSibling;
+
+        public function __construct(string $qualifiedName, ?string $value = null, string $namespace = "") {}
+
+        /** @tentative-return-type */
+        public function getAttribute(string $qualifiedName): string {}
+
+        public function getAttributeNames(): array {}
+
+        /** @tentative-return-type */
+        public function getAttributeNS(?string $namespace, string $localName): string {}
+
+        /** @return DOMAttr|DOMNameSpaceNode|false */
+        public function getAttributeNode(string $qualifiedName) {}
+
+        /** @return DOMAttr|DOMNameSpaceNode|null */
+        public function getAttributeNodeNS(?string $namespace, string $localName) {}
+
+        /** @tentative-return-type */
+        public function getElementsByTagName(string $qualifiedName): DOMNodeList {}
+
+        /** @tentative-return-type */
+        public function getElementsByTagNameNS(?string $namespace, string $localName): DOMNodeList {}
+
+        /** @tentative-return-type */
+        public function hasAttribute(string $qualifiedName): bool {}
+
+        /** @tentative-return-type */
+        public function hasAttributeNS(?string $namespace, string $localName): bool {}
+
+        /** @tentative-return-type */
+        public function removeAttribute(string $qualifiedName): bool {}
+
+        /** @tentative-return-type */
+        public function removeAttributeNS(?string $namespace, string $localName): void {}
+
+        /** @return DOMAttr|false */
+        public function removeAttributeNode(DOMAttr $attr) {}
+
+        /** @return DOMAttr|bool */
+        public function setAttribute(string $qualifiedName, string $value) {}
+
+        /** @tentative-return-type */
+        public function setAttributeNS(?string $namespace, string $qualifiedName, string $value): void {}
+
+        /** @return DOMAttr|null|false */
+        public function setAttributeNode(DOMAttr $attr) {}
+
+        /** @return DOMAttr|null|false */
+        public function setAttributeNodeNS(DOMAttr $attr) {}
+
+        /** @tentative-return-type */
+        public function setIdAttribute(string $qualifiedName, bool $isId): void {}
+
+        /** @tentative-return-type */
+        public function setIdAttributeNS(string $namespace, string $qualifiedName, bool $isId): void {}
+
+        /** @tentative-return-type */
+        public function setIdAttributeNode(DOMAttr $attr, bool $isId): void {}
+
+        public function toggleAttribute(string $qualifiedName, ?bool $force = null): bool {}
+
+        public function remove(): void {}
+
+        /** @param DOMNode|string $nodes */
+        public function before(... $nodes): void {}
+
+        /** @param DOMNode|string $nodes */
+        public function after(...$nodes): void {}
+
+        /** @param DOMNode|string $nodes */
+        public function replaceWith(...$nodes): void {}
+
+        /** @param DOMNode|string $nodes */
+        public function append(...$nodes): void {}
+
+        /** @param DOMNode|string $nodes */
+        public function prepend(...$nodes): void {}
+
+        /** @param DOMNode|string $nodes */
+        public function replaceChildren(...$nodes): void {}
+
+        public function insertAdjacentElement(string $where, DOMElement $element): ?DOMElement {}
+
+        public function insertAdjacentText(string $where, string $data): void {}
+    }
+
+    class DOMDocument extends DOMNode implements DOMParentNode
+    {
+        /** @readonly */
+        public ?DOMDocumentType $doctype;
+
+        /** @readonly */
+        public DOMImplementation $implementation;
+
+        /** @readonly */
+        public ?DOMElement $documentElement;
+
+        /**
+         * @readonly
+         * @deprecated
+         */
+        public ?string $actualEncoding;
+
+        public ?string $encoding;
+
+        /** @readonly */
+        public ?string $xmlEncoding;
+
+        public bool $standalone;
+
+        public bool $xmlStandalone;
+
+        public ?string $version;
+
+        public ?string $xmlVersion;
+
+        public bool $strictErrorChecking;
+
+        public ?string $documentURI;
+
+        /**
+         * @readonly
+         * @deprecated
+         */
+        public mixed $config;
+
+        public bool $formatOutput;
+
+        public bool $validateOnParse;
+
+        public bool $resolveExternals;
+
+        public bool $preserveWhiteSpace;
+
+        public bool $recover;
+
+        public bool $substituteEntities;
+
+        /** @readonly */
+        public ?DOMElement $firstElementChild;
+
+        /** @readonly */
+        public ?DOMElement $lastElementChild;
+
+        /** @readonly */
+        public int $childElementCount;
+
+        public function __construct(string $version = "1.0", string $encoding = "") {}
+
+        /** @return DOMAttr|false */
+        public function createAttribute(string $localName) {}
+
+        /** @return DOMAttr|false */
+        public function createAttributeNS(?string $namespace, string $qualifiedName) {}
+
+        /** @return DOMCdataSection|false */
+        public function createCDATASection(string $data) {}
+
+        /** @tentative-return-type */
+        public function createComment(string $data): DOMComment {}
+
+        /** @tentative-return-type */
+        public function createDocumentFragment(): DOMDocumentFragment {}
+
+        /** @return DOMElement|false */
+        public function createElement(string $localName, string $value = "")  {}
+
+        /** @return DOMElement|false */
+        public function createElementNS(?string $namespace, string $qualifiedName, string $value = "") {}
+
+        /** @return DOMEntityReference|false */
+        public function createEntityReference(string $name) {}
+
+        /** @return DOMProcessingInstruction|false */
+        public function createProcessingInstruction(string $target, string $data = "") {}
+
+        /** @tentative-return-type */
+        public function createTextNode(string $data): DOMText {}
+
+        /** @tentative-return-type */
+        public function getElementById(string $elementId): ?DOMElement {}
+
+        /**
+         * @tentative-return-type
+         * @implementation-alias DOMElement::getElementsByTagName
+         */
+        public function getElementsByTagName(string $qualifiedName): DOMNodeList {}
+
+        /**
+         * @tentative-return-type
+         * @implementation-alias DOMElement::getElementsByTagNameNS
+         */
+        public function getElementsByTagNameNS(?string $namespace, string $localName): DOMNodeList {}
+
+        /** @return DOMNode|false */
+        public function importNode(DOMNode $node, bool $deep = false) {}
+
+        /** @tentative-return-type */
+        public function load(string $filename, int $options = 0): bool {}
+
+        /** @tentative-return-type */
+        public function loadXML(string $source, int $options = 0): bool {}
+
+        /** @tentative-return-type */
+        public function normalizeDocument(): void {}
+
+        /** @tentative-return-type */
+        public function registerNodeClass(string $baseClass, ?string $extendedClass): true {}
+
+        /** @tentative-return-type */
+        public function save(string $filename, int $options = 0): int|false {}
+
+#ifdef LIBXML_HTML_ENABLED
+        /** @tentative-return-type */
+        public function loadHTML(string $source, int $options = 0): bool {}
+
+        /** @tentative-return-type */
+        public function loadHTMLFile(string $filename, int $options = 0): bool {}
+
+        /** @tentative-return-type */
+        public function saveHTML(?DOMNode $node = null): string|false {}
+
+        /** @tentative-return-type */
+        public function saveHTMLFile(string $filename): int|false {}
+#endif
+
+        /** @tentative-return-type */
+        public function saveXML(?DOMNode $node = null, int $options = 0): string|false {}
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+        /** @tentative-return-type */
+        public function schemaValidate(string $filename, int $flags = 0): bool {}
+
+        /** @tentative-return-type */
+        public function schemaValidateSource(string $source, int $flags = 0): bool {}
+
+        /** @tentative-return-type */
+        public function relaxNGValidate(string $filename): bool {}
+
+        /** @tentative-return-type */
+        public function relaxNGValidateSource(string $source): bool {}
+#endif
+
+        /** @tentative-return-type */
+        public function validate(): bool {}
+
+        /** @tentative-return-type */
+        public function xinclude(int $options = 0): int|false {}
+
+        /** @tentative-return-type */
+        public function adoptNode(DOMNode $node): DOMNode|false {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMElement::append
+         */
+        public function append(...$nodes): void {}
+
+        /**
+         * @param DOMNode|string $nodes
+         * @implementation-alias DOMElement::prepend
+         */
+        public function prepend(...$nodes): void {}
+
+        /** @param DOMNode|string $nodes */
+        public function replaceChildren(...$nodes): void {}
+    }
+
+    /** @alias DOM\DOMException */
+    final class DOMException extends Exception
+    {
+        /**
+         * Intentionally left untyped for BC reasons
+         * @var int
+         */
+        public $code = 0; // TODO add proper type (i.e. int|string)
+    }
+
+    class DOMText extends DOMCharacterData
+    {
+        /** @readonly */
+        public string $wholeText;
+
+        public function __construct(string $data = "") {}
+
+        /** @tentative-return-type */
+        public function isWhitespaceInElementContent(): bool {}
+
+        /**
+         * @tentative-return-type
+         * @alias DOMText::isWhitespaceInElementContent
+         */
+        public function isElementContentWhitespace(): bool {}
+
+        /** @return DOMText|false */
+        public function splitText(int $offset) {}
+    }
+
+    class DOMNamedNodeMap implements \IteratorAggregate, \Countable
+    {
+        /** @readonly */
+        public int $length;
+
+        /** @tentative-return-type */
+        public function getNamedItem(string $qualifiedName): ?DOMNode {}
+
+        /** @tentative-return-type */
+        public function getNamedItemNS(?string $namespace, string $localName): ?DOMNode {}
+
+        /** @tentative-return-type */
+        public function item(int $index): ?DOMNode {}
+
+        /** @tentative-return-type */
+        public function count(): int {}
+
+        public function getIterator(): Iterator {}
+    }
+
+    class DOMEntity extends DOMNode
+    {
+        /** @readonly */
+        public ?string $publicId;
+
+        /** @readonly */
+        public ?string $systemId;
+
+        /** @readonly */
+        public ?string $notationName;
+
+        /**
+         * @readonly
+         * @deprecated
+         */
+        public ?string $actualEncoding = null;
+
+        /**
+         * @readonly
+         * @deprecated
+         */
+        public ?string $encoding = null;
+
+        /**
+         * @readonly
+         * @deprecated
+         */
+        public ?string $version = null;
+    }
+
+    class DOMEntityReference extends DOMNode
+    {
+        public function __construct(string $name) {}
+    }
+
+    class DOMNotation extends DOMNode
+    {
+        /** @readonly */
+        public string $publicId;
+
+        /** @readonly */
+        public string $systemId;
+    }
+
+    class DOMProcessingInstruction extends DOMNode
+    {
+        /** @readonly */
+        public string $target;
+
+        public string $data;
+
+        public function __construct(string $name, string $value = "") {}
+    }
+
+#ifdef LIBXML_XPATH_ENABLED
+    /** @not-serializable */
+    class DOMXPath
+    {
+        /** @readonly */
+        public DOMDocument $document;
+
+        public bool $registerNodeNamespaces;
+
+        public function __construct(DOMDocument $document, bool $registerNodeNS = true) {}
+
+        /** @tentative-return-type */
+        public function evaluate(string $expression, ?DOMNode $contextNode = null, bool $registerNodeNS = true): mixed {}
+
+        /** @tentative-return-type */
+        public function query(string $expression, ?DOMNode $contextNode = null, bool $registerNodeNS = true): mixed {}
+
+        /** @tentative-return-type */
+        public function registerNamespace(string $prefix, string $namespace): bool {}
+
+        /** @tentative-return-type */
+        public function registerPhpFunctions(string|array|null $restrict = null): void {}
+
+        public function registerPhpFunctionNS(string $namespaceURI, string $name, callable $callable): void {}
+    }
+#endif
+
+    function dom_import_simplexml(object $node): DOMElement {}
 }
 
-class DOMDocument {
-    public function C14N(): string|false;
+namespace DOM
+{
+    /**
+     * @var int
+     * @cvalue INDEX_SIZE_ERR
+     */
+    const INDEX_SIZE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue DOMSTRING_SIZE_ERR
+     */
+    const STRING_SIZE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue HIERARCHY_REQUEST_ERR
+     */
+    const HIERARCHY_REQUEST_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue WRONG_DOCUMENT_ERR
+     */
+    const WRONG_DOCUMENT_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INVALID_CHARACTER_ERR
+     */
+    const INVALID_CHARACTER_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NO_DATA_ALLOWED_ERR
+     */
+    const NO_DATA_ALLOWED_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NO_MODIFICATION_ALLOWED_ERR
+     */
+    const NO_MODIFICATION_ALLOWED_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NOT_FOUND_ERR
+     */
+    const NOT_FOUND_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NOT_SUPPORTED_ERR
+     */
+    const NOT_SUPPORTED_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INUSE_ATTRIBUTE_ERR
+     */
+    const INUSE_ATTRIBUTE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INVALID_STATE_ERR
+     */
+    const INVALID_STATE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue SYNTAX_ERR
+     */
+    const SYNTAX_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue INVALID_MODIFICATION_ERR
+     */
+    const INVALID_MODIFICATION_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue NAMESPACE_ERR
+     */
+    const NAMESPACE_ERR = UNKNOWN;
+    /**
+     * @var int
+     * @cvalue VALIDATION_ERR
+     */
+    const VALIDATION_ERR = UNKNOWN;
+
+    /**
+     * @var int
+     * @cvalue DOM_HTML_NO_DEFAULT_NS
+     */
+    const HTML_NO_DEFAULT_NS = UNKNOWN;
+
+    interface ParentNode
+    {
+        public function append(Node|string ...$nodes): void;
+        public function prepend(Node|string ...$nodes): void;
+        public function replaceChildren(Node|string ...$nodes): void;
+    }
+
+    interface ChildNode
+    {
+        public function remove(): void;
+        public function before(Node|string ...$nodes): void;
+        public function after(Node|string ...$nodes): void;
+        public function replaceWith(Node|string ...$nodes): void;
+    }
+
+    /** @strict-properties */
+    class Node
+    {
+        private final function __construct() {}
+
+        /** @readonly */
+        public int $nodeType;
+        /** @readonly */
+        public string $nodeName;
+
+        /** @readonly */
+        public string $baseURI;
+
+        /** @readonly */
+        public bool $isConnected;
+        /** @readonly */
+        public ?Document $ownerDocument;
+
+        /** @implementation-alias DOMNode::getRootNode */
+        public function getRootNode(array $options = []): Node {}
+        /** @readonly */
+        public ?Node $parentNode;
+        /** @readonly */
+        public ?Element $parentElement;
+        /** @implementation-alias DOMNode::hasChildNodes */
+        public function hasChildNodes(): bool {}
+        /** @readonly */
+        public NodeList $childNodes;
+        /** @readonly */
+        public ?Node $firstChild;
+        /** @readonly */
+        public ?Node $lastChild;
+        /** @readonly */
+        public ?Node $previousSibling;
+        /** @readonly */
+        public ?Node $nextSibling;
+
+        public ?string $nodeValue;
+        public ?string $textContent;
+        /** @implementation-alias DOMNode::normalize */
+        public function normalize(): void {}
+
+        /** @implementation-alias DOMNode::cloneNode */
+        public function cloneNode(bool $deep = false): Node {}
+        public function isEqualNode(?Node $otherNode): bool {}
+        public function isSameNode(?Node $otherNode): bool {}
+
+        public const int DOCUMENT_POSITION_DISCONNECTED = 0x01;
+        public const int DOCUMENT_POSITION_PRECEDING = 0x02;
+        public const int DOCUMENT_POSITION_FOLLOWING = 0x04;
+        public const int DOCUMENT_POSITION_CONTAINS = 0x08;
+        public const int DOCUMENT_POSITION_CONTAINED_BY = 0x10;
+        public const int DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
+        public function compareDocumentPosition(Node $other): int {}
+        public function contains(?Node $other): bool {}
+
+        public function lookupPrefix(?string $namespace): ?string {}
+        /** @implementation-alias DOMNode::lookupNamespaceURI */
+        public function lookupNamespaceURI(?string $prefix): ?string {}
+        public function isDefaultNamespace(?string $namespace): bool {}
+
+        public function insertBefore(Node $node, ?Node $child): Node {}
+        public function appendChild(Node $node): Node {}
+        public function replaceChild(Node $node, Node $child): Node {}
+        public function removeChild(Node $child): Node {}
+
+        /** @implementation-alias DOMNode::getLineNo */
+        public function getLineNo(): int {}
+        public function getNodePath(): string {}
+
+        /** @implementation-alias DOMNode::C14N */
+        public function C14N(bool $exclusive = false, bool $withComments = false, ?array $xpath = null, ?array $nsPrefixes = null): string|false {}
+        /** @implementation-alias DOMNode::C14NFile */
+        public function C14NFile(string $uri, bool $exclusive = false, bool $withComments = false, ?array $xpath = null, ?array $nsPrefixes = null): int|false {}
+
+        /** @implementation-alias DOMNode::__sleep */
+        public function __sleep(): array {}
+        /** @implementation-alias DOMNode::__wakeup */
+        public function __wakeup(): void {}
+    }
+
+    class NodeList implements \IteratorAggregate, \Countable
+    {
+        /** @readonly */
+        public int $length;
+
+        /**
+         * @tentative-return-type
+         * @implementation-alias DOMNodeList::count
+         */
+        public function count(): int {}
+
+        /** @implementation-alias DOMNodeList::getIterator */
+        public function getIterator(): \Iterator {}
+
+        /** @implementation-alias DOMNodeList::item */
+        public function item(int $index): ?Node {}
+    }
+
+    class NamedNodeMap implements \IteratorAggregate, \Countable
+    {
+        /** @readonly */
+        public int $length;
+
+        /** @implementation-alias DOMNamedNodeMap::item */
+        public function item(int $index): ?Attr {}
+        /** @implementation-alias DOMNamedNodeMap::getNamedItem */
+        public function getNamedItem(string $qualifiedName): ?Attr {}
+        /** @implementation-alias DOMNamedNodeMap::getNamedItemNS */
+        public function getNamedItemNS(?string $namespace, string $localName): ?Attr {}
+
+        /**
+         * @tentative-return-type
+         * @implementation-alias DOMNamedNodeMap::count
+         */
+        public function count(): int {}
+
+        /** @implementation-alias DOMNamedNodeMap::getIterator */
+        public function getIterator(): \Iterator {}
+    }
+
+    class DTDNamedNodeMap implements \IteratorAggregate, \Countable
+    {
+        /** @readonly */
+        public int $length;
+
+        /** @implementation-alias DOMNamedNodeMap::item */
+        public function item(int $index): Entity|Notation|null {}
+        /** @implementation-alias DOMNamedNodeMap::getNamedItem */
+        public function getNamedItem(string $qualifiedName): Entity|Notation|null {}
+        /** @implementation-alias DOMNamedNodeMap::getNamedItemNS */
+        public function getNamedItemNS(?string $namespace, string $localName): Entity|Notation|null {}
+
+        /**
+         * @tentative-return-type
+         * @implementation-alias DOMNamedNodeMap::count
+         */
+        public function count(): int {}
+
+        /** @implementation-alias DOMNamedNodeMap::getIterator */
+        public function getIterator(): \Iterator {}
+    }
+
+    class HTMLCollection implements \IteratorAggregate, \Countable
+    {
+        /** @readonly */
+        public int $length;
+
+        /** @implementation-alias DOMNodeList::item */
+        public function item(int $index): ?Element {}
+
+        /* TODO: implement namedItem */
+
+        /**
+         * @tentative-return-type
+         * @implementation-alias DOMNodeList::count
+         */
+        public function count(): int {}
+
+        /** @implementation-alias DOMNodeList::getIterator */
+        public function getIterator(): \Iterator {}
+    }
+
+    class Element extends Node implements ParentNode, ChildNode
+    {
+        /** @readonly */
+        public ?string $namespaceURI;
+        /** @readonly */
+        public ?string $prefix;
+        /** @readonly */
+        public string $localName;
+        /** @readonly */
+        public string $tagName;
+
+        public string $id;
+        public string $className;
+
+        /** @implementation-alias DOMNode::hasAttributes */
+        public function hasAttributes(): bool {}
+        /** @readonly */
+        public NamedNodeMap $attributes;
+        /** @implementation-alias DOMElement::getAttributeNames */
+        public function getAttributeNames(): array {}
+        /** @implementation-alias DOMElement::getAttribute */
+        public function getAttribute(string $qualifiedName): ?string {}
+        /** @implementation-alias DOMElement::getAttributeNS */
+        public function getAttributeNS(?string $namespace, string $localName): ?string {}
+        /** @implementation-alias DOMElement::setAttribute */
+        public function setAttribute(string $qualifiedName, string $value): void {}
+        /** @implementation-alias DOMElement::setAttributeNS */
+        public function setAttributeNS(?string $namespace, string $qualifiedName, string $value): void {}
+        public function removeAttribute(string $qualifiedName): void {}
+        /** @implementation-alias DOMElement::removeAttributeNS */
+        public function removeAttributeNS(?string $namespace, string $localName): void {}
+        /** @implementation-alias DOMElement::toggleAttribute */
+        public function toggleAttribute(string $qualifiedName, ?bool $force = null): bool {}
+        /** @implementation-alias DOMElement::hasAttribute */
+        public function hasAttribute(string $qualifiedName): bool {}
+        /** @implementation-alias DOMElement::hasAttributeNS */
+        public function hasAttributeNS(?string $namespace, string $localName): bool {}
+
+        /** @implementation-alias DOMElement::getAttributeNode */
+        public function getAttributeNode(string $qualifiedName): ?Attr {}
+        /** @implementation-alias DOMElement::getAttributeNodeNS */
+        public function getAttributeNodeNS(?string $namespace, string $localName): ?Attr {}
+        /** @implementation-alias DOM\Element::setAttributeNodeNS */
+        public function setAttributeNode(Attr $attr) : ?Attr {}
+        public function setAttributeNodeNS(Attr $attr) : ?Attr {}
+        public function removeAttributeNode(Attr $attr) : Attr {}
+
+        public function getElementsByTagName(string $qualifiedName): HTMLCollection {}
+        public function getElementsByTagNameNS(?string $namespace, string $localName): HTMLCollection {}
+
+        public function insertAdjacentElement(string $where, Element $element): ?Element {}
+        /** @implementation-alias DOMElement::insertAdjacentText */
+        public function insertAdjacentText(string $where, string $data): void {}
+
+        /** @readonly */
+        public ?Element $firstElementChild;
+        /** @readonly */
+        public ?Element $lastElementChild;
+        /** @readonly */
+        public int $childElementCount;
+        /** @readonly */
+        public ?Element $previousElementSibling;
+        /** @readonly */
+        public ?Element $nextElementSibling;
+
+        /** @implementation-alias DOMElement::setIdAttribute */
+        public function setIdAttribute(string $qualifiedName, bool $isId): void {}
+        /** @implementation-alias DOMElement::setIdAttributeNS */
+        public function setIdAttributeNS(?string $namespace, string $qualifiedName, bool $isId): void {}
+        public function setIdAttributeNode(Attr $attr, bool $isId): void {}
+
+        /** @implementation-alias DOMElement::remove */
+        public function remove(): void {}
+        /** @implementation-alias DOMElement::before */
+        public function before(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::after */
+        public function after(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::replaceWith */
+        public function replaceWith(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::append */
+        public function append(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::prepend */
+        public function prepend(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::replaceChildren */
+        public function replaceChildren(Node|string ...$nodes): void {}
+    }
+
+    class Attr extends Node
+    {
+        /** @readonly */
+        public ?string $namespaceURI;
+        /** @readonly */
+        public ?string $prefix;
+        /** @readonly */
+        public string $localName;
+        /** @readonly */
+        public string $name;
+        public string $value;
+
+        /** @readonly */
+        public ?Element $ownerElement;
+
+        /** @readonly */
+        public bool $specified = true;
+
+        /** @implementation-alias DOMAttr::isId */
+        public function isId(): bool {}
+    }
+
+    class CharacterData extends Node implements ChildNode
+    {
+        /** @readonly */
+        public ?Element $previousElementSibling;
+        /** @readonly */
+        public ?Element $nextElementSibling;
+
+        public string $data;
+        /** @readonly */
+        public int $length;
+        /** @implementation-alias DOMCharacterData::substringData */
+        public function substringData(int $offset, int $count): string {}
+        public function appendData(string $data): void {}
+        public function insertData(int $offset, string $data): void {}
+        public function deleteData(int $offset, int $count): void {}
+        public function replaceData(int $offset, int $count, string $data): void {}
+
+        /** @implementation-alias DOMElement::remove */
+        public function remove(): void {}
+        /** @implementation-alias DOMElement::before */
+        public function before(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::after */
+        public function after(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::replaceWith */
+        public function replaceWith(Node|string ...$nodes): void {}
+    }
+
+    class Text extends CharacterData
+    {
+        /* No constructor because Node has a final private constructor, so PHP does not allow overriding that. */
+
+        /** @implementation-alias DOMText::splitText */
+        public function splitText(int $offset): Text {}
+        /** @readonly */
+        public string $wholeText;
+    }
+
+    class CDATASection extends Text {}
+
+    class ProcessingInstruction extends CharacterData
+    {
+        /** @readonly */
+        public string $target;
+    }
+
+    class Comment extends CharacterData
+    {
+        /* No constructor because Node has a final private constructor, so PHP does not allow overriding that. */
+    }
+
+    class DocumentType extends Node implements ChildNode
+    {
+        /** @readonly */
+        public string $name;
+        /** @readonly */
+        public DTDNamedNodeMap $entities;
+        /** @readonly */
+        public DTDNamedNodeMap $notations;
+        /** @readonly */
+        public string $publicId;
+        /** @readonly */
+        public string $systemId;
+        /** @readonly */
+        public ?string $internalSubset;
+
+        /** @implementation-alias DOMElement::remove */
+        public function remove(): void {}
+        /** @implementation-alias DOMElement::before */
+        public function before(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::after */
+        public function after(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::replaceWith */
+        public function replaceWith(Node|string ...$nodes): void {}
+    }
+
+    class DocumentFragment extends Node implements ParentNode
+    {
+        /** @readonly */
+        public ?Element $firstElementChild;
+        /** @readonly */
+        public ?Element $lastElementChild;
+        /** @readonly */
+        public int $childElementCount;
+
+        /** @implementation-alias DOMDocumentFragment::appendXML */
+        public function appendXML(string $data): bool {}
+        /** @implementation-alias DOMElement::append */
+        public function append(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::prepend */
+        public function prepend(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::replaceChildren */
+        public function replaceChildren(Node|string ...$nodes): void {}
+    }
+
+    class Entity extends Node
+    {
+        /** @readonly */
+        public ?string $publicId;
+        /** @readonly */
+        public ?string $systemId;
+        /** @readonly */
+        public ?string $notationName;
+    }
+
+    class EntityReference extends Node {}
+
+    class Notation extends Node
+    {
+        /** @readonly */
+        public string $publicId;
+        /** @readonly */
+        public string $systemId;
+    }
+
+    abstract class Document extends Node implements ParentNode
+    {
+        /** @readonly */
+        public string $URL;
+        /** @readonly */
+        public string $documentURI;
+        public string $characterSet;
+        public string $charset;
+        public string $inputEncoding;
+
+        /** @readonly */
+        public ?DocumentType $doctype;
+        /** @readonly */
+        public ?Element $documentElement;
+        /** @implementation-alias DOM\Element::getElementsByTagName */
+        public function getElementsByTagName(string $qualifiedName): HTMLCollection {}
+        /** @implementation-alias DOM\Element::getElementsByTagNameNS */
+        public function getElementsByTagNameNS(?string $namespace, string $localName): HTMLCollection {}
+
+        public function createElement(string $localName): Element {}
+        public function createElementNS(?string $namespace, string $qualifiedName): Element {}
+        /** @implementation-alias DOMDocument::createDocumentFragment */
+        public function createDocumentFragment(): DocumentFragment {}
+        /** @implementation-alias DOMDocument::createTextNode */
+        public function createTextNode(string $data): Text {}
+        /** @implementation-alias DOMDocument::createCDATASection */
+        public function createCDATASection(string $data): CDATASection {}
+        /** @implementation-alias DOMDocument::createComment */
+        public function createComment(string $data): Comment {}
+        public function createProcessingInstruction(string $target, string $data): ProcessingInstruction {}
+
+        public function importNode(?Node $node, bool $deep = false): Node {}
+        public function adoptNode(Node $node): Node {}
+
+        /** @implementation-alias DOMDocument::createAttribute */
+        public function createAttribute(string $localName): Attr {}
+        /** @implementation-alias DOMDocument::createAttributeNS */
+        public function createAttributeNS(?string $namespace, string $qualifiedName): Attr {}
+
+        /** @readonly */
+        public ?Element $firstElementChild;
+        /** @readonly */
+        public ?Element $lastElementChild;
+        /** @readonly */
+        public int $childElementCount;
+
+        /** @implementation-alias DOMDocument::getElementById */
+        public function getElementById(string $elementId): ?Element {}
+
+        public function registerNodeClass(string $baseClass, ?string $extendedClass): void {}
+
+#ifdef LIBXML_SCHEMAS_ENABLED
+        /** @implementation-alias DOMDocument::schemaValidate */
+        public function schemaValidate(string $filename, int $flags = 0): bool {}
+        /** @implementation-alias DOMDocument::schemaValidateSource */
+        public function schemaValidateSource(string $source, int $flags = 0): bool {}
+        /** @implementation-alias DOMDocument::relaxNGValidate */
+        public function relaxNGValidate(string $filename): bool {}
+        /** @implementation-alias DOMDocument::relaxNGValidateSource */
+        public function relaxNGValidateSource(string $source): bool {}
+#endif
+
+        /** @implementation-alias DOMElement::append */
+        public function append(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMElement::prepend */
+        public function prepend(Node|string ...$nodes): void {}
+        /** @implementation-alias DOMDocument::replaceChildren */
+        public function replaceChildren(Node|string ...$nodes): void {}
+
+        public function importLegacyNode(\DOMNode $node, bool $deep = false): Node {}
+    }
+
+    final class HTMLDocument extends Document
+    {
+        public static function createEmpty(string $encoding = "UTF-8"): HTMLDocument {}
+
+        public static function createFromFile(string $path, int $options = 0, ?string $overrideEncoding = null): HTMLDocument {}
+
+        public static function createFromString(string $source, int $options = 0, ?string $overrideEncoding = null): HTMLDocument {}
+
+        /** @implementation-alias DOM\XMLDocument::saveXML */
+        public function saveXML(?Node $node = null, int $options = 0): string|false {}
+
+        /** @implementation-alias DOMDocument::save */
+        public function saveXMLFile(string $filename, int $options = 0): int|false {}
+
+        public function saveHTML(?Node $node = null): string|false {}
+
+        public function saveHTMLFile(string $filename): int|false {}
+    }
+
+    final class XMLDocument extends Document
+    {
+        public static function createEmpty(string $version = "1.0", string $encoding = "UTF-8"): XMLDocument {}
+
+        public static function createFromFile(string $path, int $options = 0, ?string $overrideEncoding = null): XMLDocument {}
+
+        public static function createFromString(string $source, int $options = 0, ?string $overrideEncoding = null): XMLDocument {}
+
+        /** @readonly */
+        public string $xmlEncoding;
+
+        public bool $xmlStandalone;
+
+        public string $xmlVersion;
+
+        public bool $formatOutput;
+
+        /** @implementation-alias DOMDocument::createEntityReference */
+        public function createEntityReference(string $name): EntityReference {}
+
+        /** @implementation-alias DOMDocument::validate */
+        public function validate(): bool {}
+
+        /** @implementation-alias DOMDocument::xinclude */
+        public function xinclude(int $options = 0): int|false {}
+
+        public function saveXML(?Node $node = null, int $options = 0): string|false {}
+
+        /** @implementation-alias DOMDocument::save */
+        public function saveXMLFile(string $filename, int $options = 0): int|false {}
+    }
+
+#ifdef LIBXML_XPATH_ENABLED
+    /** @not-serializable */
+    final class XPath
+    {
+        /** @readonly */
+        public Document $document;
+
+        public bool $registerNodeNamespaces;
+
+        public function __construct(Document $document, bool $registerNodeNS = true) {}
+
+        public function evaluate(string $expression, ?Node $contextNode = null, bool $registerNodeNS = true): null|bool|float|string|NodeList {}
+
+        public function query(string $expression, ?Node $contextNode = null, bool $registerNodeNS = true): NodeList {}
+
+        /** @implementation-alias DOMXPath::registerNamespace */
+        public function registerNamespace(string $prefix, string $namespace): bool {}
+
+        /** @implementation-alias DOMXPath::registerPhpFunctions */
+        public function registerPhpFunctions(string|array|null $restrict = null): void {}
+
+        /** @implementation-alias DOMXPath::registerPhpFunctionNS */
+        public function registerPhpFunctionNS(string $namespaceURI, string $name, callable $callable): void {}
+    }
+#endif
+
+    function import_simplexml(object $node): Element {}
 }
diff --git a/tests/Xml/Dom/Builder/CdataTest.php b/tests/Xml/Dom/Builder/CdataTest.php
index 9b4ad5a5..00a0027a 100644
--- a/tests/Xml/Dom/Builder/CdataTest.php
+++ b/tests/Xml/Dom/Builder/CdataTest.php
@@ -4,7 +4,7 @@
 
 namespace VeeWee\Tests\Xml\Dom\Builder;
 
-use \DOM\CdataSection;
+use \DOM\CDATASection;
 use \DOM\XMLDocument;
 use PHPUnit\Framework\TestCase;
 use VeeWee\Xml\Dom\Document;
@@ -19,7 +19,7 @@ public function test_it_can_build_cdata(): void
         $doc = Document::empty()->toUnsafeDocument();
         $node = cdata($data = '<html>hello</html>')($doc);
 
-        static::assertInstanceOf(\DOM\CdataSection::class, $node);
+        static::assertInstanceOf(\DOM\CDATASection::class, $node);
         static::assertSame($data, $node->textContent);
         static::assertSame(xml_string()($node), '<![CDATA['.$data.']]>');
     }
@@ -29,7 +29,7 @@ public function test_it_can_build_cdata_with_configurators(): void
         $doc = Document::empty()->toUnsafeDocument();
         $node = cdata($data = '<html>hello</html>', identity())($doc);
 
-        static::assertInstanceOf(\DOM\CdataSection::class, $node);
+        static::assertInstanceOf(\DOM\CDATASection::class, $node);
         static::assertSame($data, $node->textContent);
     }
 }
diff --git a/tests/Xml/Dom/Builder/ElementTest.php b/tests/Xml/Dom/Builder/ElementTest.php
index c1629a3e..bd6d9c9a 100644
--- a/tests/Xml/Dom/Builder/ElementTest.php
+++ b/tests/Xml/Dom/Builder/ElementTest.php
@@ -40,7 +40,7 @@ public function test_it_can_build_an_element_with_value(): void
 
         static::assertSame('hello', $node->nodeName);
         static::assertSame('hello', $node->localName);
-        static::assertSame('world', $node->nodeValue);
+        static::assertSame('world', $node->textContent);
         static::assertSame($doc, $node->ownerDocument);
     }
 }
diff --git a/tests/Xml/Dom/Builder/EscapedValueTest.php b/tests/Xml/Dom/Builder/EscapedValueTest.php
index 96957b50..c4efa448 100644
--- a/tests/Xml/Dom/Builder/EscapedValueTest.php
+++ b/tests/Xml/Dom/Builder/EscapedValueTest.php
@@ -18,7 +18,7 @@ public function test_it_can_build_an_element_with_html_value(): void
         $doc = Document::empty()->toUnsafeDocument();
         $node = element('hello', escaped_value('<wor " ld>'))($doc);
 
-        static::assertSame('<wor " ld>', $node->nodeValue);
+        static::assertSame('<wor " ld>', $node->textContent); // TODO : nodeValue did entity substitution
         static::assertSame(xml_string()($node), '<hello>&lt;wor " ld&gt;</hello>');
     }
 }
diff --git a/tests/Xml/Dom/Builder/ValueTest.php b/tests/Xml/Dom/Builder/ValueTest.php
index 70f679b5..00453eaa 100644
--- a/tests/Xml/Dom/Builder/ValueTest.php
+++ b/tests/Xml/Dom/Builder/ValueTest.php
@@ -18,7 +18,7 @@ public function test_it_can_build_an_element_with_html_value(): void
         $doc = Document::empty()->toUnsafeDocument();
         $node = element('hello', value('<world>'))($doc);
 
-        static::assertSame('<world>', $node->nodeValue);
+        static::assertSame('<world>', $node->textContent);
         static::assertSame(xml_string()($node), '<hello>&lt;world&gt;</hello>');
     }
 }
diff --git a/tests/Xml/Dom/Collection/NodeListTest.php b/tests/Xml/Dom/Collection/NodeListTest.php
index 92a6aeb0..c1dd517d 100644
--- a/tests/Xml/Dom/Collection/NodeListTest.php
+++ b/tests/Xml/Dom/Collection/NodeListTest.php
@@ -120,7 +120,7 @@ public function test_it_can_expect_items()
     public function test_it_can_map(): void
     {
         $items = $this->loadProducts()->map(
-            static fn (\DOM\Element $element): string => $element->nodeValue
+            static fn (\DOM\Element $element): string => $element->textContent
         );
 
         static::assertSame(
@@ -139,7 +139,7 @@ public function test_it_can_loop_over_all_items(): void
         $x = new MutableVector([]);
         $this->loadProducts()->forEach(
             static function (\DOM\Element $element) use ($x) : void {
-                $x->add($element->nodeValue);
+                $x->add($element->textContent);
             }
         );
 
@@ -166,11 +166,11 @@ public function test_it_can_filter(): void
         static::assertSame($all->item(3), $filtered->item(1));
     }
 
-    
+
     public function test_it_can_reduce(): void
     {
         $total = $this->loadPrices()->reduce(
-            static fn (int $total, \DOM\Element $element): int => $total + (int) $element->nodeValue,
+            static fn (int $total, \DOM\Element $element): int => $total + (int) $element->textContent,
             0
         );
 
@@ -189,7 +189,7 @@ public function test_it_can_detect(): void
         static::assertCount(2, $list);
     }
 
-    
+
     public function test_it_can_query_xpath(): void
     {
         $items = $this->root()->query('./prices/price', identity());
@@ -199,7 +199,7 @@ public function test_it_can_query_xpath(): void
         }
     }
 
-    
+
     public function test_it_can_evaluate_xpath(): void
     {
         $evaluated = $this->loadPrices()->evaluate('number(.)', Type\int(), identity());
@@ -217,7 +217,7 @@ public function test_it_can_equal(): void
         static::assertSame([$prices->item(3)], [...$prices->eq(3)]);
         static::assertSame([], [...$prices->eq(4)]);
     }
-    
+
     public function test_it_can_get_first(): void
     {
         $prices = $this->loadPrices();
@@ -282,7 +282,7 @@ public function test_it_can_expect_last(): void
         $this->expectExceptionMessage('No last item was found');
         NodeList::empty()->expectFirst('No last item was found');
     }
-    
+
     public function test_it_can_search_ancestors(): void
     {
         $prices = $this->loadPrices();
@@ -331,7 +331,7 @@ public function test_it_can_validate_types_and_fail(): void
     public function test_it_can_sort(): void
     {
         $prices = $this->loadPrices();
-        $sorted = $prices->sort(static fn (\DOM\Node $a, \DOM\Node $b) => $b->nodeValue <=> $a->nodeValue);
+        $sorted = $prices->sort(static fn (\DOM\Node $a, \DOM\Node $b) => $b->textContent <=> $a->textContent);
 
         static::assertSame(
             [
diff --git a/tests/Xml/Dom/Configurator/LoaderTest.php b/tests/Xml/Dom/Configurator/LoaderTest.php
deleted file mode 100644
index 788cd87e..00000000
--- a/tests/Xml/Dom/Configurator/LoaderTest.php
+++ /dev/null
@@ -1,41 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace VeeWee\Tests\Xml\Dom\Configurator;
-
-use \DOM\XMLDocument;
-use Exception;
-use PHPUnit\Framework\TestCase;
-use VeeWee\Xml\Dom\Document;
-use function VeeWee\Xml\Dom\Configurator\loader;
-
-final class LoaderTest extends TestCase
-{
-    public function test_it_can_load_xml(): void
-    {
-        $doc = Document::empty()->toUnsafeDocument();
-        $xml = '<hello />';
-
-        $loader = loader(static function (\DOM\XMLDocument $doc) use ($xml): void {
-            $doc->loadXML($xml);
-        });
-
-        $result = $loader($doc);
-        static::assertSame($doc, $result);
-        static::assertXmlStringEqualsXmlString($xml, $doc->saveXML());
-    }
-
-
-    public function test_it_can_mark_xml_loading_as_failed(): void
-    {
-        $doc = Document::empty()->toUnsafeDocument();
-        $exception = new Exception('Could not load the XML document');
-        $loader = loader(static function (\DOM\XMLDocument $doc) use ($exception): void {
-            throw $exception;
-        });
-
-        $this->expectExceptionObject($exception);
-        $loader($doc);
-    }
-}
diff --git a/tests/Xml/Dom/Configurator/PrettyPrintTest.php b/tests/Xml/Dom/Configurator/PrettyPrintTest.php
index 79ed80c3..29337608 100644
--- a/tests/Xml/Dom/Configurator/PrettyPrintTest.php
+++ b/tests/Xml/Dom/Configurator/PrettyPrintTest.php
@@ -26,7 +26,7 @@ public function test_it_can_trim_contents(): void
         EOXML;
 
         static::assertSame($doc, $result);
-        static::assertFalse($doc->preserveWhiteSpace);
+        // TODO : static::assertFalse($doc->preserveWhiteSpace);
         static::assertTrue($doc->formatOutput);
         static::assertSame($expected, xml_string()($doc->documentElement));
     }
diff --git a/tests/Xml/Dom/Configurator/TrimSpacesTest.php b/tests/Xml/Dom/Configurator/TrimSpacesTest.php
index f12fff13..9fd1e130 100644
--- a/tests/Xml/Dom/Configurator/TrimSpacesTest.php
+++ b/tests/Xml/Dom/Configurator/TrimSpacesTest.php
@@ -19,7 +19,7 @@ public function test_it_can_trim_contents(): void
         $result = $configurator($doc);
 
         static::assertSame($doc, $result);
-        static::assertFalse($doc->preserveWhiteSpace);
+        // TODO : static::assertFalse($doc->preserveWhiteSpace);
         static::assertFalse($doc->formatOutput);
         static::assertSame('<hello><world/></hello>', xml_string()($doc->documentElement));
     }
diff --git a/tests/Xml/Dom/Configurator/Utf8Test.php b/tests/Xml/Dom/Configurator/Utf8Test.php
index ac45857a..de470e6f 100644
--- a/tests/Xml/Dom/Configurator/Utf8Test.php
+++ b/tests/Xml/Dom/Configurator/Utf8Test.php
@@ -19,6 +19,6 @@ public function test_it_can_convert_to_utf8(): void
 
         $result = $configurator($doc);
         static::assertSame($doc, $result);
-        static::assertSame('UTF-8', $doc->encoding);
+        static::assertSame('UTF-8', $doc->charset);
     }
 }
diff --git a/tests/Xml/Dom/Loader/XmlFileLoaderTest.php b/tests/Xml/Dom/Loader/XmlFileLoaderTest.php
index 9f3f68d8..8dd63a00 100644
--- a/tests/Xml/Dom/Loader/XmlFileLoaderTest.php
+++ b/tests/Xml/Dom/Loader/XmlFileLoaderTest.php
@@ -16,12 +16,11 @@ final class XmlFileLoaderTest extends TestCase
 
     public function test_it_can_load_xml_file(): void
     {
-        $doc = new \DOM\XMLDocument();
         $xml = '<hello />';
         [$file, $handle] = $this->fillFile($xml);
         $loader = xml_file_loader($file);
 
-        $loader($doc);
+        $doc = $loader();
         fclose($handle);
 
         static::assertXmlStringEqualsXmlString($xml, $doc->saveXML());
@@ -29,39 +28,36 @@ public function test_it_can_load_xml_file(): void
 
     public function test_it_can_load_with_options(): void
     {
-        $doc = new \DOM\XMLDocument();
         $xml = '<hello><![CDATA[HELLO]]></hello>';
         [$file, $handle] = $this->fillFile($xml);
         $loader = xml_file_loader($file, LIBXML_NOCDATA);
 
-        $loader($doc);
+        $doc = $loader();
         fclose($handle);
 
         static::assertSame('<hello>HELLO</hello>', $doc->saveXML($doc->documentElement));
     }
-    
+
     public function test_it_cannot_load_invalid_xml_file(): void
     {
-        $doc = new \DOM\XMLDocument();
         $xml = '<hello';
         [$file, $handle] = $this->fillFile($xml);
         $loader = xml_file_loader($file);
 
         $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Could not load the DOM Document');
+        $this->expectExceptionMessage('XML document is malformed');
 
-        $loader($doc);
+        $doc = $loader();
         fclose($handle);
     }
 
     public function test_it_throws_exception_on_invalid_file(): void
     {
-        $doc = new \DOM\XMLDocument();
         $loader = xml_file_loader('invalid-file');
 
         $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage('The file "invalid-file" does not exist');
 
-        $loader($doc);
+        $loader();
     }
 }
diff --git a/tests/Xml/Dom/Loader/XmlNodeLoaderTest.php b/tests/Xml/Dom/Loader/XmlNodeLoaderTest.php
index c0a115e3..ca3cc5a4 100644
--- a/tests/Xml/Dom/Loader/XmlNodeLoaderTest.php
+++ b/tests/Xml/Dom/Loader/XmlNodeLoaderTest.php
@@ -15,11 +15,10 @@ final class XmlNodeLoaderTest extends TestCase
     public function test_it_can_load_xml_node(): void
     {
         $source = Document::fromXmlString($xml = '<hello />')->toUnsafeDocument();
-        $doc = Document::empty()->toUnsafeDocument();
 
         $loader = xml_node_loader($source->documentElement);
 
-        $loader($doc);
+        $doc = $loader();
         static::assertXmlStringEqualsXmlString($xml, $doc->saveXML());
     }
 
@@ -27,13 +26,12 @@ public function test_it_can_load_xml_node(): void
     public function test_it_can_not_load_invalid_xml_node(): void
     {
         $source = Document::fromXmlString($xml = '<hello />')->toUnsafeDocument();
-        $doc = Document::empty()->toUnsafeDocument();
 
         $loader = xml_node_loader($source);
 
         $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Cannot import node: Node Type Not Supported');
+        $this->expectExceptionMessage('Not Supported Error');
 
-        $loader($doc);
+        $loader();
     }
 }
diff --git a/tests/Xml/Dom/Loader/XmlStringLoaderTest.php b/tests/Xml/Dom/Loader/XmlStringLoaderTest.php
index ebed9148..8233ce03 100644
--- a/tests/Xml/Dom/Loader/XmlStringLoaderTest.php
+++ b/tests/Xml/Dom/Loader/XmlStringLoaderTest.php
@@ -13,33 +13,30 @@ final class XmlStringLoaderTest extends TestCase
 {
     public function test_it_can_load_xml_string(): void
     {
-        $doc = new \DOM\XMLDocument();
         $xml = '<hello />';
         $loader = xml_string_loader($xml);
+        $doc = $loader();
 
-        $loader($doc);
         static::assertXmlStringEqualsXmlString($xml, $doc->saveXML());
     }
 
     public function test_it_can_not_load_invalid_xml_string(): void
     {
-        $doc = new \DOM\XMLDocument();
         $xml = '<hello';
         $loader = xml_string_loader($xml);
 
         $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Could not load the DOM Document');
+        $this->expectExceptionMessage('XML document is malformed');
 
-        $loader($doc);
+        $loader();
     }
 
     public function test_it_can_load_with_options(): void
     {
-        $doc = new \DOM\XMLDocument();
         $xml = '<hello><![CDATA[HELLO]]></hello>';
         $loader = xml_string_loader($xml, LIBXML_NOCDATA);
+        $doc = $loader();
 
-        $loader($doc);
         static::assertSame('<hello>HELLO</hello>', $doc->saveXML($doc->documentElement));
     }
 }
diff --git a/tests/Xml/Dom/Locator/Element/SiblingsTest.php b/tests/Xml/Dom/Locator/Element/SiblingsTest.php
index d55909cf..26c1a779 100644
--- a/tests/Xml/Dom/Locator/Element/SiblingsTest.php
+++ b/tests/Xml/Dom/Locator/Element/SiblingsTest.php
@@ -29,8 +29,8 @@ public function test_it_can_detect_siblings(): void
 
         $siblings = siblings($domdoc->documentElement->firstElementChild);
         static::assertCount(3, $siblings);
-        static::assertSame('1', $siblings->item(0)->nodeValue);
-        static::assertSame('2', $siblings->item(1)->nodeValue);
-        static::assertSame('3', $siblings->item(2)->nodeValue);
+        static::assertSame('1', $siblings->item(0)->textContent);
+        static::assertSame('2', $siblings->item(1)->textContent);
+        static::assertSame('3', $siblings->item(2)->textContent);
     }
 }
diff --git a/tests/Xml/Dom/Locator/Node/ChildrenTest.php b/tests/Xml/Dom/Locator/Node/ChildrenTest.php
index d9d0e5d7..c554b35a 100644
--- a/tests/Xml/Dom/Locator/Node/ChildrenTest.php
+++ b/tests/Xml/Dom/Locator/Node/ChildrenTest.php
@@ -23,6 +23,6 @@ public function test_it_can_detect_children(): void
         static::assertCount(3, $children);
         static::assertSame('world', $children->item(0)->nodeName);
         static::assertSame('moon', $children->item(1)->nodeName);
-        static::assertSame('Comment', $children->item(2)->nodeValue);
+        static::assertSame('Comment', $children->item(2)->textContent);
     }
 }
diff --git a/tests/Xml/Dom/Locator/Node/DetectDocumentTest.php b/tests/Xml/Dom/Locator/Node/DetectDocumentTest.php
index 4c7e1017..2d5ef0d4 100644
--- a/tests/Xml/Dom/Locator/Node/DetectDocumentTest.php
+++ b/tests/Xml/Dom/Locator/Node/DetectDocumentTest.php
@@ -5,7 +5,6 @@
 namespace VeeWee\Tests\Xml\Dom\Locator\Node;
 
 use \DOM\Element;
-use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
 use VeeWee\Xml\Dom\Document;
 use function VeeWee\Xml\Dom\Locator\Node\detect_document;
@@ -20,15 +19,4 @@ public function test_it_can_detect_document(): void
         static::assertSame($domdoc, detect_document($domdoc));
         static::assertSame($domdoc, detect_document($domdoc->documentElement));
     }
-
-    
-    public function test_it_throws_exception_on_unlinked_node(): void
-    {
-        $element = new \DOM\Element('name');
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Expected to find an ownerDocument on provided \DOM\Node.');
-
-        detect_document($element);
-    }
 }
diff --git a/tests/Xml/Dom/Locator/Xsd/LocateXsdSchemasTest.php b/tests/Xml/Dom/Locator/Xsd/LocateXsdSchemasTest.php
index a0d6bfdb..3289e5d2 100644
--- a/tests/Xml/Dom/Locator/Xsd/LocateXsdSchemasTest.php
+++ b/tests/Xml/Dom/Locator/Xsd/LocateXsdSchemasTest.php
@@ -12,7 +12,7 @@
 use function VeeWee\Xml\Dom\Locator\Xsd\locate_namespaced_xsd_schemas;
 use function VeeWee\Xml\Dom\Locator\Xsd\locate_no_namespaced_xsd_schemas;
 
-final class LocateAllXsdSchemasTest extends TestCase
+final class LocateXsdSchemasTest extends TestCase
 {
     public function test_it_can_locate_namespaced_xsd_schemas(): void
     {
diff --git a/tests/Xml/Dom/Manipulator/Node/ImportNodeDeeplyTest.php b/tests/Xml/Dom/Manipulator/Node/ImportNodeDeeplyTest.php
index 000cfde0..b59f5b39 100644
--- a/tests/Xml/Dom/Manipulator/Node/ImportNodeDeeplyTest.php
+++ b/tests/Xml/Dom/Manipulator/Node/ImportNodeDeeplyTest.php
@@ -57,8 +57,8 @@ public function test_it_can_recursively_import_a_node_based_on_a_target_document
 
         static::assertInstanceOf(\DOM\Element::class, $result);
         static::assertSame('world', $result->nodeName);
-        static::assertSame('myvalue', $result->attributes->getNamedItem('myattrib')->nodeValue);
+        static::assertSame('myvalue', $result->attributes->getNamedItem('myattrib')->textContent);
         static::assertSame('name', $result->firstChild->nodeName);
-        static::assertSame('VeeWee', $result->firstChild->nodeValue);
+        static::assertSame('VeeWee', $result->firstChild->textContent);
     }
 }
diff --git a/tests/Xml/Dom/Traverser/TraverserTest.php b/tests/Xml/Dom/Traverser/TraverserTest.php
index 77c134ae..5367c968 100644
--- a/tests/Xml/Dom/Traverser/TraverserTest.php
+++ b/tests/Xml/Dom/Traverser/TraverserTest.php
@@ -29,7 +29,7 @@ public function test_it_can_traverse_without_visitors(): void
         static::assertXmlStringEqualsXmlString($doc->toXmlString(), $actual);
     }
 
-    
+
     public function test_it_can_traverse_single_node(): void
     {
         $doc = Document::fromXmlString($actual = '<hello/>');
@@ -49,7 +49,7 @@ public function onNodeLeave(\DOM\Node $node): Action
         static::assertXmlStringEqualsXmlString(xml_string()($newRoot), '<hello who="Jos"/>');
     }
 
-    
+
     public function test_it_can_traverse_attributes(): void
     {
         $doc = Document::fromXmlString($actual = '<hello who="world"/>');
@@ -61,7 +61,7 @@ public function onNodeLeave(\DOM\Node $node): Action
                         return new Action\Noop();
                     }
 
-                    $node->nodeValue = 'Jos';
+                    $node->textContent = 'Jos';
 
                     return new Action\Noop();
                 }
@@ -71,7 +71,7 @@ public function onNodeLeave(\DOM\Node $node): Action
         static::assertXmlStringEqualsXmlString($doc->toXmlString(), '<hello who="Jos"/>');
     }
 
-    
+
     public function test_it_can_traverse_child_nodes(): void
     {
         $doc = Document::fromXmlString($actual = '<hello><item>    <![CDATA[Juw]]>    </item></hello>');
@@ -80,11 +80,11 @@ public function test_it_can_traverse_child_nodes(): void
                 public function onNodeLeave(\DOM\Node $node): Action
                 {
                     if (is_non_empty_text($node)) {
-                        $node->nodeValue = 'Yo';
+                        $node->textContent = 'Yo';
                         return new Action\Noop();
                     }
                     if (is_whitespace($node)) {
-                        $node->nodeValue = '';
+                        $node->textContent = '';
                         return new Action\Noop();
                     }
 
@@ -101,7 +101,7 @@ public function onNodeLeave(\DOM\Node $node): Action
         static::assertXmlStringEqualsXmlString($doc->toXmlString(), '<hello><item type="greeting">Yo</item></hello>');
     }
 
-    
+
     public function test_it_can_handle_node_enter_and_leave(): void
     {
         $doc = Document::fromXmlString($actual = '<hello />');
@@ -132,7 +132,7 @@ public function onNodeLeave(\DOM\Node $node): Action
         static::assertXmlStringEqualsXmlString($doc->toXmlString(), '<hello enter="yes" leave="yes" />');
     }
 
-    
+
     public function test_it_can_recursively_remove_empty_nodes(): void
     {
         $doc = Document::fromXmlString(