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

package/CHANGELOG.md

@@ -4,6 +4,53 @@ All notable changes to this project will be documented in this file.
 
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.0-beta.9](https://github.com/xmldom/xmldom/compare/0.9.0-beta.8...0.9.0-beta.9)
+
+### Fixed
+
+- Set nodeName property in ProcessingInstruction [`#509`](https://github.com/xmldom/xmldom/pull/509) / [`#505`](https://github.com/xmldom/xmldom/issues/505)
+- preserve DOCTYPE internal subset [`#498`](https://github.com/xmldom/xmldom/pull/498) / [`#497`](https://github.com/xmldom/xmldom/pull/497) / [`#117`](https://github.com/xmldom/xmldom/issues/117)\
+  BREAKING CHANGES: Many documents that were previously accepted by xmldom, esecially non well-formed ones are no longer accepted. Some issues that were formerly reported as errors are now a fatalError.
+- DOMParser: Align parseFromString errors with specs [`#454`](https://github.com/xmldom/xmldom/pull/454)
+
+### Chore
+
+- stop running mutation tests using stryker [`#496`](https://github.com/xmldom/xmldom/pull/496)
+- make `toErrorSnapshot` windows compatible [`#503`](https://github.com/xmldom/xmldom/pull/503)
+
+Thank you, [@cjbarth](https://github.com/cjbarth), [@shunkica](https://github.com/shunkica), [@pmahend1](https://github.com/pmahend1), [@niklasl](https://github.com/niklasl), for your contributions
+
+
+## [0.8.9](https://github.com/xmldom/xmldom/compare/0.8.8...0.8.9)
+
+### Fixed
+
+- Set nodeName property in ProcessingInstruction [`#509`](https://github.com/xmldom/xmldom/pull/509) / [`#505`](https://github.com/xmldom/xmldom/issues/505)
+
+Thank you, [@cjbarth](https://github.com/cjbarth), for your contributions
+
+
+## [0.7.12](https://github.com/xmldom/xmldom/compare/0.7.11...0.7.12)
+
+### Fixed
+
+- Set nodeName property in ProcessingInstruction [`#509`](https://github.com/xmldom/xmldom/pull/509) / [`#505`](https://github.com/xmldom/xmldom/issues/505)
+
+Thank you, [@cjbarth](https://github.com/cjbarth), for your contributions
+
+
+## [0.9.0-beta.8](https://github.com/xmldom/xmldom/compare/0.9.0-beta.7...0.9.0-beta.8)
+
+### Fixed
+
+- Throw DOMException when calling removeChild with invalid parameter [`#494`](https://github.com/xmldom/xmldom/pull/494) / [`#135`](https://github.com/xmldom/xmldom/issues/135)
+
+BREAKING CHANGE: Previously it was possible (but not documented) to call `Node.removeChild` with any node in the tree,
+and with certain exceptions, it would work. This is no longer the case: calling `Node.removeChild` with an argument that is not a direct child of the node that it is called from, will throw a NotFoundError DOMException, as it is described by the specs.
+
+Thank you, [@noseworthy](https://github.com/noseworthy), [@davidmc24](https://github.com/davidmc24), for your contributions
+
+
 ## [0.9.0-beta.7](https://github.com/xmldom/xmldom/compare/0.9.0-beta.6...0.9.0-beta.7)
 
 ### Feature

package/index.d.ts

@@ -1,45 +1,385 @@
 /// <reference lib="dom" />
 
 declare module '@xmldom/xmldom' {
-	var DOMParser: DOMParserStatic
-	var XMLSerializer: XMLSerializerStatic
-	var DOMImplementation: DOMImplementationStatic
+	// START ./lib/conventions.js
+	/**
+	 * Since xmldom can not rely on `Object.assign`,
+	 * it uses/provides a simplified version that is sufficient for its needs.
+	 *
+	 * @throws TypeError if target is not an object
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+	 * @see https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-object.assign
+	 */
+	function assign<T, S>(target:T, source:S): T & S;
+	/**
+	 * Only returns true if `value` matches MIME_TYPE.HTML, which indicates an HTML document.
+	 *
+	 * @see https://www.iana.org/assignments/media-types/text/html
+	 * @see https://en.wikipedia.org/wiki/HTML
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString
+	 * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring
+	 */
+	function isHtmlMimeType(mimeType: string): mimeType is MIME_TYPE.HTML;
+	/**
+	 * Only returns true if `mimeType` is one of the allowed values for `DOMParser.parseFromString`.
+	 */
+	function isValidMimeType(mimeType: string): mimeType is MIME_TYPE;
 
-	interface DOMImplementationStatic {
-		new (): DOMImplementation
+	/**
+	 * All mime types that are allowed as input to `DOMParser.parseFromString`
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString#Argument02 MDN
+	 * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#domparsersupportedtype WHATWG HTML Spec
+	 * @see DOMParser.prototype.parseFromString
+	 */
+	enum MIME_TYPE {
+		/**
+		 * `text/html`, the only mime type that triggers treating an XML document as HTML.
+		 *
+		 * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+		 * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+		 * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+		 */
+		HTML = 'text/html',
+		/**
+		 * `application/xml`, the standard mime type for XML documents.
+		 *
+		 * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+		 * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+		 * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+		 */
+		XML_APPLICATION = 'application/xml',
+		/**
+		 * `text/html`, an alias for `application/xml`.
+		 *
+		 * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+		 * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+		 * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+		 */
+		XML_TEXT = 'text/xml',
+		/**
+		 * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+		 * but is parsed as an XML document.
+		 *
+		 * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+		 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+		 * @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+		 */
+		XML_XHTML_APPLICATION = 'application/xhtml+xml',
+		/**
+		 * `image/svg+xml`,
+		 *
+		 * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+		 * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+		 * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+		 */
+		XML_SVG_IMAGE = 'image/svg+xml',
 	}
+	/**
+	 * Namespaces that are used in xmldom.
+	 *
+	 * @see http://www.w3.org/TR/REC-xml-names
+	 */
+	enum NAMESPACE {
+		/**
+		 * The XHTML namespace.
+		 *
+		 * @see http://www.w3.org/1999/xhtml
+		 */
+		HTML = 'http://www.w3.org/1999/xhtml',
+		/**
+		 * The SVG namespace.
+		 *
+		 * @see http://www.w3.org/2000/svg
+		 */
+		SVG = 'http://www.w3.org/2000/svg',
+		/**
+		 * The `xml:` namespace.
+		 *
+		 * @see http://www.w3.org/XML/1998/namespace
+		 */
+		XML = 'http://www.w3.org/XML/1998/namespace',
 
-	interface DOMParserStatic {
-		new (): DOMParser
-		new (options: DOMParserOptions): DOMParser
+		/**
+		 * The `xmlns:` namespace
+		 *
+		 * @see https://www.w3.org/2000/xmlns/
+		 */
+		XMLNS = 'http://www.w3.org/2000/xmlns/',
+	}
+
+	/**
+	 * A custom error that will not be caught by XMLReader aka the SAX parser.
+	 */
+	class ParseError extends Error {
+		constructor(message:string, locator?:any);
+	}
+	// END ./lib/conventions.js
+
+	// START ./lib/dom.js
+	/**
+	 * The error class for errors reported by the DOM API.
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/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
+	 */
+	class DOMException extends Error {
+		constructor(code: number, message: string);
 	}
 
+	interface DOMImplementation {
+		/**
+		 * 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
+		 *
+		 * @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/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
+		 */
+		new (): DOMImplementation;
+
+		/**
+		 * 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'`).
+		 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+		 *
+		 * @returns {Document} the XML document
+		 *
+		 * @see DOMImplementation.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
+		 */
+		createDocument(
+			namespaceURI: string | null,
+			qualifiedName: string,
+			doctype?: DocumentType | null
+		): Document;
+
+		/**
+		 * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
+		 *
+		 * __This behavior is slightly different from the in the specs__:
+		 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+		 *
+		 * @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
+		 */
+		createDocumentType(
+			qualifiedName: string,
+			publicId?: string,
+			systemId?: string
+		): DocumentType;
+
+		/**
+		 * 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.
+		 *
+		 * @see DOMImplementation.createDocument
+		 *
+		 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
+		 * @see https://dom.spec.whatwg.org/#html-document
+		 */
+		createHTMLDocument(title?: string | false): Document;
+
+		/**
+		 * 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.
+		 *
+		 * @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(feature: string, version?: string): true;
+	}
+
+	var XMLSerializer: XMLSerializerStatic;
 	interface XMLSerializerStatic {
-		new (): XMLSerializer
+		new (): XMLSerializer;
 	}
+	// END ./lib/dom.js
 
+	// START ./lib/dom-parser.js
+	var DOMParser: DOMParserStatic;
+	interface DOMParserStatic {
+		/**
+		 * The DOMParser interface provides the ability to parse XML or HTML source code
+		 * from a string into a DOM `Document`.
+		 *
+		 * _xmldom is different from the spec in that it allows an `options` parameter,
+		 * to control the behavior._
+		 *
+		 * @param {DOMParserOptions} [options]
+		 * @constructor
+		 *
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
+		 * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsing-and-serialization
+		 */
+		new (options?: DOMParserOptions): DOMParser;
+	}
+
+	/**
+	 * The DOMParser interface provides the ability to parse XML or HTML source code
+	 * from a string into a DOM `Document`.
+	 *
+	 * _xmldom is different from the spec in that it allows an `options` parameter,
+	 * to control the behavior._
+	 *
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
+	 * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-parsing-and-serialization
+	 */
 	interface DOMParser {
-		parseFromString(source: string, mimeType?: string): Document | undefined
+		/**
+		 * 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 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`.
+		 *
+		 * @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
+		 */
+		parseFromString(source: string, mimeType: MIME_TYPE = MIME_TYPE.XML_TEXT): Document;
 	}
 
 	interface XMLSerializer {
-		serializeToString(node: Node): string
+		serializeToString(node: Node, nodeFilter?: (node: Node) => boolean): string;
 	}
 
 	interface DOMParserOptions {
-		errorHandler?: ErrorHandlerFunction | ErrorHandlerObject
-		locator?: boolean
-		normalizeLineEndings?: (source: string) => string
-		xmlns?: Record<string, string | null | undefined>
+		/**
+		 * The method to use instead of `Object.assign` (defaults to `conventions.assign`),
+		 * which is used to copy values from the options before they are used for parsing.
+		 *
+		 * @private
+		 * @see conventions.assign
+		 */
+		readonly assign?: typeof Object.assign;
+		/**
+		 * 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.**__
+		 *
+		 * @private
+		 */
+		readonly domHandler?: unknown;
+
+		/**
+		 * DEPRECATED: Use `onError` instead!
+		 *
+		 * For backwards compatibility:
+		 * If it is a function, it will be used as a value for `onError`,
+		 * but it receives different argument types than before 0.9.0.
+		 * @throws If it is an object.
+		 * @deprecated
+		 */
+		readonly errorHandler?: ErrorHandlerFunction;
+
+		/**
+		 * Configures if the nodes created during parsing
+		 * will have a `lineNumber` and a `columnNumber` attribute
+		 * describing their location in the XML string.
+		 * Default is true.
+		 */
+		readonly locator?: boolean;
+
+		/**
+		 * used to replace line endings before parsing, defaults to `normalizeLineEndings`,
+		 * which normalizes line endings according to <https://www.w3.org/TR/xml11/#sec-line-ends>.
+		 */
+		readonly normalizeLineEndings?: (source: string) => string;
+		/**
+		 * 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.
+		 *
+		 * @param level the error level as reported by the SAXParser
+		 * @param message the error message
+		 * @param context the DOMHandler instance used for parsing
+		 *
+		 * @see onErrorStopParsing
+		 * @see onWarningStopParsing
+		 */
+		readonly onError?: ErrorHandlerFunction;
+
+		/**
+		 * The XML namespaces that should be assumed when parsing.
+		 * The default namespace can be provided by the key that is the empty string.
+		 * When the `mimeType` for HTML, XHTML or SVG are passed to `parseFromString`,
+		 * the default namespace that will be used,
+		 * will be overridden according to the specification.
+		 */
+		readonly xmlns?: Readonly<Record<string, string | null | undefined>>;
 	}
 
 	interface ErrorHandlerFunction {
-		(level: 'warn' | 'error' | 'fatalError', msg: string): void
+		(level: 'warn' | 'error' | 'fatalError', msg: string, context: any): void;
 	}
 
-	interface ErrorHandlerObject {
-		warning?: (msg: string) => void
-		error?: (msg: string) => void
-		fatalError?: (msg: string) => void
-	}
+	/**
+	 * A method that prevents any further parsing when an `error`
+	 * with level `error` is reported during parsing.
+	 *
+	 * @see DOMParserOptions.onError
+	 * @see onWarningStopParsing
+	 */
+	function onErrorStopParsing(): void | never;
+	/**
+	 * A method that prevents any further parsing when an `error`
+	 * with any level is reported during parsing.
+	 *
+	 * @see DOMParserOptions.onError
+	 * @see onErrorStopParsing
+	 */
+	function onWarningStopParsing(): never;
+	// END ./lib/dom-parser.js
 }

package/lib/conventions.js

@@ -55,8 +55,8 @@ function freeze(object, oc) {
 }
 
 /**
- * Since we can not rely on `Object.assign` we provide a simplified version
- * that is sufficient for our needs.
+ * Since xmldom can not rely on `Object.assign`,
+ * it uses/provides a simplified version that is sufficient for its needs.
  *
  * @param {Object} target
  * @param {Object | null | undefined} source
@@ -227,6 +227,34 @@ function isHTMLEscapableRawTextElement(tagName) {
 	var key = tagName.toLowerCase();
 	return HTML_RAW_TEXT_ELEMENTS.hasOwnProperty(key) && HTML_RAW_TEXT_ELEMENTS[key];
 }
+/**
+ * Only returns true if `value` matches MIME_TYPE.HTML, which indicates an HTML document.
+ *
+ * @param {string} mimeType
+ * @returns {mimeType is 'text/html'}
+ *
+ * @see https://www.iana.org/assignments/media-types/text/html
+ * @see https://en.wikipedia.org/wiki/HTML
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString
+ * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring
+ */
+function isHTMLMimeType(mimeType) {
+	return mimeType === MIME_TYPE.HTML;
+}
+/**
+ * For both the `text/html` and the `application/xhtml+xml` namespace
+ * the spec defines that the HTML namespace is provided as the default.
+ *
+ * @param {string} mimeType
+ * @returns {boolean}
+ *
+ * @see https://dom.spec.whatwg.org/#dom-document-createelement
+ * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument
+ * @see https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
+ */
+function hasDefaultHTMLNamespace(mimeType) {
+	return isHTMLMimeType(mimeType) || mimeType === MIME_TYPE.XML_XHTML_APPLICATION;
+}
 
 /**
  * All mime types that are allowed as input to `DOMParser.parseFromString`
@@ -239,7 +267,6 @@ var MIME_TYPE = freeze({
 	/**
 	 * `text/html`, the only mime type that triggers treating an XML document as HTML.
 	 *
-	 * @see DOMParser.SupportedType.isHTML
 	 * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
 	 * @see https://en.wikipedia.org/wiki/HTML Wikipedia
 	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
@@ -247,36 +274,6 @@ var MIME_TYPE = freeze({
 	 */
 	HTML: 'text/html',
 
-	/**
-	 * Helper method to check a mime type if it indicates an HTML document
-	 *
-	 * @param {string} [value]
-	 * @returns {boolean}
-	 *
-	 * @see [IANA MimeType registration](https://www.iana.org/assignments/media-types/text/html)
-	 * @see [Wikipedia](https://en.wikipedia.org/wiki/HTML)
-	 * @see [`DOMParser.parseFromString` @ MDN](https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString)
-	 * @see [`DOMParser.parseFromString` @ HTML Specification](https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring)
-	 */
-	isHTML: function (value) {
-		return value === MIME_TYPE.HTML;
-	},
-
-	/**
-	 * For both the `text/html` and the `application/xhtml+xml` namespace
-	 * the spec defines that the HTML namespace is provided as the default in some cases.
-	 *
-	 * @param {string} mimeType
-	 * @returns {boolean}
-	 *
-	 * @see https://dom.spec.whatwg.org/#dom-document-createelement
-	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument
-	 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
-	 */
-	hasDefaultHTMLNamespace: function (mimeType) {
-		return MIME_TYPE.isHTML(mimeType) || mimeType === MIME_TYPE.XML_XHTML_APPLICATION;
-	},
-
 	/**
 	 * `application/xml`, the standard mime type for XML documents.
 	 *
@@ -314,7 +311,25 @@ var MIME_TYPE = freeze({
 	 */
 	XML_SVG_IMAGE: 'image/svg+xml',
 });
+/**
+ * @typedef {'application/xhtml+xml' | 'application/xml' | 'image/svg+xml' |  'text/html' | 'text/xml'} MimeType
+ */
+/**
+ * @type {MimeType[]}
+ * @private
+ */
+var _MIME_TYPES = Object.keys(MIME_TYPE).map(function (key) {
+	return MIME_TYPE[key];
+});
 
+/**
+ * Only returns true if `mimeType` is one of the allowed values for `DOMParser.parseFromString`.
+ * @param {string} mimeType
+ * @returns {mimeType is 'application/xhtml+xml' | 'application/xml' | 'image/svg+xml' |  'text/html' | 'text/xml'}
+ */
+function isValidMimeType(mimeType) {
+	return _MIME_TYPES.indexOf(mimeType) > -1;
+}
 /**
  * Namespaces that are used in this code base.
  *
@@ -328,17 +343,6 @@ var NAMESPACE = freeze({
 	 */
 	HTML: 'http://www.w3.org/1999/xhtml',
 
-	/**
-	 * Checks if `uri` equals `NAMESPACE.HTML`.
-	 *
-	 * @param {string} [uri]
-	 *
-	 * @see NAMESPACE.HTML
-	 */
-	isHTML: function (uri) {
-		return uri === NAMESPACE.HTML;
-	},
-
 	/**
 	 * The SVG namespace.
 	 *
@@ -361,22 +365,20 @@ var NAMESPACE = freeze({
 	XMLNS: 'http://www.w3.org/2000/xmlns/',
 });
 
-// https://www.w3.org/TR/xml-names/#ns-decl
-// https://www.w3.org/TR/REC-xml/#NT-Name
-// https://www.w3.org/TR/xml-names/#ns-qualnames
-// NAME_START_CHAR without ":"
-var QNAME_START_CHAR =
-	/[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/; //\u10000-\uEFFFF
-//[4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
-var NAME_START_CHAR = new RegExp('[:' + QNAME_START_CHAR.source.slice(1, -1) + ']');
-var NAME_CHAR = new RegExp('[\\-\\.0-9' + NAME_START_CHAR.source.slice(1, -1) + '\\u00B7\\u0300-\\u036F\\u203F-\\u2040]');
-//[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
-// NAME_CHAR without ":"
-var QNAME_CHAR = new RegExp('[\\-\\.0-9' + QNAME_START_CHAR.source.slice(1, -1) + '\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*');
-// https://www.w3.org/TR/xml-names/#NT-NCName
-var NCNAME = QNAME_START_CHAR.source + QNAME_CHAR.source;
-// https://www.w3.org/TR/xml-names/#ns-qualnames
-var QNAME = new RegExp('^' + NCNAME + '(?::' + NCNAME + ')?$');
+/**
+ * Creates an error that will not be caught by XMLReader aka the SAX parser.
+ *
+ * @param {string} message
+ * @param {any?} locator Optional, can provide details about the location in the source
+ * @constructor
+ */
+function ParseError(message, locator) {
+	this.message = message;
+	this.locator = locator;
+	if (Error.captureStackTrace) Error.captureStackTrace(this, ParseError);
+}
+ParseError.prototype = new Error();
+ParseError.prototype.name = ParseError.name;
 
 exports.assign = assign;
 exports.find = find;
@@ -384,14 +386,13 @@ exports.freeze = freeze;
 exports.HTML_BOOLEAN_ATTRIBUTES = HTML_BOOLEAN_ATTRIBUTES;
 exports.HTML_RAW_TEXT_ELEMENTS = HTML_RAW_TEXT_ELEMENTS;
 exports.HTML_VOID_ELEMENTS = HTML_VOID_ELEMENTS;
+exports.hasDefaultHTMLNamespace = hasDefaultHTMLNamespace;
 exports.isHTMLBooleanAttribute = isHTMLBooleanAttribute;
 exports.isHTMLRawTextElement = isHTMLRawTextElement;
 exports.isHTMLEscapableRawTextElement = isHTMLEscapableRawTextElement;
+exports.isHTMLMimeType = isHTMLMimeType;
 exports.isHTMLVoidElement = isHTMLVoidElement;
+exports.isValidMimeType = isValidMimeType;
 exports.MIME_TYPE = MIME_TYPE;
-exports.NAME_CHAR = NAME_CHAR;
-exports.NAME_START_CHAR = NAME_START_CHAR;
 exports.NAMESPACE = NAMESPACE;
-exports.QNAME = QNAME;
-exports.QNAME_CHAR = QNAME_CHAR;
-exports.QNAME_START_CHAR = QNAME_START_CHAR;
+exports.ParseError = ParseError;