@xmldom/xmldom 0.9.0-beta.8 → 0.9.0

package/lib/dom.js

@@ -2,25 +2,63 @@
 
 var conventions = require('./conventions');
 var find = conventions.find;
+var hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;
+var hasOwn = conventions.hasOwn;
+var isHTMLMimeType = conventions.isHTMLMimeType;
 var isHTMLRawTextElement = conventions.isHTMLRawTextElement;
 var isHTMLVoidElement = conventions.isHTMLVoidElement;
 var MIME_TYPE = conventions.MIME_TYPE;
 var NAMESPACE = conventions.NAMESPACE;
 
 /**
- * A prerequisite for `[].filter`, to drop elements that are empty
+ * Private DOM Constructor symbol
+ *
+ * Internal symbol used for construction of all classes whose constructors should be private.
+ * Currently used for checks in `Node`, `Document`, `Element`, `Attr`, `CharacterData`, `Text`, `Comment`,
+ * `CDATASection`, `DocumentType`, `Notation`, `Entity`, `EntityReference`, `DocumentFragment`, `ProcessingInstruction`
+ * so the constructor can't be used from outside the module.
+ */
+var PDC = Symbol();
+
+var errors = require('./errors');
+var DOMException = errors.DOMException;
+
+var g = require('./grammar');
+
+/**
+ * Checks if the given symbol equals the Private DOM Constructor symbol (PDC)
+ * and throws an Illegal constructor exception when the symbols don't match.
+ * This ensures that the constructor remains private and can't be used outside this module.
+ */
+function checkSymbol(symbol) {
+	if (symbol !== PDC) {
+		throw new TypeError('Illegal constructor');
+	}
+}
+
+/**
+ * A prerequisite for `[].filter`, to drop elements that are empty.
+ *
  * @param {string} input
+ * The string to be checked.
  * @returns {boolean}
+ * Returns `true` if the input string is not empty, `false` otherwise.
  */
 function notEmptyString(input) {
 	return input !== '';
 }
 /**
- * @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace
- * @see https://infra.spec.whatwg.org/#ascii-whitespace
+ * Splits a string on ASCII whitespace characters (U+0009 TAB, U+000A LF, U+000C FF, U+000D CR,
+ * U+0020 SPACE).
+ * It follows the definition from the infra specification from WHATWG.
  *
  * @param {string} input
- * @returns {string[]} (can be empty)
+ * The string to be split.
+ * @returns {string[]}
+ * An array of the split strings. The array can be empty if the input string is empty or only
+ * contains whitespace characters.
+ * @see {@link https://infra.spec.whatwg.org/#split-on-ascii-whitespace}
+ * @see {@link https://infra.spec.whatwg.org/#ascii-whitespace}
  */
 function splitOnASCIIWhitespace(input) {
 	// U+0009 TAB, U+000A LF, U+000C FF, U+000D CR, U+0020 SPACE
@@ -31,20 +69,31 @@ function splitOnASCIIWhitespace(input) {
  * Adds element as a key to current if it is not already present.
  *
  * @param {Record<string, boolean | undefined>} current
+ * The current record object to which the element will be added as a key.
+ * The object's keys are string types and values are either boolean or undefined.
  * @param {string} element
+ * The string to be added as a key to the current record.
  * @returns {Record<string, boolean | undefined>}
+ * The updated record object after the addition of the new element.
  */
 function orderedSetReducer(current, element) {
-	if (!current.hasOwnProperty(element)) {
+	if (!hasOwn(current, element)) {
 		current[element] = true;
 	}
 	return current;
 }
 
 /**
- * @see https://infra.spec.whatwg.org/#ordered-set
+ * Converts a string into an ordered set by splitting the input on ASCII whitespace and
+ * ensuring uniqueness of elements.
+ * This follows the definition of an ordered set from the infra specification by WHATWG.
+ *
  * @param {string} input
+ * The input string to be transformed into an ordered set.
  * @returns {string[]}
+ * An array of unique strings obtained from the input, preserving the original order.
+ * The array can be empty if the input string is empty or only contains whitespace characters.
+ * @see {@link https://infra.spec.whatwg.org/#ordered-set}
  */
 function toOrderedSet(input) {
 	if (!input) return [];
@@ -53,11 +102,14 @@ function toOrderedSet(input) {
 }
 
 /**
- * Uses `list.indexOf` to implement something like `Array.prototype.includes`,
- * which we can not rely on being available.
+ * Uses `list.indexOf` to implement a function that behaves like `Array.prototype.includes`.
+ * This function is used in environments where `Array.prototype.includes` may not be available.
  *
  * @param {any[]} list
+ * The array in which to search for the element.
  * @returns {function(any): boolean}
+ * A function that accepts an element and returns a boolean indicating whether the element is
+ * included in the provided list.
  */
 function arrayIncludes(list) {
 	return function (element) {
@@ -66,28 +118,43 @@ function arrayIncludes(list) {
 }
 
 /**
+ * Validates a qualified name based on the criteria provided in the DOM specification by
+ * WHATWG.
+ *
  * @param {string} qualifiedName
- * @throws DOMException
- * @see https://dom.spec.whatwg.org/#validate
+ * The qualified name to be validated.
+ * @throws {DOMException}
+ * With code {@link DOMException.INVALID_CHARACTER_ERR} if the qualified name contains an
+ * invalid character.
+ * @see {@link https://dom.spec.whatwg.org/#validate}
  */
 function validateQualifiedName(qualifiedName) {
-	if (!conventions.QNAME.test(qualifiedName)) {
-		throw new DOMException(INVALID_CHARACTER_ERR, 'invalid character in qualified name "' + qualifiedName + '"');
+	if (!g.QName_exact.test(qualifiedName)) {
+		throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'invalid character in qualified name "' + qualifiedName + '"');
 	}
 }
 
 /**
+ * Validates a qualified name and the namespace associated with it,
+ * based on the criteria provided in the DOM specification by WHATWG.
  *
  * @param {string | null} namespace
+ * The namespace to be validated. It can be a string or null.
  * @param {string} qualifiedName
- *
- * @returns {[namespace:string|null, prefix:string|null, localName:string]}
- * @see https://dom.spec.whatwg.org/#validate-and-extract
+ * The qualified name to be validated.
+ * @returns {[namespace: string | null, prefix: string | null, localName: string]}
+ * Returns a tuple with the namespace,
+ * prefix and local name of the qualified name.
+ * @throws {DOMException}
+ * Throws a DOMException if the qualified name or the namespace is not valid.
+ * @see {@link https://dom.spec.whatwg.org/#validate-and-extract}
  */
 function validateAndExtract(namespace, qualifiedName) {
 	validateQualifiedName(qualifiedName);
 	namespace = namespace || null;
-	/** @type {string | null} */
+	/**
+	 * @type {string | null}
+	 */
 	var prefix = null;
 	var localName = qualifiedName;
 	if (qualifiedName.indexOf(':') >= 0) {
@@ -96,31 +163,57 @@ function validateAndExtract(namespace, qualifiedName) {
 		localName = splitResult[1];
 	}
 	if (prefix !== null && namespace === null) {
-		throw new DOMException(NAMESPACE_ERR, 'prefix is non-null and namespace is null');
+		throw new DOMException(DOMException.NAMESPACE_ERR, 'prefix is non-null and namespace is null');
 	}
 	if (prefix === 'xml' && namespace !== conventions.NAMESPACE.XML) {
-		throw new DOMException(NAMESPACE_ERR, 'prefix is "xml" and namespace is not the XML namespace');
+		throw new DOMException(DOMException.NAMESPACE_ERR, 'prefix is "xml" and namespace is not the XML namespace');
 	}
 	if ((prefix === 'xmlns' || qualifiedName === 'xmlns') && namespace !== conventions.NAMESPACE.XMLNS) {
-		throw new DOMException(NAMESPACE_ERR, 'either qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace');
+		throw new DOMException(
+			DOMException.NAMESPACE_ERR,
+			'either qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace'
+		);
 	}
 	if (namespace === conventions.NAMESPACE.XMLNS && prefix !== 'xmlns' && qualifiedName !== 'xmlns') {
-		throw new DOMException(NAMESPACE_ERR, 'namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns"');
+		throw new DOMException(
+			DOMException.NAMESPACE_ERR,
+			'namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns"'
+		);
 	}
 	return [namespace, prefix, localName];
 }
 
+/**
+ * Copies properties from one object to another.
+ * It only copies the object's own (not inherited) properties.
+ *
+ * @param {Object} src
+ * The source object from which properties are copied.
+ * @param {Object} dest
+ * The destination object to which properties are copied.
+ */
 function copy(src, dest) {
 	for (var p in src) {
-		if (Object.prototype.hasOwnProperty.call(src, p)) {
+		if (hasOwn(src, p)) {
 			dest[p] = src[p];
 		}
 	}
 }
 
 /**
-^\w+\.prototype\.([_\w]+)\s*=\s*((?:.*\{\s*?[\r\n][\s\S]*?^})|\S.*?(?=[;\r\n]));?
-^\w+\.prototype\.([_\w]+)\s*=\s*(\S.*?(?=[;\r\n]));?
+ * Extends a class with the properties and methods of a super class.
+ * It uses a form of prototypal inheritance, and establishes the `constructor` property
+ * correctly(?).
+ *
+ * It is not clear to the current maintainers if this implementation is making sense,
+ * since it creates an intermediate prototype function,
+ * which all properties of `Super` are copied onto using `_copy`.
+ *
+ * @param {Object} Class
+ * The class that is to be extended.
+ * @param {Object} Super
+ * The super class from which properties and methods are inherited.
+ * @private
  */
 function _extends(Class, Super) {
 	var pt = Class.prototype;
@@ -139,7 +232,6 @@ function _extends(Class, Super) {
 	}
 }
 
-// Node Types
 var NodeType = {};
 var ELEMENT_NODE = (NodeType.ELEMENT_NODE = 1);
 var ATTRIBUTE_NODE = (NodeType.ATTRIBUTE_NODE = 2);
@@ -154,41 +246,23 @@ var DOCUMENT_TYPE_NODE = (NodeType.DOCUMENT_TYPE_NODE = 10);
 var DOCUMENT_FRAGMENT_NODE = (NodeType.DOCUMENT_FRAGMENT_NODE = 11);
 var NOTATION_NODE = (NodeType.NOTATION_NODE = 12);
 
-// ExceptionCode
-var ExceptionCode = {};
-var ExceptionMessage = {};
-var INDEX_SIZE_ERR = (ExceptionCode.INDEX_SIZE_ERR = ((ExceptionMessage[1] = 'Index size error'), 1));
-var DOMSTRING_SIZE_ERR = (ExceptionCode.DOMSTRING_SIZE_ERR = ((ExceptionMessage[2] = 'DOMString size error'), 2));
-var HIERARCHY_REQUEST_ERR = (ExceptionCode.HIERARCHY_REQUEST_ERR = ((ExceptionMessage[3] = 'Hierarchy request error'), 3));
-var WRONG_DOCUMENT_ERR = (ExceptionCode.WRONG_DOCUMENT_ERR = ((ExceptionMessage[4] = 'Wrong document'), 4));
-var INVALID_CHARACTER_ERR = (ExceptionCode.INVALID_CHARACTER_ERR = ((ExceptionMessage[5] = 'Invalid character'), 5));
-var NO_DATA_ALLOWED_ERR = (ExceptionCode.NO_DATA_ALLOWED_ERR = ((ExceptionMessage[6] = 'No data allowed'), 6));
-var NO_MODIFICATION_ALLOWED_ERR = (ExceptionCode.NO_MODIFICATION_ALLOWED_ERR =
-	((ExceptionMessage[7] = 'No modification allowed'), 7));
-var NOT_FOUND_ERR = (ExceptionCode.NOT_FOUND_ERR = ((ExceptionMessage[8] = 'Not found'), 8));
-var NOT_SUPPORTED_ERR = (ExceptionCode.NOT_SUPPORTED_ERR = ((ExceptionMessage[9] = 'Not supported'), 9));
-var INUSE_ATTRIBUTE_ERR = (ExceptionCode.INUSE_ATTRIBUTE_ERR = ((ExceptionMessage[10] = 'Attribute in use'), 10));
-//level2
-var INVALID_STATE_ERR = (ExceptionCode.INVALID_STATE_ERR = ((ExceptionMessage[11] = 'Invalid state'), 11));
-var SYNTAX_ERR = (ExceptionCode.SYNTAX_ERR = ((ExceptionMessage[12] = 'Syntax error'), 12));
-var INVALID_MODIFICATION_ERR = (ExceptionCode.INVALID_MODIFICATION_ERR = ((ExceptionMessage[13] = 'Invalid modification'), 13));
-var NAMESPACE_ERR = (ExceptionCode.NAMESPACE_ERR = ((ExceptionMessage[14] = 'Invalid namespace'), 14));
-var INVALID_ACCESS_ERR = (ExceptionCode.INVALID_ACCESS_ERR = ((ExceptionMessage[15] = 'Invalid access'), 15));
-
-// compareDocumentPosition bitmask results
-var DocumentPosition = {};
-var DOCUMENT_POSITION_DISCONNECTED = (DocumentPosition.DOCUMENT_POSITION_DISCONNECTED = 1);
-var DOCUMENT_POSITION_PRECEDING = (DocumentPosition.DOCUMENT_POSITION_PRECEDING = 2);
-var DOCUMENT_POSITION_FOLLOWING = (DocumentPosition.DOCUMENT_POSITION_FOLLOWING = 4);
-var DOCUMENT_POSITION_CONTAINS = (DocumentPosition.DOCUMENT_POSITION_CONTAINS = 8);
-var DOCUMENT_POSITION_CONTAINED_BY = (DocumentPosition.DOCUMENT_POSITION_CONTAINED_BY = 16);
-var DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = (DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32);
+var DocumentPosition = conventions.freeze({
+	DOCUMENT_POSITION_DISCONNECTED: 1,
+	DOCUMENT_POSITION_PRECEDING: 2,
+	DOCUMENT_POSITION_FOLLOWING: 4,
+	DOCUMENT_POSITION_CONTAINS: 8,
+	DOCUMENT_POSITION_CONTAINED_BY: 16,
+	DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32,
+});
 
 //helper functions for compareDocumentPosition
 /**
- * Construct a parent chain for a node.
- * @param {Node} node The start node.
- * @return {Node[]} The parent chain.
+ * Constructs a parent chain for a node.
+ *
+ * @param {Node} node
+ * The start node from which the parent chain will be constructed.
+ * @returns {Node[]}
+ * The array of nodes representing the parent chain from the root to the specified node.
  */
 function parentChain(node) {
 	var chain = [];
@@ -200,10 +274,15 @@ function parentChain(node) {
 }
 
 /**
- * Find the common ancestor in two parent chains.
- * @param {Node[]} a A parent chain.
- * @param {Node[]} b A parent chain.
- * @return {Node} The common ancestor if it exists.
+ * Finds the common ancestor in two parent chains.
+ *
+ * @param {Node[]} a
+ * The first parent chain.
+ * @param {Node[]} b
+ * The second parent chain.
+ * @returns {Node}
+ * The common ancestor node if it exists. If there is no common ancestor, the function will
+ * return `null`.
  */
 function commonAncestor(a, b) {
 	if (b.length < a.length) return commonAncestor(b, a);
@@ -216,10 +295,14 @@ function commonAncestor(a, b) {
 }
 
 /**
- * Comparing unrelated nodes must be consistent, so we assign a guid to the
- * compared docs for further reference.
- * @param {Document} doc The document.
- * @return {string} The document's guid.
+ * Assigns a unique identifier to a document to ensure consistency while comparing unrelated
+ * nodes.
+ *
+ * @param {Document} doc
+ * The document to which a unique identifier is to be assigned.
+ * @returns {string}
+ * The unique identifier of the document. If the document already had a unique identifier, the
+ * function will return the existing one.
  */
 function docGUID(doc) {
 	if (!doc.guid) doc.guid = Math.random();
@@ -228,50 +311,46 @@ function docGUID(doc) {
 //-- end of helper functions
 
 /**
- * DOM Level 2
- * Object DOMException
- * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html
- * @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html
- */
-function DOMException(code, message) {
-	if (message instanceof Error) {
-		var error = message;
-	} else {
-		error = this;
-		Error.call(this, ExceptionMessage[code]);
-		this.message = ExceptionMessage[code];
-		if (Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
-	}
-	error.code = code;
-	if (message) this.message = this.message + ': ' + message;
-	return error;
-}
-DOMException.prototype = Error.prototype;
-copy(ExceptionCode, DOMException);
-
-/**
- * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
- * The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.
+ * The NodeList interface provides the abstraction of an ordered collection of nodes,
+ * without defining or constraining how this collection is implemented.
+ * NodeList objects in the DOM are live.
  * The items in the NodeList are accessible via an integral index, starting from 0.
+ * You can also access the items of the NodeList with a `for...of` loop.
+ *
+ * @class NodeList
+ * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
+ * @constructs NodeList
  */
 function NodeList() {}
 NodeList.prototype = {
 	/**
-	 * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
-	 * @standard level1
+	 * The number of nodes in the list. The range of valid child node indices is 0 to length-1
+	 * inclusive.
+	 *
+	 * @type {number}
 	 */
 	length: 0,
 	/**
-	 * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
-	 * @standard level1
-	 * @param index  unsigned long
-	 *   Index into the collection.
-	 * @return Node
-	 * 	The node at the indexth position in the NodeList, or null if that is not a valid index.
+	 * Returns the item at `index`. If index is greater than or equal to the number of nodes in
+	 * the list, this returns null.
+	 *
+	 * @param index
+	 * Unsigned long Index into the collection.
+	 * @returns {Node | null}
+	 * The node at position `index` in the NodeList,
+	 * or null if that is not a valid index.
 	 */
 	item: function (index) {
-		return this[index] || null;
+		return index >= 0 && index < this.length ? this[index] : null;
 	},
+	/**
+	 * Returns a string representation of the NodeList.
+	 *
+	 * @param {unknown} nodeFilter
+	 * __A filter function? Not implemented according to the spec?__.
+	 * @returns {string}
+	 * A string representation of the NodeList.
+	 */
 	toString: function (nodeFilter) {
 		for (var buf = [], i = 0; i < this.length; i++) {
 			serializeToString(this[i], buf, nodeFilter);
@@ -279,51 +358,119 @@ NodeList.prototype = {
 		return buf.join('');
 	},
 	/**
-	 * @private
-	 * @param {function (Node):boolean} predicate
+	 * Filters the NodeList based on a predicate.
+	 *
+	 * @param {function(Node): boolean} predicate
+	 * - A predicate function to filter the NodeList.
 	 * @returns {Node[]}
+	 * An array of nodes that satisfy the predicate.
+	 * @private
 	 */
 	filter: function (predicate) {
 		return Array.prototype.filter.call(this, predicate);
 	},
 	/**
-	 * @private
+	 * Returns the first index at which a given node can be found in the NodeList, or -1 if it is
+	 * not present.
+	 *
 	 * @param {Node} item
+	 * - The Node item to locate in the NodeList.
 	 * @returns {number}
+	 * The first index of the node in the NodeList; -1 if not found.
+	 * @private
 	 */
 	indexOf: function (item) {
 		return Array.prototype.indexOf.call(this, item);
 	},
 };
+NodeList.prototype[Symbol.iterator] = function () {
+	var me = this;
+	var index = 0;
+
+	return {
+		next: function () {
+			if (index < me.length) {
+				return {
+					value: me[index++],
+					done: false,
+				};
+			} else {
+				return {
+					done: true,
+				};
+			}
+		},
+		return: function () {
+			return {
+				done: true,
+			};
+		},
+	};
+};
 
+/**
+ * Represents a live collection of nodes that is automatically updated when its associated
+ * document changes.
+ *
+ * @class LiveNodeList
+ * @param {Node} node
+ * The associated node.
+ * @param {function} refresh
+ * The function to refresh the live node list.
+ * @augments NodeList
+ * @constructs LiveNodeList
+ */
 function LiveNodeList(node, refresh) {
 	this._node = node;
 	this._refresh = refresh;
 	_updateLiveList(this);
 }
+/**
+ * Updates the live node list.
+ *
+ * @param {LiveNodeList} list
+ * The live node list to update.
+ * @private
+ */
 function _updateLiveList(list) {
 	var inc = list._node._inc || list._node.ownerDocument._inc;
-	if (list._inc != inc) {
+	if (list._inc !== inc) {
 		var ls = list._refresh(list._node);
-		//console.log(ls.length)
 		__set__(list, 'length', ls.length);
+		if (!list.$$length || ls.length < list.$$length) {
+			for (var i = ls.length; i in list; i++) {
+				if (hasOwn(list, i)) {
+					delete list[i];
+				}
+			}
+		}
 		copy(ls, list);
 		list._inc = inc;
 	}
 }
+/**
+ * Returns the node at position `index` in the LiveNodeList, or null if that is not a valid
+ * index.
+ *
+ * @param {number} i
+ * Index into the collection.
+ * @returns {Node | null}
+ * The node at position `index` in the LiveNodeList, or null if that is not a valid index.
+ */
 LiveNodeList.prototype.item = function (i) {
 	_updateLiveList(this);
-	return this[i];
+	return this[i] || null;
 };
 
 _extends(LiveNodeList, NodeList);
 
 /**
- * Objects implementing the NamedNodeMap interface are used
- * to represent collections of nodes that can be accessed by name.
+ * Objects implementing the NamedNodeMap interface are used to represent collections of nodes
+ * that can be accessed by name.
  * Note that NamedNodeMap does not inherit from NodeList;
  * NamedNodeMaps are not maintained in any particular order.
- * Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index,
+ * Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal
+ * index,
  * but this is simply to allow convenient enumeration of the contents of a NamedNodeMap,
  * and does not imply that the DOM specifies an order to these Nodes.
  * NamedNodeMap objects in the DOM are live.
@@ -332,11 +479,23 @@ _extends(LiveNodeList, NodeList);
  * This implementation only supports property indices, but does not support named properties,
  * as specified in the living standard.
  *
+ * @class NamedNodeMap
  * @see https://dom.spec.whatwg.org/#interface-namednodemap
  * @see https://webidl.spec.whatwg.org/#dfn-supported-property-names
+ * @constructs NamedNodeMap
  */
 function NamedNodeMap() {}
-
+/**
+ * Returns the index of a node within the list.
+ *
+ * @param {Array} list
+ * The list of nodes.
+ * @param {Node} node
+ * The node to find.
+ * @returns {number}
+ * The index of the node within the list, or -1 if not found.
+ * @private
+ */
 function _findNodeIndex(list, node) {
 	var i = 0;
 	while (i < list.length) {
@@ -346,7 +505,20 @@ function _findNodeIndex(list, node) {
 		i++;
 	}
 }
-
+/**
+ * Adds a new attribute to the list and updates the owner element of the attribute.
+ *
+ * @param {Element} el
+ * The element which will become the owner of the new attribute.
+ * @param {NamedNodeMap} list
+ * The list to which the new attribute will be added.
+ * @param {Attr} newAttr
+ * The new attribute to be added.
+ * @param {Attr} oldAttr
+ * The old attribute to be replaced, or null if no attribute is to be replaced.
+ * @returns {void}
+ * @private
+ */
 function _addNamedNode(el, list, newAttr, oldAttr) {
 	if (oldAttr) {
 		list[_findNodeIndex(list, oldAttr)] = newAttr;
@@ -363,6 +535,18 @@ function _addNamedNode(el, list, newAttr, oldAttr) {
 		}
 	}
 }
+/**
+ * Removes an attribute from the list and updates the owner element of the attribute.
+ *
+ * @param {Element} el
+ * The element which is the current owner of the attribute.
+ * @param {NamedNodeMap} list
+ * The list from which the attribute will be removed.
+ * @param {Attr} attr
+ * The attribute to be removed.
+ * @returns {void}
+ * @private
+ */
 function _removeNamedNode(el, list, attr) {
 	//console.log('remove attr:'+attr)
 	var i = _findNodeIndex(list, attr);
@@ -386,11 +570,13 @@ NamedNodeMap.prototype = {
 	item: NodeList.prototype.item,
 
 	/**
-	 * get an attribute by name (lower case in case of HTML namespace and document)
-	 *
-	 * @param  {string} localName
-	 * @return {Attr | null}
+	 * Get an attribute by name. Note: Name is in lower case in case of HTML namespace and
+	 * document.
 	 *
+	 * @param {string} localName
+	 * The local name of the attribute.
+	 * @returns {Attr | null}
+	 * The attribute with the given local name, or null if no such attribute exists.
 	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name
 	 */
 	getNamedItem: function (localName) {
@@ -409,16 +595,23 @@ NamedNodeMap.prototype = {
 	},
 
 	/**
-	 * set an attribute
+	 * Set an attribute.
 	 *
 	 * @param {Attr} attr
-	 * @return {Attr | null}
+	 * The attribute to set.
+	 * @returns {Attr | null}
+	 * The old attribute with the same local name and namespace URI as the new one, or null if no
+	 * such attribute exists.
+	 * @throws {DOMException}
+	 * With code:
+	 * - {@link INUSE_ATTRIBUTE_ERR} - If the attribute is already an attribute of another
+	 * element.
 	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-set
 	 */
 	setNamedItem: function (attr) {
 		var el = attr.ownerElement;
 		if (el && el !== this._ownerElement) {
-			throw new DOMException(INUSE_ATTRIBUTE_ERR);
+			throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR);
 		}
 		var oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
 		if (oldAttr === attr) {
@@ -429,11 +622,17 @@ NamedNodeMap.prototype = {
 	},
 
 	/**
-	 * set an attribute
+	 * Set an attribute, replacing an existing attribute with the same local name and namespace
+	 * URI if one exists.
 	 *
 	 * @param {Attr} attr
-	 * @return {Attr | null}
-	 *
+	 * The attribute to set.
+	 * @returns {Attr | null}
+	 * The old attribute with the same local name and namespace URI as the new one, or null if no
+	 * such attribute exists.
+	 * @throws {DOMException}
+	 * Throws a DOMException with the name "InUseAttributeError" if the attribute is already an
+	 * attribute of another element.
 	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-set
 	 */
 	setNamedItemNS: function (attr) {
@@ -441,49 +640,62 @@ NamedNodeMap.prototype = {
 	},
 
 	/**
-	 * remove an attribute by name (lower case in case of HTML namespace and document)
+	 * Removes an attribute specified by the local name.
 	 *
 	 * @param {string} localName
-	 * @return {Attr | null}
-	 *
+	 * The local name of the attribute to be removed.
+	 * @returns {Attr}
+	 * The attribute node that was removed.
+	 * @throws {DOMException}
+	 * With code:
+	 * - {@link DOMException.NOT_FOUND_ERR} if no attribute with the given name is found.
 	 * @see https://dom.spec.whatwg.org/#dom-namednodemap-removenameditem
 	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-name
 	 */
 	removeNamedItem: function (localName) {
 		var attr = this.getNamedItem(localName);
 		if (!attr) {
-			throw new DOMException(NOT_FOUND_ERR, localName);
+			throw new DOMException(DOMException.NOT_FOUND_ERR, localName);
 		}
 		_removeNamedNode(this._ownerElement, this, attr);
 		return attr;
 	},
 
 	/**
-	 * remove an attribute by namespace and local name
+	 * Removes an attribute specified by the namespace and local name.
 	 *
 	 * @param {string | null} namespaceURI
+	 * The namespace URI of the attribute to be removed.
 	 * @param {string} localName
-	 * @return {Attr | null}
-	 *
+	 * The local name of the attribute to be removed.
+	 * @returns {Attr}
+	 * The attribute node that was removed.
+	 * @throws {DOMException}
+	 * With code:
+	 * - {@link DOMException.NOT_FOUND_ERR} if no attribute with the given namespace URI and local
+	 * name is found.
 	 * @see https://dom.spec.whatwg.org/#dom-namednodemap-removenameditemns
 	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-namespace
 	 */
 	removeNamedItemNS: function (namespaceURI, localName) {
 		var attr = this.getNamedItemNS(namespaceURI, localName);
 		if (!attr) {
-			throw new DOMException(NOT_FOUND_ERR, namespaceURI ? namespaceURI + ' : ' + localName : localName);
+			throw new DOMException(DOMException.NOT_FOUND_ERR, namespaceURI ? namespaceURI + ' : ' + localName : localName);
 		}
 		_removeNamedNode(this._ownerElement, this, attr);
 		return attr;
 	},
 
 	/**
-	 * get an attribute by namespace and local name
+	 * Get an attribute by namespace and local name.
 	 *
 	 * @param {string | null} namespaceURI
+	 * The namespace URI of the attribute.
 	 * @param {string} localName
-	 * @return {Attr | null}
-	 *
+	 * The local name of the attribute.
+	 * @returns {Attr | null}
+	 * The attribute with the given namespace URI and local name, or null if no such attribute
+	 * exists.
 	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-namespace
 	 */
 	getNamedItemNS: function (namespaceURI, localName) {
@@ -501,66 +713,138 @@ NamedNodeMap.prototype = {
 		return null;
 	},
 };
+NamedNodeMap.prototype[Symbol.iterator] = function () {
+	var me = this;
+	var index = 0;
+
+	return {
+		next: function () {
+			if (index < me.length) {
+				return {
+					value: me[index++],
+					done: false,
+				};
+			} else {
+				return {
+					done: true,
+				};
+			}
+		},
+		return: function () {
+			return {
+				done: true,
+			};
+		},
+	};
+};
 
 /**
- * The DOMImplementation interface represents an object providing methods
- * which are not dependent on any particular document.
- * Such an object is returned by the `Document.implementation` property.
+ * The DOMImplementation interface provides a number of methods for performing operations that
+ * are independent of any particular instance of the document object model.
  *
- * __The individual methods describe the differences compared to the specs.__
+ * The DOMImplementation interface represents an object providing methods which are not
+ * dependent on any particular document.
+ * Such an object is returned by the `Document.implementation` property.
  *
- * @constructor
+ * **The individual methods describe the differences compared to the specs**.
  *
+ * @class DOMImplementation
  * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation MDN
- * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490 DOM Level 1 Core (Initial)
+ * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490 DOM Level 1 Core
+ *      (Initial)
  * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-102161490 DOM Level 2 Core
  * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-102161490 DOM Level 3 Core
  * @see https://dom.spec.whatwg.org/#domimplementation DOM Living Standard
+ * @constructs DOMImplementation
  */
 function DOMImplementation() {}
 
 DOMImplementation.prototype = {
 	/**
-	 * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.
-	 * The different implementations fairly diverged in what kind of features were reported.
-	 * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.
+	 * Test if the DOM implementation implements a specific feature and version, as specified in
+	 * {@link https://www.w3.org/TR/DOM-Level-3-Core/core.html#DOMFeatures DOM Features}.
 	 *
-	 * @deprecated It is deprecated and modern browsers return true in all cases.
+	 * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given
+	 * feature is supported. The different implementations fairly diverged in what kind of
+	 * features were reported. The latest version of the spec settled to force this method to
+	 * always return true, where the functionality was accurate and in use.
 	 *
+	 * @deprecated
+	 * It is deprecated and modern browsers return true in all cases.
+	 * @function DOMImplementation#hasFeature
 	 * @param {string} feature
+	 * The name of the feature to test.
 	 * @param {string} [version]
-	 * @returns {boolean} always true
-	 *
+	 * This is the version number of the feature to test.
+	 * @returns {boolean}
+	 * Always returns true.
 	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN
 	 * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core
 	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard
+	 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-5CED94D7 DOM Level 3 Core
 	 */
 	hasFeature: function (feature, version) {
 		return true;
 	},
 	/**
-	 * Creates an XML Document object of the specified type with its document element.
+	 * Creates a DOM Document object of the specified type with its document element. Note that
+	 * based on the {@link DocumentType}
+	 * given to create the document, the implementation may instantiate specialized
+	 * {@link Document} objects that support additional features than the "Core", such as "HTML"
+	 * {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#DOM2HTML DOM Level 2 HTML}.
+	 * On the other hand, setting the {@link DocumentType} after the document was created makes
+	 * this very unlikely to happen. Alternatively, specialized {@link Document} creation methods,
+	 * such as createHTMLDocument
+	 * {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#DOM2HTML DOM Level 2 HTML},
+	 * can be used to obtain specific types of {@link Document} objects.
 	 *
 	 * __It behaves slightly different from the description in the living standard__:
-	 * - There is no interface/class `XMLDocument`, it returns a `Document` instance (with it's `type` set to `'xml'`).
+	 * - There is no interface/class `XMLDocument`, it returns a `Document`
+	 * instance (with it's `type` set to `'xml'`).
 	 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
-	 * - The methods provided by this implementation are not validating names or qualified names.
-	 *   (They are only validated by the SAX parser when calling `DOMParser.parseFromString`)
 	 *
+	 * @function DOMImplementation.createDocument
 	 * @param {string | null} namespaceURI
-	 * @param {string} qualifiedName
+	 * The
+	 * {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-namespaceURI namespace URI}
+	 * of the document element to create or null.
+	 * @param {string | null} qualifiedName
+	 * The
+	 * {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-qualifiedname qualified name}
+	 * of the document element to be created or null.
 	 * @param {DocumentType | null} [doctype=null]
-	 * @returns {Document} the XML document
-	 *
-	 * @see #createHTMLDocument
+	 * The type of document to be created or null. When doctype is not null, its
+	 * {@link Node#ownerDocument} attribute is set to the document being created. Default is
+	 * `null`
+	 * @returns {Document}
+	 * A new {@link Document} object with its document element. If the NamespaceURI,
+	 * qualifiedName, and doctype are null, the returned {@link Document} is empty with no
+	 * document element.
+	 * @throws {DOMException}
+	 * With code:
 	 *
+	 * - `INVALID_CHARACTER_ERR`: Raised if the specified qualified name is not an XML name
+	 * according to {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#XML XML 1.0}.
+	 * - `NAMESPACE_ERR`: Raised if the qualifiedName is malformed, if the qualifiedName has a
+	 * prefix and the namespaceURI is null, or if the qualifiedName is null and the namespaceURI
+	 * is different from null, or if the qualifiedName has a prefix that is "xml" and the
+	 * namespaceURI is different from "{@link http://www.w3.org/XML/1998/namespace}"
+	 * {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#Namespaces XML Namespaces},
+	 * or if the DOM implementation does not support the "XML" feature but a non-null namespace
+	 * URI was provided, since namespaces were defined by XML.
+	 * - `WRONG_DOCUMENT_ERR`: Raised if doctype has already been used with a different document
+	 * or was created from a different implementation.
+	 * - `NOT_SUPPORTED_ERR`: May be raised if the implementation does not support the feature
+	 * "XML" and the language exposed through the Document does not support XML Namespaces (such
+	 * as {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#HTML40 HTML 4.01}).
+	 * @since DOM Level 2.
+	 * @see {@link #createHTMLDocument}
 	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN
-	 * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)
-	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument  DOM Level 2 Core
-	 *
-	 * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
-	 * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
-	 * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument DOM Living Standard
+	 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Level-2-Core-DOM-createDocument DOM
+	 *      Level 3 Core
+	 * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM
+	 *      Level 2 Core (initial)
 	 */
 	createDocument: function (namespaceURI, qualifiedName, doctype) {
 		var contentType = MIME_TYPE.XML_APPLICATION;
@@ -569,7 +853,7 @@ DOMImplementation.prototype = {
 		} else if (namespaceURI === NAMESPACE.SVG) {
 			contentType = MIME_TYPE.XML_SVG_IMAGE;
 		}
-		var doc = new Document({ contentType: contentType });
+		var doc = new Document(PDC, { contentType: contentType });
 		doc.implementation = this;
 		doc.childNodes = new NodeList();
 		doc.doctype = doctype || null;
@@ -583,28 +867,58 @@ DOMImplementation.prototype = {
 		return doc;
 	},
 	/**
-	 * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
+	 * Creates an empty DocumentType node. Entity declarations and notations are not made
+	 * available. Entity reference expansions and default attribute additions do not occur.
 	 *
-	 * __This behavior is slightly different from the in the specs__:
+	 * **This behavior is slightly different from the in the specs**:
 	 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+	 * - `publicId` and `systemId` contain the raw data including any possible quotes,
+	 *   so they can always be serialized back to the original value
+	 * - `internalSubset` contains the raw string between `[` and `]` if present,
+	 *   but is not parsed or validated in any form.
 	 *
+	 * @function DOMImplementation#createDocumentType
 	 * @param {string} qualifiedName
+	 * The {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-qualifiedname qualified
+	 * name} of the document type to be created.
 	 * @param {string} [publicId]
+	 * The external subset public identifier.
 	 * @param {string} [systemId]
-	 * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation
-	 * 				  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`
+	 * The external subset system identifier.
+	 * @param {string} [internalSubset]
+	 * the internal subset or an empty string if it is not present
+	 * @returns {DocumentType}
+	 * A new {@link DocumentType} node with {@link Node#ownerDocument} set to null.
+	 * @throws {DOMException}
+	 * With code:
 	 *
-	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN
-	 * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core
-	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard
+	 * - `INVALID_CHARACTER_ERR`: Raised if the specified qualified name is not an XML name
+	 * according to {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#XML XML 1.0}.
+	 * - `NAMESPACE_ERR`: Raised if the qualifiedName is malformed.
+	 * - `NOT_SUPPORTED_ERR`: May be raised if the implementation does not support the feature
+	 * "XML" and the language exposed through the Document does not support XML Namespaces (such
+	 * as {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#HTML40 HTML 4.01}).
+	 * @since DOM Level 2.
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType
+	 *      MDN
+	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living
+	 *      Standard
+	 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Level-3-Core-DOM-createDocType DOM
+	 *      Level 3 Core
+	 * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM
+	 *      Level 2 Core
+	 * @see https://github.com/xmldom/xmldom/blob/master/CHANGELOG.md#050
+	 * @see https://www.w3.org/TR/DOM-Level-2-Core/#core-ID-Core-DocType-internalSubset
+	 * @prettierignore
 	 */
-	createDocumentType: function (qualifiedName, publicId, systemId) {
+	createDocumentType: function (qualifiedName, publicId, systemId, internalSubset) {
 		validateQualifiedName(qualifiedName);
-		var node = new DocumentType();
+		var node = new DocumentType(PDC);
 		node.name = qualifiedName;
 		node.nodeName = qualifiedName;
 		node.publicId = publicId || '';
 		node.systemId = systemId || '';
+		node.internalSubset = internalSubset || '';
 
 		return node;
 	},
@@ -612,17 +926,21 @@ DOMImplementation.prototype = {
 	 * Returns an HTML document, that might already have a basic DOM structure.
 	 *
 	 * __It behaves slightly different from the description in the living standard__:
-	 * - If the first argument is `false` no initial nodes are added (steps 3-7 in the specs are omitted)
+	 * - If the first argument is `false` no initial nodes are added (steps 3-7 in the specs are
+	 * omitted)
 	 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
 	 *
 	 * @param {string | false} [title]
-	 * @returns {Document} The HTML document
-	 *
+	 * A string containing the title to give the new HTML document.
+	 * @returns {Document}
+	 * The HTML document.
+	 * @since WHATWG Living Standard.
+	 * @see {@link #createDocument}
 	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
 	 * @see https://dom.spec.whatwg.org/#html-document
 	 */
 	createHTMLDocument: function (title) {
-		var doc = new Document({ contentType: MIME_TYPE.HTML });
+		var doc = new Document(PDC, { contentType: MIME_TYPE.HTML });
 		doc.implementation = this;
 		doc.childNodes = new NodeList();
 		if (title !== false) {
@@ -645,48 +963,225 @@ DOMImplementation.prototype = {
 };
 
 /**
+ * The DOM Node interface is an abstract base class upon which many other DOM API objects are
+ * based, thus letting those object types to be used similarly and often interchangeably. As an
+ * abstract class, there is no such thing as a plain Node object. All objects that implement
+ * Node functionality are based on one of its subclasses. Most notable are Document, Element,
+ * and DocumentFragment.
+ *
+ * In addition, every kind of DOM node is represented by an interface based on Node. These
+ * include Attr, CharacterData (which Text, Comment, CDATASection and ProcessingInstruction are
+ * all based on), and DocumentType.
+ *
+ * In some cases, a particular feature of the base Node interface may not apply to one of its
+ * child interfaces; in that case, the inheriting node may return null or throw an exception,
+ * depending on circumstances. For example, attempting to add children to a node type that
+ * cannot have children will throw an exception.
+ *
+ * **This behavior is slightly different from the in the specs**:
+ * - undeclared properties: nodeType, baseURI, isConnected, parentElement, textContent
+ * - missing methods: nodeType, baseURI, isConnected, parentElement, textContent
+ *
+ * @class
+ * @abstract
+ * @param {Symbol} symbol
  * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
+ * @see https://dom.spec.whatwg.org/#node
+ * @prettierignore
  */
-function Node() {}
+function Node(symbol) {
+	checkSymbol(symbol);
+}
 
 Node.prototype = {
+	/**
+	 * The first child of this node.
+	 *
+	 * @type {Node | null}
+	 */
 	firstChild: null,
+	/**
+	 * The last child of this node.
+	 *
+	 * @type {Node | null}
+	 */
 	lastChild: null,
+	/**
+	 * The previous sibling of this node.
+	 *
+	 * @type {Node | null}
+	 */
 	previousSibling: null,
+	/**
+	 * The next sibling of this node.
+	 *
+	 * @type {Node | null}
+	 */
 	nextSibling: null,
+	/**
+	 * The attributes of this node.
+	 *
+	 * @type {NamedNodeMap | null}
+	 */
 	attributes: null,
+	/**
+	 * The parent node of this node.
+	 *
+	 * @type {Node | null}
+	 */
 	parentNode: null,
+	/**
+	 * The child nodes of this node.
+	 *
+	 * @type {NodeList | null}
+	 */
 	childNodes: null,
+	/**
+	 * The document object associated with this node.
+	 *
+	 * @type {Document | null}
+	 */
 	ownerDocument: null,
+	/**
+	 * The value of this node.
+	 *
+	 * @type {string | null}
+	 */
 	nodeValue: null,
+	/**
+	 * The namespace URI of this node.
+	 *
+	 * @type {string | null}
+	 */
 	namespaceURI: null,
+	/**
+	 * The prefix of the namespace for this node.
+	 *
+	 * @type {string | null}
+	 */
 	prefix: null,
+	/**
+	 * The local part of the qualified name of this node.
+	 *
+	 * @type {string | null}
+	 */
 	localName: null,
-	// Modified in DOM Level 2:
+	/**
+	 * Inserts a node before a reference node as a child of this node.
+	 *
+	 * @param {Node} newChild
+	 * The new child node to be inserted.
+	 * @param {Node | null} refChild
+	 * The reference node before which newChild will be inserted.
+	 * @returns {Node}
+	 * The new child node successfully inserted.
+	 * @throws {DOMException}
+	 * Throws a DOMException if inserting the node would result in a DOM tree that is not
+	 * well-formed, or if `child` is provided but is not a child of `parent`.
+	 * See {@link _insertBefore} for more details.
+	 * @since Modified in DOM L2
+	 */
 	insertBefore: function (newChild, refChild) {
-		//raises
 		return _insertBefore(this, newChild, refChild);
 	},
+	/**
+	 * Replaces an old child node with a new child node within this node.
+	 *
+	 * @param {Node} newChild
+	 * The new node that is to replace the old node.
+	 * If it already exists in the DOM, it is removed from its original position.
+	 * @param {Node} oldChild
+	 * The existing child node to be replaced.
+	 * @returns {Node}
+	 * Returns the replaced child node.
+	 * @throws {DOMException}
+	 * Throws a DOMException if replacing the node would result in a DOM tree that is not
+	 * well-formed, or if `oldChild` is not a child of `this`.
+	 * This can also occur if the pre-replacement validity assertion fails.
+	 * See {@link _insertBefore}, {@link Node.removeChild}, and
+	 * {@link assertPreReplacementValidityInDocument} for more details.
+	 * @see https://dom.spec.whatwg.org/#concept-node-replace
+	 */
 	replaceChild: function (newChild, oldChild) {
-		//raises
 		_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
 		if (oldChild) {
 			this.removeChild(oldChild);
 		}
 	},
+	/**
+	 * Removes an existing child node from this node.
+	 *
+	 * @param {Node} oldChild
+	 * The child node to be removed.
+	 * @returns {Node}
+	 * Returns the removed child node.
+	 * @throws {DOMException}
+	 * Throws a DOMException if `oldChild` is not a child of `this`.
+	 * See {@link _removeChild} for more details.
+	 */
 	removeChild: function (oldChild) {
 		return _removeChild(this, oldChild);
 	},
+	/**
+	 * Appends a child node to this node.
+	 *
+	 * @param {Node} newChild
+	 * The child node to be appended to this node.
+	 * If it already exists in the DOM, it is removed from its original position.
+	 * @returns {Node}
+	 * Returns the appended child node.
+	 * @throws {DOMException}
+	 * Throws a DOMException if appending the node would result in a DOM tree that is not
+	 * well-formed, or if `newChild` is not a valid Node.
+	 * See {@link insertBefore} for more details.
+	 */
 	appendChild: function (newChild) {
 		return this.insertBefore(newChild, null);
 	},
+	/**
+	 * Determines whether this node has any child nodes.
+	 *
+	 * @returns {boolean}
+	 * Returns true if this node has any child nodes, and false otherwise.
+	 */
 	hasChildNodes: function () {
 		return this.firstChild != null;
 	},
+	/**
+	 * Creates a copy of the calling node.
+	 *
+	 * @param {boolean} deep
+	 * If true, the contents of the node are recursively copied.
+	 * If false, only the node itself (and its attributes, if it is an element) are copied.
+	 * @returns {Node}
+	 * Returns the newly created copy of the node.
+	 * @throws {DOMException}
+	 * May throw a DOMException if operations within {@link Element#setAttributeNode} or
+	 * {@link Node#appendChild} (which are potentially invoked in this method) do not meet their
+	 * specific constraints.
+	 * @see {@link cloneNode}
+	 */
 	cloneNode: function (deep) {
 		return cloneNode(this.ownerDocument || this, this, deep);
 	},
-	// Modified in DOM Level 2:
+	/**
+	 * Puts the specified node and all of its subtree into a "normalized" form. In a normalized
+	 * subtree, no text nodes in the subtree are empty and there are no adjacent text nodes.
+	 *
+	 * Specifically, this method merges any adjacent text nodes (i.e., nodes for which `nodeType`
+	 * is `TEXT_NODE`) into a single node with the combined data. It also removes any empty text
+	 * nodes.
+	 *
+	 * This method operates recursively, so it also normalizes any and all descendent nodes within
+	 * the subtree.
+	 *
+	 * @throws {DOMException}
+	 * May throw a DOMException if operations within removeChild or appendData (which are
+	 * potentially invoked in this method) do not meet their specific constraints.
+	 * @since Modified in DOM Level 2
+	 * @see {@link Node.removeChild}
+	 * @see {@link CharacterData.appendData}
+	 */
 	normalize: function () {
 		var child = this.firstChild;
 		while (child) {
@@ -700,11 +1195,31 @@ Node.prototype = {
 			}
 		}
 	},
-	// Introduced in DOM Level 2:
+	/**
+	 * Checks whether the DOM implementation implements a specific feature and its version.
+	 *
+	 * @deprecated
+	 * Since `DOMImplementation.hasFeature` is deprecated and always returns true.
+	 * @param {string} feature
+	 * The package name of the feature to test. This is the same name that can be passed to the
+	 * method `hasFeature` on `DOMImplementation`.
+	 * @param {string} version
+	 * This is the version number of the package name to test.
+	 * @returns {boolean}
+	 * Returns true in all cases in the current implementation.
+	 * @since Introduced in DOM Level 2
+	 * @see {@link DOMImplementation.hasFeature}
+	 */
 	isSupported: function (feature, version) {
 		return this.ownerDocument.implementation.hasFeature(feature, version);
 	},
-	// Introduced in DOM Level 2:
+	/**
+	 * Determines if the node has any attributes.
+	 *
+	 * @returns {boolean}
+	 * Returns true if the node has any attributes, and false otherwise.
+	 * @since Introduced in DOM Level 2
+	 */
 	hasAttributes: function () {
 		return this.attributes.length > 0;
 	},
@@ -713,14 +1228,19 @@ Node.prototype = {
 	 * **The default namespace declarations are ignored by this method.**
 	 * See Namespace Prefix Lookup for details on the algorithm used by this method.
 	 *
-	 * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._
+	 * **This behavior is different from the in the specs**:
+	 * - no node type specific handling
+	 * - uses the internal attribute _nsMap for resolving namespaces that is updated when changing attributes
 	 *
 	 * @param {string | null} namespaceURI
+	 * The namespace URI for which to find the associated prefix.
 	 * @returns {string | null}
+	 * The associated prefix, if found; otherwise, null.
 	 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix
 	 * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo
 	 * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix
 	 * @see https://github.com/xmldom/xmldom/issues/322
+	 * @prettierignore
 	 */
 	lookupPrefix: function (namespaceURI) {
 		var el = this;
@@ -729,7 +1249,7 @@ Node.prototype = {
 			//console.dir(map)
 			if (map) {
 				for (var n in map) {
-					if (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) {
+					if (hasOwn(map, n) && map[n] === namespaceURI) {
 						return n;
 					}
 				}
@@ -738,14 +1258,30 @@ Node.prototype = {
 		}
 		return null;
 	},
-	// Introduced in DOM Level 3:
+	/**
+	 * This function is used to look up the namespace URI associated with the given prefix,
+	 * starting from this node.
+	 *
+	 * **This behavior is different from the in the specs**:
+	 * - no node type specific handling
+	 * - uses the internal attribute _nsMap for resolving namespaces that is updated when changing attributes
+	 *
+	 * @param {string | null} prefix
+	 * The prefix for which to find the associated namespace URI.
+	 * @returns {string | null}
+	 * The associated namespace URI, if found; otherwise, null.
+	 * @since DOM Level 3
+	 * @see https://dom.spec.whatwg.org/#dom-node-lookupnamespaceuri
+	 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespaceURI
+	 * @prettierignore
+	 */
 	lookupNamespaceURI: function (prefix) {
 		var el = this;
 		while (el) {
 			var map = el._nsMap;
 			//console.dir(map)
 			if (map) {
-				if (Object.prototype.hasOwnProperty.call(map, prefix)) {
+				if (hasOwn(map, prefix)) {
 					return map[prefix];
 				}
 			}
@@ -753,21 +1289,43 @@ Node.prototype = {
 		}
 		return null;
 	},
-	// Introduced in DOM Level 3:
+	/**
+	 * Determines whether the given namespace URI is the default namespace.
+	 *
+	 * The function works by looking up the prefix associated with the given namespace URI. If no
+	 * prefix is found (i.e., the namespace URI is not registered in the namespace map of this
+	 * node or any of its ancestors), it returns `true`, implying the namespace URI is considered
+	 * the default.
+	 *
+	 * **This behavior is different from the in the specs**:
+	 * - no node type specific handling
+	 * - uses the internal attribute _nsMap for resolving namespaces that is updated when changing attributes
+	 *
+	 * @param {string | null} namespaceURI
+	 * The namespace URI to be checked.
+	 * @returns {boolean}
+	 * Returns true if the given namespace URI is the default namespace, false otherwise.
+	 * @since DOM Level 3
+	 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-isDefaultNamespace
+	 * @see https://dom.spec.whatwg.org/#dom-node-isdefaultnamespace
+	 * @prettierignore
+	 */
 	isDefaultNamespace: function (namespaceURI) {
 		var prefix = this.lookupPrefix(namespaceURI);
 		return prefix == null;
 	},
-	// Introduced in DOM Level 3:
 	/**
-	 * Compares the reference node with a node with regard to their position
-	 * in the document and according to the document order.
-	 *
-	 * @param {Node} other The node to compare the reference node to.
-	 * @return {number} Returns how the node is positioned relatively to the
-	 *    reference node according to the bitmask. 0 if reference node and
-	 *    given node are the same.
-	 * @see https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#Node3-compareDocumentPosition
+	 * Compares the reference node with a node with regard to their position in the document and
+	 * according to the document order.
+	 *
+	 * @param {Node} other
+	 * The node to compare the reference node to.
+	 * @returns {number}
+	 * Returns how the node is positioned relatively to the reference node according to the
+	 * bitmask. 0 if reference node and given node are the same.
+	 * @since DOM Level 3
+	 * @see https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#Node3-compare
+	 * @see https://dom.spec.whatwg.org/#dom-node-comparedocumentposition
 	 */
 	compareDocumentPosition: function (other) {
 		if (this === other) return 0;
@@ -784,38 +1342,51 @@ Node.prototype = {
 			node2 = attr2.ownerElement;
 			if (attr1 && node1 && node2 === node1) {
 				for (var i = 0, attr; (attr = node2.attributes[i]); i++) {
-					if (attr === attr1) return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DOCUMENT_POSITION_PRECEDING;
-					if (attr === attr2) return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DOCUMENT_POSITION_FOLLOWING;
+					if (attr === attr1)
+						return DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DocumentPosition.DOCUMENT_POSITION_PRECEDING;
+					if (attr === attr2)
+						return DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
 				}
 			}
 		}
 		if (!node1 || !node2 || node2.ownerDocument !== node1.ownerDocument) {
 			return (
-				DOCUMENT_POSITION_DISCONNECTED +
-				DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC +
-				(docGUID(node2.ownerDocument) > docGUID(node1.ownerDocument) ? DOCUMENT_POSITION_FOLLOWING : DOCUMENT_POSITION_PRECEDING)
+				DocumentPosition.DOCUMENT_POSITION_DISCONNECTED +
+				DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC +
+				(docGUID(node2.ownerDocument) > docGUID(node1.ownerDocument)
+					? DocumentPosition.DOCUMENT_POSITION_FOLLOWING
+					: DocumentPosition.DOCUMENT_POSITION_PRECEDING)
 			);
 		}
 		var chain1 = parentChain(node1);
 		var chain2 = parentChain(node2);
 		if ((!attr1 && chain2.indexOf(node1) >= 0) || (attr2 && node1 === node2)) {
-			return DOCUMENT_POSITION_CONTAINS + DOCUMENT_POSITION_PRECEDING;
+			return DocumentPosition.DOCUMENT_POSITION_CONTAINS + DocumentPosition.DOCUMENT_POSITION_PRECEDING;
 		}
 		if ((!attr2 && chain1.indexOf(node2) >= 0) || (attr1 && node1 === node2)) {
-			return DOCUMENT_POSITION_CONTAINED_BY + DOCUMENT_POSITION_FOLLOWING;
+			return DocumentPosition.DOCUMENT_POSITION_CONTAINED_BY + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
 		}
 		var ca = commonAncestor(chain2, chain1);
 		for (var n in ca.childNodes) {
 			var child = ca.childNodes[n];
-			if (child === node2) return DOCUMENT_POSITION_FOLLOWING;
-			if (child === node1) return DOCUMENT_POSITION_PRECEDING;
-			if (chain2.indexOf(child) >= 0) return DOCUMENT_POSITION_FOLLOWING;
-			if (chain1.indexOf(child) >= 0) return DOCUMENT_POSITION_PRECEDING;
+			if (child === node2) return DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
+			if (child === node1) return DocumentPosition.DOCUMENT_POSITION_PRECEDING;
+			if (chain2.indexOf(child) >= 0) return DocumentPosition.DOCUMENT_POSITION_FOLLOWING;
+			if (chain1.indexOf(child) >= 0) return DocumentPosition.DOCUMENT_POSITION_PRECEDING;
 		}
 		return 0;
 	},
 };
 
+/**
+ * Encodes special XML characters to their corresponding entities.
+ *
+ * @param {string} c
+ * The character to be encoded.
+ * @returns {string}
+ * The encoded character.
+ * @private
+ */
 function _xmlEncoder(c) {
 	return (
 		(c == '<' && '&lt;') || (c == '>' && '&gt;') || (c == '&' && '&amp;') || (c == '"' && '&quot;') || '&#' + c.charCodeAt() + ';'
@@ -828,8 +1399,10 @@ copy(DocumentPosition, Node);
 copy(DocumentPosition, Node.prototype);
 
 /**
- * @param callback return true for continue,false for break
- * @return boolean true: break visit;
+ * @param callback
+ * Return true for continue,false for break.
+ * @returns
+ * boolean true: break visit;
  */
 function _visitNode(node, callback) {
 	if (callback(node)) {
@@ -854,41 +1427,52 @@ function _visitNode(node, callback) {
  * It should usually be created using `new DOMImplementation().createDocument(...)`
  * or `new DOMImplementation().createHTMLDocument(...)`.
  *
- * The constructor is considered a private API and offers to initially set the `contentType` property
- * via it's options parameter.
+ * The constructor is considered a private API and offers to initially set the `contentType`
+ * property via it's options parameter.
  *
+ * @class
+ * @param {Symbol} symbol
  * @param {DocumentOptions} [options]
+ * @augments Node
  * @private
- * @constructor
- *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/Document
  * @see https://dom.spec.whatwg.org/#interface-document
  */
-function Document(options) {
+function Document(symbol, options) {
+	checkSymbol(symbol);
+
 	var opt = options || {};
 	this.ownerDocument = this;
 	/**
 	 * The mime type of the document is determined at creation time and can not be modified.
 	 *
 	 * @type {string}
-	 * @readonly
-	 *
 	 * @see https://dom.spec.whatwg.org/#concept-document-content-type
-	 * @see DOMImplementation
-	 * @see MIME_TYPE
+	 * @see {@link DOMImplementation}
+	 * @see {@link MIME_TYPE}
+	 * @readonly
 	 */
 	this.contentType = opt.contentType || MIME_TYPE.XML_APPLICATION;
 	/**
-	 *
 	 * @type {'html' | 'xml'}
-	 * @readonly
-	 *
 	 * @see https://dom.spec.whatwg.org/#concept-document-type
-	 * @see DOMImplementation
+	 * @see {@link DOMImplementation}
+	 * @readonly
 	 */
-	this.type = MIME_TYPE.isHTML(this.contentType) ? 'html' : 'xml';
+	this.type = isHTMLMimeType(this.contentType) ? 'html' : 'xml';
 }
 
+/**
+ * Updates the namespace mapping of an element when a new attribute is added.
+ *
+ * @param {Document} doc
+ * The document that the element belongs to.
+ * @param {Element} el
+ * The element to which the attribute is being added.
+ * @param {Attr} newAttr
+ * The new attribute being added.
+ * @private
+ */
 function _onAddAttribute(doc, el, newAttr) {
 	doc && doc._inc++;
 	var ns = newAttr.namespaceURI;
@@ -898,6 +1482,19 @@ function _onAddAttribute(doc, el, newAttr) {
 	}
 }
 
+/**
+ * Updates the namespace mapping of an element when an attribute is removed.
+ *
+ * @param {Document} doc
+ * The document that the element belongs to.
+ * @param {Element} el
+ * The element from which the attribute is being removed.
+ * @param {Attr} newAttr
+ * The attribute being removed.
+ * @param {boolean} remove
+ * Indicates whether the attribute is to be removed.
+ * @private
+ */
 function _onRemoveAttribute(doc, el, newAttr, remove) {
 	doc && doc._inc++;
 	var ns = newAttr.namespaceURI;
@@ -908,15 +1505,19 @@ function _onRemoveAttribute(doc, el, newAttr, remove) {
 }
 
 /**
- * Updates `el.childNodes`, updating the indexed items and it's `length`.
- * Passing `newChild` means it will be appended.
- * Otherwise it's assumed that an item has been removed,
- * and `el.firstNode` and it's `.nextSibling` are used
- * to walk the current list of child nodes.
+ * Updates `el.childNodes`, adjusting the indexed items and its `length`.
+ * If `newChild` is provided, it will be appended to the childNodes list.
+ * Otherwise, it's assumed that an item has been removed,
+ * and `el.firstNode` and its `.nextSibling` are used to iterate over the current list of child
+ * nodes, effectively reindexing them.
  *
  * @param {Document} doc
+ * The parent document of `el`.
  * @param {Node} el
+ * The parent node whose childNodes list needs to be updated.
  * @param {Node} [newChild]
+ * The new child node to be appended. If not provided, the function assumes a node has been
+ * removed.
  * @private
  */
 function _onUpdateChild(doc, el, newChild) {
@@ -943,17 +1544,22 @@ function _onUpdateChild(doc, el, newChild) {
  * Removes the connections between `parentNode` and `child`
  * and any existing `child.previousSibling` or `child.nextSibling`.
  *
- * @see https://github.com/xmldom/xmldom/issues/135
- * @see https://github.com/xmldom/xmldom/issues/145
- *
  * @param {Node} parentNode
+ * The parent node from which the child node is to be removed.
  * @param {Node} child
- * @returns {Node} the child that was removed.
+ * The child node to be removed from the parentNode.
+ * @returns {Node}
+ * Returns the child node that was removed.
+ * @throws {DOMException}
+ * With code:
+ * - {@link DOMException.NOT_FOUND_ERR} If the parentNode is not the parent of the child node.
  * @private
+ * @see https://github.com/xmldom/xmldom/issues/135
+ * @see https://github.com/xmldom/xmldom/issues/145
  */
 function _removeChild(parentNode, child) {
 	if (parentNode !== child.parentNode) {
-		throw new DOMException(NOT_FOUND_ERR, "child's parent is not parent");
+		throw new DOMException(DOMException.NOT_FOUND_ERR, "child's parent is not parent");
 	}
 	//var index = parentNode.childNodes.
 	var oldPreviousSibling = child.previousSibling;
@@ -977,6 +1583,7 @@ function _removeChild(parentNode, child) {
 
 /**
  * Returns `true` if `node` can be a parent for insertion.
+ *
  * @param {Node} node
  * @returns {boolean}
  */
@@ -989,6 +1596,7 @@ function hasValidParentNodeType(node) {
 
 /**
  * Returns `true` if `node` can be inserted according to it's `nodeType`.
+ *
  * @param {Node} node
  * @returns {boolean}
  */
@@ -996,7 +1604,7 @@ function hasInsertableNodeType(node) {
 	return (
 		node &&
 		(isElementNode(node) ||
-			isTextNode(node) ||
+			node instanceof CharacterData ||
 			isDocTypeNode(node) ||
 			node.nodeType === Node.DOCUMENT_FRAGMENT_NODE ||
 			node.nodeType === Node.COMMENT_NODE ||
@@ -1005,7 +1613,8 @@ function hasInsertableNodeType(node) {
 }
 
 /**
- * Returns true if `node` is a DOCTYPE node
+ * Returns true if `node` is a DOCTYPE node.
+ *
  * @param {Node} node
  * @returns {boolean}
  */
@@ -1014,7 +1623,8 @@ function isDocTypeNode(node) {
 }
 
 /**
- * Returns true if the node is an element
+ * Returns true if the node is an element.
+ *
  * @param {Node} node
  * @returns {boolean}
  */
@@ -1022,7 +1632,8 @@ function isElementNode(node) {
 	return node && node.nodeType === Node.ELEMENT_NODE;
 }
 /**
- * Returns true if `node` is a text node
+ * Returns true if `node` is a text node.
+ *
  * @param {Node} node
  * @returns {boolean}
  */
@@ -1034,11 +1645,13 @@ function isTextNode(node) {
  * Check if en element node can be inserted before `child`, or at the end if child is falsy,
  * according to the presence and position of a doctype node on the same level.
  *
- * @param {Document} doc The document node
- * @param {Node} child the node that would become the nextSibling if the element would be inserted
- * @returns {boolean} `true` if an element can be inserted before child
+ * @param {Document} doc
+ * The document node.
+ * @param {Node} child
+ * The node that would become the nextSibling if the element would be inserted.
+ * @returns {boolean}
+ * `true` if an element can be inserted before child.
  * @private
- * https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
  */
 function isElementInsertionPossible(doc, child) {
 	var parentChildNodes = doc.childNodes || [];
@@ -1053,11 +1666,13 @@ function isElementInsertionPossible(doc, child) {
  * Check if en element node can be inserted before `child`, or at the end if child is falsy,
  * according to the presence and position of a doctype node on the same level.
  *
- * @param {Node} doc The document node
- * @param {Node} child the node that would become the nextSibling if the element would be inserted
- * @returns {boolean} `true` if an element can be inserted before child
+ * @param {Node} doc
+ * The document node.
+ * @param {Node} child
+ * The node that would become the nextSibling if the element would be inserted.
+ * @returns {boolean}
+ * `true` if an element can be inserted before child.
  * @private
- * https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
  */
 function isElementReplacementPossible(doc, child) {
 	var parentChildNodes = doc.childNodes || [];
@@ -1074,28 +1689,41 @@ function isElementReplacementPossible(doc, child) {
 }
 
 /**
- * @private
- * Steps 1-5 of the checks before inserting and before replacing a child are the same.
+ * Asserts pre-insertion validity of a node into a parent before a child.
+ * Throws errors for invalid node combinations that would result in an ill-formed DOM.
  *
- * @param {Node} parent the parent node to insert `node` into
- * @param {Node} node the node to insert
- * @param {Node=} child the node that should become the `nextSibling` of `node`
- * @returns {Node}
- * @throws DOMException for several node combinations that would create a DOM that is not well-formed.
- * @throws DOMException if `child` is provided but is not a child of `parent`.
+ * @param {Node} parent
+ * The parent node to insert `node` into.
+ * @param {Node} node
+ * The node to insert.
+ * @param {Node | null} child
+ * The node that should become the `nextSibling` of `node`. If null, no sibling is considered.
+ * @throws {DOMException}
+ * With code:
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If `parent` is not a Document,
+ * DocumentFragment, or Element node.
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If `node` is a host-including inclusive
+ * ancestor of `parent`. (Currently not implemented)
+ * - {@link DOMException.NOT_FOUND_ERR} If `child` is non-null and its `parent` is not
+ * `parent`.
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If `node` is not a DocumentFragment,
+ * DocumentType, Element, or CharacterData node.
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If either `node` is a Text node and `parent` is
+ * a document, or if `node` is a doctype and `parent` is not a document.
+ * @private
  * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
  * @see https://dom.spec.whatwg.org/#concept-node-replace
  */
 function assertPreInsertionValidity1to5(parent, node, child) {
 	// 1. If `parent` is not a Document, DocumentFragment, or Element node, then throw a "HierarchyRequestError" DOMException.
 	if (!hasValidParentNodeType(parent)) {
-		throw new DOMException(HIERARCHY_REQUEST_ERR, 'Unexpected parent node type ' + parent.nodeType);
+		throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Unexpected parent node type ' + parent.nodeType);
 	}
 	// 2. If `node` is a host-including inclusive ancestor of `parent`, then throw a "HierarchyRequestError" DOMException.
 	// not implemented!
 	// 3. If `child` is non-null and its parent is not `parent`, then throw a "NotFoundError" DOMException.
 	if (child && child.parentNode !== parent) {
-		throw new DOMException(NOT_FOUND_ERR, 'child not in parent');
+		throw new DOMException(DOMException.NOT_FOUND_ERR, 'child not in parent');
 	}
 	if (
 		// 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.
@@ -1107,22 +1735,38 @@ function assertPreInsertionValidity1to5(parent, node, child) {
 		(isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE)
 	) {
 		throw new DOMException(
-			HIERARCHY_REQUEST_ERR,
+			DOMException.HIERARCHY_REQUEST_ERR,
 			'Unexpected node type ' + node.nodeType + ' for parent node type ' + parent.nodeType
 		);
 	}
 }
 
 /**
- * @private
- * Step 6 of the checks before inserting and before replacing a child are different.
+ * Asserts pre-insertion validity of a node into a document before a child.
+ * Throws errors for invalid node combinations that would result in an ill-formed DOM.
  *
- * @param {Document} parent the parent node to insert `node` into
- * @param {Node} node the node to insert
- * @param {Node | undefined} child the node that should become the `nextSibling` of `node`
+ * @param {Document} parent
+ * The parent node to insert `node` into.
+ * @param {Node} node
+ * The node to insert.
+ * @param {Node | undefined} child
+ * The node that should become the `nextSibling` of `node`. If undefined, no sibling is
+ * considered.
  * @returns {Node}
- * @throws DOMException for several node combinations that would create a DOM that is not well-formed.
- * @throws DOMException if `child` is provided but is not a child of `parent`.
+ * @throws {DOMException}
+ * With code:
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If `node` is a DocumentFragment with more than
+ * one element child or has a Text node child.
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If `node` is a DocumentFragment with one
+ * element child and either `parent` has an element child, `child` is a doctype, or `child` is
+ * non-null and a doctype is following `child`.
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If `node` is an Element and `parent` has an
+ * element child, `child` is a doctype, or `child` is non-null and a doctype is following
+ * `child`.
+ * - {@link DOMException.HIERARCHY_REQUEST_ERR} If `node` is a DocumentType and `parent` has a
+ * doctype child, `child` is non-null and an element is preceding `child`, or `child` is null
+ * and `parent` has an element child.
+ * @private
  * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
  * @see https://dom.spec.whatwg.org/#concept-node-replace
  */
@@ -1135,12 +1779,12 @@ function assertPreInsertionValidityInDocument(parent, node, child) {
 		var nodeChildElements = nodeChildNodes.filter(isElementNode);
 		// If node has more than one element child or has a Text node child.
 		if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');
 		}
 		// Otherwise, if `node` has one element child and either `parent` has an element child,
 		// `child` is a doctype, or `child` is non-null and a doctype is following `child`.
 		if (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');
 		}
 	}
 	// Element
@@ -1148,37 +1792,40 @@ function assertPreInsertionValidityInDocument(parent, node, child) {
 		// `parent` has an element child, `child` is a doctype,
 		// or `child` is non-null and a doctype is following `child`.
 		if (!isElementInsertionPossible(parent, child)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');
 		}
 	}
 	// DocumentType
 	if (isDocTypeNode(node)) {
 		// `parent` has a doctype child,
 		if (find(parentChildNodes, isDocTypeNode)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');
 		}
 		var parentElementChild = find(parentChildNodes, isElementNode);
 		// `child` is non-null and an element is preceding `child`,
 		if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');
 		}
 		// or `child` is null and `parent` has an element child.
 		if (!child && parentElementChild) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Doctype can not be appended since element is present');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Doctype can not be appended since element is present');
 		}
 	}
 }
 
 /**
- * @private
- * Step 6 of the checks before inserting and before replacing a child are different.
- *
- * @param {Document} parent the parent node to insert `node` into
- * @param {Node} node the node to insert
- * @param {Node | undefined} child the node that should become the `nextSibling` of `node`
+ * @param {Document} parent
+ * The parent node to insert `node` into.
+ * @param {Node} node
+ * The node to insert.
+ * @param {Node | undefined} child
+ * the node that should become the `nextSibling` of `node`
  * @returns {Node}
- * @throws DOMException for several node combinations that would create a DOM that is not well-formed.
- * @throws DOMException if `child` is provided but is not a child of `parent`.
+ * @throws {DOMException}
+ * For several node combinations that would create a DOM that is not well-formed.
+ * @throws {DOMException}
+ * If `child` is provided but is not a child of `parent`.
+ * @private
  * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
  * @see https://dom.spec.whatwg.org/#concept-node-replace
  */
@@ -1191,18 +1838,18 @@ function assertPreReplacementValidityInDocument(parent, node, child) {
 		var nodeChildElements = nodeChildNodes.filter(isElementNode);
 		// If `node` has more than one element child or has a Text node child.
 		if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');
 		}
 		// Otherwise, if `node` has one element child and either `parent` has an element child that is not `child` or a doctype is following `child`.
 		if (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');
 		}
 	}
 	// Element
 	if (isElementNode(node)) {
 		// `parent` has an element child that is not `child` or a doctype is following `child`.
 		if (!isElementReplacementPossible(parent, child)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');
 		}
 	}
 	// DocumentType
@@ -1213,24 +1860,39 @@ function assertPreReplacementValidityInDocument(parent, node, child) {
 
 		// `parent` has a doctype child that is not `child`,
 		if (find(parentChildNodes, hasDoctypeChildThatIsNotChild)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');
 		}
 		var parentElementChild = find(parentChildNodes, isElementNode);
 		// or an element is preceding `child`.
 		if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
-			throw new DOMException(HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');
+			throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');
 		}
 	}
 }
 
 /**
- * @private
- * @param {Node} parent the parent node to insert `node` into
- * @param {Node} node the node to insert
- * @param {Node=} child the node that should become the `nextSibling` of `node`
+ * Inserts a node into a parent node before a child node.
+ *
+ * @param {Node} parent
+ * The parent node to insert the node into.
+ * @param {Node} node
+ * The node to insert into the parent.
+ * @param {Node | null} child
+ * The node that should become the next sibling of the node.
+ * If null, the function inserts the node at the end of the children of the parent node.
+ * @param {Function} [_inDocumentAssertion]
+ * An optional function to check pre-insertion validity if parent is a document node.
+ * Defaults to {@link assertPreInsertionValidityInDocument}
  * @returns {Node}
- * @throws DOMException for several node combinations that would create a DOM that is not well-formed.
- * @throws DOMException if `child` is provided but is not a child of `parent`.
+ * Returns the inserted node.
+ * @throws {DOMException}
+ * Throws a DOMException if inserting the node would result in a DOM tree that is not
+ * well-formed. See {@link assertPreInsertionValidity1to5},
+ * {@link assertPreInsertionValidityInDocument}.
+ * @throws {DOMException}
+ * Throws a DOMException if child is provided but is not a child of the parent. See
+ * {@link Node.removeChild}
+ * @private
  * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
  */
 function _insertBefore(parent, node, child, _inDocumentAssertion) {
@@ -1282,39 +1944,12 @@ function _insertBefore(parent, node, child, _inDocumentAssertion) {
 	return node;
 }
 
-/**
- * Appends `newChild` to `parentNode`.
- * If `newChild` is already connected to a `parentNode` it is first removed from it.
- *
- * @see https://github.com/xmldom/xmldom/issues/135
- * @see https://github.com/xmldom/xmldom/issues/145
- * @param {Node} parentNode
- * @param {Node} newChild
- * @returns {Node}
- * @private
- */
-function _appendSingleChild(parentNode, newChild) {
-	if (newChild.parentNode) {
-		newChild.parentNode.removeChild(newChild);
-	}
-	newChild.parentNode = parentNode;
-	newChild.previousSibling = parentNode.lastChild;
-	newChild.nextSibling = null;
-	if (newChild.previousSibling) {
-		newChild.previousSibling.nextSibling = newChild;
-	} else {
-		parentNode.firstChild = newChild;
-	}
-	parentNode.lastChild = newChild;
-	_onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
-	return newChild;
-}
-
 Document.prototype = {
 	/**
-	 * The implementation that created this document
-	 * @readonly
+	 * The implementation that created this document.
+	 *
 	 * @type DOMImplementation
+	 * @readonly
 	 */
 	implementation: null,
 	nodeName: '#document',
@@ -1322,8 +1957,8 @@ Document.prototype = {
 	/**
 	 * The DocumentType node of the document.
 	 *
-	 * @readonly
 	 * @type DocumentType
+	 * @readonly
 	 */
 	doctype: null,
 	documentElement: null,
@@ -1385,19 +2020,20 @@ Document.prototype = {
 	},
 
 	/**
-	 * The `getElementsByClassName` method of `Document` interface returns an array-like object
-	 * of all child elements which have **all** of the given class name(s).
-	 *
-	 * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.
+	 * The `getElementsByClassName` method of `Document` interface returns an array-like object of
+	 * all child elements which have **all** of the given class name(s).
 	 *
+	 * Returns an empty list if `classeNames` is an empty string or only contains HTML white space
+	 * characters.
 	 *
 	 * Warning: This is a live LiveNodeList.
 	 * Changes in the DOM will reflect in the array as the changes occur.
 	 * If an element selected by this array no longer qualifies for the selector,
 	 * it will automatically be removed. Be aware of this for iteration purposes.
 	 *
-	 * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace
-	 *
+	 * @param {string} classNames
+	 * Is a string representing the class name(s) to match; multiple class names are separated by
+	 * (ASCII-)whitespace.
 	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName
 	 * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname
 	 */
@@ -1434,26 +2070,25 @@ Document.prototype = {
 	 * otherwise no transformation is being applied.
 	 * When `contentType` implies the HTML namespace, it will be set as `namespaceURI`.
 	 *
-	 * __This implementation differs from the specification:__
-	 * - The provided name is not checked against the `Name` production,
-	 *   so no related error will be thrown.
+	 * __This implementation differs from the specification:__ - The provided name is not checked
+	 * against the `Name` production,
+	 * so no related error will be thrown.
 	 * - There is no interface `HTMLElement`, it is always an `Element`.
 	 * - There is no support for a second argument to indicate using custom elements.
 	 *
 	 * @param {string} tagName
-	 * @return {Element}
-	 *
+	 * @returns {Element}
 	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createElement
 	 * @see https://dom.spec.whatwg.org/#dom-document-createelement
 	 * @see https://dom.spec.whatwg.org/#concept-create-element
 	 */
 	createElement: function (tagName) {
-		var node = new Element();
+		var node = new Element(PDC);
 		node.ownerDocument = this;
 		if (this.type === 'html') {
 			tagName = tagName.toLowerCase();
 		}
-		if (MIME_TYPE.hasDefaultHTMLNamespace(this.contentType)) {
+		if (hasDefaultHTMLNamespace(this.contentType)) {
 			node.namespaceURI = NAMESPACE.HTML;
 		}
 		node.nodeName = tagName;
@@ -1465,33 +2100,33 @@ Document.prototype = {
 		return node;
 	},
 	createDocumentFragment: function () {
-		var node = new DocumentFragment();
+		var node = new DocumentFragment(PDC);
 		node.ownerDocument = this;
 		node.childNodes = new NodeList();
 		return node;
 	},
 	createTextNode: function (data) {
-		var node = new Text();
+		var node = new Text(PDC);
 		node.ownerDocument = this;
 		node.appendData(data);
 		return node;
 	},
 	createComment: function (data) {
-		var node = new Comment();
+		var node = new Comment(PDC);
 		node.ownerDocument = this;
 		node.appendData(data);
 		return node;
 	},
 	createCDATASection: function (data) {
-		var node = new CDATASection();
+		var node = new CDATASection(PDC);
 		node.ownerDocument = this;
 		node.appendData(data);
 		return node;
 	},
 	createProcessingInstruction: function (target, data) {
-		var node = new ProcessingInstruction();
+		var node = new ProcessingInstruction(PDC);
 		node.ownerDocument = this;
-		node.tagName = node.target = target;
+		node.nodeName = node.target = target;
 		node.nodeValue = node.data = data;
 		return node;
 	},
@@ -1500,19 +2135,18 @@ Document.prototype = {
 	 * In HTML Documents `localName` is the lower cased `name`,
 	 * otherwise no transformation is being applied.
 	 *
-	 * __This implementation differs from the specification:__
-	 * - The provided name is not checked against the `Name` production,
-	 *   so no related error will be thrown.
+	 * __This implementation differs from the specification:__ - The provided name is not checked
+	 * against the `Name` production,
+	 * so no related error will be thrown.
 	 *
 	 * @param {string} name
-	 * @return {Attr}
-	 *
+	 * @returns {Attr}
 	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createAttribute
 	 * @see https://dom.spec.whatwg.org/#dom-document-createattribute
 	 */
 	createAttribute: function (name) {
-		if (!conventions.QNAME.test(name)) {
-			throw new DOMException(INVALID_CHARACTER_ERR, 'invalid character in name "' + name + '"');
+		if (!g.QName_exact.test(name)) {
+			throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'invalid character in name "' + name + '"');
 		}
 		if (this.type === 'html') {
 			name = name.toLowerCase();
@@ -1520,7 +2154,7 @@ Document.prototype = {
 		return this._createAttribute(name);
 	},
 	_createAttribute: function (name) {
-		var node = new Attr();
+		var node = new Attr(PDC);
 		node.ownerDocument = this;
 		node.name = name;
 		node.nodeName = name;
@@ -1529,7 +2163,7 @@ Document.prototype = {
 		return node;
 	},
 	createEntityReference: function (name) {
-		var node = new EntityReference();
+		var node = new EntityReference(PDC);
 		node.ownerDocument = this;
 		node.nodeName = name;
 		return node;
@@ -1537,7 +2171,7 @@ Document.prototype = {
 	// Introduced in DOM Level 2:
 	createElementNS: function (namespaceURI, qualifiedName) {
 		var validated = validateAndExtract(namespaceURI, qualifiedName);
-		var node = new Element();
+		var node = new Element(PDC);
 		var attrs = (node.attributes = new NamedNodeMap());
 		node.childNodes = new NodeList();
 		node.ownerDocument = this;
@@ -1552,8 +2186,7 @@ Document.prototype = {
 	// Introduced in DOM Level 2:
 	createAttributeNS: function (namespaceURI, qualifiedName) {
 		var validated = validateAndExtract(namespaceURI, qualifiedName);
-		var node = new Attr();
-		var pl = qualifiedName.split(':');
+		var node = new Attr(PDC);
 		node.ownerDocument = this;
 		node.nodeName = qualifiedName;
 		node.name = qualifiedName;
@@ -1566,8 +2199,10 @@ Document.prototype = {
 };
 _extends(Document, Node);
 
-function Element() {
-	this._nsMap = {};
+function Element(symbol) {
+	checkSymbol(symbol);
+
+	this._nsMap = Object.create(null);
 }
 Element.prototype = {
 	nodeType: ELEMENT_NODE,
@@ -1581,10 +2216,11 @@ Element.prototype = {
 		return !!this.getAttributeNode(name);
 	},
 	/**
-	 * Returns element’s first attribute whose qualified name is `name`, and `null` if there is no such attribute.
+	 * Returns element’s first attribute whose qualified name is `name`, and `null`
+	 * if there is no such attribute.
 	 *
 	 * @param {string} name
-	 * @return {string | null}
+	 * @returns {string | null}
 	 */
 	getAttribute: function (name) {
 		var attr = this.getAttributeNode(name);
@@ -1619,15 +2255,6 @@ Element.prototype = {
 		var attr = this.getAttributeNode(name);
 		attr && this.removeAttributeNode(attr);
 	},
-
-	// four real operation method
-	appendChild: function (newChild) {
-		if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
-			return this.insertBefore(newChild, null);
-		} else {
-			return _appendSingleChild(this, newChild);
-		}
-	},
 	setAttributeNode: function (newAttr) {
 		return this.attributes.setNamedItem(newAttr);
 	},
@@ -1648,24 +2275,25 @@ Element.prototype = {
 		return this.getAttributeNodeNS(namespaceURI, localName) != null;
 	},
 	/**
-	 * Returns element’s attribute whose namespace is `namespaceURI` and local name is `localName`,
+	 * Returns element’s attribute whose namespace is `namespaceURI` and local name is
+	 * `localName`,
 	 * or `null` if there is no such attribute.
 	 *
 	 * @param {string} namespaceURI
 	 * @param {string} localName
-	 * @return {string | null}
+	 * @returns {string | null}
 	 */
 	getAttributeNS: function (namespaceURI, localName) {
 		var attr = this.getAttributeNodeNS(namespaceURI, localName);
 		return attr ? attr.value : null;
 	},
 	/**
-	 * Sets the value of element’s attribute whose namespace is `namespaceURI` and local name is `localName` to value.
+	 * Sets the value of element’s attribute whose namespace is `namespaceURI` and local name is
+	 * `localName` to value.
 	 *
 	 * @param {string} namespaceURI
 	 * @param {string} qualifiedName
 	 * @param {string} value
-	 *
 	 * @see https://dom.spec.whatwg.org/#dom-element-setattributens
 	 */
 	setAttributeNS: function (namespaceURI, qualifiedName, value) {
@@ -1695,8 +2323,8 @@ Element.prototype = {
 	 *
 	 * When called on an HTML element in an HTML document,
 	 * `getElementsByTagName` lower-cases the argument before searching for it.
-	 * This is undesirable when trying to match camel-cased SVG elements
-	 * (such as `<linearGradient>`) in an HTML document.
+	 * This is undesirable when trying to match camel-cased SVG elements (such as
+	 * `<linearGradient>`) in an HTML document.
 	 * Instead, use `Element.getElementsByTagNameNS()`,
 	 * which preserves the capitalization of the tag name.
 	 *
@@ -1704,8 +2332,7 @@ Element.prototype = {
 	 * except that it only searches for elements that are descendants of the specified element.
 	 *
 	 * @param {string} qualifiedName
-	 * @return {LiveNodeList}
-	 *
+	 * @returns {LiveNodeList}
 	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByTagName
 	 * @see https://dom.spec.whatwg.org/#concept-getelementsbytagname
 	 */
@@ -1752,7 +2379,9 @@ Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName
 Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
 
 _extends(Element, Node);
-function Attr() {
+function Attr(symbol) {
+	checkSymbol(symbol);
+
 	this.namespaceURI = null;
 	this.prefix = null;
 	this.ownerElement = null;
@@ -1760,7 +2389,9 @@ function Attr() {
 Attr.prototype.nodeType = ATTRIBUTE_NODE;
 _extends(Attr, Node);
 
-function CharacterData() {}
+function CharacterData(symbol) {
+	checkSymbol(symbol);
+}
 CharacterData.prototype = {
 	data: '',
 	substringData: function (offset, count) {
@@ -1774,9 +2405,6 @@ CharacterData.prototype = {
 	insertData: function (offset, text) {
 		this.replaceData(offset, 0, text);
 	},
-	appendChild: function (newChild) {
-		throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
-	},
 	deleteData: function (offset, count) {
 		this.replaceData(offset, count, '');
 	},
@@ -1789,7 +2417,9 @@ CharacterData.prototype = {
 	},
 };
 _extends(CharacterData, Node);
-function Text() {}
+function Text(symbol) {
+	checkSymbol(symbol);
+}
 Text.prototype = {
 	nodeName: '#text',
 	nodeType: TEXT_NODE,
@@ -1807,42 +2437,58 @@ Text.prototype = {
 	},
 };
 _extends(Text, CharacterData);
-function Comment() {}
+function Comment(symbol) {
+	checkSymbol(symbol);
+}
 Comment.prototype = {
 	nodeName: '#comment',
 	nodeType: COMMENT_NODE,
 };
 _extends(Comment, CharacterData);
 
-function CDATASection() {}
+function CDATASection(symbol) {
+	checkSymbol(symbol);
+}
 CDATASection.prototype = {
 	nodeName: '#cdata-section',
 	nodeType: CDATA_SECTION_NODE,
 };
 _extends(CDATASection, CharacterData);
 
-function DocumentType() {}
+function DocumentType(symbol) {
+	checkSymbol(symbol);
+}
 DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
 _extends(DocumentType, Node);
 
-function Notation() {}
+function Notation(symbol) {
+	checkSymbol(symbol);
+}
 Notation.prototype.nodeType = NOTATION_NODE;
 _extends(Notation, Node);
 
-function Entity() {}
+function Entity(symbol) {
+	checkSymbol(symbol);
+}
 Entity.prototype.nodeType = ENTITY_NODE;
 _extends(Entity, Node);
 
-function EntityReference() {}
+function EntityReference(symbol) {
+	checkSymbol(symbol);
+}
 EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
 _extends(EntityReference, Node);
 
-function DocumentFragment() {}
+function DocumentFragment(symbol) {
+	checkSymbol(symbol);
+}
 DocumentFragment.prototype.nodeName = '#document-fragment';
 DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
 _extends(DocumentFragment, Node);
 
-function ProcessingInstruction() {}
+function ProcessingInstruction(symbol) {
+	checkSymbol(symbol);
+}
 ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
 _extends(ProcessingInstruction, Node);
 function XMLSerializer() {}
@@ -1897,17 +2543,19 @@ function needNamespaceDefine(node, isHTML, visibleNamespaces) {
 	return true;
 }
 /**
- * Well-formed constraint: No < in Attribute Values
+ * Literal whitespace other than space that appear in attribute values are serialized as
+ * their entity references, so they will be preserved.
+ * (In contrast to whitespace literals in the input which are normalized to spaces).
+ *
+ * Well-formed constraint: No < in Attribute Values:
  * > The replacement text of any entity referred to directly or indirectly
  * > in an attribute value must not contain a <.
+ *
  * @see https://www.w3.org/TR/xml11/#CleanAttrVals
  * @see https://www.w3.org/TR/xml11/#NT-AttValue
- *
- * Literal whitespace other than space that appear in attribute values
- * are serialized as their entity references, so they will be preserved.
- * (In contrast to whitespace literals in the input which are normalized to spaces)
  * @see https://www.w3.org/TR/xml11/#AVNormalize
  * @see https://w3c.github.io/DOM-Parsing/#serializing-an-element-s-attributes
+ * @prettierignore
  */
 function addSerializedAttribute(buf, qualifiedName, value) {
 	buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
@@ -2008,7 +2656,7 @@ function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
 			}
 			// in XML elements can be closed when they have no children
 			var canCloseTag = !child;
-			if (canCloseTag && (isHTML || NAMESPACE.isHTML(node.namespaceURI))) {
+			if (canCloseTag && (isHTML || node.namespaceURI === NAMESPACE.HTML)) {
 				// in HTML (doc or ns) only void elements can be closed right away
 				canCloseTag = isHTMLVoidElement(nodeName);
 			}
@@ -2048,46 +2696,45 @@ function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
 		case ATTRIBUTE_NODE:
 			return addSerializedAttribute(buf, node.name, node.value);
 		case TEXT_NODE:
-			/**
+			/*
 			 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
-			 * except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.
-			 * If they are needed elsewhere, they must be escaped using either numeric character references or the strings
-			 * `&amp;` and `&lt;` respectively.
-			 * The right angle bracket (>) may be represented using the string " &gt; ", and must, for compatibility,
-			 * be escaped using either `&gt;` or a character reference when it appears in the string `]]>` in content,
+			 * except when used as markup delimiters, or within a comment, a processing instruction,
+			 * or a CDATA section.
+			 * If they are needed elsewhere, they must be escaped using either numeric character
+			 * references or the strings `&amp;` and `&lt;` respectively.
+			 * The right angle bracket (>) may be represented using the string " &gt; ",
+			 * and must, for compatibility, be escaped using either `&gt;`,
+			 * or a character reference when it appears in the string `]]>` in content,
 			 * when that string is not marking the end of a CDATA section.
 			 *
-			 * In the content of elements, character data is any string of characters
-			 * which does not contain the start-delimiter of any markup
-			 * and does not include the CDATA-section-close delimiter, `]]>`.
+			 * In the content of elements, character data is any string of characters which does not
+			 * contain the start-delimiter of any markup and does not include the CDATA-section-close
+			 * delimiter, `]]>`.
 			 *
 			 * @see https://www.w3.org/TR/xml/#NT-CharData
 			 * @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node
 			 */
 			return buf.push(node.data.replace(/[<&>]/g, _xmlEncoder));
 		case CDATA_SECTION_NODE:
-			return buf.push('<![CDATA[', node.data, ']]>');
+			return buf.push(g.CDATA_START, node.data, g.CDATA_END);
 		case COMMENT_NODE:
-			return buf.push('<!--', node.data, '-->');
+			return buf.push(g.COMMENT_START, node.data, g.COMMENT_END);
 		case DOCUMENT_TYPE_NODE:
 			var pubid = node.publicId;
 			var sysid = node.systemId;
-			buf.push('<!DOCTYPE ', node.name);
+			buf.push(g.DOCTYPE_DECL_START, ' ', node.name);
 			if (pubid) {
-				buf.push(' PUBLIC ', pubid);
-				if (sysid && sysid != '.') {
+				buf.push(' ', g.PUBLIC, ' ', pubid);
+				if (sysid && sysid !== '.') {
 					buf.push(' ', sysid);
 				}
-				buf.push('>');
-			} else if (sysid && sysid != '.') {
-				buf.push(' SYSTEM ', sysid, '>');
-			} else {
-				var sub = node.internalSubset;
-				if (sub) {
-					buf.push(' [', sub, ']');
-				}
-				buf.push('>');
+			} else if (sysid && sysid !== '.') {
+				buf.push(' ', g.SYSTEM, ' ', sysid);
+			}
+			if (node.internalSubset) {
+				buf.push(' [', node.internalSubset, ']');
 			}
+			buf.push('>');
 			return;
 		case PROCESSING_INSTRUCTION_NODE:
 			return buf.push('<?', node.target, ' ', node.data, '?>');
@@ -2144,13 +2791,27 @@ function importNode(doc, node, deep) {
 	}
 	return node2;
 }
-//
-//var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,
-//					attributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};
+
+/**
+ * Creates a copy of a node from an existing one.
+ *
+ * @param {Document} doc
+ * The Document object representing the document that the new node will belong to.
+ * @param {Node} node
+ * The node to clone.
+ * @param {boolean} deep
+ * If true, the contents of the node are recursively copied.
+ * If false, only the node itself (and its attributes, if it is an element) are copied.
+ * @returns {Node}
+ * Returns the newly created copy of the node.
+ * @throws {DOMException}
+ * May throw a DOMException if operations within setAttributeNode or appendChild (which are
+ * potentially invoked in this function) do not meet their specific constraints.
+ */
 function cloneNode(doc, node, deep) {
-	var node2 = new node.constructor();
+	var node2 = new node.constructor(PDC);
 	for (var n in node) {
-		if (Object.prototype.hasOwnProperty.call(node, n)) {
+		if (hasOwn(node, n)) {
 			var v = node[n];
 			if (typeof v != 'object') {
 				if (v != node2[n]) {
@@ -2251,13 +2912,23 @@ try {
 	//ie8
 }
 
+exports._updateLiveList = _updateLiveList;
 exports.Attr = Attr;
+exports.CDATASection = CDATASection;
+exports.CharacterData = CharacterData;
+exports.Comment = Comment;
 exports.Document = Document;
+exports.DocumentFragment = DocumentFragment;
 exports.DocumentType = DocumentType;
-exports.DOMException = DOMException;
 exports.DOMImplementation = DOMImplementation;
 exports.Element = Element;
+exports.Entity = Entity;
+exports.EntityReference = EntityReference;
+exports.LiveNodeList = LiveNodeList;
 exports.NamedNodeMap = NamedNodeMap;
 exports.Node = Node;
 exports.NodeList = NodeList;
+exports.Notation = Notation;
+exports.Text = Text;
 exports.XMLSerializer = XMLSerializer;
+exports.ProcessingInstruction = ProcessingInstruction;