@xmldom/xmldom 0.9.0 → 0.9.1

package/index.d.ts

@@ -1,5 +1,3 @@
-/// <reference lib="dom" />
-
 declare module '@xmldom/xmldom' {
 	// START ./lib/conventions.js
 	/**
@@ -12,6 +10,21 @@ declare module '@xmldom/xmldom' {
 	 * @see https://tc39.es/ecma262/multipage/fundamental-objects.html#sec-object.assign
 	 */
 	function assign<T, S>(target: T, source: S): T & S;
+
+	/**
+	 * 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: string
+	): mimeType is typeof MIME_TYPE.HTML | typeof MIME_TYPE.XML_XHTML_APPLICATION;
+
 	/**
 	 * Only returns true if `value` matches MIME_TYPE.HTML, which indicates an HTML document.
 	 *
@@ -20,7 +33,8 @@ declare module '@xmldom/xmldom' {
 	 * @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;
+	function isHTMLMimeType(mimeType: string): mimeType is typeof MIME_TYPE.HTML;
+
 	/**
 	 * Only returns true if `mimeType` is one of the allowed values for `DOMParser.parseFromString`.
 	 */
@@ -32,10 +46,20 @@ declare module '@xmldom/xmldom' {
 	 * @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
+	 *      WHATWG HTML Spec
+	 * @see {@link DOMParser.prototype.parseFromString}
+	 */
+	type MIME_TYPE = (typeof MIME_TYPE)[keyof typeof MIME_TYPE];
+	/**
+	 * 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 {@link DOMParser.prototype.parseFromString}
 	 */
-	enum MIME_TYPE {
+	var MIME_TYPE: {
 		/**
 		 * `text/html`, the only mime type that triggers treating an XML document as HTML.
 		 *
@@ -43,9 +67,9 @@ declare module '@xmldom/xmldom' {
 		 * @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
+		 *      WHATWG HTML Spec
 		 */
-		HTML = 'text/html',
+		readonly HTML: 'text/html';
 		/**
 		 * `application/xml`, the standard mime type for XML documents.
 		 *
@@ -54,7 +78,7 @@ declare module '@xmldom/xmldom' {
 		 * @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',
+		readonly XML_APPLICATION: 'application/xml';
 		/**
 		 * `text/html`, an alias for `application/xml`.
 		 *
@@ -62,7 +86,7 @@ declare module '@xmldom/xmldom' {
 		 * @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',
+		readonly XML_TEXT: 'text/xml';
 		/**
 		 * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
 		 * but is parsed as an XML document.
@@ -72,7 +96,7 @@ declare module '@xmldom/xmldom' {
 		 * @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',
+		readonly XML_XHTML_APPLICATION: 'application/xhtml+xml';
 		/**
 		 * `image/svg+xml`,
 		 *
@@ -80,62 +104,1154 @@ declare module '@xmldom/xmldom' {
 		 * @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',
-	}
+		readonly XML_SVG_IMAGE: 'image/svg+xml';
+	};
 	/**
 	 * Namespaces that are used in xmldom.
 	 *
 	 * @see http://www.w3.org/TR/REC-xml-names
 	 */
-	enum NAMESPACE {
+	type NAMESPACE = (typeof NAMESPACE)[keyof typeof NAMESPACE];
+	/**
+	 * Namespaces that are used in xmldom.
+	 *
+	 * @see http://www.w3.org/TR/REC-xml-names
+	 */
+	var NAMESPACE: {
 		/**
 		 * The XHTML namespace.
 		 *
 		 * @see http://www.w3.org/1999/xhtml
 		 */
-		HTML = 'http://www.w3.org/1999/xhtml',
+		readonly HTML: 'http://www.w3.org/1999/xhtml';
 		/**
 		 * The SVG namespace.
 		 *
 		 * @see http://www.w3.org/2000/svg
 		 */
-		SVG = 'http://www.w3.org/2000/svg',
+		readonly 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',
+		readonly XML: 'http://www.w3.org/XML/1998/namespace';
 
 		/**
 		 * The `xmlns:` namespace.
 		 *
 		 * @see https://www.w3.org/2000/xmlns/
 		 */
-		XMLNS = 'http://www.w3.org/2000/xmlns/',
+		readonly XMLNS: 'http://www.w3.org/2000/xmlns/';
+	};
+
+	// END ./lib/conventions.js
+
+	// START ./lib/errors.js
+	type DOMExceptionName =
+		(typeof DOMExceptionName)[keyof typeof DOMExceptionName];
+	var DOMExceptionName: {
+		/**
+		 * the default value as defined by the spec
+		 */
+		readonly Error: 'Error';
+		/**
+		 * @deprecated
+		 * Use RangeError instead.
+		 */
+		readonly IndexSizeError: 'IndexSizeError';
+		/**
+		 * @deprecated
+		 * Just to match the related static code, not part of the spec.
+		 */
+		readonly DomstringSizeError: 'DomstringSizeError';
+		readonly HierarchyRequestError: 'HierarchyRequestError';
+		readonly WrongDocumentError: 'WrongDocumentError';
+		readonly InvalidCharacterError: 'InvalidCharacterError';
+		/**
+		 * @deprecated
+		 * Just to match the related static code, not part of the spec.
+		 */
+		readonly NoDataAllowedError: 'NoDataAllowedError';
+		readonly NoModificationAllowedError: 'NoModificationAllowedError';
+		readonly NotFoundError: 'NotFoundError';
+		readonly NotSupportedError: 'NotSupportedError';
+		readonly InUseAttributeError: 'InUseAttributeError';
+		readonly InvalidStateError: 'InvalidStateError';
+		readonly SyntaxError: 'SyntaxError';
+		readonly InvalidModificationError: 'InvalidModificationError';
+		readonly NamespaceError: 'NamespaceError';
+		/**
+		 * @deprecated
+		 * Use TypeError for invalid arguments,
+		 * "NotSupportedError" DOMException for unsupported operations,
+		 * and "NotAllowedError" DOMException for denied requests instead.
+		 */
+		readonly InvalidAccessError: 'InvalidAccessError';
+		/**
+		 * @deprecated
+		 * Just to match the related static code, not part of the spec.
+		 */
+		readonly ValidationError: 'ValidationError';
+		/**
+		 * @deprecated
+		 * Use TypeError instead.
+		 */
+		readonly TypeMismatchError: 'TypeMismatchError';
+		readonly SecurityError: 'SecurityError';
+		readonly NetworkError: 'NetworkError';
+		readonly AbortError: 'AbortError';
+		/**
+		 * @deprecated
+		 * Just to match the related static code, not part of the spec.
+		 */
+		readonly URLMismatchError: 'URLMismatchError';
+		readonly QuotaExceededError: 'QuotaExceededError';
+		readonly TimeoutError: 'TimeoutError';
+		readonly InvalidNodeTypeError: 'InvalidNodeTypeError';
+		readonly DataCloneError: 'DataCloneError';
+		readonly EncodingError: 'EncodingError';
+		readonly NotReadableError: 'NotReadableError';
+		readonly UnknownError: 'UnknownError';
+		readonly ConstraintError: 'ConstraintError';
+		readonly DataError: 'DataError';
+		readonly TransactionInactiveError: 'TransactionInactiveError';
+		readonly ReadOnlyError: 'ReadOnlyError';
+		readonly VersionError: 'VersionError';
+		readonly OperationError: 'OperationError';
+		readonly NotAllowedError: 'NotAllowedError';
+		readonly OptOutError: 'OptOutError';
+	};
+	type ExceptionCode = (typeof ExceptionCode)[keyof typeof ExceptionCode];
+
+	var ExceptionCode: {
+		readonly INDEX_SIZE_ERR: 1;
+		readonly DOMSTRING_SIZE_ERR: 2;
+		readonly HIERARCHY_REQUEST_ERR: 3;
+		readonly WRONG_DOCUMENT_ERR: 4;
+		readonly INVALID_CHARACTER_ERR: 5;
+		readonly NO_DATA_ALLOWED_ERR: 6;
+		readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+		readonly NOT_FOUND_ERR: 8;
+		readonly NOT_SUPPORTED_ERR: 9;
+		readonly INUSE_ATTRIBUTE_ERR: 10;
+		readonly INVALID_STATE_ERR: 11;
+		readonly SYNTAX_ERR: 12;
+		readonly INVALID_MODIFICATION_ERR: 13;
+		readonly NAMESPACE_ERR: 14;
+		readonly INVALID_ACCESS_ERR: 15;
+		readonly VALIDATION_ERR: 16;
+		readonly TYPE_MISMATCH_ERR: 17;
+		readonly SECURITY_ERR: 18;
+		readonly NETWORK_ERR: 19;
+		readonly ABORT_ERR: 20;
+		readonly URL_MISMATCH_ERR: 21;
+		readonly QUOTA_EXCEEDED_ERR: 22;
+		readonly TIMEOUT_ERR: 23;
+		readonly INVALID_NODE_TYPE_ERR: 24;
+		readonly DATA_CLONE_ERR: 25;
+	};
+
+	/**
+	 * DOM operations only raise exceptions in "exceptional" circumstances, i.e., when an
+	 * operation is impossible to perform (either for logical reasons, because data is lost, or
+	 * because the implementation has become unstable). In general, DOM methods return specific
+	 * error values in ordinary processing situations, such as out-of-bound errors when using
+	 * NodeList.
+	 *
+	 * Implementations should raise other exceptions under other circumstances. For example,
+	 * implementations should raise an implementation-dependent exception if a null argument is
+	 * passed when null was not expected.
+	 *
+	 * This implementation supports the following usages:
+	 * 1. according to the living standard (both arguments are optional):
+	 * ```
+	 * new DOMException("message (can be empty)", DOMExceptionNames.HierarchyRequestError)
+	 * ```
+	 * 2. according to previous xmldom implementation (only the first argument is required):
+	 * ```
+	 * new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "optional message")
+	 * ```
+	 * both result in the proper name being set.
+	 *
+	 * @see https://webidl.spec.whatwg.org/#idl-DOMException
+	 * @see https://webidl.spec.whatwg.org/#dfn-error-names-table
+	 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-17189187
+	 * @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(message?: string, name?: DOMExceptionName | string);
+		constructor(code?: ExceptionCode, message?: string);
+
+		readonly name: DOMExceptionName;
+		readonly code: ExceptionCode | 0;
+		static readonly INDEX_SIZE_ERR: 1;
+		static readonly DOMSTRING_SIZE_ERR: 2;
+		static readonly HIERARCHY_REQUEST_ERR: 3;
+		static readonly WRONG_DOCUMENT_ERR: 4;
+		static readonly INVALID_CHARACTER_ERR: 5;
+		static readonly NO_DATA_ALLOWED_ERR: 6;
+		static readonly NO_MODIFICATION_ALLOWED_ERR: 7;
+		static readonly NOT_FOUND_ERR: 8;
+		static readonly NOT_SUPPORTED_ERR: 9;
+		static readonly INUSE_ATTRIBUTE_ERR: 10;
+		static readonly INVALID_STATE_ERR: 11;
+		static readonly SYNTAX_ERR: 12;
+		static readonly INVALID_MODIFICATION_ERR: 13;
+		static readonly NAMESPACE_ERR: 14;
+		static readonly INVALID_ACCESS_ERR: 15;
+		static readonly VALIDATION_ERR: 16;
+		static readonly TYPE_MISMATCH_ERR: 17;
+		static readonly SECURITY_ERR: 18;
+		static readonly NETWORK_ERR: 19;
+		static readonly ABORT_ERR: 20;
+		static readonly URL_MISMATCH_ERR: 21;
+		static readonly QUOTA_EXCEEDED_ERR: 22;
+		static readonly TIMEOUT_ERR: 23;
+		static readonly INVALID_NODE_TYPE_ERR: 24;
+		static readonly DATA_CLONE_ERR: 25;
 	}
 
 	/**
-	 * A custom error that will not be caught by XMLReader aka the SAX parser.
+	 * Creates an error that will not be caught by XMLReader aka the SAX parser.
 	 */
 	class ParseError extends Error {
-		constructor(message: string, locator?: any);
+		constructor(message: string, locator?: any, cause?: Error);
+
+		readonly message: string;
+		readonly locator?: any;
 	}
-	// END ./lib/conventions.js
+
+	// END ./lib/errors.js
 
 	// START ./lib/dom.js
+
+	type InstanceOf<T> = {
+		// instanceof pre ts 5.3
+		(val: unknown): val is T;
+		// instanceof post ts 5.3
+		[Symbol.hasInstance](val: unknown): val is T;
+	};
 	/**
-	 * The error class for errors reported by the DOM API.
+	 * The DOM Node interface is an abstract base class upon which many other DOM API objects are
+	 * based, thus letting those object types to be used similarly and often interchangeably. As an
+	 * abstract class, there is no such thing as a plain Node object. All objects that implement
+	 * Node functionality are based on one of its subclasses. Most notable are Document, Element,
+	 * and DocumentFragment.
 	 *
-	 * @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
+	 * In addition, every kind of DOM node is represented by an interface based on Node. These
+	 * include Attr, CharacterData (which Text, Comment, CDATASection and ProcessingInstruction are
+	 * all based on), and DocumentType.
+	 *
+	 * In some cases, a particular feature of the base Node interface may not apply to one of its
+	 * child interfaces; in that case, the inheriting node may return null or throw an exception,
+	 * depending on circumstances. For example, attempting to add children to a node type that
+	 * cannot have children will throw an exception.
+	 *
+	 * **This behavior is slightly different from the in the specs**:
+	 * - undeclared properties: nodeType, baseURI, isConnected, parentElement, textContent
+	 * - missing methods: contains, getRootNode, isEqualNode, isSameNode
+	 *
+	 * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
+	 * @see https://dom.spec.whatwg.org/#node
+	 * @prettierignore
 	 */
-	class DOMException extends Error {
-		constructor(code: number, message: string);
+	interface Node {
+		/**
+		 * Returns the children.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/childNodes)
+		 */
+		readonly childNodes: NodeList;
+		/**
+		 * Returns the first child.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/firstChild)
+		 */
+		readonly firstChild: Node | null;
+		/**
+		 * Returns the last child.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/lastChild)
+		 */
+		readonly lastChild: Node | null;
+		/**
+		 * The local part of the qualified name of this node.
+		 */
+		localName: string | null;
+		/**
+		 * The namespace URI of this node.
+		 */
+		readonly namespaceURI: string | null;
+		/**
+		 * Returns the next sibling.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/nextSibling)
+		 */
+		readonly nextSibling: Node | null;
+		/**
+		 * Returns a string appropriate for the type of node.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/nodeName)
+		 */
+		readonly nodeName: string;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/nodeValue) */
+		nodeValue: string | null;
+		/**
+		 * Returns the node document. Returns null for documents.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/ownerDocument)
+		 */
+		readonly ownerDocument: Document | null;
+		/**
+		 * Returns the parent.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/parentNode)
+		 */
+		readonly parentNode: Node | null;
+		/**
+		 * The prefix of the namespace for this node.
+		 */
+		prefix: string | null;
+		/**
+		 * Returns the previous sibling.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/previousSibling)
+		 */
+		readonly previousSibling: Node | null;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/appendChild) */
+		appendChild(node: Node): Node;
+
+		/**
+		 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
+		 *
+		 * @throws {DOMException}
+		 * May throw a DOMException if operations within {@link Element#setAttributeNode} or
+		 * {@link Node#appendChild} (which are potentially invoked in this method) do not meet their
+		 * specific constraints.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/cloneNode)
+		 */
+		cloneNode(deep?: boolean): Node;
+
+		/**
+		 * Returns a bitmask indicating the position of other relative to node.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/compareDocumentPosition)
+		 */
+		compareDocumentPosition(other: Node): number;
+
+		/**
+		 * Returns whether node has children.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/hasChildNodes)
+		 */
+		hasChildNodes(): boolean;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/insertBefore) */
+		insertBefore(node: Node, child: Node | null): Node;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/isDefaultNamespace) */
+		isDefaultNamespace(namespace: string | null): boolean;
+
+		/**
+		 * Checks whether the DOM implementation implements a specific feature and its version.
+		 *
+		 * @deprecated
+		 * Since `DOMImplementation.hasFeature` is deprecated and always returns true.
+		 * @param feature
+		 * The package name of the feature to test. This is the same name that can be passed to the
+		 * method `hasFeature` on `DOMImplementation`.
+		 * @param version
+		 * This is the version number of the package name to test.
+		 * @since Introduced in DOM Level 2
+		 * @see {@link DOMImplementation.hasFeature}
+		 */
+		isSupported(feature: string, version: string): true;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/lookupNamespaceURI) */
+		lookupNamespaceURI(prefix: string | null): string | null;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/lookupPrefix) */
+		lookupPrefix(namespace: string | null): string | null;
+
+		/**
+		 * Removes empty exclusive Text nodes and concatenates the data of remaining contiguous
+		 * exclusive Text nodes into the first of their nodes.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/normalize)
+		 */
+		normalize(): void;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/removeChild) */
+		removeChild(child: Node): Node;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/replaceChild) */
+		replaceChild(node: Node, child: Node): Node;
+
+		/** node is an element. */
+		readonly ELEMENT_NODE: 1;
+		readonly ATTRIBUTE_NODE: 2;
+		/** node is a Text node. */
+		readonly TEXT_NODE: 3;
+		/** node is a CDATASection node. */
+		readonly CDATA_SECTION_NODE: 4;
+		readonly ENTITY_REFERENCE_NODE: 5;
+		readonly ENTITY_NODE: 6;
+		/** node is a ProcessingInstruction node. */
+		readonly PROCESSING_INSTRUCTION_NODE: 7;
+		/** node is a Comment node. */
+		readonly COMMENT_NODE: 8;
+		/** node is a document. */
+		readonly DOCUMENT_NODE: 9;
+		/** node is a doctype. */
+		readonly DOCUMENT_TYPE_NODE: 10;
+		/** node is a DocumentFragment node. */
+		readonly DOCUMENT_FRAGMENT_NODE: 11;
+		readonly NOTATION_NODE: 12;
+		/** Set when node and other are not in the same tree. */
+		readonly DOCUMENT_POSITION_DISCONNECTED: 0x01;
+		/** Set when other is preceding node. */
+		readonly DOCUMENT_POSITION_PRECEDING: 0x02;
+		/** Set when other is following node. */
+		readonly DOCUMENT_POSITION_FOLLOWING: 0x04;
+		/** Set when other is an ancestor of node. */
+		readonly DOCUMENT_POSITION_CONTAINS: 0x08;
+		/** Set when other is a descendant of node. */
+		readonly DOCUMENT_POSITION_CONTAINED_BY: 0x10;
+		readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 0x20;
 	}
 
-	interface DOMImplementation {
+	var Node: InstanceOf<Node> & {
+		/** node is an element. */
+		readonly ELEMENT_NODE: 1;
+		readonly ATTRIBUTE_NODE: 2;
+		/** node is a Text node. */
+		readonly TEXT_NODE: 3;
+		/** node is a CDATASection node. */
+		readonly CDATA_SECTION_NODE: 4;
+		readonly ENTITY_REFERENCE_NODE: 5;
+		readonly ENTITY_NODE: 6;
+		/** node is a ProcessingInstruction node. */
+		readonly PROCESSING_INSTRUCTION_NODE: 7;
+		/** node is a Comment node. */
+		readonly COMMENT_NODE: 8;
+		/** node is a document. */
+		readonly DOCUMENT_NODE: 9;
+		/** node is a doctype. */
+		readonly DOCUMENT_TYPE_NODE: 10;
+		/** node is a DocumentFragment node. */
+		readonly DOCUMENT_FRAGMENT_NODE: 11;
+		readonly NOTATION_NODE: 12;
+		/** Set when node and other are not in the same tree. */
+		readonly DOCUMENT_POSITION_DISCONNECTED: 0x01;
+		/** Set when other is preceding node. */
+		readonly DOCUMENT_POSITION_PRECEDING: 0x02;
+		/** Set when other is following node. */
+		readonly DOCUMENT_POSITION_FOLLOWING: 0x04;
+		/** Set when other is an ancestor of node. */
+		readonly DOCUMENT_POSITION_CONTAINS: 0x08;
+		/** Set when other is a descendant of node. */
+		readonly DOCUMENT_POSITION_CONTAINED_BY: 0x10;
+		readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 0x20;
+	};
+
+	/**
+	 * A DOM element's attribute as an object. In most DOM methods, you will probably directly
+	 * retrieve the attribute as a string (e.g., Element.getAttribute(), but certain functions (e.g.,
+	 * Element.getAttributeNode()) or means of iterating give Attr types.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr)
+	 */
+	interface Attr extends Node {
+		readonly nodeType: typeof Node.ATTRIBUTE_NODE;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/name) */
+		readonly name: string;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/namespaceURI) */
+		readonly namespaceURI: string | null;
+		readonly ownerDocument: Document;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/ownerElement) */
+		readonly ownerElement: Element | null;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/prefix) */
+		readonly prefix: string | null;
+		/**
+		 * @deprecated
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/specified)
+		 */
+		readonly specified: true;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr/value) */
+		value: string;
+	}
+	/**
+	 * A DOM element's attribute as an object. In most DOM methods, you will probably directly
+	 * retrieve the attribute as a string (e.g., Element.getAttribute(), but certain functions (e.g.,
+	 * Element.getAttributeNode()) or means of iterating give Attr types.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Attr)
+	 */
+	var Attr: InstanceOf<Attr>;
+
+	/**
+	 * 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,
+	 * 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
+	 */
+	class NamedNodeMap implements Iterable<Attr> {
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NamedNodeMap/length) */
+		readonly length: number;
+		/**
+		 * Get an attribute by name. Note: Name is in lower case in case of HTML namespace and
+		 * document.
+		 *
+		 * @param {string} localName
+		 * The local name of the attribute.
+		 * @returns {Attr | null}
+		 * The attribute with the given local name, or null if no such attribute exists.
+		 * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name
+		 */
+		getNamedItem(qualifiedName: string): Attr | null;
+		/**
+		 * Get an attribute by namespace and local name.
+		 *
+		 * @param {string | null} namespaceURI
+		 * The namespace URI of the attribute.
+		 * @param {string} localName
+		 * The local name of the attribute.
+		 * @returns {Attr | null}
+		 * The attribute with the given namespace URI and local name, or null if no such attribute
+		 * exists.
+		 * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-namespace
+		 */
+		getNamedItemNS(namespace: string | null, localName: string): Attr | null;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/NamedNodeMap/item) */
+		item(index: number): Attr | null;
+
+		/**
+		 * Removes an attribute specified by the local name.
+		 *
+		 * @param {string} localName
+		 * The local name of the attribute to be removed.
+		 * @returns {Attr}
+		 * The attribute node that was removed.
+		 * @throws {DOMException}
+		 * With code:
+		 * - {@link DOMException.NOT_FOUND_ERR} if no attribute with the given name is found.
+		 * @see https://dom.spec.whatwg.org/#dom-namednodemap-removenameditem
+		 * @see https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-name
+		 */
+		removeNamedItem(qualifiedName: string): Attr;
+		/**
+		 * Removes an attribute specified by the namespace and local name.
+		 *
+		 * @param {string | null} namespaceURI
+		 * The namespace URI of the attribute to be removed.
+		 * @param {string} localName
+		 * The local name of the attribute to be removed.
+		 * @returns {Attr}
+		 * The attribute node that was removed.
+		 * @throws {DOMException}
+		 * With code:
+		 * - {@link DOMException.NOT_FOUND_ERR} if no attribute with the given namespace URI and
+		 * local name is found.
+		 * @see https://dom.spec.whatwg.org/#dom-namednodemap-removenameditemns
+		 * @see https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-namespace
+		 */
+		removeNamedItemNS(namespace: string | null, localName: string): Attr;
+		/**
+		 * Set an attribute.
+		 *
+		 * @param {Attr} attr
+		 * The attribute to set.
+		 * @returns {Attr | null}
+		 * The old attribute with the same local name and namespace URI as the new one, or null if no
+		 * such attribute exists.
+		 * @throws {DOMException}
+		 * With code:
+		 * - {@link INUSE_ATTRIBUTE_ERR} - If the attribute is already an attribute of another
+		 * element.
+		 * @see https://dom.spec.whatwg.org/#concept-element-attributes-set
+		 */
+		setNamedItem(attr: Attr): Attr | null;
+		/**
+		 * Set an attribute, replacing an existing attribute with the same local name and namespace
+		 * URI if one exists.
+		 *
+		 * @param {Attr} attr
+		 * The attribute to set.
+		 * @returns {Attr | null}
+		 * The old attribute with the same local name and namespace URI as the new one, or null if no
+		 * such attribute exists.
+		 * @throws {DOMException}
+		 * Throws a DOMException with the name "InUseAttributeError" if the attribute is already an
+		 * attribute of another element.
+		 * @see https://dom.spec.whatwg.org/#concept-element-attributes-set
+		 */
+		setNamedItemNS(attr: Attr): Attr | null;
+		[index: number]: Attr;
+		[Symbol.iterator](): Iterator<Attr>;
+	}
+
+	/**
+	 * NodeList objects are collections of nodes, usually returned by properties such as
+	 * Node.childNodes and methods such as document.querySelectorAll().
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList)
+	 */
+	class NodeList implements Iterable<Node> {
+		/**
+		 * Returns the number of nodes in the collection.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/length)
+		 */
+		readonly length: number;
+		/**
+		 * Returns the node with index index from the collection. The nodes are sorted in tree order.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/item)
+		 */
+		item(index: number): Node | null;
+		/**
+		 * Returns a string representation of the NodeList.
+		 */
+		toString(nodeFilter: (node: Node) => Node | undefined): string;
+		/**
+		 * Filters the NodeList based on a predicate.
+		 *
+		 * @private
+		 */
+		filter(predicate: (node: Node) => boolean): Node[];
+		/**
+		 * Returns the first index at which a given node can be found in the NodeList, or -1 if it is
+		 * not present.
+		 *
+		 * @private
+		 */
+		indexOf(node: Node): number;
+		[index: number]: Node | undefined;
+
+		[Symbol.iterator](): Iterator<Node>;
+	}
+
+	/**
+	 * Represents a live collection of nodes that is automatically updated when its associated
+	 * document changes.
+	 */
+	interface LiveNodeList extends NodeList {}
+	/**
+	 * Represents a live collection of nodes that is automatically updated when its associated
+	 * document changes.
+	 */
+	var LiveNodeList: InstanceOf<LiveNodeList>;
+
+	/**
+	 * Element is the most general base class from which all objects in a Document inherit. It only
+	 * has methods and properties common to all kinds of elements. More specific classes inherit from
+	 * Element.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element)
+	 */
+	interface Element extends Node {
+		readonly nodeType: typeof Node.ELEMENT_NODE;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/attributes) */
+		readonly attributes: NamedNodeMap;
+		/**
+		 * Returns element's first attribute whose qualified name is qualifiedName, and null if there
+		 * is no such attribute otherwise.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getAttribute)
+		 */
+		getAttribute(qualifiedName: string): string | null;
+		/**
+		 * Returns element's attribute whose namespace is namespace and local name is localName, and
+		 * null if there is no such attribute otherwise.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getAttributeNS)
+		 */
+		getAttributeNS(namespace: string | null, localName: string): string | null;
+		/**
+		 * Returns the qualified names of all element's attributes. Can contain duplicates.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getAttributeNames)
+		 */
+		getAttributeNames(): string[];
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getAttributeNode) */
+		getAttributeNode(qualifiedName: string): Attr | null;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getAttributeNodeNS) */
+		getAttributeNodeNS(
+			namespace: string | null,
+			localName: string
+		): Attr | null;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getBoundingClientRect) */
+
+		/**
+		 * 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.
+		 *
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByTagName
+		 * @see https://dom.spec.whatwg.org/#concept-getelementsbytagname
+		 */
+		getElementsByTagName(qualifiedName: string): LiveNodeList;
+
+		/**
+		 * Returns a `LiveNodeList` of elements with the given tag name belonging to the given
+		 * namespace. It is similar to `Document.getElementsByTagNameNS`, except that its search is
+		 * restricted to descendants of the specified element.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getElementsByTagNameNS)
+		 * */
+		getElementsByTagNameNS(
+			namespaceURI: string | null,
+			localName: string
+		): LiveNodeList;
+
+		getQualifiedName(): string;
+		/**
+		 * Returns true if element has an attribute whose qualified name is qualifiedName, and false
+		 * otherwise.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/hasAttribute)
+		 */
+		hasAttribute(qualifiedName: string): boolean;
+		/**
+		 * Returns true if element has an attribute whose namespace is namespace and local name is
+		 * localName.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/hasAttributeNS)
+		 */
+		hasAttributeNS(namespace: string | null, localName: string): boolean;
+		/**
+		 * Returns true if element has attributes, and false otherwise.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/hasAttributes)
+		 */
+		hasAttributes(): boolean;
+		/**
+		 * Removes element's first attribute whose qualified name is qualifiedName.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttribute)
+		 */
+		removeAttribute(qualifiedName: string): void;
+		/**
+		 * Removes element's attribute whose namespace is namespace and local name is localName.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttributeNS)
+		 */
+		removeAttributeNS(namespace: string | null, localName: string): void;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/removeAttributeNode) */
+		removeAttributeNode(attr: Attr): Attr;
+		/**
+		 * Sets the value of element's first attribute whose qualified name is qualifiedName to value.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/setAttribute)
+		 */
+		setAttribute(qualifiedName: string, value: string): void;
+		/**
+		 * Sets the value of element's attribute whose namespace is namespace and local name is
+		 * localName to value.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/setAttributeNS)
+		 */
+		setAttributeNS(
+			namespace: string | null,
+			qualifiedName: string,
+			value: string
+		): void;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/setAttributeNode) */
+		setAttributeNode(attr: Attr): Attr | null;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/setAttributeNodeNS) */
+		setAttributeNodeNS(attr: Attr): Attr | null;
+	}
+	/**
+	 * Element is the most general base class from which all objects in a Document inherit. It only
+	 * has methods and properties common to all kinds of elements. More specific classes inherit from
+	 * Element.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element)
+	 */
+	var Element: InstanceOf<Element>;
+
+	/**
+	 * The CharacterData abstract interface represents a Node object that contains characters. This
+	 * is an abstract interface, meaning there aren't any object of type CharacterData: it is
+	 * implemented by other interfaces, like Text, Comment, or ProcessingInstruction which aren't
+	 * abstract.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData)
+	 */
+	interface CharacterData extends Node {
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/data) */
+		data: string;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/length) */
+		readonly length: number;
+		readonly ownerDocument: Document;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/appendData) */
+		appendData(data: string): void;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/deleteData) */
+		deleteData(offset: number, count: number): void;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/insertData) */
+		insertData(offset: number, data: string): void;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/replaceData) */
+		replaceData(offset: number, count: number, data: string): void;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/substringData) */
+		substringData(offset: number, count: number): string;
+	}
+	/**
+	 * The CharacterData abstract interface represents a Node object that contains characters. This
+	 * is an abstract interface, meaning there aren't any object of type CharacterData: it is
+	 * implemented by other interfaces, like Text, Comment, or ProcessingInstruction which aren't
+	 * abstract.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData)
+	 */
+	var CharacterData: {
+		// instanceof pre ts 5.3
+		(val: unknown): val is CharacterData;
+		// instanceof post ts 5.3
+		[Symbol.hasInstance](val: unknown): val is CharacterData;
+	};
+
+	/**
+	 * The textual content of Element or Attr. If an element has no markup within its content, it has
+	 * a single child implementing Text that contains the element's text. However, if the element
+	 * contains markup, it is parsed into information items and Text nodes that form its children.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Text)
+	 */
+	interface Text extends CharacterData {
+		nodeName: '#text' | '#cdata-section';
+		nodeType: typeof Node.TEXT_NODE | typeof Node.CDATA_SECTION_NODE;
+		/**
+		 * Splits data at the given offset and returns the remainder as Text node.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Text/splitText)
+		 */
+		splitText(offset: number): Text;
+	}
+
+	/**
+	 * The textual content of Element or Attr. If an element has no markup within its content, it has
+	 * a single child implementing Text that contains the element's text. However, if the element
+	 * contains markup, it is parsed into information items and Text nodes that form its children.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Text)
+	 */
+	var Text: InstanceOf<Text>;
+
+	/**
+	 * The Comment interface represents textual notations within markup; although it is generally not
+	 * visually shown, such comments are available to be read in the source view. Comments are
+	 * represented in HTML and XML as content between '<!--' and '-->'. In XML, like inside SVG or
+	 * MathML markup, the character sequence '--' cannot be used within a comment.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Comment)
+	 */
+	interface Comment extends CharacterData {
+		nodeName: '#comment';
+		nodeType: typeof Node.COMMENT_NODE;
+	}
+	/**
+	 * The Comment interface represents textual notations within markup; although it is generally not
+	 * visually shown, such comments are available to be read in the source view. Comments are
+	 * represented in HTML and XML as content between '<!--' and '-->'. In XML, like inside SVG or
+	 * MathML markup, the character sequence '--' cannot be used within a comment.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Comment)
+	 */
+	var Comment: InstanceOf<Comment>;
+
+	/**
+	 * A CDATA section that can be used within XML to include extended portions of unescaped text.
+	 * The symbols < and & don’t need escaping as they normally do when inside a CDATA section.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CDATASection)
+	 */
+	interface CDATASection extends Text {
+		nodeName: '#cdata-section';
+		nodeType: typeof Node.CDATA_SECTION_NODE;
+	}
+	/**
+	 * A CDATA section that can be used within XML to include extended portions of unescaped text.
+	 * The symbols < and & don’t need escaping as they normally do when inside a CDATA section.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CDATASection)
+	 */
+	var CDATASection: InstanceOf<CDATASection>;
+
+	/**
+	 * The DocumentFragment interface represents a minimal document object that has no parent.
+	 * It is used as a lightweight version of Document that stores a segment of a document structure
+	 * comprised of nodes just like a standard document.
+	 * The key difference is due to the fact that the document fragment isn't part
+	 * of the active document tree structure.
+	 * Changes made to the fragment don't affect the document.
+	 */
+	interface DocumentFragment extends Node {
+		readonly ownerDocument: Document;
+		getElementById(elementId: string): Element | null;
+	}
+	var DocumentFragment: InstanceOf<DocumentFragment>;
+
+	interface Entity extends Node {
+		nodeType: typeof Node.ENTITY_NODE;
+	}
+	var Entity: InstanceOf<Entity>;
+
+	interface EntityReference extends Node {
+		nodeType: typeof Node.ENTITY_REFERENCE_NODE;
+	}
+	var EntityReference: InstanceOf<EntityReference>;
+
+	interface Notation extends Node {
+		nodeType: typeof Node.NOTATION_NODE;
+	}
+	var Notation: InstanceOf<Notation>;
+
+	interface ProcessingInstruction extends Node {
+		nodeType: typeof Node.PROCESSING_INSTRUCTION_NODE;
+	}
+	var ProcessingInstruction: InstanceOf<ProcessingInstruction>;
+
+	interface Document extends Node {
+		/**
+		 * The mime type of the document is determined at creation time and can not be modified.
+		 *
+		 * @see https://dom.spec.whatwg.org/#concept-document-content-type
+		 * @see {@link DOMImplementation}
+		 * @see {@link MIME_TYPE}
+		 */
+		readonly contentType: MIME_TYPE;
+		/**
+		 * @see https://dom.spec.whatwg.org/#concept-document-type
+		 * @see {@link DOMImplementation}
+		 */
+		readonly type: 'html' | 'xml';
+		/**
+		 * The implementation that created this document.
+		 *
+		 * @type DOMImplementation
+		 * @readonly
+		 */
+		readonly implementation: DOMImplementation;
+		readonly ownerDocument: Document;
+		readonly nodeName: '#document';
+		readonly nodeType: typeof Node.DOCUMENT_NODE;
+		readonly doctype: DocumentType | null;
+
+		/**
+		 * Creates an attribute object with a specified name.
+		 *
+		 * @param name
+		 * String that sets the attribute object's name.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createAttribute)
+		 */
+		createAttribute(localName: string): Attr;
+
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createAttributeNS) */
+		createAttributeNS(namespace: string | null, qualifiedName: string): Attr;
+
+		/**
+		 * Returns a CDATASection node whose data is data.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createCDATASection)
+		 */
+		createCDATASection(data: string): CDATASection;
+
+		/**
+		 * Creates a comment object with the specified data.
+		 *
+		 * @param data
+		 * Sets the comment object's data.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createComment)
+		 */
+		createComment(data: string): Comment;
+
+		/**
+		 * Creates a new document.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createDocumentFragment)
+		 */
+		createDocumentFragment(): DocumentFragment;
+
+
+		createElement(tagName: string): Element;
+
+		/**
+		 * Returns an element with namespace namespace. Its namespace prefix will be everything before
+		 * ":" (U+003E) in qualifiedName or null. Its local name will be everything after ":" (U+003E)
+		 * in qualifiedName or qualifiedName.
+		 *
+		 * If localName does not match the Name production an "InvalidCharacterError" DOMException will
+		 * be thrown.
+		 *
+		 * If one of the following conditions is true a "NamespaceError" DOMException will be thrown:
+		 *
+		 * localName does not match the QName production.
+		 * Namespace prefix is not null and namespace is the empty string.
+		 * Namespace prefix is "xml" and namespace is not the XML namespace.
+		 * qualifiedName or namespace prefix is "xmlns" and namespace is not the XMLNS namespace.
+		 * namespace is the XMLNS namespace and neither qualifiedName nor namespace prefix is "xmlns".
+		 *
+		 * When supplied, options's is can be used to create a customized built-in element.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createElementNS)
+		 */
+		createElementNS(
+			namespace: string | null,
+			qualifiedName: string,
+		): Element;
+
+		/**
+		 * Returns a ProcessingInstruction node whose target is target and data is data. If target does
+		 * not match the Name production an "InvalidCharacterError" DOMException will be thrown. If
+		 * data contains "?>" an "InvalidCharacterError" DOMException will be thrown.
+		 *
+		 * [MDN
+		 * Reference](https://developer.mozilla.org/docs/Web/API/Document/createProcessingInstruction)
+		 */
+		createProcessingInstruction(
+			target: string,
+			data: string
+		): ProcessingInstruction;
+
+		/**
+		 * Creates a text string from the specified value.
+		 *
+		 * @param data
+		 * String that specifies the nodeValue property of the text node.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/createTextNode)
+		 */
+		createTextNode(data: string): Text;
+
+		/**
+		 * Returns a reference to the first object with the specified value of the ID attribute.
+		 *
+		 * @param elementId
+		 * String that specifies the ID value.
+		 */
+		getElementById(elementId: string): Element | null;
+
+		/**
+		 * 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.
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName
+		 * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname
+		 */
+		getElementsByClassName(classNames: string): LiveNodeList;
+
+		/**
+		 * Returns a LiveNodeList of elements with the given qualifiedName.
+		 * Searching for all descendants can be done by passing `*` as `qualifiedName`.
+		 *
+		 * The complete document is searched, including the root node.
+		 * 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.
+		 *
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByTagName
+		 * @see https://dom.spec.whatwg.org/#concept-getelementsbytagname
+		 */
+		getElementsByTagName(qualifiedName: string): LiveNodeList;
+
+		/**
+		 * Returns a `LiveNodeList` of elements with the given tag name belonging to the given
+		 * namespace. The complete document is searched, including the root node.
+		 *
+		 * 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.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Element/getElementsByTagNameNS)
+		 * */
+		getElementsByTagNameNS(
+			namespaceURI: string | null,
+			localName: string
+		): LiveNodeList;
+		/**
+		 * Returns a copy of node. If deep is true, the copy also includes the node's descendants.
+		 *
+		 * If node is a document or a shadow root, throws a "NotSupportedError" DOMException.
+		 *
+		 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/importNode)
+		 */
+		importNode<T extends Node>(node: T, deep?: boolean): T;
+	}
+
+	var Document: InstanceOf<Document>;
+
+	/**
+	 * A Node containing a doctype.
+	 *
+	 * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DocumentType)
+	 */
+	interface DocumentType extends Node {
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DocumentType/name) */
+		readonly name: string;
+		readonly internalSubset: string;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DocumentType/publicId) */
+		readonly publicId: string;
+		/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DocumentType/systemId) */
+		readonly systemId: string;
+	}
+
+	var DocumentType: InstanceOf<DocumentFragment>;
+
+	class DOMImplementation {
 		/**
 		 * The DOMImplementation interface represents an object providing methods which are not
 		 * dependent on any particular document.
@@ -151,7 +1267,7 @@ declare module '@xmldom/xmldom' {
 		 * @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;
+		constructor();
 
 		/**
 		 * Creates an XML Document object of the specified type with its document element.
@@ -161,7 +1277,8 @@ declare module '@xmldom/xmldom' {
 		 * `type` set to `'xml'`).
 		 * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.
 		 *
-		 * @returns {Document} The XML document.
+		 * @returns {Document}
+		 * The XML document.
 		 * @see {@link 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
@@ -169,7 +1286,7 @@ declare module '@xmldom/xmldom' {
 		 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument DOM Level 2 Core
 		 */
 		createDocument(
-			namespaceURI: string | null,
+			namespaceURI: NAMESPACE | string | null,
 			qualifiedName: string,
 			doctype?: DocumentType | null
 		): Document;
@@ -180,9 +1297,10 @@ declare module '@xmldom/xmldom' {
 		 * __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()`
+		 * @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
@@ -202,7 +1320,7 @@ declare module '@xmldom/xmldom' {
 		 * __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.
+		 * - several properties and methods are missing - Nothing related to events is implemented.
 		 *
 		 * @see {@link DOMImplementation.createDocument}
 		 * @see https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument
@@ -226,15 +1344,24 @@ declare module '@xmldom/xmldom' {
 		hasFeature(feature: string, version?: string): true;
 	}
 
-	var XMLSerializer: XMLSerializerStatic;
-	interface XMLSerializerStatic {
-		new (): XMLSerializer;
+	class XMLSerializer {
+		serializeToString(node: Node, nodeFilter?: (node: Node) => boolean): string;
 	}
+
 	// 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._.
+	 *
+	 * @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
+	 */
+	class DOMParser {
 		/**
 		 * The DOMParser interface provides the ability to parse XML or HTML source code from a
 		 * string into a DOM `Document`.
@@ -247,20 +1374,8 @@ declare module '@xmldom/xmldom' {
 		 * @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;
-	}
+		constructor(options?: DOMParserOptions);
 
-	/**
-	 * 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 {
 		/**
 		 * Parses `source` using the options in the way configured by the `DOMParserOptions` of
 		 * `this`
@@ -275,21 +1390,16 @@ declare module '@xmldom/xmldom' {
 		 * - 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`.
 		 *
-		 * @returns The `Document` node.
+		 * @returns
+		 * The `Document` node.
 		 * @throws {ParseError}
 		 * for any `fatalError` or anything that is thrown by `onError`
-		 * @throws {TypeError} for any invalid `mimeType`
+		 * @throws {TypeError}
+		 * for any invalid `mimeType`
 		 * @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, nodeFilter?: (node: Node) => boolean): string;
+		parseFromString(source: string, mimeType: MIME_TYPE | string): Document;
 	}
 
 	interface DOMParserOptions {
@@ -298,7 +1408,7 @@ declare module '@xmldom/xmldom' {
 		 * which is used to copy values from the options before they are used for parsing.
 		 *
 		 * @private
-		 * @see {@link conventions.assign}
+		 * @see {@link assign}
 		 */
 		readonly assign?: typeof Object.assign;
 		/**
@@ -319,7 +1429,8 @@ declare module '@xmldom/xmldom' {
 		 * but it receives different argument types than before 0.9.0.
 		 *
 		 * @deprecated
-		 * @throws {TypeError} If it is an object.
+		 * @throws {TypeError}
+		 * If it is an object.
 		 */
 		readonly errorHandler?: ErrorHandlerFunction;
 
@@ -381,6 +1492,7 @@ declare module '@xmldom/xmldom' {
 	 * @see {@link onWarningStopParsing}
 	 */
 	function onErrorStopParsing(): void | never;
+
 	/**
 	 * A method that prevents any further parsing when an `error`
 	 * with any level is reported during parsing.
@@ -389,5 +1501,6 @@ declare module '@xmldom/xmldom' {
 	 * @see {@link onErrorStopParsing}
 	 */
 	function onWarningStopParsing(): never;
+
 	// END ./lib/dom-parser.js
 }