@xmldom/xmldom 0.9.0-beta.7 → 0.9.0-beta.9

package/lib/dom-parser.js

@@ -7,10 +7,13 @@ var sax = require('./sax');
 
 var DOMImplementation = dom.DOMImplementation;
 
+var hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;
+var isHTMLMimeType = conventions.isHTMLMimeType;
+var isValidMimeType = conventions.isValidMimeType;
 var MIME_TYPE = conventions.MIME_TYPE;
 var NAMESPACE = conventions.NAMESPACE;
+var ParseError = conventions.ParseError;
 
-var ParseError = sax.ParseError;
 var XMLReader = sax.XMLReader;
 
 /**
@@ -51,8 +54,23 @@ function normalizeLineEndings(input) {
  * which is used to copy values from the options before they are used for parsing.
  * @property {typeof DOMHandler} [domHandler]
  * For internal testing: The class for creating an instance for handling events from the SAX parser.
- * Warning: By configuring a faulty implementation, the specified behavior can completely be broken.
+ * __**Warning: By configuring a faulty implementation,
+ * the specified behavior can completely be broken.**__
+ *
  * @property {Function} [errorHandler]
+ * DEPRECATED! use `onError` instead.
+ * @property {function(level:ErrorLevel, message:string, context: DOMHandler):void} [onError]
+ * A function that is invoked for every error that occurs during parsing.
+ *
+ * If it is not provided, all errors are reported to `console.error`
+ * and only `fatalError`s are thrown as a `ParseError`,
+ * which prevents any further processing.
+ * If the provided method throws, a `ParserError` is thrown,
+ * which prevents any further processing.
+ *
+ * Be aware that many `warning`s are considered an error
+ * that prevents further processing in most implementations.
+ *.
  * @property {boolean} [locator=true]
  * Configures if the nodes created during parsing
  * will have a `lineNumber` and a `columnNumber` attribute
@@ -87,7 +105,7 @@ function DOMParser(options) {
 	options = options || { locator: true };
 
 	/**
-	 * The method to use instead of `Object.assign` (or if not available `conventions.assign`),
+	 * The method to use instead of `Object.assign` (defaults to or `conventions.assign`),
 	 * which is used to copy values from the options before they are used for parsing.
 	 *
 	 * @type {function (target: object, source: object | null | undefined): object}
@@ -95,7 +113,7 @@ function DOMParser(options) {
 	 * @private
 	 * @see conventions.assign
 	 */
-	this.assign = options.assign || Object.assign || conventions.assign;
+	this.assign = options.assign || conventions.assign;
 
 	/**
 	 * For internal testing: The class for creating an instance for handling events from the SAX parser.
@@ -108,11 +126,28 @@ function DOMParser(options) {
 	this.domHandler = options.domHandler || DOMHandler;
 
 	/**
-	 * A function that can be invoked as the errorHandler instead of the default ones.
-	 * @type {Function | undefined}
-	 * @readonly
+	 * A function that is invoked for every error that occurs during parsing.
+	 *
+	 * If it is not provided, all errors are reported to `console.error`
+	 * and only `fatalError`s are thrown as a `ParseError`,
+	 * which prevents any further processing.
+	 * If the provided method throws, a `ParserError` is thrown,
+	 * which prevents any further processing.
+	 *
+	 * Be aware that many `warning`s are considered an error
+	 * that prevents further processing in most implementations.
+	 *
+	 * @type {function(level:ErrorLevel, message:string, context: DOMHandler):void}
+	 *
+	 * @see onErrorStopParsing
+	 * @see onWarningStopParsing
 	 */
-	this.errorHandler = options.errorHandler;
+	this.onError = options.onError || options.errorHandler;
+	if (options.errorHandler && typeof options.errorHandler !== 'function') {
+		throw new TypeError('errorHandler object is no longer supported, switch to onError!');
+	} else if (options.errorHandler) {
+		options.errorHandler('warning', 'The `errorHandler` option has been deprecated, use `onError` instead!', this);
+	}
 
 	/**
 	 * used to replace line endings before parsing, defaults to `normalizeLineEndings`
@@ -144,38 +179,40 @@ function DOMParser(options) {
 }
 
 /**
- * Parses `source` using the options in the way configured by the `DOMParserOptions` of `this` `DOMParser`.
- * If `mimeType` is `text/html` an HTML `Document` is created, otherwise an XML `Document` is created.
+ * Parses `source` using the options in the way configured by the `DOMParserOptions` of `this`
+ * `DOMParser`. If `mimeType` is `text/html` an HTML `Document` is created, otherwise an XML
+ * `Document` is created.
  *
- * __It behaves very different from the description in the living standard__:
- * - Only allows the first argument to be a string (calls `error` handler otherwise.)
- * - The second parameter is optional (defaults to `application/xml`) and can be any string,
- *   no `TypeError` will be thrown for values not listed in the spec.
- * - Uses the `options` passed to the `DOMParser` constructor to modify the behavior/implementation.
- * - Instead of creating a Document containing the error message,
- *   it triggers `errorHandler`(s) when unexpected input is found, which means it can return `undefined`.
- *   All error handlers can throw an `Error`, by default only the `fatalError` handler throws (a `ParserError`).
- * - All errors thrown during the parsing that are not a `ParserError` are caught and reported using the `error` handler.
- * - If no `ParserError` is thrown, this method returns the `DOMHandler.doc`,
- *   which most likely is the `Document` that has been created during parsing, or `undefined`.
- *   __**Warning: By configuring a faulty DOMHandler implementation,
- *   the specified behavior can completely be broken.**__
+ * __It behaves different from the description in the living standard__:
+ * - Uses the `options` passed to the `DOMParser` constructor to modify the
+ *   behavior.
+ * - Any unexpected input is reported to `onError` with either a `warning`, `error` or `fatalError` level.
+ *   - Any `fatalError` throws a `ParseError` which prevents further processing.
+ *   - Any error thrown by `onError` is converted to a `ParseError` which prevents further processing
+ * - If no `Document` was created during parsing it is reported as a `fatalError`.
+ * __**Warning: By configuring a faulty DOMHandler implementation,
+ * the specified behavior can completely be broken.**__
  *
- * @param {string} source Only string input is possible!
+ * @param {string} source The XML mime type only allows string input!
  * @param {string} [mimeType='application/xml']
  *        the mimeType or contentType of the document to be created
  *        determines the `type` of document created (XML or HTML)
- * @returns {Document | undefined}
- * @throws ParseError for specific errors depending on the configured `errorHandler`s and/or `domBuilder`
+ *
+ * @throws ParseError for any `fatalError` or anything that is thrown by `onError`
+ * @throws TypeError for any invalid `mimeType`
+ * @returns the `Document` node
  *
  * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString
  * @see https://html.spec.whatwg.org/#dom-domparser-parsefromstring-dev
  */
 DOMParser.prototype.parseFromString = function (source, mimeType) {
+	if (!isValidMimeType(mimeType)) {
+		throw new TypeError('DOMParser.parseFromString: the provided mimeType "' + mimeType + '" is not valid.');
+	}
 	var defaultNSMap = this.assign({}, this.xmlns);
 	var entityMap = entities.XML_ENTITIES;
 	var defaultNamespace = defaultNSMap[''] || null;
-	if (MIME_TYPE.hasDefaultHTMLNamespace(mimeType)) {
+	if (hasDefaultHTMLNamespace(mimeType)) {
 		entityMap = entities.HTML_ENTITIES;
 		defaultNamespace = NAMESPACE.HTML;
 	} else if (mimeType === MIME_TYPE.XML_SVG_IMAGE) {
@@ -187,6 +224,7 @@ DOMParser.prototype.parseFromString = function (source, mimeType) {
 	var domBuilder = new this.domHandler({
 		mimeType: mimeType,
 		defaultNamespace: defaultNamespace,
+		onError: this.onError,
 	});
 	var locator = this.locator ? {} : undefined;
 	if (this.locator) {
@@ -194,47 +232,18 @@ DOMParser.prototype.parseFromString = function (source, mimeType) {
 	}
 
 	var sax = new XMLReader();
-	sax.errorHandler = buildErrorHandler(this.errorHandler, domBuilder, locator);
+	sax.errorHandler = domBuilder;
 	sax.domBuilder = domBuilder;
-	if (source && typeof source === 'string') {
-		sax.parse(this.normalizeLineEndings(source), defaultNSMap, entityMap);
-	} else {
-		sax.errorHandler.error('invalid doc source');
+	var isXml = !conventions.isHTMLMimeType(mimeType);
+	if (isXml && typeof source !== 'string') {
+		sax.errorHandler.fatalError('source is not a string');
+	}
+	sax.parse(this.normalizeLineEndings(String(source)), defaultNSMap, entityMap);
+	if (!domBuilder.doc.documentElement) {
+		sax.errorHandler.fatalError('missing root element');
 	}
 	return domBuilder.doc;
 };
-function buildErrorHandler(errorImpl, domBuilder, locator) {
-	if (!errorImpl) {
-		if (domBuilder instanceof DOMHandler) {
-			return domBuilder;
-		}
-		errorImpl = domBuilder;
-	}
-	var errorHandler = {};
-	var isCallback = errorImpl instanceof Function;
-	locator = locator || {};
-	function build(key) {
-		var fn = errorImpl[key];
-		if (!fn && isCallback) {
-			fn =
-				errorImpl.length == 2
-					? function (msg) {
-							errorImpl(key, msg);
-					  }
-					: errorImpl;
-		}
-		errorHandler[key] =
-			(fn &&
-				function (msg) {
-					fn('[xmldom ' + key + ']\t' + msg + _locator(locator));
-				}) ||
-			function () {};
-	}
-	build('warning');
-	build('error');
-	build('fatalError');
-	return errorHandler;
-}
 
 /**
  * @typedef DOMHandlerOptions
@@ -318,11 +327,18 @@ function DOMHandler(options) {
 	 * @private
 	 */
 	this.locator = undefined;
+	/**
+	 * @type {function (level:ErrorLevel ,message:string, context:DOMHandler):void}
+	 * @readonly
+	 */
+	this.onError = opt.onError;
 }
+
 function position(locator, node) {
 	node.lineNumber = locator.lineNumber;
 	node.columnNumber = locator.columnNumber;
 }
+
 DOMHandler.prototype = {
 	/**
 	 * Either creates an XML or an HTML document and stores it under `this.doc`.
@@ -334,7 +350,7 @@ DOMHandler.prototype = {
 	 */
 	startDocument: function () {
 		var impl = new DOMImplementation();
-		this.doc = MIME_TYPE.isHTML(this.mimeType) ? impl.createHTMLDocument(false) : impl.createDocument(this.defaultNamespace, '');
+		this.doc = isHTMLMimeType(this.mimeType) ? impl.createHTMLDocument(false) : impl.createDocument(this.defaultNamespace, '');
 	},
 	startElement: function (namespaceURI, localName, qName, attrs) {
 		var doc = this.doc;
@@ -415,34 +431,54 @@ DOMHandler.prototype = {
 		this.cdata = false;
 	},
 
-	startDTD: function (name, publicId, systemId) {
+	startDTD: function (name, publicId, systemId, internalSubset) {
 		var impl = this.doc.implementation;
 		if (impl && impl.createDocumentType) {
-			var dt = impl.createDocumentType(name, publicId, systemId);
+			var dt = impl.createDocumentType(name, publicId, systemId, internalSubset);
 			this.locator && position(this.locator, dt);
 			appendElement(this, dt);
 			this.doc.doctype = dt;
 		}
 	},
+	reportError: function (level, message) {
+		if (typeof this.onError === 'function') {
+			try {
+				this.onError(level, message, this);
+			} catch (e) {
+				throw new ParseError('Reporting ' + level + ' "' + message + '" caused ' + e, this.locator);
+			}
+		} else {
+			console.error('[xmldom ' + level + ']\t' + message, _locator(this.locator));
+		}
+	},
 	/**
-	 * @see org.xml.sax.ErrorHandler
-	 * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+	 * @see http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
 	 */
-	warning: function (error) {
-		console.warn('[xmldom warning]\t' + error, _locator(this.locator));
+	warning: function (message) {
+		this.reportError('warning', message);
 	},
-	error: function (error) {
-		console.error('[xmldom error]\t' + error, _locator(this.locator));
+	error: function (message) {
+		this.reportError('error', message);
 	},
-	fatalError: function (error) {
-		throw new ParseError(error, this.locator);
+	/**
+	 * This function reports a fatal error and throws a ParseError.
+	 *
+	 * @param {string} message - The message to be used for reporting and throwing the error.
+	 * @returns {never} This function always throws an error and never returns a value.
+	 * @throws {ParseError} Always throws a ParseError with the provided message.
+	 */
+	fatalError: function (message) {
+		this.reportError('fatalError', message);
+		throw new ParseError(message, this.locator);
 	},
 };
+
 function _locator(l) {
 	if (l) {
 		return '\n@#[line:' + l.lineNumber + ',col:' + l.columnNumber + ']';
 	}
 }
+
 function _toString(chars, start, length) {
 	if (typeof chars == 'string') {
 		return chars.substr(start, length);
@@ -496,14 +532,37 @@ function _toString(chars, start, length) {
 );
 
 /* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */
-function appendElement(hander, node) {
-	if (!hander.currentElement) {
-		hander.doc.appendChild(node);
+function appendElement(handler, node) {
+	if (!handler.currentElement) {
+		handler.doc.appendChild(node);
 	} else {
-		hander.currentElement.appendChild(node);
+		handler.currentElement.appendChild(node);
 	}
-} //appendChild and setAttributeNS are preformance key
+}
+
+/**
+ * A method that prevents any further parsing when an `error`
+ * with level `error` is reported during parsing.
+ *
+ * @see DOMParserOptions.onError
+ * @see onWarningStopParsing
+ */
+function onErrorStopParsing(level) {
+	if (level === 'error') throw 'onErrorStopParsing';
+}
+
+/**
+ * A method that prevents any further parsing when any `error` is reported during parsing.
+ *
+ * @see DOMParserOptions.onError
+ * @see onErrorStopParsing
+ */
+function onWarningStopParsing() {
+	throw 'onWarningStopParsing';
+}
 
 exports.__DOMHandler = DOMHandler;
-exports.normalizeLineEndings = normalizeLineEndings;
 exports.DOMParser = DOMParser;
+exports.normalizeLineEndings = normalizeLineEndings;
+exports.onErrorStopParsing = onErrorStopParsing;
+exports.onWarningStopParsing = onWarningStopParsing;

package/lib/dom.js

@@ -2,10 +2,13 @@
 
 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
@@ -71,7 +74,7 @@ function arrayIncludes(list) {
  * @see https://dom.spec.whatwg.org/#validate
  */
 function validateQualifiedName(qualifiedName) {
-	if (!conventions.QNAME.test(qualifiedName)) {
+	if (!g.QName_exact.test(qualifiedName)) {
 		throw new DOMException(INVALID_CHARACTER_ERR, 'invalid character in qualified name "' + qualifiedName + '"');
 	}
 }
@@ -544,8 +547,6 @@ DOMImplementation.prototype = {
 	 * __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'`).
 	 * - `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
@@ -557,10 +558,6 @@ DOMImplementation.prototype = {
 	 * @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
 	 */
 	createDocument: function (namespaceURI, qualifiedName, doctype) {
 		var contentType = MIME_TYPE.XML_APPLICATION;
@@ -587,24 +584,33 @@ DOMImplementation.prototype = {
 	 *
 	 * __This behavior is slightly different from the in the specs__:
 	 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+	 * - `publicId` and `systemId` contain the raw data including any possible quotes,
+	 *   so they can always be serialized back to the original value
+	 * - `internalSubset` contains the raw string between `[` and `]` if present,
+	 *   but is not parsed or validated in any form
 	 *
 	 * @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()`
+	 * @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;
 	},
@@ -886,7 +892,7 @@ function Document(options) {
 	 * @see https://dom.spec.whatwg.org/#concept-document-type
 	 * @see DOMImplementation
 	 */
-	this.type = MIME_TYPE.isHTML(this.contentType) ? 'html' : 'xml';
+	this.type = isHTMLMimeType(this.contentType) ? 'html' : 'xml';
 }
 
 function _onAddAttribute(doc, el, newAttr) {
@@ -952,22 +958,26 @@ function _onUpdateChild(doc, el, newChild) {
  * @private
  */
 function _removeChild(parentNode, child) {
-	var previous = child.previousSibling;
-	var next = child.nextSibling;
-	if (previous) {
-		previous.nextSibling = next;
+	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;
 }
 
@@ -1345,10 +1355,11 @@ Document.prototype = {
 		return newChild;
 	},
 	removeChild: function (oldChild) {
-		if (this.documentElement == oldChild) {
+		var removed = _removeChild(this, oldChild);
+		if (removed === this.documentElement) {
 			this.documentElement = null;
 		}
-		return _removeChild(this, oldChild);
+		return removed;
 	},
 	replaceChild: function (newChild, oldChild) {
 		//raises
@@ -1448,7 +1459,7 @@ Document.prototype = {
 		if (this.type === 'html') {
 			tagName = tagName.toLowerCase();
 		}
-		if (MIME_TYPE.hasDefaultHTMLNamespace(this.contentType)) {
+		if (hasDefaultHTMLNamespace(this.contentType)) {
 			node.namespaceURI = NAMESPACE.HTML;
 		}
 		node.nodeName = tagName;
@@ -1486,7 +1497,7 @@ Document.prototype = {
 	createProcessingInstruction: function (target, data) {
 		var node = new ProcessingInstruction();
 		node.ownerDocument = this;
-		node.tagName = node.target = target;
+		node.nodeName = node.target = target;
 		node.nodeValue = node.data = data;
 		return node;
 	},
@@ -1506,7 +1517,7 @@ Document.prototype = {
 	 * @see https://dom.spec.whatwg.org/#dom-document-createattribute
 	 */
 	createAttribute: function (name) {
-		if (!conventions.QNAME.test(name)) {
+		if (!g.QName_exact.test(name)) {
 			throw new DOMException(INVALID_CHARACTER_ERR, 'invalid character in name "' + name + '"');
 		}
 		if (this.type === 'html') {
@@ -2003,7 +2014,7 @@ function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
 			}
 			// in XML elements can be closed when they have no children
 			var canCloseTag = !child;
-			if (canCloseTag && (isHTML || NAMESPACE.isHTML(node.namespaceURI))) {
+			if (canCloseTag && (isHTML || node.namespaceURI === NAMESPACE.HTML)) {
 				// in HTML (doc or ns) only void elements can be closed right away
 				canCloseTag = isHTMLVoidElement(nodeName);
 			}
@@ -2061,28 +2072,25 @@ function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
 			 */
 			return buf.push(node.data.replace(/[<&>]/g, _xmlEncoder));
 		case CDATA_SECTION_NODE:
-			return buf.push('<![CDATA[', node.data, ']]>');
+			return buf.push(g.CDATA_START, node.data, g.CDATA_END);
 		case COMMENT_NODE:
-			return buf.push('<!--', node.data, '-->');
+			return buf.push(g.COMMENT_START, node.data, g.COMMENT_END);
 		case DOCUMENT_TYPE_NODE:
 			var pubid = node.publicId;
 			var sysid = node.systemId;
-			buf.push('<!DOCTYPE ', node.name);
+			buf.push(g.DOCTYPE_DECL_START, ' ', node.name);
 			if (pubid) {
-				buf.push(' PUBLIC ', pubid);
-				if (sysid && sysid != '.') {
+				buf.push(' ', g.PUBLIC, ' ', pubid);
+				if (sysid && sysid !== '.') {
 					buf.push(' ', sysid);
 				}
-				buf.push('>');
-			} else if (sysid && sysid != '.') {
-				buf.push(' SYSTEM ', sysid, '>');
-			} else {
-				var sub = node.internalSubset;
-				if (sub) {
-					buf.push(' [', sub, ']');
-				}
-				buf.push('>');
+			} else if (sysid && sysid !== '.') {
+				buf.push(' ', g.SYSTEM, ' ', sysid);
+			}
+			if (node.internalSubset) {
+				buf.push(' [', node.internalSubset, ']');
 			}
+			buf.push('>');
 			return;
 		case PROCESSING_INSTRUCTION_NODE:
 			return buf.push('<?', node.target, ' ', node.data, '?>');