@xmldom/xmldom 0.8.2 → 0.9.0-beta.1

package/lib/dom.js

@@ -1,5 +1,7 @@
 var conventions = require("./conventions");
-
+var isHTMLRawTextElement = conventions.isHTMLRawTextElement;
+var isHTMLVoidElement = conventions.isHTMLVoidElement;
+var MIME_TYPE = conventions.MIME_TYPE;
 var NAMESPACE = conventions.NAMESPACE;
 
 /**
@@ -156,23 +158,23 @@ NodeList.prototype = {
 	 * 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 
+	 * @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. 
+	 * 	The node at the indexth position in the NodeList, or null if that is not a valid index.
 	 */
 	item: function(index) {
 		return this[index] || null;
 	},
-	toString:function(isHTML,nodeFilter){
+	toString: function (nodeFilter) {
 		for(var buf = [], i = 0;i<this.length;i++){
-			serializeToString(this[i],buf,isHTML,nodeFilter);
+			serializeToString(this[i], buf, nodeFilter)
 		}
-		return buf.join('');
+		return buf.join('')
 	}
 };
 
@@ -207,7 +209,7 @@ _extends(LiveNodeList,NodeList);
  * 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 
+ * used for attributes or DocumentType entities
  */
 function NamedNodeMap() {
 };
@@ -296,10 +298,10 @@ NamedNodeMap.prototype = {
 		var attr = this.getNamedItem(key);
 		_removeNamedNode(this._ownerElement,this,attr);
 		return attr;
-		
-		
+
+
 	},// raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
-	
+
 	//for level2
 	removeNamedItemNS:function(namespaceURI,localName){
 		var attr = this.getNamedItemNS(namespaceURI,localName);
@@ -359,15 +361,17 @@ DOMImplementation.prototype = {
 	 * 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.
-	 * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.
-	 * - this implementation is not validating names or qualified names
-	 *   (when parsing XML strings, the SAX parser takes care of that)
+	 * - 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 | null} namespaceURI
 	 * @param {string} qualifiedName
-	 * @param {DocumentType=null} doctype
-	 * @returns {Document}
+	 * @param {DocumentType | null} [doctype=null]
+	 * @returns {Document} the XML document
+	 *
+	 * @see #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)
@@ -378,7 +382,13 @@ DOMImplementation.prototype = {
 	 * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
 	 */
 	createDocument: function(namespaceURI,  qualifiedName, doctype){
-		var doc = new Document();
+		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
+		}
+		var doc = new Document({contentType: contentType});
 		doc.implementation = this;
 		doc.childNodes = new NodeList();
 		doc.doctype = doctype || null;
@@ -397,6 +407,7 @@ DOMImplementation.prototype = {
 	 * __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.
 	 *
 	 * @param {string} qualifiedName
 	 * @param {string} [publicId]
@@ -420,6 +431,40 @@ DOMImplementation.prototype = {
 		node.systemId = systemId || '';
 
 		return node;
+	},
+	/**
+	 * 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)
+	 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+	 *
+	 * @param {string | false} [title]
+	 * @returns {Document} The HTML document
+	 *
+	 * @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()
+		if (title !== false) {
+			doc.doctype = this.createDocumentType('html')
+			doc.doctype.ownerDocument = this;
+			doc.appendChild(doc.doctype);
+			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)
+			}
+			htmlNode.appendChild(doc.createElement('body'))
+		}
+		return doc
 	}
 };
 
@@ -427,7 +472,6 @@ DOMImplementation.prototype = {
 /**
  * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
  */
-
 function Node() {
 };
 
@@ -445,10 +489,10 @@ Node.prototype = {
 	prefix : null,
 	localName : null,
 	// Modified in DOM Level 2:
-	insertBefore:function(newChild, refChild){//raises 
+	insertBefore:function(newChild, refChild){//raises
 		return _insertBefore(this,newChild,refChild);
 	},
-	replaceChild:function(newChild, oldChild){//raises 
+	replaceChild:function(newChild, oldChild){//raises
 		this.insertBefore(newChild,oldChild);
 		if(oldChild){
 			this.removeChild(oldChild);
@@ -568,9 +612,48 @@ function _visitNode(node,callback){
     }
 }
 
-
-
-function Document(){
+/**
+ * @typedef DocumentOptions
+ * @property {string} [contentType=MIME_TYPE.XML_APPLICATION]
+ */
+/**
+ * The Document interface describes the common properties and methods for any kind of document.
+ *
+ * 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.
+ *
+ * @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){
+	var opt = options || {};
+	/**
+	 * 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
+	 */
+	this.contentType = opt.contentType || MIME_TYPE.XML_APPLICATION
+	/**
+	 *
+	 * @type {'html' | 'xml'}
+	 * @readonly
+	 *
+	 * @see https://dom.spec.whatwg.org/#concept-document-type
+	 * @see DOMImplementation
+	 */
+	this.type = MIME_TYPE.isHTML(this.contentType) ? 'html' : 'xml'
 }
 
 function _onAddAttribute(doc,el,newAttr){
@@ -675,8 +758,8 @@ function _insertBefore(parentNode,newChild,nextChild){
 
 	newFirst.previousSibling = pre;
 	newLast.nextSibling = nextChild;
-	
-	
+
+
 	if(pre){
 		pre.nextSibling = newFirst;
 	}else{
@@ -727,7 +810,12 @@ function _appendSingleChild (parentNode, newChild) {
 }
 
 Document.prototype = {
-	//implementation : null,
+	/**
+	 * The implementation that created this document
+	 * @readonly
+	 * @type DOMImplementation
+	 */
+	implementation : null,
 	nodeName :  '#document',
 	nodeType :  DOCUMENT_NODE,
 	/**
@@ -824,10 +912,34 @@ Document.prototype = {
 		});
 	},
 
-	//document factory method:
+	/**
+	 * Creates a new `Element` that is owned by this `Document`.
+	 * In HTML Documents `localName` is the lower cased `tagName`,
+	 * 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.
+	 * - 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}
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createElement
+	 * @see https://dom.spec.whatwg.org/#dom-document-createelement
+	 * @see https://dom.spec.whatwg.org/#concept-create-element
+	 */
 	createElement :	function(tagName){
 		var node = new Element();
 		node.ownerDocument = this;
+		if (this.type === 'html') {
+			tagName = tagName.toLowerCase()
+		}
+		if (MIME_TYPE.hasDefaultHTMLNamespace(this.contentType)) {
+			node.namespaceURI = NAMESPACE.HTML
+		}
 		node.nodeName = tagName;
 		node.tagName = tagName;
 		node.localName = tagName;
@@ -867,9 +979,30 @@ Document.prototype = {
 		node.nodeValue= node.data = data;
 		return node;
 	},
-	createAttribute :	function(name){
+	/**
+	 * Creates an `Attr` node that is owned by this document.
+	 * 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.
+	 *
+	 * @param {string} name
+	 * @return {Attr}
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createAttribute
+	 * @see https://dom.spec.whatwg.org/#dom-document-createattribute
+	 */
+	createAttribute: function(name){
+		if (this.type === 'html') {
+			name = name.toLowerCase()
+		}
+		return this._createAttribute(name);
+	},
+	_createAttribute: function(name){
 		var node = new Attr();
-		node.ownerDocument	= this;
+		node.ownerDocument = this;
 		node.name = name;
 		node.nodeName	= name;
 		node.localName = name;
@@ -929,6 +1062,12 @@ function Element() {
 };
 Element.prototype = {
 	nodeType : ELEMENT_NODE,
+	getQualifiedName: function () {
+		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;
 	},
@@ -937,10 +1076,16 @@ Element.prototype = {
 		return attr && attr.value || '';
 	},
 	getAttributeNode : function(name){
+		if (this._isInHTMLDocumentAndNamespace()) {
+			name = name.toLowerCase()
+		}
 		return this.attributes.getNamedItem(name);
 	},
 	setAttribute : function(name, value){
-		var attr = this.ownerDocument.createAttribute(name);
+		if (this._isInHTMLDocumentAndNamespace()) {
+			name = name.toLowerCase()
+		}
+		var attr = this.ownerDocument._createAttribute(name)
 		attr.value = attr.nodeValue = "" + value;
 		this.setAttributeNode(attr)
 	},
@@ -948,8 +1093,8 @@ Element.prototype = {
 		var attr = this.getAttributeNode(name)
 		attr && this.removeAttributeNode(attr);
 	},
-	
-	//four real opeartion method
+
+	// four real operation method
 	appendChild:function(newChild){
 		if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
 			return this.insertBefore(newChild,null);
@@ -972,7 +1117,7 @@ Element.prototype = {
 		var old = this.getAttributeNodeNS(namespaceURI, localName);
 		old && this.removeAttributeNode(old);
 	},
-	
+
 	hasAttributeNS : function(namespaceURI, localName){
 		return this.getAttributeNodeNS(namespaceURI, localName)!=null;
 	},
@@ -988,13 +1133,51 @@ Element.prototype = {
 	getAttributeNodeNS : function(namespaceURI, localName){
 		return this.attributes.getNamedItemNS(namespaceURI, localName);
 	},
-	
-	getElementsByTagName : function(tagName){
+
+	/**
+	 * Returns a LiveNodeList of elements with the given qualifiedName.
+	 * Searching for all descendants can be done by passing `*` as `qualifiedName`.
+	 *
+	 * All descendants of the specified element are searched, but not the element itself.
+	 * The returned list is live, which means it updates itself with the DOM tree automatically.
+	 * Therefore, there is no need to call `Element.getElementsByTagName()`
+	 * with the same element and arguments repeatedly if the DOM changes in between calls.
+	 *
+	 * 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.
+	 * Instead, use `Element.getElementsByTagNameNS()`,
+	 * which preserves the capitalization of the tag name.
+	 *
+	 * `Element.getElementsByTagName` is similar to `Document.getElementsByTagName()`,
+	 * except that it only searches for elements that are descendants of the specified element.
+	 *
+	 * @param {string} qualifiedName
+	 * @return {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){
 			var ls = [];
-			_visitNode(base,function(node){
-				if(node !== base && node.nodeType == ELEMENT_NODE && (tagName === '*' || node.tagName == tagName)){
+			_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){
+						ls.push(node);
+					}
 				}
 			});
 			return ls;
@@ -1009,7 +1192,7 @@ Element.prototype = {
 				}
 			});
 			return ls;
-			
+
 		});
 	}
 };
@@ -1038,7 +1221,7 @@ CharacterData.prototype = {
 	},
 	insertData: function(offset,text) {
 		this.replaceData(offset,0,text);
-	
+
 	},
 	appendChild:function(newChild){
 		throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR])
@@ -1123,29 +1306,26 @@ function ProcessingInstruction() {
 ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
 _extends(ProcessingInstruction,Node);
 function XMLSerializer(){}
-XMLSerializer.prototype.serializeToString = function(node,isHtml,nodeFilter){
-	return nodeSerializeToString.call(node,isHtml,nodeFilter);
+XMLSerializer.prototype.serializeToString = function (node, nodeFilter) {
+	return nodeSerializeToString.call(node, nodeFilter);
 }
 Node.prototype.toString = nodeSerializeToString;
-function nodeSerializeToString(isHtml,nodeFilter){
+function nodeSerializeToString(nodeFilter) {
 	var buf = [];
-	var refNode = this.nodeType == 9 && this.documentElement || this;
+	var refNode = this.nodeType === DOCUMENT_NODE && this.documentElement || this;
 	var prefix = refNode.prefix;
 	var uri = refNode.namespaceURI;
-	
+
 	if(uri && prefix == null){
-		//console.log(prefix)
 		var prefix = refNode.lookupPrefix(uri);
 		if(prefix == null){
-			//isHTML = true;
 			var visibleNamespaces=[
 			{namespace:uri,prefix:null}
 			//{namespace:uri,prefix:''}
 			]
 		}
 	}
-	serializeToString(this,buf,isHtml,nodeFilter,visibleNamespaces);
-	//console.log('###',this.nodeType,uri,prefix,buf.join(''))
+	serializeToString(this,buf,nodeFilter,visibleNamespaces);
 	return buf.join('');
 }
 
@@ -1165,8 +1345,8 @@ function needNamespaceDefine(node, isHTML, visibleNamespaces) {
 	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
@@ -1193,10 +1373,12 @@ function addSerializedAttribute(buf, qualifiedName, value) {
 	buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"')
 }
 
-function serializeToString(node,buf,isHTML,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'
 
 	if(nodeFilter){
 		node = nodeFilter(node);
@@ -1217,8 +1399,6 @@ function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
 		var len = attrs.length;
 		var child = node.firstChild;
 		var nodeName = node.tagName;
-		
-		isHTML = NAMESPACE.isHTML(node.namespaceURI) || isHTML
 
 		var prefixedNodeName = nodeName
 		if (!isHTML && !node.prefix && node.namespaceURI) {
@@ -1273,39 +1453,43 @@ function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
 				addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : "xmlns", uri);
 				visibleNamespaces.push({ prefix: prefix, namespace:uri });
 			}
-			serializeToString(attr,buf,isHTML,nodeFilter,visibleNamespaces);
+			serializeToString(attr,buf,nodeFilter,visibleNamespaces);
 		}
 
-		// add namespace for current node		
+		// 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 });
 		}
-		
-		if(child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)){
-			buf.push('>');
+		// 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 && /^script$/i.test(nodeName)){
+			if (isHTML && isHTMLRawTextElement(nodeName)) {
 				while(child){
 					if(child.data){
 						buf.push(child.data);
 					}else{
-						serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+						serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
 					}
 					child = child.nextSibling;
 				}
-			}else
-			{
+			} else {
 				while(child){
-					serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+					serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
 					child = child.nextSibling;
 				}
 			}
-			buf.push('</',prefixedNodeName,'>');
-		}else{
-			buf.push('/>');
+			buf.push("</", prefixedNodeName, ">");
 		}
 		// remove added visible namespaces
 		//visibleNamespaces.length = startVisibleNamespaces;
@@ -1314,7 +1498,7 @@ function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
 	case DOCUMENT_FRAGMENT_NODE:
 		var child = node.firstChild;
 		while(child){
-			serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+			serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
 			child = child.nextSibling;
 		}
 		return;
@@ -1496,7 +1680,7 @@ try{
 				}
 			}
 		})
-		
+
 		function getTextContent(node){
 			switch(node.nodeType){
 			case ELEMENT_NODE:
@@ -1523,12 +1707,11 @@ try{
 }catch(e){//ie8
 }
 
-//if(typeof require == 'function'){
-	exports.DocumentType = DocumentType;
-	exports.DOMException = DOMException;
-	exports.DOMImplementation = DOMImplementation;
-	exports.Element = Element;
-	exports.Node = Node;
-	exports.NodeList = NodeList;
-	exports.XMLSerializer = XMLSerializer;
-//}
+exports.Document = Document;
+exports.DocumentType = DocumentType;
+exports.DOMException = DOMException;
+exports.DOMImplementation = DOMImplementation;
+exports.Element = Element;
+exports.Node = Node;
+exports.NodeList = NodeList;
+exports.XMLSerializer = XMLSerializer;

package/lib/entities.js

@@ -1,3 +1,5 @@
+'use strict'
+
 var freeze = require('./conventions').freeze;
 
 /**

package/lib/index.js

@@ -1,3 +1,5 @@
+'use strict'
+
 var dom = require('./dom')
 exports.DOMImplementation = dom.DOMImplementation
 exports.XMLSerializer = dom.XMLSerializer