Added namespace constants to Node

lib/Attr.php

@@ -26,7 +26,7 @@ class Attr extends Node {
 
     protected function __get_namespaceURI(): ?string {
         $namespace = $this->innerNode->namespaceURI;
-        return (!$this->ownerDocument instanceof XMLDocument && $namespace === null) ? Parser::HTML_NAMESPACE : $namespace;
+        return (!$this->ownerDocument instanceof XMLDocument && $namespace === null) ? Node::HTML_NAMESPACE : $namespace;
     }
 
     protected function __get_ownerElement(): Element {

lib/DOMImplementation.php

@@ -11,7 +11,6 @@ use MensBeam\HTML\DOM\Inner\{
     Document as InnerDocument,
     Reflection
 };
-use MensBeam\HTML\DOM\Parser;
 
 
 class DOMImplementation {
@@ -55,12 +54,12 @@ class DOMImplementation {
         # 7. document’s content type is determined by namespace:
         switch ($namespace) {
             # ↪ HTML namespace
-            case Parser::HTML_NAMESPACE:
+            case self::HTML_NAMESPACE:
                 # application/xhtml+xml
                 $contentType = 'application/xhtml+xml';
             break;
             # ↪ SVG namespace
-            case Parser::SVG_NAMESPACE:
+            case self::SVG_NAMESPACE:
                 # image/svg+xml
                 $contentType = 'image/svg+xml';
             break;
@@ -85,7 +84,7 @@ class DOMImplementation {
         if (!preg_match(InnerDocument::QNAME_PRODUCTION_REGEX, $qualifiedName)) {
             throw new DOMException(DOMException::INVALID_CHARACTER);
         }
-        
+
         # 2. Return a new doctype, with qualifiedName as its name, publicId as its
         #    public ID, and systemId as its system ID, and with its node document set to
         #    the associated document of this.

lib/DocumentOrElement.php

@@ -11,7 +11,6 @@ use MensBeam\HTML\DOM\Inner\{
     Document as InnerDocument,
     Reflection
 };
-use MensBeam\HTML\Parser;
 use MensBeam\HTML\Parser\Data;
 
 
@@ -121,7 +120,7 @@ trait DocumentOrElement {
         if (!$wrapperDoc instanceof XMLDocument) {
             if ($namespace === null) {
                 return Reflection::createFromProtectedConstructor(__NAMESPACE__ . '\\HTMLCollection', $doc, new \DOMNodeList());
-            } elseif ($namespace === Parser::HTML_NAMESPACE) {
+            } elseif ($namespace === self::HTML_NAMESPACE) {
                 $namespace = null;
             }
         }
@@ -187,9 +186,9 @@ trait DocumentOrElement {
         #      "xmlns", then throw a "NamespaceError" DOMException.
         if (
             ($prefix !== null && $namespace === null) ||
-            ($prefix === 'xml' && $namespace !== Parser::XML_NAMESPACE) ||
-            (($qualifiedName === 'xmlns' || $prefix === 'xmlns') && $namespace !== Parser::XMLNS_NAMESPACE) ||
-            ($namespace === Parser::XMLNS_NAMESPACE && $qualifiedName !== 'xmlns' && $prefix !== 'xmlns')
+            ($prefix === 'xml' && $namespace !== self::XML_NAMESPACE) ||
+            (($qualifiedName === 'xmlns' || $prefix === 'xmlns') && $namespace !== self::XMLNS_NAMESPACE) ||
+            ($namespace === self::XMLNS_NAMESPACE && $qualifiedName !== 'xmlns' && $prefix !== 'xmlns')
         ) {
             throw new DOMException(DOMException::NAMESPACE_ERROR);
         }
@@ -197,7 +196,7 @@ trait DocumentOrElement {
         # 10. Return namespace, prefix, and localName.
         return [
             // Internally HTML namespaced elements in HTML documents use null because of a PHP DOM bug.
-            'namespace' => (!$this->getInnerDocument() instanceof XMLDocument && $namespace === Parser::HTML_NAMESPACE) ? null : $namespace,
+            'namespace' => (!$this->getInnerDocument() instanceof XMLDocument && $namespace === self::HTML_NAMESPACE) ? null : $namespace,
             'prefix' => $prefix,
             'localName' => $localName
         ];

lib/Element.php

@@ -46,7 +46,7 @@ class Element extends Node {
         // but print out the HTML namespace instead.
         $namespace = $this->innerNode->namespaceURI;
         $doc = $this->ownerDocument;
-        return (!$doc instanceof XMLDocument && $namespace === null) ? Parser::HTML_NAMESPACE : $namespace;
+        return (!$doc instanceof XMLDocument && $namespace === null) ? self::HTML_NAMESPACE : $namespace;
     }
 
     protected function __get_prefix(): ?string {
@@ -92,7 +92,7 @@ class Element extends Node {
         # 1. If element is in the HTML namespace and its node document is an HTML document,
         #    then set qualifiedName to qualifiedName in ASCII lowercase.
         // Document will always be an HTML document
-        if (!$this instanceof XMLDocument && $this->namespaceURI === Parser::HTML_NAMESPACE) {
+        if (!$this instanceof XMLDocument && $this->namespaceURI === self::HTML_NAMESPACE) {
             $qualifiedName = strtolower($qualifiedName);
         }
 
@@ -130,7 +130,7 @@ class Element extends Node {
         #
         # 1. If this is in the HTML namespace and its node document is an HTML document,
         #    then set qualifiedName to qualifiedName in ASCII lowercase.
-        if (!$this->ownerDocument instanceof XMLDocument && $this->namespaceURI === Parser::HTML_NAMESPACE) {
+        if (!$this->ownerDocument instanceof XMLDocument && $this->namespaceURI === self::HTML_NAMESPACE) {
             $qualifiedName = strtolower($qualifiedName);
         }
 
@@ -220,7 +220,7 @@ class Element extends Node {
         // when we can because it's faster.
         // NOTE: We create attribute nodes so that xmlns attributes don't get lost;
         // otherwise they cannot be serialized
-        if ($namespace === Parser::XMLNS_NAMESPACE) {
+        if ($namespace === self::XMLNS_NAMESPACE) {
             // Xmlns attributes have special bugs just for them. How lucky! Xmlns attribute
             // nodes won't stick and can actually cause segmentation faults if created on a
             // no longer existing document element, appended to another element, and then

lib/Inner/Document.php

@@ -14,7 +14,6 @@ use MensBeam\HTML\DOM\{
     Node as WrapperNode,
     XMLDocument as WrapperXMLDocument
 };
-use MensBeam\HTML\Parser;
 
 
 class Document extends \DOMDocument {
@@ -85,9 +84,9 @@ class Document extends \DOMDocument {
                 } else {
                     $className = 'HTMLElement';
                 }
-            } elseif ($namespace === Parser::SVG_NAMESPACE) {
+            } elseif ($namespace === WrapperNode::SVG_NAMESPACE) {
                 $className = 'SVGElement';
-            } elseif ($namespace === Parser::MATHML_NAMESPACE) {
+            } elseif ($namespace === WrapperNode::MATHML_NAMESPACE) {
                 $className = 'MathMLElement';
             } else {
                 $className = 'Element';

lib/Node.php

@@ -19,6 +19,14 @@ use MensBeam\HTML\DOM\Inner\{
 abstract class Node {
     use MagicProperties, NameCoercion;
 
+    // Namespace constants
+    public const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+    public const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+    public const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+    public const XLINK_NAMESPACE = 'http://www.w3.org/1999/xlink';
+    public const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+    public const XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/';
+
     public const ELEMENT_NODE = 1;
     public const ATTRIBUTE_NODE = 2;
     public const TEXT_NODE = 3;
@@ -359,12 +367,12 @@ abstract class Node {
                     foreach ($attributes as $attr) {
                         # 1. If attr equals attr1, then return the result of adding DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and DOCUMENT_POSITION_PRECEDING.
                         if ($attr === $attr1) {
-                            return Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | Node::DOCUMENT_POSITION_PRECEDING;
+                            return self::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | self::DOCUMENT_POSITION_PRECEDING;
                         }
 
                         # 2. If attr equals attr2, then return the result of adding DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and DOCUMENT_POSITION_FOLLOWING.
                         if ($attr === $attr2) {
-                            return Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | Node::DOCUMENT_POSITION_FOLLOWING;
+                            return self::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | self::DOCUMENT_POSITION_FOLLOWING;
                         }
                     }
                 }
@@ -395,33 +403,33 @@ abstract class Node {
         } while ($n = $n->parentNode);
 
         if ($node1 === null || $node2 === null || $root1 !== $root2) {
-            return Node::DOCUMENT_POSITION_DISCONNECTED | Node::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | ((self::$rand === 0) ? Node::DOCUMENT_POSITION_PRECEDING : Node::DOCUMENT_POSITION_FOLLOWING);
+            return self::DOCUMENT_POSITION_DISCONNECTED | self::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | ((self::$rand === 0) ? self::DOCUMENT_POSITION_PRECEDING : self::DOCUMENT_POSITION_FOLLOWING);
         }
 
         # 7. If node1 is an ancestor of node2 and attr1 is null, or node1 is node2 and attr2
         #    is non-null, then return the result of adding DOCUMENT_POSITION_CONTAINS to
         #    DOCUMENT_POSITION_PRECEDING.
         if (($node1 === $node2 && $attr2 !== null) || ($attr1 === null && $this->containsInner($innerNode1, $innerNode2))) {
-            return Node::DOCUMENT_POSITION_CONTAINS | Node::DOCUMENT_POSITION_PRECEDING;
+            return self::DOCUMENT_POSITION_CONTAINS | self::DOCUMENT_POSITION_PRECEDING;
         }
 
         # 8. If node1 is a descendant of node2 and attr2 is null, or node1 is node2 and attr1
         #    is non-null, then return the result of adding DOCUMENT_POSITION_CONTAINED_BY to
         #    DOCUMENT_POSITION_FOLLOWING.
         if (($node1 === $node2 && $attr1 !== null) || ($attr2 === null && $this->containsInner($innerNode2, $innerNode1))) {
-            return Node::DOCUMENT_POSITION_CONTAINED_BY | Node::DOCUMENT_POSITION_FOLLOWING;
+            return self::DOCUMENT_POSITION_CONTAINED_BY | self::DOCUMENT_POSITION_FOLLOWING;
         }
 
         # 9. If node1 is preceding node2, then return DOCUMENT_POSITION_PRECEDING.
         $n = $innerNode2;
         while ($n = $n->previousSibling) {
             if ($n === $innerNode1) {
-                return Node::DOCUMENT_POSITION_PRECEDING;
+                return self::DOCUMENT_POSITION_PRECEDING;
             }
         }
 
         # 10. Return DOCUMENT_POSITION_FOLLOWING.
-        return Node::DOCUMENT_POSITION_FOLLOWING;
+        return self::DOCUMENT_POSITION_FOLLOWING;
     }
 
     public function contains(?Node $other): bool {
@@ -1064,7 +1072,7 @@ abstract class Node {
         if ($node instanceof \DOMElement) {
             // Work around PHP DOM HTML namespace bug
             if ($node->namespaceURI === null && !$node->ownerDocument->getWrapperNode($node->ownerDocument) instanceof XMLDocument) {
-                $namespace = Parser::HTML_NAMESPACE;
+                $namespace = self::HTML_NAMESPACE;
             } else {
                 $namespace = $node->namespaceURI;
             }
@@ -1095,7 +1103,7 @@ abstract class Node {
                     // our lives miserable, so if we followed the specification as written we could
                     // get an incorrect answer. So, also check to see if the local name is not
                     // 'xmlns', too.
-                    if (($attr->namespaceURI === Parser::XMLNS_NAMESPACE && $attr->prefix === 'xmlns' && $attr->localName === $prefix) || ($prefix === null && $attr->namespaceURI === Parser::XMLNS_NAMESPACE && ($attr->prefix === null || $attr->prefix === '' || $attr->prefix === 'xmlns') && $attr->localName === 'xmlns')) {
+                    if (($attr->namespaceURI === self::XMLNS_NAMESPACE && $attr->prefix === 'xmlns' && $attr->localName === $prefix) || ($prefix === null && $attr->namespaceURI === self::XMLNS_NAMESPACE && ($attr->prefix === null || $attr->prefix === '' || $attr->prefix === 'xmlns') && $attr->localName === 'xmlns')) {
                         return ($attr->value !== '') ? $attr->value : null;
                     }
                 }
@@ -1213,10 +1221,10 @@ abstract class Node {
             // fashioned way by walking the DOM.
             $foreign = $this->walkInner($element, function(\DOMNode $n) {
                 if ($n instanceof \DOMElement && ($n->parentNode !== null && $n->parentNode->namespaceURI === null) && $n->namespaceURI !== null && $n->prefix === '') {
-                    return Node::WALK_ACCEPT | Node::WALK_SKIP_CHILDREN;
+                    return self::WALK_ACCEPT | self::WALK_SKIP_CHILDREN;
                 }
 
-                return Node::WALK_REJECT;
+                return self::WALK_REJECT;
             });
 
             $this->bullshitReplacements = [];

tests/cases/TestDocument.php

@@ -16,8 +16,7 @@ use MensBeam\HTML\DOM\{
     Text,
     XMLDocument
 };
-use MensBeam\HTML\Parser,
-    org\bovigo\vfs\vfsStream;
+use org\bovigo\vfs\vfsStream;
 
 
 /** @covers \MensBeam\HTML\DOM\Document */

tests/cases/TestDocumentOrElement.php

@@ -16,7 +16,6 @@ use MensBeam\HTML\DOM\{
     Text,
     XMLDocument
 };
-use MensBeam\HTML\Parser;
 
 
 /** @covers \MensBeam\HTML\DOM\DocumentOrElement */
@@ -83,10 +82,10 @@ class TestDocumentOrElement extends \PHPUnit\Framework\TestCase {
     public function testMethod_getElementsByTagNameNS() {
         $d = new Document('<!DOCTYPE html><html><body><div><div><span></span></div></div><div></div><span></span><span></span><svg></svg></body></html>');
         $svg = $d->body->lastChild;
-        $svg->appendChild($d->createElementNS(Parser::SVG_NAMESPACE, 'div'));
+        $svg->appendChild($d->createElementNS(Node::SVG_NAMESPACE, 'div'));
 
         // HTML namespace
-        $div = $d->getElementsByTagNameNS(Parser::HTML_NAMESPACE, 'div');
+        $div = $d->getElementsByTagNameNS(Node::HTML_NAMESPACE, 'div');
         $this->assertEquals(3, $div->length);
 
         // Null namespace
@@ -106,7 +105,7 @@ class TestDocumentOrElement extends \PHPUnit\Framework\TestCase {
         $this->assertEquals(4, $div->length);
 
         // Wildcard local name
-        $svg = $d->getElementsByTagNameNS(Parser::SVG_NAMESPACE, '*');
+        $svg = $d->getElementsByTagNameNS(Node::SVG_NAMESPACE, '*');
         $this->assertEquals(2, $svg->length);
     }
 
@@ -115,11 +114,11 @@ class TestDocumentOrElement extends \PHPUnit\Framework\TestCase {
         return [
             [ function() {
                 $d = new Document();
-                $d->createElementNS(Parser::HTML_NAMESPACE, 'this will fail');
+                $d->createElementNS(Node::HTML_NAMESPACE, 'this will fail');
             }, DOMException::INVALID_CHARACTER ],
             [ function() {
                 $d = new Document();
-                $d->createAttributeNS(Parser::HTML_NAMESPACE, 'xmlns');
+                $d->createAttributeNS(Node::HTML_NAMESPACE, 'xmlns');
             }, DOMException::NAMESPACE_ERROR ]
         ];
     }

tests/cases/TestNode.php

@@ -14,7 +14,6 @@ use MensBeam\HTML\DOM\{
     Node,
     XMLDocument
 };
-use MensBeam\HTML\Parser;
 
 
 /** @covers \MensBeam\HTML\DOM\Node */
@@ -461,44 +460,44 @@ class TestNode extends \PHPUnit\Framework\TestCase {
         $d = new Document();
 
         // Empty document
-        $this->assertFalse($d->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertFalse($d->isDefaultNamespace(Node::HTML_NAMESPACE));
 
         $doctype = $d->appendChild($d->implementation->createDocumentType('html', '', ''));
         $documentElement = $d->createElement('html');
         $documentElement = $d->appendChild($d->createElement('html'));
-        $documentElement->setAttributeNS(Parser::XMLNS_NAMESPACE, 'xmlns:poop💩', 'https://poop💩.poop');
+        $documentElement->setAttributeNS(Node::XMLNS_NAMESPACE, 'xmlns:poop💩', 'https://poop💩.poop');
         $body = $documentElement->appendChild($d->createElement('body'));
-        $mathml = $body->appendChild($d->createElementNS(Parser::MATHML_NAMESPACE, 'mathml'));
-        $mathml->setAttributeNS(Parser::XMLNS_NAMESPACE, 'xmlns:xlink', Parser::XLINK_NAMESPACE);
+        $mathml = $body->appendChild($d->createElementNS(Node::MATHML_NAMESPACE, 'mathml'));
+        $mathml->setAttributeNS(Node::XMLNS_NAMESPACE, 'xmlns:xlink', Node::XLINK_NAMESPACE);
         $comment = $d->createComment('Ook');
 
         // Detached comment
-        $this->assertFalse($comment->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertFalse($comment->isDefaultNamespace(Node::HTML_NAMESPACE));
 
         $body->appendChild($comment);
         $jeff = $body->appendChild($d->createElementNS('https://poop💩.poop', 'poop💩:jeff'));
-        $attr = $d->createAttributeNS(Parser::XMLNS_NAMESPACE, 'xmlns');
-        $attr->value = Parser::HTML_NAMESPACE;
+        $attr = $d->createAttributeNS(Node::XMLNS_NAMESPACE, 'xmlns');
+        $attr->value = Node::HTML_NAMESPACE;
 
         // Detached attribute
-        $this->assertFalse($attr->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertFalse($attr->isDefaultNamespace(Node::HTML_NAMESPACE));
 
         $attr = $documentElement->setAttributeNodeNS($attr);
         $frag = $d->createDocumentFragment();
 
         $d2 = new XMLDocument();
         $xmlDocumentElement = $d2->appendChild($d2->createElement('poop'));
-        $xmlDocumentElement->setAttributeNS(Parser::XMLNS_NAMESPACE, 'xmlns', 'https://poop💩.poop');
+        $xmlDocumentElement->setAttributeNS(Node::XMLNS_NAMESPACE, 'xmlns', 'https://poop💩.poop');
         $detached = $d2->createElement('div');
 
         // Namespace empty string
         $this->assertFalse($d->isDefaultNamespace(''));
         // HTML namespace on document
-        $this->assertTrue($d->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertTrue($d->isDefaultNamespace(Node::HTML_NAMESPACE));
         // HTML namespace on element
-        $this->assertTrue($body->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertTrue($body->isDefaultNamespace(Node::HTML_NAMESPACE));
         // MathML namespace on mathml element
-        $this->assertTrue($mathml->isDefaultNamespace(Parser::MATHML_NAMESPACE));
+        $this->assertTrue($mathml->isDefaultNamespace(Node::MATHML_NAMESPACE));
         // On detached XML element with null namespace
         $this->assertTrue($detached->isDefaultNamespace(null));
         // Custom namespace on namespaced element
@@ -506,13 +505,13 @@ class TestNode extends \PHPUnit\Framework\TestCase {
         // xmlns attribute on document element of XML document
         $this->assertTrue($xmlDocumentElement->isDefaultNamespace('https://poop💩.poop'));
         // Attribute
-        $this->assertTrue($attr->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertTrue($attr->isDefaultNamespace(Node::HTML_NAMESPACE));
         // On doctype
-        $this->assertFalse($doctype->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertFalse($doctype->isDefaultNamespace(Node::HTML_NAMESPACE));
         // Document fragment
-        $this->assertFalse($frag->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertFalse($frag->isDefaultNamespace(Node::HTML_NAMESPACE));
         // Comment
-        $this->assertTrue($comment->isDefaultNamespace(Parser::HTML_NAMESPACE));
+        $this->assertTrue($comment->isDefaultNamespace(Node::HTML_NAMESPACE));
     }
 
 
@@ -565,37 +564,37 @@ class TestNode extends \PHPUnit\Framework\TestCase {
         $d = new Document();
         $doctype = $d->appendChild($d->implementation->createDocumentType('html', '', ''));
         $documentElement = $d->appendChild($d->createElement('html'));
-        $documentElement->setAttributeNS(Parser::XMLNS_NAMESPACE, 'xmlns:poop💩', 'https://poop💩.poop');
+        $documentElement->setAttributeNS(Node::XMLNS_NAMESPACE, 'xmlns:poop💩', 'https://poop💩.poop');
         $body = $documentElement->appendChild($d->createElement('body'));
-        $svg = $body->appendChild($d->createElementNS(Parser::SVG_NAMESPACE, 'svg'));
-        $svg->setAttributeNS(Parser::XMLNS_NAMESPACE, 'xmlns:xlink', Parser::XLINK_NAMESPACE);
+        $svg = $body->appendChild($d->createElementNS(Node::SVG_NAMESPACE, 'svg'));
+        $svg->setAttributeNS(Node::XMLNS_NAMESPACE, 'xmlns:xlink', Node::XLINK_NAMESPACE);
         $comment = $body->appendChild($d->createComment('Ook'));
         $jeff = $body->appendChild($d->createElementNS('https://poop💩.poop', 'poop💩:jeff'));
-        $attr = $d->createAttributeNS(Parser::XMLNS_NAMESPACE, 'xmlns');
-        $attr->value = Parser::HTML_NAMESPACE;
+        $attr = $d->createAttributeNS(Node::XMLNS_NAMESPACE, 'xmlns');
+        $attr->value = Node::HTML_NAMESPACE;
         $attr = $documentElement->setAttributeNodeNS($attr);
         $frag = $d->createDocumentFragment();
 
         // HTML namespace on document
-        $this->assertNull($d->lookupPrefix(Parser::HTML_NAMESPACE));
+        $this->assertNull($d->lookupPrefix(Node::HTML_NAMESPACE));
         // HTML namespace on element
-        $this->assertNull($body->lookupPrefix(Parser::HTML_NAMESPACE));
+        $this->assertNull($body->lookupPrefix(Node::HTML_NAMESPACE));
         // SVG namespace on element
-        $this->assertNull($svg->lookupPrefix(Parser::SVG_NAMESPACE));
+        $this->assertNull($svg->lookupPrefix(Node::SVG_NAMESPACE));
         // Custom namespace on namespaced element
         $this->assertSame('poop💩', $jeff->lookupPrefix('https://poop💩.poop'));
         // Xlink namespace
-        $this->assertSame('xlink', $svg->lookupPrefix(Parser::XLINK_NAMESPACE));
+        $this->assertSame('xlink', $svg->lookupPrefix(Node::XLINK_NAMESPACE));
         // Null prefix
         $this->assertNull($body->lookupPrefix());
         // On doctype
-        $this->assertNull($doctype->lookupPrefix(Parser::HTML_NAMESPACE));
+        $this->assertNull($doctype->lookupPrefix(Node::HTML_NAMESPACE));
         // Document fragment
-        $this->assertNull($frag->lookupPrefix(Parser::HTML_NAMESPACE));
+        $this->assertNull($frag->lookupPrefix(Node::HTML_NAMESPACE));
         // Attribute with namespace on element with no prefix
-        $this->assertNull($attr->lookupPrefix(Parser::HTML_NAMESPACE));
+        $this->assertNull($attr->lookupPrefix(Node::HTML_NAMESPACE));
         // Comment
-        $this->assertNull($comment->lookupPrefix(Parser::HTML_NAMESPACE));
+        $this->assertNull($comment->lookupPrefix(Node::HTML_NAMESPACE));
         // Look up prefix on ancestor
         $this->assertSame('poop💩', $comment->lookupPrefix('https://poop💩.poop'));
     }
@@ -631,7 +630,7 @@ class TestNode extends \PHPUnit\Framework\TestCase {
         $d->appendChild($d->createElement('html'));
 
         // Nust need to test empty string prefix, rest is covered elsewhere
-        $this->assertSame(Parser::HTML_NAMESPACE, $d->lookupNamespaceURI(''));
+        $this->assertSame(Node::HTML_NAMESPACE, $d->lookupNamespaceURI(''));
     }
 
 
@@ -1430,9 +1429,9 @@ class TestNode extends \PHPUnit\Framework\TestCase {
         // Node::nodeName on attribute node with coerced name
         $this->assertSame('poop💩', $d->createAttribute('poop💩')->nodeName);
         // Node::nodeName on attribute node with coerced name and HTML namespace
-        $this->assertSame('poop💩', $d->createAttributeNS(Parser::HTML_NAMESPACE, 'poop💩')->nodeName);
+        $this->assertSame('poop💩', $d->createAttributeNS(Node::HTML_NAMESPACE, 'poop💩')->nodeName);
         // Node::nodeName on namespaced attribute node
-        $this->assertSame('xlink:href', $d->createAttributeNS(Parser::XLINK_NAMESPACE, 'xlink:href')->nodeName);
+        $this->assertSame('xlink:href', $d->createAttributeNS(Node::XLINK_NAMESPACE, 'xlink:href')->nodeName);
         // Node::nodeName on namespaced attribute node with coerced name
         $this->assertSame('poop💩:poop💩', $d->createAttributeNS('https://poop💩.poop', 'poop💩:poop💩')->nodeName);
 
@@ -1456,7 +1455,7 @@ class TestNode extends \PHPUnit\Framework\TestCase {
         // Node::nodeName on element with coerced name
         $this->assertSame('POOP💩', $d->createElement('poop💩')->nodeName);
         // Node::nodeName on namespaced element
-        $this->assertSame('SVG', $d->createElementNS(Parser::SVG_NAMESPACE, 'svg')->nodeName);
+        $this->assertSame('SVG', $d->createElementNS(Node::SVG_NAMESPACE, 'svg')->nodeName);
         // Node::nodeName on namespaced element with empty namespace
         $this->assertSame('HTML', $d->createElementNS('', 'html')->nodeName);
         // Node::nodeName on namespaced element with coerced name