@xmldom/xmldom 0.9.0-beta.1 → 0.9.0-beta.10

package/lib/dom.js

@@ -1,27 +1,33 @@
-var conventions = require("./conventions");
+'use strict';
+
+var conventions = require('./conventions');
+var find = conventions.find;
+var hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;
+var isHTMLMimeType = conventions.isHTMLMimeType;
 var isHTMLRawTextElement = conventions.isHTMLRawTextElement;
 var isHTMLVoidElement = conventions.isHTMLVoidElement;
 var MIME_TYPE = conventions.MIME_TYPE;
 var NAMESPACE = conventions.NAMESPACE;
+var g = require('./grammar');
 
 /**
- * A prerequisite for `[].filter`, to drop elements that are empty
+ * A prerequisite for `[].filter`, to drop elements that are empty.
+ *
  * @param {string} input
  * @returns {boolean}
  */
-function notEmptyString (input) {
-	return input !== ''
+function notEmptyString(input) {
+	return input !== '';
 }
 /**
- * @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace
- * @see https://infra.spec.whatwg.org/#ascii-whitespace
- *
  * @param {string} input
  * @returns {string[]} (can be empty)
+ * @see https://infra.spec.whatwg.org/#split-on-ascii-whitespace
+ * @see 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
-	return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : []
+	return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
 }
 
 /**
@@ -31,7 +37,7 @@ function splitOnASCIIWhitespace(input) {
  * @param {string} element
  * @returns {Record<string, boolean | undefined>}
  */
-function orderedSetReducer (current, element) {
+function orderedSetReducer(current, element) {
 	if (!current.hasOwnProperty(element)) {
 		current[element] = true;
 	}
@@ -39,14 +45,14 @@ function orderedSetReducer (current, element) {
 }
 
 /**
- * @see https://infra.spec.whatwg.org/#ordered-set
  * @param {string} input
  * @returns {string[]}
+ * @see https://infra.spec.whatwg.org/#ordered-set
  */
 function toOrderedSet(input) {
 	if (!input) return [];
 	var list = splitOnASCIIWhitespace(input);
-	return Object.keys(list.reduce(orderedSetReducer, {}))
+	return Object.keys(list.reduce(orderedSetReducer, {}));
 }
 
 /**
@@ -56,15 +62,62 @@ function toOrderedSet(input) {
  * @param {any[]} list
  * @returns {function(any): boolean}
  */
-function arrayIncludes (list) {
-	return function(element) {
+function arrayIncludes(list) {
+	return function (element) {
 		return list && list.indexOf(element) !== -1;
+	};
+}
+
+/**
+ * @param {string} qualifiedName
+ * @throws {DOMException}
+ * @see https://dom.spec.whatwg.org/#validate
+ */
+function validateQualifiedName(qualifiedName) {
+	if (!g.QName_exact.test(qualifiedName)) {
+		throw new DOMException(INVALID_CHARACTER_ERR, 'invalid character in qualified name "' + qualifiedName + '"');
 	}
 }
 
-function copy(src,dest){
-	for(var p in src){
-		dest[p] = src[p];
+/**
+ * @param {string | null} namespace
+ * @param {string} qualifiedName
+ * @returns {[namespace: string | null, prefix: string | null, localName: string]}
+ * @see https://dom.spec.whatwg.org/#validate-and-extract
+ */
+function validateAndExtract(namespace, qualifiedName) {
+	validateQualifiedName(qualifiedName);
+	namespace = namespace || null;
+	/**
+	 * @type {string | null}
+	 */
+	var prefix = null;
+	var localName = qualifiedName;
+	if (qualifiedName.indexOf(':') >= 0) {
+		var splitResult = qualifiedName.split(':');
+		prefix = splitResult[0];
+		localName = splitResult[1];
+	}
+	if (prefix !== null && namespace === null) {
+		throw new 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');
+	}
+	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');
+	}
+	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"');
+	}
+	return [namespace, prefix, localName];
+}
+
+function copy(src, dest) {
+	for (var p in src) {
+		if (Object.prototype.hasOwnProperty.call(src, p)) {
+			dest[p] = src[p];
+		}
 	}
 }
 
@@ -72,330 +125,471 @@ function copy(src,dest){
 ^\w+\.prototype\.([_\w]+)\s*=\s*((?:.*\{\s*?[\r\n][\s\S]*?^})|\S.*?(?=[;\r\n]));?
 ^\w+\.prototype\.([_\w]+)\s*=\s*(\S.*?(?=[;\r\n]));?
  */
-function _extends(Class,Super){
+function _extends(Class, Super) {
 	var pt = Class.prototype;
-	if(!(pt instanceof Super)){
-		function t(){};
+	if (!(pt instanceof Super)) {
+		function t() {}
 		t.prototype = Super.prototype;
 		t = new t();
-		copy(pt,t);
+		copy(pt, t);
 		Class.prototype = pt = t;
 	}
-	if(pt.constructor != Class){
-		if(typeof Class != 'function'){
-			console.error("unknown Class:"+Class)
+	if (pt.constructor != Class) {
+		if (typeof Class != 'function') {
+			console.error('unknown Class:' + Class);
 		}
-		pt.constructor = Class
+		pt.constructor = Class;
 	}
 }
 
 // Node Types
-var NodeType = {}
-var ELEMENT_NODE                = NodeType.ELEMENT_NODE                = 1;
-var ATTRIBUTE_NODE              = NodeType.ATTRIBUTE_NODE              = 2;
-var TEXT_NODE                   = NodeType.TEXT_NODE                   = 3;
-var CDATA_SECTION_NODE          = NodeType.CDATA_SECTION_NODE          = 4;
-var ENTITY_REFERENCE_NODE       = NodeType.ENTITY_REFERENCE_NODE       = 5;
-var ENTITY_NODE                 = NodeType.ENTITY_NODE                 = 6;
-var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
-var COMMENT_NODE                = NodeType.COMMENT_NODE                = 8;
-var DOCUMENT_NODE               = NodeType.DOCUMENT_NODE               = 9;
-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;
+var NodeType = {};
+var ELEMENT_NODE = (NodeType.ELEMENT_NODE = 1);
+var ATTRIBUTE_NODE = (NodeType.ATTRIBUTE_NODE = 2);
+var TEXT_NODE = (NodeType.TEXT_NODE = 3);
+var CDATA_SECTION_NODE = (NodeType.CDATA_SECTION_NODE = 4);
+var ENTITY_REFERENCE_NODE = (NodeType.ENTITY_REFERENCE_NODE = 5);
+var ENTITY_NODE = (NodeType.ENTITY_NODE = 6);
+var PROCESSING_INSTRUCTION_NODE = (NodeType.PROCESSING_INSTRUCTION_NODE = 7);
+var COMMENT_NODE = (NodeType.COMMENT_NODE = 8);
+var DOCUMENT_NODE = (NodeType.DOCUMENT_NODE = 9);
+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 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);
+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);
+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);
+
+//helper functions for compareDocumentPosition
+/**
+ * Construct a parent chain for a node.
+ *
+ * @param {Node} node
+ * The start node.
+ * @returns {Node[]} The parent chain.
+ */
+function parentChain(node) {
+	var chain = [];
+	while (node.parentNode || node.ownerElement) {
+		node = node.parentNode || node.ownerElement;
+		chain.unshift(node);
+	}
+	return chain;
+}
+
+/**
+ * Find the common ancestor in two parent chains.
+ *
+ * @param {Node[]} a
+ * A parent chain.
+ * @param {Node[]} b
+ * A parent chain.
+ * @returns {Node} The common ancestor if it exists.
+ */
+function commonAncestor(a, b) {
+	if (b.length < a.length) return commonAncestor(b, a);
+	var c = null;
+	for (var n in a) {
+		if (a[n] !== b[n]) return c;
+		c = a[n];
+	}
+	return c;
+}
+
+/**
+ * Comparing unrelated nodes must be consistent, so we assign a guid to the compared docs for
+ * further reference.
+ *
+ * @param {Document} doc
+ * The document.
+ * @returns {string} The document's guid.
+ */
+function docGUID(doc) {
+	if (!doc.guid) doc.guid = Math.random();
+	return doc.guid;
+}
+//-- end of helper functions
 
 /**
- * DOM Level 2
- * Object DOMException
+ * 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){
+	if (message instanceof Error) {
 		var error = message;
-	}else{
+	} else {
 		error = this;
 		Error.call(this, ExceptionMessage[code]);
 		this.message = ExceptionMessage[code];
-		if(Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
 	}
 	error.code = code;
-	if(message) this.message = this.message + ": " + message;
+	if (message) this.message = this.message + ': ' + message;
 	return error;
-};
+}
 DOMException.prototype = Error.prototype;
-copy(ExceptionCode,DOMException)
+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.
+ *
+ * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
  */
-function 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.
+	 * The number of nodes in the list. The range of valid child node indices is 0 to length-1
+	 * inclusive.
+	 *
 	 * @standard level1
 	 */
-	length:0,
+	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 The node at position `index` in the NodeList,
+	 *          or null if that is not a valid index.
 	 */
-	item: function(index) {
-		return this[index] || null;
+	item: function (index) {
+		return index >= 0 && index < this.length ? this[index] : null;
 	},
 	toString: function (nodeFilter) {
-		for(var buf = [], i = 0;i<this.length;i++){
-			serializeToString(this[i], buf, nodeFilter)
+		for (var buf = [], i = 0; i < this.length; i++) {
+			serializeToString(this[i], buf, nodeFilter);
 		}
-		return buf.join('')
-	}
+		return buf.join('');
+	},
+	/**
+	 * @param {function (Node):boolean} predicate
+	 * @returns {Node[]}
+	 * @private
+	 */
+	filter: function (predicate) {
+		return Array.prototype.filter.call(this, predicate);
+	},
+	/**
+	 * @param {Node} item
+	 * @returns {number}
+	 * @private
+	 */
+	indexOf: function (item) {
+		return Array.prototype.indexOf.call(this, item);
+	},
 };
 
-function LiveNodeList(node,refresh){
+function LiveNodeList(node, refresh) {
 	this._node = node;
-	this._refresh = refresh
+	this._refresh = refresh;
 	_updateLiveList(this);
 }
-function _updateLiveList(list){
+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);
-		copy(ls,list);
+		__set__(list, 'length', ls.length);
+		if (!list.$$length || ls.length < list.$$length) {
+			for (var i = ls.length; i in list; i++) {
+				if (Object.prototype.hasOwnProperty.call(list, i)) {
+					delete list[i];
+				}
+			}
+		}
+		copy(ls, list);
 		list._inc = inc;
 	}
 }
-LiveNodeList.prototype.item = function(i){
+LiveNodeList.prototype.item = function (i) {
 	_updateLiveList(this);
-	return this[i];
-}
+	return this[i] || null;
+};
 
-_extends(LiveNodeList,NodeList);
+_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.
  * used for attributes or DocumentType entities
+ *
+ * This implementation only supports property indices, but does not support named properties,
+ * as specified in the living standard.
+ *
+ * @see https://dom.spec.whatwg.org/#interface-namednodemap
+ * @see https://webidl.spec.whatwg.org/#dfn-supported-property-names
  */
-function NamedNodeMap() {
-};
+function NamedNodeMap() {}
 
-function _findNodeIndex(list,node){
-	var i = list.length;
-	while(i--){
-		if(list[i] === node){return i}
+function _findNodeIndex(list, node) {
+	var i = 0;
+	while (i < list.length) {
+		if (list[i] === node) {
+			return i;
+		}
+		i++;
 	}
 }
 
-function _addNamedNode(el,list,newAttr,oldAttr){
-	if(oldAttr){
-		list[_findNodeIndex(list,oldAttr)] = newAttr;
-	}else{
-		list[list.length++] = newAttr;
+function _addNamedNode(el, list, newAttr, oldAttr) {
+	if (oldAttr) {
+		list[_findNodeIndex(list, oldAttr)] = newAttr;
+	} else {
+		list[list.length] = newAttr;
+		list.length++;
 	}
-	if(el){
+	if (el) {
 		newAttr.ownerElement = el;
 		var doc = el.ownerDocument;
-		if(doc){
-			oldAttr && _onRemoveAttribute(doc,el,oldAttr);
-			_onAddAttribute(doc,el,newAttr);
+		if (doc) {
+			oldAttr && _onRemoveAttribute(doc, el, oldAttr);
+			_onAddAttribute(doc, el, newAttr);
 		}
 	}
 }
-function _removeNamedNode(el,list,attr){
+function _removeNamedNode(el, list, attr) {
 	//console.log('remove attr:'+attr)
-	var i = _findNodeIndex(list,attr);
-	if(i>=0){
-		var lastIndex = list.length-1
-		while(i<lastIndex){
-			list[i] = list[++i]
+	var i = _findNodeIndex(list, attr);
+	if (i >= 0) {
+		var lastIndex = list.length - 1;
+		while (i <= lastIndex) {
+			list[i] = list[++i];
 		}
 		list.length = lastIndex;
-		if(el){
+		if (el) {
 			var doc = el.ownerDocument;
-			if(doc){
-				_onRemoveAttribute(doc,el,attr);
-				attr.ownerElement = null;
+			if (doc) {
+				_onRemoveAttribute(doc, el, attr);
 			}
+			attr.ownerElement = null;
 		}
-	}else{
-		throw DOMException(NOT_FOUND_ERR,new Error(el.tagName+'@'+attr))
 	}
 }
 NamedNodeMap.prototype = {
-	length:0,
-	item:NodeList.prototype.item,
-	getNamedItem: function(key) {
-//		if(key.indexOf(':')>0 || key == 'xmlns'){
-//			return null;
-//		}
-		//console.log()
-		var i = this.length;
-		while(i--){
+	length: 0,
+	item: NodeList.prototype.item,
+
+	/**
+	 * get an attribute by name (lower case in case of HTML namespace and document)
+	 *
+	 * @param {string} localName
+	 * @returns {Attr | null}
+	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name
+	 */
+	getNamedItem: function (localName) {
+		if (this._ownerElement && this._ownerElement._isInHTMLDocumentAndNamespace()) {
+			localName = localName.toLowerCase();
+		}
+		var i = 0;
+		while (i < this.length) {
 			var attr = this[i];
-			//console.log(attr.nodeName,key)
-			if(attr.nodeName == key){
+			if (attr.nodeName === localName) {
 				return attr;
 			}
+			i++;
 		}
+		return null;
 	},
-	setNamedItem: function(attr) {
+
+	/**
+	 * Set an attribute.
+	 *
+	 * @param {Attr} attr
+	 * @returns {Attr | null}
+	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-set
+	 */
+	setNamedItem: function (attr) {
 		var el = attr.ownerElement;
-		if(el && el!=this._ownerElement){
+		if (el && el !== this._ownerElement) {
 			throw new DOMException(INUSE_ATTRIBUTE_ERR);
 		}
-		var oldAttr = this.getNamedItem(attr.nodeName);
-		_addNamedNode(this._ownerElement,this,attr,oldAttr);
-		return oldAttr;
-	},
-	/* returns Node */
-	setNamedItemNS: function(attr) {// raises: WRONG_DOCUMENT_ERR,NO_MODIFICATION_ALLOWED_ERR,INUSE_ATTRIBUTE_ERR
-		var el = attr.ownerElement, oldAttr;
-		if(el && el!=this._ownerElement){
-			throw new DOMException(INUSE_ATTRIBUTE_ERR);
+		var oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
+		if (oldAttr === attr) {
+			return attr;
 		}
-		oldAttr = this.getNamedItemNS(attr.namespaceURI,attr.localName);
-		_addNamedNode(this._ownerElement,this,attr,oldAttr);
+		_addNamedNode(this._ownerElement, this, attr, oldAttr);
 		return oldAttr;
 	},
 
-	/* returns Node */
-	removeNamedItem: function(key) {
-		var attr = this.getNamedItem(key);
-		_removeNamedNode(this._ownerElement,this,attr);
-		return attr;
-
+	/**
+	 * Set an attribute.
+	 *
+	 * @param {Attr} attr
+	 * @returns {Attr | null}
+	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-set
+	 */
+	setNamedItemNS: function (attr) {
+		return this.setNamedItem(attr);
+	},
 
-	},// raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
+	/**
+	 * remove an attribute by name (lower case in case of HTML namespace and document)
+	 *
+	 * @param {string} localName
+	 * @returns {Attr | null}
+	 * @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);
+		}
+		_removeNamedNode(this._ownerElement, this, attr);
+		return attr;
+	},
 
-	//for level2
-	removeNamedItemNS:function(namespaceURI,localName){
-		var attr = this.getNamedItemNS(namespaceURI,localName);
-		_removeNamedNode(this._ownerElement,this,attr);
+	/**
+	 * Remove an attribute by namespace and local name.
+	 *
+	 * @param {string | null} namespaceURI
+	 * @param {string} localName
+	 * @returns {Attr | null}
+	 * @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);
+		}
+		_removeNamedNode(this._ownerElement, this, attr);
 		return attr;
 	},
-	getNamedItemNS: function(namespaceURI, localName) {
-		var i = this.length;
-		while(i--){
+
+	/**
+	 * Get an attribute by namespace and local name.
+	 *
+	 * @param {string | null} namespaceURI
+	 * @param {string} localName
+	 * @returns {Attr | null}
+	 * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-namespace
+	 */
+	getNamedItemNS: function (namespaceURI, localName) {
+		if (!namespaceURI) {
+			namespaceURI = null;
+		}
+		var i = 0;
+		while (i < this.length) {
 			var node = this[i];
-			if(node.localName == localName && node.namespaceURI == namespaceURI){
+			if (node.localName === localName && node.namespaceURI === namespaceURI) {
 				return node;
 			}
+			i++;
 		}
 		return null;
-	}
+	},
 };
 
 /**
- * The DOMImplementation interface represents an object providing methods
- * which are not dependent on any particular document.
+ * 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 individual methods describe the differences compared to the specs.__
- *
- * @constructor
+ * **The individual methods describe the differences compared to the specs**.
  *
+ * @class
  * @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
  */
-function DOMImplementation() {
-}
+function DOMImplementation() {}
 
 DOMImplementation.prototype = {
 	/**
-	 * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.
+	 * 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.
+	 * 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.
 	 * @param {string} feature
 	 * @param {string} [version]
-	 * @returns {boolean} always true
-	 *
+	 * @returns {boolean} Always 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
 	 */
-	hasFeature: function(feature, version) {
-			return true;
+	hasFeature: function (feature, version) {
+		return true;
 	},
 	/**
 	 * Creates an XML Document object of the specified type with its document element.
 	 *
 	 * __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`)
 	 *
 	 * @param {string | null} namespaceURI
 	 * @param {string} qualifiedName
 	 * @param {DocumentType | null} [doctype=null]
-	 * @returns {Document} the XML document
-	 *
-	 * @see #createHTMLDocument
-	 *
+	 * @returns {Document} The XML document.
+	 * @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://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
 	 */
-	createDocument: function(namespaceURI,  qualifiedName, doctype){
+	createDocument: function (namespaceURI, qualifiedName, doctype) {
 		var contentType = MIME_TYPE.XML_APPLICATION;
 		if (namespaceURI === NAMESPACE.HTML) {
 			contentType = MIME_TYPE.XML_XHTML_APPLICATION;
 		} else if (namespaceURI === NAMESPACE.SVG) {
-			contentType = MIME_TYPE.XML_SVG_IMAGE
+			contentType = MIME_TYPE.XML_SVG_IMAGE;
 		}
-		var doc = new Document({contentType: contentType});
+		var doc = new Document({ contentType: contentType });
 		doc.implementation = this;
 		doc.childNodes = new NodeList();
 		doc.doctype = doctype || null;
-		if (doctype){
+		if (doctype) {
 			doc.appendChild(doctype);
 		}
-		if (qualifiedName){
+		if (qualifiedName) {
 			var root = doc.createElementNS(namespaceURI, qualifiedName);
 			doc.appendChild(root);
 		}
@@ -405,30 +599,37 @@ DOMImplementation.prototype = {
 	 * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
 	 *
 	 * __This behavior is slightly different from the in the specs__:
-	 * - this implementation is not validating names or qualified names
-	 *   (when parsing XML strings, the SAX parser takes care of that)
 	 * - `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.
 	 *
 	 * @param {string} qualifiedName
 	 * @param {string} [publicId]
 	 * @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()`
-	 *
-	 * @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
-	 *
-	 * @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
+	 * @param {string} [internalSubset]
+	 * (from DOM Level 2 Core)
+	 * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument`
+	 *                         on document creation or can be put into the document via methods
+	 *                         like `Node.insertBefore()` or `Node.replaceChild()`
+	 * @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
+	 * @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
 	 */
-	createDocumentType: function(qualifiedName, publicId, systemId){
+	createDocumentType: function (qualifiedName, publicId, systemId, internalSubset) {
+		validateQualifiedName(qualifiedName);
 		var node = new DocumentType();
 		node.name = qualifiedName;
 		node.nodeName = qualifiedName;
 		node.publicId = publicId || '';
 		node.systemId = systemId || '';
+		node.internalSubset = internalSubset || '';
 
 		return node;
 	},
@@ -436,108 +637,110 @@ 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
-	 *
+	 * @returns {Document} The HTML document.
+	 * @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})
-		doc.implementation = this
-		doc.childNodes = new NodeList()
+	createHTMLDocument: function (title) {
+		var doc = new Document({ contentType: MIME_TYPE.HTML });
+		doc.implementation = this;
+		doc.childNodes = new NodeList();
 		if (title !== false) {
-			doc.doctype = this.createDocumentType('html')
-			doc.doctype.ownerDocument = this;
+			doc.doctype = this.createDocumentType('html');
+			doc.doctype.ownerDocument = doc;
 			doc.appendChild(doc.doctype);
-			var htmlNode = doc.createElement('html')
-			doc.appendChild(htmlNode)
-			var headNode = doc.createElement('head')
-			htmlNode.appendChild(headNode)
+			var htmlNode = doc.createElement('html');
+			doc.appendChild(htmlNode);
+			var headNode = doc.createElement('head');
+			htmlNode.appendChild(headNode);
 			if (typeof title === 'string') {
 				var titleNode = doc.createElement('title');
-				titleNode.appendChild(doc.createTextNode(title))
-				headNode.appendChild(titleNode)
+				titleNode.appendChild(doc.createTextNode(title));
+				headNode.appendChild(titleNode);
 			}
-			htmlNode.appendChild(doc.createElement('body'))
+			htmlNode.appendChild(doc.createElement('body'));
 		}
-		return doc
-	}
+		return doc;
+	},
 };
 
-
 /**
  * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
  */
-function Node() {
-};
+function Node() {}
 
 Node.prototype = {
-	firstChild : null,
-	lastChild : null,
-	previousSibling : null,
-	nextSibling : null,
-	attributes : null,
-	parentNode : null,
-	childNodes : null,
-	ownerDocument : null,
-	nodeValue : null,
-	namespaceURI : null,
-	prefix : null,
-	localName : null,
+	firstChild: null,
+	lastChild: null,
+	previousSibling: null,
+	nextSibling: null,
+	attributes: null,
+	parentNode: null,
+	childNodes: null,
+	ownerDocument: null,
+	nodeValue: null,
+	namespaceURI: null,
+	prefix: null,
+	localName: null,
 	// Modified in DOM Level 2:
-	insertBefore:function(newChild, refChild){//raises
-		return _insertBefore(this,newChild,refChild);
+	insertBefore: function (newChild, refChild) {
+		//raises
+		return _insertBefore(this, newChild, refChild);
 	},
-	replaceChild:function(newChild, oldChild){//raises
-		this.insertBefore(newChild,oldChild);
-		if(oldChild){
+	replaceChild: function (newChild, oldChild) {
+		//raises
+		_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
+		if (oldChild) {
 			this.removeChild(oldChild);
 		}
 	},
-	removeChild:function(oldChild){
-		return _removeChild(this,oldChild);
+	removeChild: function (oldChild) {
+		return _removeChild(this, oldChild);
 	},
-	appendChild:function(newChild){
-		return this.insertBefore(newChild,null);
+	appendChild: function (newChild) {
+		return this.insertBefore(newChild, null);
 	},
-	hasChildNodes:function(){
+	hasChildNodes: function () {
 		return this.firstChild != null;
 	},
-	cloneNode:function(deep){
-		return cloneNode(this.ownerDocument||this,this,deep);
+	cloneNode: function (deep) {
+		return cloneNode(this.ownerDocument || this, this, deep);
 	},
 	// Modified in DOM Level 2:
-	normalize:function(){
+	normalize: function () {
 		var child = this.firstChild;
-		while(child){
+		while (child) {
 			var next = child.nextSibling;
-			if(next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE){
+			if (next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE) {
 				this.removeChild(next);
 				child.appendData(next.data);
-			}else{
+			} else {
 				child.normalize();
 				child = next;
 			}
 		}
 	},
-  	// Introduced in DOM Level 2:
-	isSupported:function(feature, version){
-		return this.ownerDocument.implementation.hasFeature(feature,version);
+	// Introduced in DOM Level 2:
+	isSupported: function (feature, version) {
+		return this.ownerDocument.implementation.hasFeature(feature, version);
+	},
+	// Introduced in DOM Level 2:
+	hasAttributes: function () {
+		return this.attributes.length > 0;
 	},
-    // Introduced in DOM Level 2:
-    hasAttributes:function(){
-    	return this.attributes.length>0;
-    },
 	/**
 	 * Look up the prefix associated to the given namespace URI, starting from this node.
 	 * **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._
+	 * _Note: The implementation seems to be incomplete when compared to the algorithm described
+	 * in the specs._.
 	 *
 	 * @param {string | null} namespaceURI
 	 * @returns {string | null}
@@ -546,70 +749,128 @@ Node.prototype = {
 	 * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix
 	 * @see https://github.com/xmldom/xmldom/issues/322
 	 */
-    lookupPrefix:function(namespaceURI){
-    	var el = this;
-    	while(el){
-    		var map = el._nsMap;
-    		//console.dir(map)
-    		if(map){
-    			for(var n in map){
-    				if(map[n] == namespaceURI){
-    					return n;
-    				}
-    			}
-    		}
-    		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
-    	}
-    	return null;
-    },
-    // Introduced in DOM Level 3:
-    lookupNamespaceURI:function(prefix){
-    	var el = this;
-    	while(el){
-    		var map = el._nsMap;
-    		//console.dir(map)
-    		if(map){
-    			if(prefix in map){
-    				return map[prefix] ;
-    			}
-    		}
-    		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
-    	}
-    	return null;
-    },
-    // Introduced in DOM Level 3:
-    isDefaultNamespace:function(namespaceURI){
-    	var prefix = this.lookupPrefix(namespaceURI);
-    	return prefix == null;
-    }
+	lookupPrefix: function (namespaceURI) {
+		var el = this;
+		while (el) {
+			var map = el._nsMap;
+			//console.dir(map)
+			if (map) {
+				for (var n in map) {
+					if (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) {
+						return n;
+					}
+				}
+			}
+			el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
+		}
+		return null;
+	},
+	// Introduced in DOM Level 3:
+	lookupNamespaceURI: function (prefix) {
+		var el = this;
+		while (el) {
+			var map = el._nsMap;
+			//console.dir(map)
+			if (map) {
+				if (Object.prototype.hasOwnProperty.call(map, prefix)) {
+					return map[prefix];
+				}
+			}
+			el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
+		}
+		return null;
+	},
+	// Introduced in DOM Level 3:
+	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.
+	 * @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.
+	 * @see https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#Node3-compareDocumentPosition
+	 */
+	compareDocumentPosition: function (other) {
+		if (this === other) return 0;
+		var node1 = other;
+		var node2 = this;
+		var attr1 = null;
+		var attr2 = null;
+		if (node1 instanceof Attr) {
+			attr1 = node1;
+			node1 = attr1.ownerElement;
+		}
+		if (node2 instanceof Attr) {
+			attr2 = node2;
+			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 (!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)
+			);
+		}
+		var chain1 = parentChain(node1);
+		var chain2 = parentChain(node2);
+		if ((!attr1 && chain2.indexOf(node1) >= 0) || (attr2 && node1 === node2)) {
+			return DOCUMENT_POSITION_CONTAINS + DOCUMENT_POSITION_PRECEDING;
+		}
+		if ((!attr2 && chain1.indexOf(node2) >= 0) || (attr1 && node1 === node2)) {
+			return DOCUMENT_POSITION_CONTAINED_BY + 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;
+		}
+		return 0;
+	},
 };
 
-
-function _xmlEncoder(c){
-	return c == '<' && '&lt;' ||
-         c == '>' && '&gt;' ||
-         c == '&' && '&amp;' ||
-         c == '"' && '&quot;' ||
-         '&#'+c.charCodeAt()+';'
+function _xmlEncoder(c) {
+	return (
+		(c == '<' && '&lt;') || (c == '>' && '&gt;') || (c == '&' && '&amp;') || (c == '"' && '&quot;') || '&#' + c.charCodeAt() + ';'
+	);
 }
 
-
-copy(NodeType,Node);
-copy(NodeType,Node.prototype);
+copy(NodeType, Node);
+copy(NodeType, Node.prototype);
+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)){
+function _visitNode(node, callback) {
+	if (callback(node)) {
 		return true;
 	}
-	if(node = node.firstChild){
-		do{
-			if(_visitNode(node,callback)){return true}
-        }while(node=node.nextSibling)
-    }
+	if ((node = node.firstChild)) {
+		do {
+			if (_visitNode(node, callback)) {
+				return true;
+			}
+		} while ((node = node.nextSibling));
+	}
 }
 
 /**
@@ -622,55 +883,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 {DocumentOptions} [options]
  * @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(options) {
 	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
+	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';
 }
 
-function _onAddAttribute(doc,el,newAttr){
+function _onAddAttribute(doc, el, newAttr) {
 	doc && doc._inc++;
-	var ns = newAttr.namespaceURI ;
-	if(ns === NAMESPACE.XMLNS){
+	var ns = newAttr.namespaceURI;
+	if (ns === NAMESPACE.XMLNS) {
 		//update namespace
-		el._nsMap[newAttr.prefix?newAttr.localName:''] = newAttr.value
+		el._nsMap[newAttr.prefix ? newAttr.localName : ''] = newAttr.value;
 	}
 }
 
-function _onRemoveAttribute(doc,el,newAttr,remove){
+function _onRemoveAttribute(doc, el, newAttr, remove) {
 	doc && doc._inc++;
-	var ns = newAttr.namespaceURI ;
-	if(ns === NAMESPACE.XMLNS){
+	var ns = newAttr.namespaceURI;
+	if (ns === NAMESPACE.XMLNS) {
 		//update namespace
-		delete el._nsMap[newAttr.prefix?newAttr.localName:'']
+		delete el._nsMap[newAttr.prefix ? newAttr.localName : ''];
 	}
 }
 
@@ -678,16 +936,15 @@ 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.
+ * and `el.firstNode` and it's `.nextSibling` are used to walk the current list of child nodes.
  *
  * @param {Document} doc
  * @param {Node} el
  * @param {Node} [newChild]
  * @private
  */
-function _onUpdateChild (doc, el, newChild) {
-	if(doc && doc._inc){
+function _onUpdateChild(doc, el, newChild) {
+	if (doc && doc._inc) {
 		doc._inc++;
 		//update childNodes
 		var cs = el.childNodes;
@@ -710,89 +967,377 @@ 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
  * @param {Node} child
- * @returns {Node} the child that was removed.
+ * @returns {Node} The child that was removed.
  * @private
+ * @see https://github.com/xmldom/xmldom/issues/135
+ * @see https://github.com/xmldom/xmldom/issues/145
  */
-function _removeChild (parentNode, child) {
-	var previous = child.previousSibling;
-	var next = child.nextSibling;
-	if (previous) {
-		previous.nextSibling = next;
+function _removeChild(parentNode, child) {
+	if (parentNode !== child.parentNode) {
+		throw new DOMException(NOT_FOUND_ERR, "child's parent is not parent");
+	}
+	//var index = parentNode.childNodes.
+	var oldPreviousSibling = child.previousSibling;
+	var oldNextSibling = child.nextSibling;
+	if (oldPreviousSibling) {
+		oldPreviousSibling.nextSibling = oldNextSibling;
 	} else {
-		parentNode.firstChild = next;
+		parentNode.firstChild = oldNextSibling;
 	}
-	if (next) {
-		next.previousSibling = previous;
+	if (oldNextSibling) {
+		oldNextSibling.previousSibling = oldPreviousSibling;
 	} else {
-		parentNode.lastChild = previous;
+		parentNode.lastChild = oldPreviousSibling;
 	}
+	_onUpdateChild(parentNode.ownerDocument, parentNode);
 	child.parentNode = null;
 	child.previousSibling = null;
 	child.nextSibling = null;
-	_onUpdateChild(parentNode.ownerDocument, parentNode);
 	return child;
 }
+
 /**
- * preformance key(refChild == null)
+ * Returns `true` if `node` can be a parent for insertion.
+ *
+ * @param {Node} node
+ * @returns {boolean}
  */
-function _insertBefore(parentNode,newChild,nextChild){
-	var cp = newChild.parentNode;
-	if(cp){
-		cp.removeChild(newChild);//remove and update
+function hasValidParentNodeType(node) {
+	return (
+		node &&
+		(node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE)
+	);
+}
+
+/**
+ * Returns `true` if `node` can be inserted according to it's `nodeType`.
+ *
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function hasInsertableNodeType(node) {
+	return (
+		node &&
+		(isElementNode(node) ||
+			isTextNode(node) ||
+			isDocTypeNode(node) ||
+			node.nodeType === Node.DOCUMENT_FRAGMENT_NODE ||
+			node.nodeType === Node.COMMENT_NODE ||
+			node.nodeType === Node.PROCESSING_INSTRUCTION_NODE)
+	);
+}
+
+/**
+ * Returns true if `node` is a DOCTYPE node.
+ *
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isDocTypeNode(node) {
+	return node && node.nodeType === Node.DOCUMENT_TYPE_NODE;
+}
+
+/**
+ * Returns true if the node is an element.
+ *
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isElementNode(node) {
+	return node && node.nodeType === Node.ELEMENT_NODE;
+}
+/**
+ * Returns true if `node` is a text node.
+ *
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isTextNode(node) {
+	return node && node.nodeType === Node.TEXT_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.
+ * @private
+ */
+function isElementInsertionPossible(doc, child) {
+	var parentChildNodes = doc.childNodes || [];
+	if (find(parentChildNodes, isElementNode) || isDocTypeNode(child)) {
+		return false;
 	}
-	if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
-		var newFirst = newChild.firstChild;
+	var docTypeNode = find(parentChildNodes, isDocTypeNode);
+	return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(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.
+ * @private
+ */
+function isElementReplacementPossible(doc, child) {
+	var parentChildNodes = doc.childNodes || [];
+
+	function hasElementChildThatIsNotChild(node) {
+		return isElementNode(node) && node !== child;
+	}
+
+	if (find(parentChildNodes, hasElementChildThatIsNotChild)) {
+		return false;
+	}
+	var docTypeNode = find(parentChildNodes, isDocTypeNode);
+	return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
+}
+
+/**
+ * @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`.
+ * @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);
+	}
+	// 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');
+	}
+	if (
+		// 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.
+		!hasInsertableNodeType(node) ||
+		// 5. If either `node` is a Text node and `parent` is a document,
+		// the sax parser currently adds top level text nodes, this will be fixed in 0.9.0
+		// || (node.nodeType === Node.TEXT_NODE && parent.nodeType === Node.DOCUMENT_NODE)
+		// or `node` is a doctype and `parent` is not a document, then throw a "HierarchyRequestError" DOMException.
+		(isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE)
+	) {
+		throw new DOMException(
+			HIERARCHY_REQUEST_ERR,
+			'Unexpected node type ' + node.nodeType + ' for parent node type ' + parent.nodeType
+		);
+	}
+}
+
+/**
+ * @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`.
+ * @private
+ * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
+ * @see https://dom.spec.whatwg.org/#concept-node-replace
+ */
+function assertPreInsertionValidityInDocument(parent, node, child) {
+	var parentChildNodes = parent.childNodes || [];
+	var nodeChildNodes = node.childNodes || [];
+
+	// DocumentFragment
+	if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+		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');
+		}
+		// 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');
+		}
+	}
+	// Element
+	if (isElementNode(node)) {
+		// `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');
+		}
+	}
+	// DocumentType
+	if (isDocTypeNode(node)) {
+		// `parent` has a doctype child,
+		if (find(parentChildNodes, isDocTypeNode)) {
+			throw new 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');
+		}
+		// 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');
+		}
+	}
+}
+
+/**
+ * @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`.
+ * @private
+ * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
+ * @see https://dom.spec.whatwg.org/#concept-node-replace
+ */
+function assertPreReplacementValidityInDocument(parent, node, child) {
+	var parentChildNodes = parent.childNodes || [];
+	var nodeChildNodes = node.childNodes || [];
+
+	// DocumentFragment
+	if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+		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');
+		}
+		// 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');
+		}
+	}
+	// 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');
+		}
+	}
+	// DocumentType
+	if (isDocTypeNode(node)) {
+		function hasDoctypeChildThatIsNotChild(node) {
+			return isDocTypeNode(node) && 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');
+		}
+		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');
+		}
+	}
+}
+
+/**
+ * @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`.
+ * @private
+ * @see https://dom.spec.whatwg.org/#concept-node-ensure-pre-insertion-validity
+ */
+function _insertBefore(parent, node, child, _inDocumentAssertion) {
+	// To ensure pre-insertion validity of a node into a parent before a child, run these steps:
+	assertPreInsertionValidity1to5(parent, node, child);
+
+	// If parent is a document, and any of the statements below, switched on the interface node implements,
+	// are true, then throw a "HierarchyRequestError" DOMException.
+	if (parent.nodeType === Node.DOCUMENT_NODE) {
+		(_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);
+	}
+
+	var cp = node.parentNode;
+	if (cp) {
+		cp.removeChild(node); //remove and update
+	}
+	if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+		var newFirst = node.firstChild;
 		if (newFirst == null) {
-			return newChild;
+			return node;
 		}
-		var newLast = newChild.lastChild;
-	}else{
-		newFirst = newLast = newChild;
+		var newLast = node.lastChild;
+	} else {
+		newFirst = newLast = node;
 	}
-	var pre = nextChild ? nextChild.previousSibling : parentNode.lastChild;
+	var pre = child ? child.previousSibling : parent.lastChild;
 
 	newFirst.previousSibling = pre;
-	newLast.nextSibling = nextChild;
+	newLast.nextSibling = child;
 
-
-	if(pre){
+	if (pre) {
 		pre.nextSibling = newFirst;
-	}else{
-		parentNode.firstChild = newFirst;
+	} else {
+		parent.firstChild = newFirst;
 	}
-	if(nextChild == null){
-		parentNode.lastChild = newLast;
-	}else{
-		nextChild.previousSibling = newLast;
+	if (child == null) {
+		parent.lastChild = newLast;
+	} else {
+		child.previousSibling = newLast;
 	}
-	do{
-		newFirst.parentNode = parentNode;
-	}while(newFirst !== newLast && (newFirst= newFirst.nextSibling))
-	_onUpdateChild(parentNode.ownerDocument||parentNode,parentNode);
-	//console.log(parentNode.lastChild.nextSibling == null)
-	if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
-		newChild.firstChild = newChild.lastChild = null;
+	do {
+		newFirst.parentNode = parent;
+	} while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
+	_onUpdateChild(parent.ownerDocument || parent, parent);
+	//console.log(parent.lastChild.nextSibling == null)
+	if (node.nodeType == DOCUMENT_FRAGMENT_NODE) {
+		node.firstChild = node.lastChild = null;
 	}
-	return newChild;
+	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
+ * @see https://github.com/xmldom/xmldom/issues/135
+ * @see https://github.com/xmldom/xmldom/issues/145
  */
-function _appendSingleChild (parentNode, newChild) {
+function _appendSingleChild(parentNode, newChild) {
 	if (newChild.parentNode) {
 		newChild.parentNode.removeChild(newChild);
 	}
@@ -811,97 +1356,114 @@ function _appendSingleChild (parentNode, newChild) {
 
 Document.prototype = {
 	/**
-	 * The implementation that created this document
-	 * @readonly
+	 * The implementation that created this document.
+	 *
 	 * @type DOMImplementation
+	 * @readonly
 	 */
-	implementation : null,
-	nodeName :  '#document',
-	nodeType :  DOCUMENT_NODE,
+	implementation: null,
+	nodeName: '#document',
+	nodeType: DOCUMENT_NODE,
 	/**
 	 * The DocumentType node of the document.
 	 *
-	 * @readonly
 	 * @type DocumentType
+	 * @readonly
 	 */
-	doctype :  null,
-	documentElement :  null,
-	_inc : 1,
+	doctype: null,
+	documentElement: null,
+	_inc: 1,
 
-	insertBefore :  function(newChild, refChild){//raises
-		if(newChild.nodeType == DOCUMENT_FRAGMENT_NODE){
+	insertBefore: function (newChild, refChild) {
+		//raises
+		if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
 			var child = newChild.firstChild;
-			while(child){
+			while (child) {
 				var next = child.nextSibling;
-				this.insertBefore(child,refChild);
+				this.insertBefore(child, refChild);
 				child = next;
 			}
 			return newChild;
 		}
-		if(this.documentElement == null && newChild.nodeType == ELEMENT_NODE){
+		_insertBefore(this, newChild, refChild);
+		newChild.ownerDocument = this;
+		if (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) {
 			this.documentElement = newChild;
 		}
 
-		return _insertBefore(this,newChild,refChild),(newChild.ownerDocument = this),newChild;
+		return newChild;
 	},
-	removeChild :  function(oldChild){
-		if(this.documentElement == oldChild){
+	removeChild: function (oldChild) {
+		var removed = _removeChild(this, oldChild);
+		if (removed === this.documentElement) {
 			this.documentElement = null;
 		}
-		return _removeChild(this,oldChild);
+		return removed;
+	},
+	replaceChild: function (newChild, oldChild) {
+		//raises
+		_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
+		newChild.ownerDocument = this;
+		if (oldChild) {
+			this.removeChild(oldChild);
+		}
+		if (isElementNode(newChild)) {
+			this.documentElement = newChild;
+		}
 	},
 	// Introduced in DOM Level 2:
-	importNode : function(importedNode,deep){
-		return importNode(this,importedNode,deep);
+	importNode: function (importedNode, deep) {
+		return importNode(this, importedNode, deep);
 	},
 	// Introduced in DOM Level 2:
-	getElementById :	function(id){
+	getElementById: function (id) {
 		var rtv = null;
-		_visitNode(this.documentElement,function(node){
-			if(node.nodeType == ELEMENT_NODE){
-				if(node.getAttribute('id') == id){
+		_visitNode(this.documentElement, function (node) {
+			if (node.nodeType == ELEMENT_NODE) {
+				if (node.getAttribute('id') == id) {
 					rtv = node;
 					return true;
 				}
 			}
-		})
+		});
 		return rtv;
 	},
 
 	/**
-	 * 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
 	 */
-	getElementsByClassName: function(classNames) {
-		var classNamesSet = toOrderedSet(classNames)
-		return new LiveNodeList(this, function(base) {
+	getElementsByClassName: function (classNames) {
+		var classNamesSet = toOrderedSet(classNames);
+		return new LiveNodeList(this, function (base) {
 			var ls = [];
 			if (classNamesSet.length > 0) {
-				_visitNode(base.documentElement, function(node) {
-					if(node !== base && node.nodeType === ELEMENT_NODE) {
-						var nodeClassNames = node.getAttribute('class')
+				_visitNode(base.documentElement, function (node) {
+					if (node !== base && node.nodeType === ELEMENT_NODE) {
+						var nodeClassNames = node.getAttribute('class');
 						// can be null if the attribute does not exist
 						if (nodeClassNames) {
 							// before splitting and iterating just compare them for the most common case
 							var matches = classNames === nodeClassNames;
 							if (!matches) {
-								var nodeClassNamesSet = toOrderedSet(nodeClassNames)
-								matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet))
+								var nodeClassNamesSet = toOrderedSet(nodeClassNames);
+								matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
 							}
-							if(matches) {
+							if (matches) {
 								ls.push(node);
 							}
 						}
@@ -918,65 +1480,64 @@ 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){
+	createElement: function (tagName) {
 		var node = new Element();
 		node.ownerDocument = this;
 		if (this.type === 'html') {
-			tagName = tagName.toLowerCase()
+			tagName = tagName.toLowerCase();
 		}
-		if (MIME_TYPE.hasDefaultHTMLNamespace(this.contentType)) {
-			node.namespaceURI = NAMESPACE.HTML
+		if (hasDefaultHTMLNamespace(this.contentType)) {
+			node.namespaceURI = NAMESPACE.HTML;
 		}
 		node.nodeName = tagName;
 		node.tagName = tagName;
 		node.localName = tagName;
 		node.childNodes = new NodeList();
-		var attrs	= node.attributes = new NamedNodeMap();
+		var attrs = (node.attributes = new NamedNodeMap());
 		attrs._ownerElement = node;
 		return node;
 	},
-	createDocumentFragment :	function(){
+	createDocumentFragment: function () {
 		var node = new DocumentFragment();
 		node.ownerDocument = this;
 		node.childNodes = new NodeList();
 		return node;
 	},
-	createTextNode :	function(data){
+	createTextNode: function (data) {
 		var node = new Text();
 		node.ownerDocument = this;
-		node.appendData(data)
+		node.appendData(data);
 		return node;
 	},
-	createComment :	function(data){
+	createComment: function (data) {
 		var node = new Comment();
 		node.ownerDocument = this;
-		node.appendData(data)
+		node.appendData(data);
 		return node;
 	},
-	createCDATASection :	function(data){
+	createCDATASection: function (data) {
 		var node = new CDATASection();
 		node.ownerDocument = this;
-		node.appendData(data)
+		node.appendData(data);
 		return node;
 	},
-	createProcessingInstruction :	function(target,data){
+	createProcessingInstruction: function (target, data) {
 		var node = new ProcessingInstruction();
 		node.ownerDocument = this;
-		node.tagName = node.target = target;
-		node.nodeValue= node.data = data;
+		node.nodeName = node.target = target;
+		node.nodeValue = node.data = data;
 		return node;
 	},
 	/**
@@ -984,153 +1545,188 @@ 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){
+	createAttribute: function (name) {
+		if (!g.QName_exact.test(name)) {
+			throw new DOMException(INVALID_CHARACTER_ERR, 'invalid character in name "' + name + '"');
+		}
 		if (this.type === 'html') {
-			name = name.toLowerCase()
+			name = name.toLowerCase();
 		}
 		return this._createAttribute(name);
 	},
-	_createAttribute: function(name){
+	_createAttribute: function (name) {
 		var node = new Attr();
 		node.ownerDocument = this;
 		node.name = name;
-		node.nodeName	= name;
+		node.nodeName = name;
 		node.localName = name;
 		node.specified = true;
 		return node;
 	},
-	createEntityReference :	function(name){
+	createEntityReference: function (name) {
 		var node = new EntityReference();
-		node.ownerDocument	= this;
-		node.nodeName	= name;
+		node.ownerDocument = this;
+		node.nodeName = name;
 		return node;
 	},
 	// Introduced in DOM Level 2:
-	createElementNS :	function(namespaceURI,qualifiedName){
+	createElementNS: function (namespaceURI, qualifiedName) {
+		var validated = validateAndExtract(namespaceURI, qualifiedName);
 		var node = new Element();
-		var pl = qualifiedName.split(':');
-		var attrs	= node.attributes = new NamedNodeMap();
+		var attrs = (node.attributes = new NamedNodeMap());
 		node.childNodes = new NodeList();
 		node.ownerDocument = this;
 		node.nodeName = qualifiedName;
 		node.tagName = qualifiedName;
-		node.namespaceURI = namespaceURI;
-		if(pl.length == 2){
-			node.prefix = pl[0];
-			node.localName = pl[1];
-		}else{
-			//el.prefix = null;
-			node.localName = qualifiedName;
-		}
+		node.namespaceURI = validated[0];
+		node.prefix = validated[1];
+		node.localName = validated[2];
 		attrs._ownerElement = node;
 		return node;
 	},
 	// Introduced in DOM Level 2:
-	createAttributeNS :	function(namespaceURI,qualifiedName){
+	createAttributeNS: function (namespaceURI, qualifiedName) {
+		var validated = validateAndExtract(namespaceURI, qualifiedName);
 		var node = new Attr();
 		var pl = qualifiedName.split(':');
 		node.ownerDocument = this;
 		node.nodeName = qualifiedName;
 		node.name = qualifiedName;
-		node.namespaceURI = namespaceURI;
 		node.specified = true;
-		if(pl.length == 2){
-			node.prefix = pl[0];
-			node.localName = pl[1];
-		}else{
-			//el.prefix = null;
-			node.localName = qualifiedName;
-		}
+		node.namespaceURI = validated[0];
+		node.prefix = validated[1];
+		node.localName = validated[2];
 		return node;
-	}
+	},
 };
-_extends(Document,Node);
-
+_extends(Document, Node);
 
 function Element() {
 	this._nsMap = {};
-};
+}
 Element.prototype = {
-	nodeType : ELEMENT_NODE,
+	nodeType: ELEMENT_NODE,
 	getQualifiedName: function () {
-		return this.prefix ? this.prefix+':'+this.localName : this.localName
+		return this.prefix ? this.prefix + ':' + this.localName : this.localName;
 	},
 	_isInHTMLDocumentAndNamespace: function () {
 		return this.ownerDocument.type === 'html' && this.namespaceURI === NAMESPACE.HTML;
 	},
-	hasAttribute : function(name){
-		return this.getAttributeNode(name)!=null;
+	hasAttribute: function (name) {
+		return !!this.getAttributeNode(name);
 	},
-	getAttribute : function(name){
+	/**
+	 * Returns element’s first attribute whose qualified name is `name`, and `null`
+	 * if there is no such attribute.
+	 *
+	 * @param {string} name
+	 * @returns {string | null}
+	 */
+	getAttribute: function (name) {
 		var attr = this.getAttributeNode(name);
-		return attr && attr.value || '';
+		return attr ? attr.value : null;
 	},
-	getAttributeNode : function(name){
+	getAttributeNode: function (name) {
 		if (this._isInHTMLDocumentAndNamespace()) {
-			name = name.toLowerCase()
+			name = name.toLowerCase();
 		}
 		return this.attributes.getNamedItem(name);
 	},
-	setAttribute : function(name, value){
+	/**
+	 * Sets the value of element’s first attribute whose qualified name is qualifiedName to value.
+	 *
+	 * @param {string} name
+	 * @param {string} value
+	 */
+	setAttribute: function (name, value) {
 		if (this._isInHTMLDocumentAndNamespace()) {
-			name = name.toLowerCase()
+			name = name.toLowerCase();
+		}
+		var attr = this.getAttributeNode(name);
+		if (attr) {
+			attr.value = attr.nodeValue = '' + value;
+		} else {
+			attr = this.ownerDocument._createAttribute(name);
+			attr.value = attr.nodeValue = '' + value;
+			this.setAttributeNode(attr);
 		}
-		var attr = this.ownerDocument._createAttribute(name)
-		attr.value = attr.nodeValue = "" + value;
-		this.setAttributeNode(attr)
 	},
-	removeAttribute : function(name){
-		var attr = this.getAttributeNode(name)
+	removeAttribute: function (name) {
+		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);
+	appendChild: function (newChild) {
+		if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
+			return this.insertBefore(newChild, null);
+		} else {
+			return _appendSingleChild(this, newChild);
 		}
 	},
-	setAttributeNode : function(newAttr){
+	setAttributeNode: function (newAttr) {
 		return this.attributes.setNamedItem(newAttr);
 	},
-	setAttributeNodeNS : function(newAttr){
+	setAttributeNodeNS: function (newAttr) {
 		return this.attributes.setNamedItemNS(newAttr);
 	},
-	removeAttributeNode : function(oldAttr){
+	removeAttributeNode: function (oldAttr) {
 		//console.log(this == oldAttr.ownerElement)
 		return this.attributes.removeNamedItem(oldAttr.nodeName);
 	},
 	//get real attribute name,and remove it by removeAttributeNode
-	removeAttributeNS : function(namespaceURI, localName){
+	removeAttributeNS: function (namespaceURI, localName) {
 		var old = this.getAttributeNodeNS(namespaceURI, localName);
 		old && this.removeAttributeNode(old);
 	},
 
-	hasAttributeNS : function(namespaceURI, localName){
-		return this.getAttributeNodeNS(namespaceURI, localName)!=null;
+	hasAttributeNS: function (namespaceURI, localName) {
+		return this.getAttributeNodeNS(namespaceURI, localName) != null;
 	},
-	getAttributeNS : function(namespaceURI, 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
+	 * @returns {string | null}
+	 */
+	getAttributeNS: function (namespaceURI, localName) {
 		var attr = this.getAttributeNodeNS(namespaceURI, localName);
-		return attr && attr.value || '';
+		return attr ? attr.value : null;
 	},
-	setAttributeNS : function(namespaceURI, qualifiedName, value){
-		var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
-		attr.value = attr.nodeValue = "" + value;
-		this.setAttributeNode(attr)
+	/**
+	 * 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) {
+		var validated = validateAndExtract(namespaceURI, qualifiedName);
+		var localName = validated[2];
+		var attr = this.getAttributeNodeNS(namespaceURI, localName);
+		if (attr) {
+			attr.value = attr.nodeValue = '' + value;
+		} else {
+			attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
+			attr.value = attr.nodeValue = '' + value;
+			this.setAttributeNode(attr);
+		}
 	},
-	getAttributeNodeNS : function(namespaceURI, localName){
+	getAttributeNodeNS: function (namespaceURI, localName) {
 		return this.attributes.getNamedItemNS(namespaceURI, localName);
 	},
 
@@ -1145,8 +1741,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.
 	 *
@@ -1154,28 +1750,25 @@ 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
 	 */
-	getElementsByTagName : function(qualifiedName){
-		var isHTMLDocument = (this.nodeType === DOCUMENT_NODE ? this : this.ownerDocument).type === 'html'
-		var lowerQualifiedName = qualifiedName.toLowerCase()
-		return new LiveNodeList(this,function(base){
+	getElementsByTagName: function (qualifiedName) {
+		var isHTMLDocument = (this.nodeType === DOCUMENT_NODE ? this : this.ownerDocument).type === 'html';
+		var lowerQualifiedName = qualifiedName.toLowerCase();
+		return new LiveNodeList(this, function (base) {
 			var ls = [];
-			_visitNode(base, function(node) {
-				if (node === base || node.nodeType !==  ELEMENT_NODE) {
-					return
+			_visitNode(base, function (node) {
+				if (node === base || node.nodeType !== ELEMENT_NODE) {
+					return;
 				}
 				if (qualifiedName === '*') {
 					ls.push(node);
 				} else {
 					var nodeQualifiedName = node.getQualifiedName();
-					var matchingQName = isHTMLDocument && node.namespaceURI === NAMESPACE.HTML
-						? lowerQualifiedName
-						: qualifiedName
-					if(nodeQualifiedName === matchingQName){
+					var matchingQName = isHTMLDocument && node.namespaceURI === NAMESPACE.HTML ? lowerQualifiedName : qualifiedName;
+					if (nodeQualifiedName === matchingQName) {
 						ls.push(node);
 					}
 				}
@@ -1183,149 +1776,141 @@ Element.prototype = {
 			return ls;
 		});
 	},
-	getElementsByTagNameNS : function(namespaceURI, localName){
-		return new LiveNodeList(this,function(base){
+	getElementsByTagNameNS: function (namespaceURI, localName) {
+		return new LiveNodeList(this, function (base) {
 			var ls = [];
-			_visitNode(base,function(node){
-				if(node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === '*' || node.namespaceURI === namespaceURI) && (localName === '*' || node.localName == localName)){
+			_visitNode(base, function (node) {
+				if (
+					node !== base &&
+					node.nodeType === ELEMENT_NODE &&
+					(namespaceURI === '*' || node.namespaceURI === namespaceURI) &&
+					(localName === '*' || node.localName == localName)
+				) {
 					ls.push(node);
 				}
 			});
 			return ls;
-
 		});
-	}
+	},
 };
 Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
 Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
 
-
-_extends(Element,Node);
+_extends(Element, Node);
 function Attr() {
-};
+	this.namespaceURI = null;
+	this.prefix = null;
+	this.ownerElement = null;
+}
 Attr.prototype.nodeType = ATTRIBUTE_NODE;
-_extends(Attr,Node);
-
+_extends(Attr, Node);
 
-function CharacterData() {
-};
+function CharacterData() {}
 CharacterData.prototype = {
-	data : '',
-	substringData : function(offset, count) {
-		return this.data.substring(offset, offset+count);
+	data: '',
+	substringData: function (offset, count) {
+		return this.data.substring(offset, offset + count);
 	},
-	appendData: function(text) {
-		text = this.data+text;
+	appendData: function (text) {
+		text = this.data + text;
 		this.nodeValue = this.data = text;
 		this.length = text.length;
 	},
-	insertData: function(offset,text) {
-		this.replaceData(offset,0,text);
-
+	insertData: function (offset, text) {
+		this.replaceData(offset, 0, text);
 	},
-	appendChild:function(newChild){
-		throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR])
+	appendChild: function (newChild) {
+		throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
 	},
-	deleteData: function(offset, count) {
-		this.replaceData(offset,count,"");
+	deleteData: function (offset, count) {
+		this.replaceData(offset, count, '');
 	},
-	replaceData: function(offset, count, text) {
-		var start = this.data.substring(0,offset);
-		var end = this.data.substring(offset+count);
+	replaceData: function (offset, count, text) {
+		var start = this.data.substring(0, offset);
+		var end = this.data.substring(offset + count);
 		text = start + text + end;
 		this.nodeValue = this.data = text;
 		this.length = text.length;
-	}
-}
-_extends(CharacterData,Node);
-function Text() {
+	},
 };
+_extends(CharacterData, Node);
+function Text() {}
 Text.prototype = {
-	nodeName : "#text",
-	nodeType : TEXT_NODE,
-	splitText : function(offset) {
+	nodeName: '#text',
+	nodeType: TEXT_NODE,
+	splitText: function (offset) {
 		var text = this.data;
 		var newText = text.substring(offset);
 		text = text.substring(0, offset);
 		this.data = this.nodeValue = text;
 		this.length = text.length;
 		var newNode = this.ownerDocument.createTextNode(newText);
-		if(this.parentNode){
+		if (this.parentNode) {
 			this.parentNode.insertBefore(newNode, this.nextSibling);
 		}
 		return newNode;
-	}
-}
-_extends(Text,CharacterData);
-function Comment() {
+	},
 };
+_extends(Text, CharacterData);
+function Comment() {}
 Comment.prototype = {
-	nodeName : "#comment",
-	nodeType : COMMENT_NODE
-}
-_extends(Comment,CharacterData);
-
-function CDATASection() {
+	nodeName: '#comment',
+	nodeType: COMMENT_NODE,
 };
-CDATASection.prototype = {
-	nodeName : "#cdata-section",
-	nodeType : CDATA_SECTION_NODE
-}
-_extends(CDATASection,CharacterData);
-
+_extends(Comment, CharacterData);
 
-function DocumentType() {
+function CDATASection() {}
+CDATASection.prototype = {
+	nodeName: '#cdata-section',
+	nodeType: CDATA_SECTION_NODE,
 };
+_extends(CDATASection, CharacterData);
+
+function DocumentType() {}
 DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
-_extends(DocumentType,Node);
+_extends(DocumentType, Node);
 
-function Notation() {
-};
+function Notation() {}
 Notation.prototype.nodeType = NOTATION_NODE;
-_extends(Notation,Node);
+_extends(Notation, Node);
 
-function Entity() {
-};
+function Entity() {}
 Entity.prototype.nodeType = ENTITY_NODE;
-_extends(Entity,Node);
+_extends(Entity, Node);
 
-function EntityReference() {
-};
+function EntityReference() {}
 EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
-_extends(EntityReference,Node);
-
-function DocumentFragment() {
-};
-DocumentFragment.prototype.nodeName =	"#document-fragment";
-DocumentFragment.prototype.nodeType =	DOCUMENT_FRAGMENT_NODE;
-_extends(DocumentFragment,Node);
+_extends(EntityReference, Node);
 
+function DocumentFragment() {}
+DocumentFragment.prototype.nodeName = '#document-fragment';
+DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
+_extends(DocumentFragment, Node);
 
-function ProcessingInstruction() {
-}
+function ProcessingInstruction() {}
 ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
-_extends(ProcessingInstruction,Node);
-function XMLSerializer(){}
+_extends(ProcessingInstruction, Node);
+function XMLSerializer() {}
 XMLSerializer.prototype.serializeToString = function (node, nodeFilter) {
 	return nodeSerializeToString.call(node, nodeFilter);
-}
+};
 Node.prototype.toString = nodeSerializeToString;
 function nodeSerializeToString(nodeFilter) {
 	var buf = [];
-	var refNode = this.nodeType === DOCUMENT_NODE && this.documentElement || this;
+	var refNode = (this.nodeType === DOCUMENT_NODE && this.documentElement) || this;
 	var prefix = refNode.prefix;
 	var uri = refNode.namespaceURI;
 
-	if(uri && prefix == null){
+	if (uri && prefix == null) {
 		var prefix = refNode.lookupPrefix(uri);
-		if(prefix == null){
-			var visibleNamespaces=[
-			{namespace:uri,prefix:null}
-			//{namespace:uri,prefix:''}
-			]
+		if (prefix == null) {
+			var visibleNamespaces = [
+				{ namespace: uri, prefix: null },
+				//{namespace:uri,prefix:''}
+			];
 		}
 	}
-	serializeToString(this,buf,nodeFilter,visibleNamespaces);
+	serializeToString(this, buf, nodeFilter, visibleNamespaces);
 	return buf.join('');
 }
 
@@ -1342,11 +1927,11 @@ function needNamespaceDefine(node, isHTML, visibleNamespaces) {
 	if (!uri) {
 		return false;
 	}
-	if (prefix === "xml" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {
+	if ((prefix === 'xml' && uri === NAMESPACE.XML) || uri === NAMESPACE.XMLNS) {
 		return false;
 	}
 
-	var i = visibleNamespaces.length
+	var i = visibleNamespaces.length;
 	while (i--) {
 		var ns = visibleNamespaces[i];
 		// get namespace prefix
@@ -1357,247 +1942,249 @@ 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), '"')
+	buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
 }
 
-function serializeToString (node, buf, nodeFilter, visibleNamespaces) {
+function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
 	if (!visibleNamespaces) {
 		visibleNamespaces = [];
 	}
-	var doc = node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument
-	var isHTML = doc.type === 'html'
+	var doc = node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
+	var isHTML = doc.type === 'html';
 
-	if(nodeFilter){
+	if (nodeFilter) {
 		node = nodeFilter(node);
-		if(node){
-			if(typeof node == 'string'){
+		if (node) {
+			if (typeof node == 'string') {
 				buf.push(node);
 				return;
 			}
-		}else{
+		} else {
 			return;
 		}
 		//buf.sort.apply(attrs, attributeSorter);
 	}
 
-	switch(node.nodeType){
-	case ELEMENT_NODE:
-		var attrs = node.attributes;
-		var len = attrs.length;
-		var child = node.firstChild;
-		var nodeName = node.tagName;
-
-		var prefixedNodeName = nodeName
-		if (!isHTML && !node.prefix && node.namespaceURI) {
-			var defaultNS
-			// lookup current default ns from `xmlns` attribute
-			for (var ai = 0; ai < attrs.length; ai++) {
-				if (attrs.item(ai).name === 'xmlns') {
-					defaultNS = attrs.item(ai).value
-					break
+	switch (node.nodeType) {
+		case ELEMENT_NODE:
+			var attrs = node.attributes;
+			var len = attrs.length;
+			var child = node.firstChild;
+			var nodeName = node.tagName;
+
+			var prefixedNodeName = nodeName;
+			if (!isHTML && !node.prefix && node.namespaceURI) {
+				var defaultNS;
+				// lookup current default ns from `xmlns` attribute
+				for (var ai = 0; ai < attrs.length; ai++) {
+					if (attrs.item(ai).name === 'xmlns') {
+						defaultNS = attrs.item(ai).value;
+						break;
+					}
 				}
-			}
-			if (!defaultNS) {
-				// lookup current default ns in visibleNamespaces
-				for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
-					var namespace = visibleNamespaces[nsi]
-					if (namespace.prefix === '' && namespace.namespace === node.namespaceURI) {
-						defaultNS = namespace.namespace
-						break
+				if (!defaultNS) {
+					// lookup current default ns in visibleNamespaces
+					for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+						var namespace = visibleNamespaces[nsi];
+						if (namespace.prefix === '' && namespace.namespace === node.namespaceURI) {
+							defaultNS = namespace.namespace;
+							break;
+						}
 					}
 				}
-			}
-			if (defaultNS !== node.namespaceURI) {
-				for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
-					var namespace = visibleNamespaces[nsi]
-					if (namespace.namespace === node.namespaceURI) {
-						if (namespace.prefix) {
-							prefixedNodeName = namespace.prefix + ':' + nodeName
+				if (defaultNS !== node.namespaceURI) {
+					for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+						var namespace = visibleNamespaces[nsi];
+						if (namespace.namespace === node.namespaceURI) {
+							if (namespace.prefix) {
+								prefixedNodeName = namespace.prefix + ':' + nodeName;
+							}
+							break;
 						}
-						break
 					}
 				}
 			}
-		}
-
-		buf.push('<', prefixedNodeName);
 
-		for(var i=0;i<len;i++){
-			// add namespaces for attributes
-			var attr = attrs.item(i);
-			if (attr.prefix == 'xmlns') {
-				visibleNamespaces.push({ prefix: attr.localName, namespace: attr.value });
-			}else if(attr.nodeName == 'xmlns'){
-				visibleNamespaces.push({ prefix: '', namespace: attr.value });
+			buf.push('<', prefixedNodeName);
+
+			for (var i = 0; i < len; i++) {
+				// add namespaces for attributes
+				var attr = attrs.item(i);
+				if (attr.prefix == 'xmlns') {
+					visibleNamespaces.push({
+						prefix: attr.localName,
+						namespace: attr.value,
+					});
+				} else if (attr.nodeName == 'xmlns') {
+					visibleNamespaces.push({ prefix: '', namespace: attr.value });
+				}
 			}
-		}
 
-		for(var i=0;i<len;i++){
-			var attr = attrs.item(i);
-			if (needNamespaceDefine(attr,isHTML, visibleNamespaces)) {
-				var prefix = attr.prefix||'';
-				var uri = attr.namespaceURI;
-				addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : "xmlns", uri);
-				visibleNamespaces.push({ prefix: prefix, namespace:uri });
+			for (var i = 0; i < len; i++) {
+				var attr = attrs.item(i);
+				if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {
+					var prefix = attr.prefix || '';
+					var uri = attr.namespaceURI;
+					addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : 'xmlns', uri);
+					visibleNamespaces.push({ prefix: prefix, namespace: uri });
+				}
+				serializeToString(attr, buf, nodeFilter, visibleNamespaces);
 			}
-			serializeToString(attr,buf,nodeFilter,visibleNamespaces);
-		}
 
-		// add namespace for current node
-		if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
-			var prefix = node.prefix||'';
-			var uri = node.namespaceURI;
-			addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : "xmlns", uri);
-			visibleNamespaces.push({ prefix: prefix, namespace:uri });
-		}
-		// in XML elements can be closed when they have no children
-		var canCloseTag = !child;
-		if (canCloseTag && (isHTML || NAMESPACE.isHTML(node.namespaceURI))) {
-			// in HTML (doc or ns) only void elements can be closed right away
-			canCloseTag = isHTMLVoidElement(nodeName)
-		}
-		if (canCloseTag) {
-			buf.push("/>");
-		} else {
-			buf.push(">");
-			//if is cdata child node
-			if (isHTML && isHTMLRawTextElement(nodeName)) {
-				while(child){
-					if(child.data){
-						buf.push(child.data);
-					}else{
+			// add namespace for current node
+			if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
+				var prefix = node.prefix || '';
+				var uri = node.namespaceURI;
+				addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : 'xmlns', uri);
+				visibleNamespaces.push({ prefix: prefix, namespace: uri });
+			}
+			// in XML elements can be closed when they have no children
+			var canCloseTag = !child;
+			if (canCloseTag && (isHTML || node.namespaceURI === NAMESPACE.HTML)) {
+				// in HTML (doc or ns) only void elements can be closed right away
+				canCloseTag = isHTMLVoidElement(nodeName);
+			}
+			if (canCloseTag) {
+				buf.push('/>');
+			} else {
+				buf.push('>');
+				//if is cdata child node
+				if (isHTML && isHTMLRawTextElement(nodeName)) {
+					while (child) {
+						if (child.data) {
+							buf.push(child.data);
+						} else {
+							serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
+						}
+						child = child.nextSibling;
+					}
+				} else {
+					while (child) {
 						serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
+						child = child.nextSibling;
 					}
-					child = child.nextSibling;
 				}
-			} else {
-				while(child){
-					serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
-					child = child.nextSibling;
+				buf.push('</', prefixedNodeName, '>');
+			}
+			// remove added visible namespaces
+			//visibleNamespaces.length = startVisibleNamespaces;
+			return;
+		case DOCUMENT_NODE:
+		case DOCUMENT_FRAGMENT_NODE:
+			var child = node.firstChild;
+			while (child) {
+				serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
+				child = child.nextSibling;
+			}
+			return;
+		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,
+			 * 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, `]]>`.
+			 *
+			 * @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(g.CDATA_START, node.data, g.CDATA_END);
+		case COMMENT_NODE:
+			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(g.DOCTYPE_DECL_START, ' ', node.name);
+			if (pubid) {
+				buf.push(' ', g.PUBLIC, ' ', pubid);
+				if (sysid && sysid !== '.') {
+					buf.push(' ', sysid);
 				}
+			} else if (sysid && sysid !== '.') {
+				buf.push(' ', g.SYSTEM, ' ', sysid);
 			}
-			buf.push("</", prefixedNodeName, ">");
-		}
-		// remove added visible namespaces
-		//visibleNamespaces.length = startVisibleNamespaces;
-		return;
-	case DOCUMENT_NODE:
-	case DOCUMENT_FRAGMENT_NODE:
-		var child = node.firstChild;
-		while(child){
-			serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
-			child = child.nextSibling;
-		}
-		return;
-	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,
-		 * 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, `]]>`.
-		 *
-		 * @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,']]>');
-	case COMMENT_NODE:
-		return buf.push( "<!--",node.data,"-->");
-	case DOCUMENT_TYPE_NODE:
-		var pubid = node.publicId;
-		var sysid = node.systemId;
-		buf.push('<!DOCTYPE ',node.name);
-		if(pubid){
-			buf.push(' PUBLIC ', pubid);
-			if (sysid && sysid!='.') {
-				buf.push(' ', sysid);
+			if (node.internalSubset) {
+				buf.push(' [', node.internalSubset, ']');
 			}
 			buf.push('>');
-		}else if(sysid && sysid!='.'){
-			buf.push(' SYSTEM ', sysid, '>');
-		}else{
-			var sub = node.internalSubset;
-			if(sub){
-				buf.push(" [",sub,"]");
-			}
-			buf.push(">");
-		}
-		return;
-	case PROCESSING_INSTRUCTION_NODE:
-		return buf.push( "<?",node.target," ",node.data,"?>");
-	case ENTITY_REFERENCE_NODE:
-		return buf.push( '&',node.nodeName,';');
-	//case ENTITY_NODE:
-	//case NOTATION_NODE:
-	default:
-		buf.push('??',node.nodeName);
+			return;
+		case PROCESSING_INSTRUCTION_NODE:
+			return buf.push('<?', node.target, ' ', node.data, '?>');
+		case ENTITY_REFERENCE_NODE:
+			return buf.push('&', node.nodeName, ';');
+		//case ENTITY_NODE:
+		//case NOTATION_NODE:
+		default:
+			buf.push('??', node.nodeName);
 	}
 }
-function importNode(doc,node,deep){
+function importNode(doc, node, deep) {
 	var node2;
 	switch (node.nodeType) {
-	case ELEMENT_NODE:
-		node2 = node.cloneNode(false);
-		node2.ownerDocument = doc;
+		case ELEMENT_NODE:
+			node2 = node.cloneNode(false);
+			node2.ownerDocument = doc;
 		//var attrs = node2.attributes;
 		//var len = attrs.length;
 		//for(var i=0;i<len;i++){
-			//node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
+		//node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
 		//}
-	case DOCUMENT_FRAGMENT_NODE:
-		break;
-	case ATTRIBUTE_NODE:
-		deep = true;
-		break;
-	//case ENTITY_REFERENCE_NODE:
-	//case PROCESSING_INSTRUCTION_NODE:
-	////case TEXT_NODE:
-	//case CDATA_SECTION_NODE:
-	//case COMMENT_NODE:
-	//	deep = false;
-	//	break;
-	//case DOCUMENT_NODE:
-	//case DOCUMENT_TYPE_NODE:
-	//cannot be imported.
-	//case ENTITY_NODE:
-	//case NOTATION_NODE：
-	//can not hit in level3
-	//default:throw e;
+		case DOCUMENT_FRAGMENT_NODE:
+			break;
+		case ATTRIBUTE_NODE:
+			deep = true;
+			break;
+		//case ENTITY_REFERENCE_NODE:
+		//case PROCESSING_INSTRUCTION_NODE:
+		////case TEXT_NODE:
+		//case CDATA_SECTION_NODE:
+		//case COMMENT_NODE:
+		//	deep = false;
+		//	break;
+		//case DOCUMENT_NODE:
+		//case DOCUMENT_TYPE_NODE:
+		//cannot be imported.
+		//case ENTITY_NODE:
+		//case NOTATION_NODE：
+		//can not hit in level3
+		//default:throw e;
 	}
-	if(!node2){
-		node2 = node.cloneNode(false);//false
+	if (!node2) {
+		node2 = node.cloneNode(false); //false
 	}
 	node2.ownerDocument = doc;
 	node2.parentNode = null;
-	if(deep){
+	if (deep) {
 		var child = node.firstChild;
-		while(child){
-			node2.appendChild(importNode(doc,child,deep));
+		while (child) {
+			node2.appendChild(importNode(doc, child, deep));
 			child = child.nextSibling;
 		}
 	}
@@ -1606,112 +2193,119 @@ function importNode(doc,node,deep){
 //
 //var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,
 //					attributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};
-function cloneNode(doc,node,deep){
+function cloneNode(doc, node, deep) {
 	var node2 = new node.constructor();
-	for(var n in node){
-		var v = node[n];
-		if(typeof v != 'object' ){
-			if(v != node2[n]){
-				node2[n] = v;
+	for (var n in node) {
+		if (Object.prototype.hasOwnProperty.call(node, n)) {
+			var v = node[n];
+			if (typeof v != 'object') {
+				if (v != node2[n]) {
+					node2[n] = v;
+				}
 			}
 		}
 	}
-	if(node.childNodes){
+	if (node.childNodes) {
 		node2.childNodes = new NodeList();
 	}
 	node2.ownerDocument = doc;
 	switch (node2.nodeType) {
-	case ELEMENT_NODE:
-		var attrs	= node.attributes;
-		var attrs2	= node2.attributes = new NamedNodeMap();
-		var len = attrs.length
-		attrs2._ownerElement = node2;
-		for(var i=0;i<len;i++){
-			node2.setAttributeNode(cloneNode(doc,attrs.item(i),true));
-		}
-		break;;
-	case ATTRIBUTE_NODE:
-		deep = true;
+		case ELEMENT_NODE:
+			var attrs = node.attributes;
+			var attrs2 = (node2.attributes = new NamedNodeMap());
+			var len = attrs.length;
+			attrs2._ownerElement = node2;
+			for (var i = 0; i < len; i++) {
+				node2.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+			}
+			break;
+		case ATTRIBUTE_NODE:
+			deep = true;
 	}
-	if(deep){
+	if (deep) {
 		var child = node.firstChild;
-		while(child){
-			node2.appendChild(cloneNode(doc,child,deep));
+		while (child) {
+			node2.appendChild(cloneNode(doc, child, deep));
 			child = child.nextSibling;
 		}
 	}
 	return node2;
 }
 
-function __set__(object,key,value){
-	object[key] = value
+function __set__(object, key, value) {
+	object[key] = value;
 }
 //do dynamic
-try{
-	if(Object.defineProperty){
-		Object.defineProperty(LiveNodeList.prototype,'length',{
-			get:function(){
+try {
+	if (Object.defineProperty) {
+		Object.defineProperty(LiveNodeList.prototype, 'length', {
+			get: function () {
 				_updateLiveList(this);
 				return this.$$length;
-			}
+			},
 		});
 
-		Object.defineProperty(Node.prototype,'textContent',{
-			get:function(){
+		Object.defineProperty(Node.prototype, 'textContent', {
+			get: function () {
 				return getTextContent(this);
 			},
 
-			set:function(data){
-				switch(this.nodeType){
+			set: function (data) {
+				switch (this.nodeType) {
+					case ELEMENT_NODE:
+					case DOCUMENT_FRAGMENT_NODE:
+						while (this.firstChild) {
+							this.removeChild(this.firstChild);
+						}
+						if (data || String(data)) {
+							this.appendChild(this.ownerDocument.createTextNode(data));
+						}
+						break;
+
+					default:
+						this.data = data;
+						this.value = data;
+						this.nodeValue = data;
+				}
+			},
+		});
+
+		function getTextContent(node) {
+			switch (node.nodeType) {
 				case ELEMENT_NODE:
 				case DOCUMENT_FRAGMENT_NODE:
-					while(this.firstChild){
-						this.removeChild(this.firstChild);
-					}
-					if(data || String(data)){
-						this.appendChild(this.ownerDocument.createTextNode(data));
+					var buf = [];
+					node = node.firstChild;
+					while (node) {
+						if (node.nodeType !== 7 && node.nodeType !== 8) {
+							buf.push(getTextContent(node));
+						}
+						node = node.nextSibling;
 					}
-					break;
-
+					return buf.join('');
 				default:
-					this.data = data;
-					this.value = data;
-					this.nodeValue = data;
-				}
-			}
-		})
-
-		function getTextContent(node){
-			switch(node.nodeType){
-			case ELEMENT_NODE:
-			case DOCUMENT_FRAGMENT_NODE:
-				var buf = [];
-				node = node.firstChild;
-				while(node){
-					if(node.nodeType!==7 && node.nodeType !==8){
-						buf.push(getTextContent(node));
-					}
-					node = node.nextSibling;
-				}
-				return buf.join('');
-			default:
-				return node.nodeValue;
+					return node.nodeValue;
 			}
 		}
 
-		__set__ = function(object,key,value){
+		__set__ = function (object, key, value) {
 			//console.log(value)
-			object['$$'+key] = value
-		}
+			object['$$' + key] = value;
+		};
 	}
-}catch(e){//ie8
+} catch (e) {
+	//ie8
 }
 
+exports._updateLiveList = _updateLiveList;
+exports.Attr = Attr;
 exports.Document = Document;
 exports.DocumentType = DocumentType;
 exports.DOMException = DOMException;
 exports.DOMImplementation = DOMImplementation;
 exports.Element = Element;
+exports.LiveNodeList = LiveNodeList;
+exports.NamedNodeMap = NamedNodeMap;
 exports.Node = Node;
 exports.NodeList = NodeList;
 exports.XMLSerializer = XMLSerializer;