html-react-parser 6.1.6 → 6.1.8

package/dist/html-react-parser.js

@@ -58,6 +58,414 @@
 
 	var utilities$1 = {};
 
+	var node = {};
+
+	var dist$2 = {};
+
+	var hasRequiredDist$1;
+
+	function requireDist$1 () {
+		if (hasRequiredDist$1) return dist$2;
+		hasRequiredDist$1 = 1;
+		(function (exports) {
+			//#region node_modules/domelementtype/dist/index.js
+			/** Types of elements found in htmlparser2's DOM */
+			var ElementType;
+			(function(ElementType) {
+				/** Type for the root element of a document */
+				ElementType["Root"] = "root";
+				/** Type for Text */
+				ElementType["Text"] = "text";
+				/** Type for <? ... ?> */
+				ElementType["Directive"] = "directive";
+				/** Type for <!-- ... --> */
+				ElementType["Comment"] = "comment";
+				/** Type for <script> tags */
+				ElementType["Script"] = "script";
+				/** Type for <style> tags */
+				ElementType["Style"] = "style";
+				/** Type for Any tag */
+				ElementType["Tag"] = "tag";
+				/** Type for <![CDATA[ ... ]]> */
+				ElementType["CDATA"] = "cdata";
+				/** Type for <!doctype ...> */
+				ElementType["Doctype"] = "doctype";
+			})(ElementType || (ElementType = {}));
+			/**
+			* Tests whether an element is a tag or not.
+			* @param element Element to test
+			* @param element.type Node type discriminator to check.
+			*/
+			function isTag(element) {
+				return element.type === ElementType.Tag || element.type === ElementType.Script || element.type === ElementType.Style;
+			}
+			ElementType.Root;
+			ElementType.Text;
+			ElementType.Directive;
+			ElementType.Comment;
+			ElementType.Script;
+			ElementType.Style;
+			ElementType.Tag;
+			ElementType.CDATA;
+			ElementType.Doctype;
+			//#endregion
+			Object.defineProperty(exports, "ElementType", {
+				enumerable: true,
+				get: function() {
+					return ElementType;
+				}
+			});
+			exports.isTag = isTag;
+
+			
+		} (dist$2));
+		return dist$2;
+	}
+
+	var hasRequiredNode;
+
+	function requireNode () {
+		if (hasRequiredNode) return node;
+		hasRequiredNode = 1;
+		const require_index = requireDist$1();
+		//#region node_modules/domhandler/dist/node.js
+		/**
+		* This object will be used as the prototype for Nodes when creating a
+		* DOM-Level-1-compliant structure.
+		*/
+		var Node = class {
+			/** Parent of the node */
+			parent = null;
+			/** Previous sibling */
+			prev = null;
+			/** Next sibling */
+			next = null;
+			/** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
+			startIndex = null;
+			/** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
+			endIndex = null;
+			/**
+			* Same as {@link parent}.
+			* [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+			*/
+			get parentNode() {
+				return this.parent;
+			}
+			set parentNode(parent) {
+				this.parent = parent;
+			}
+			/**
+			* Same as {@link prev}.
+			* [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+			*/
+			get previousSibling() {
+				return this.prev;
+			}
+			set previousSibling(previous) {
+				this.prev = previous;
+			}
+			/**
+			* Same as {@link next}.
+			* [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+			*/
+			get nextSibling() {
+				return this.next;
+			}
+			set nextSibling(next) {
+				this.next = next;
+			}
+			/**
+			* Clone this node, and optionally its children.
+			* @param recursive Clone child nodes as well.
+			* @returns A clone of the node.
+			*/
+			cloneNode(recursive = false) {
+				return cloneNode(this, recursive);
+			}
+		};
+		/**
+		* A node that contains some data.
+		*/
+		var DataNode = class extends Node {
+			data;
+			/**
+			* @param data The content of the data node
+			*/
+			constructor(data) {
+				super();
+				this.data = data;
+			}
+			/**
+			* Same as {@link data}.
+			* [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+			*/
+			get nodeValue() {
+				return this.data;
+			}
+			set nodeValue(data) {
+				this.data = data;
+			}
+		};
+		/**
+		* Text within the document.
+		*/
+		var Text = class extends DataNode {
+			type = require_index.ElementType.Text;
+			get nodeType() {
+				return 3;
+			}
+		};
+		/**
+		* Comments within the document.
+		*/
+		var Comment = class extends DataNode {
+			type = require_index.ElementType.Comment;
+			get nodeType() {
+				return 8;
+			}
+		};
+		/**
+		* Processing instructions, including doc types.
+		*/
+		var ProcessingInstruction = class extends DataNode {
+			type = require_index.ElementType.Directive;
+			name;
+			constructor(name, data) {
+				super(data);
+				this.name = name;
+			}
+			get nodeType() {
+				return 1;
+			}
+			/** If this is a doctype, the document type name (parse5 only). */
+			"x-name";
+			/** If this is a doctype, the document type public identifier (parse5 only). */
+			"x-publicId";
+			/** If this is a doctype, the document type system identifier (parse5 only). */
+			"x-systemId";
+		};
+		/**
+		* A node that can have children.
+		*/
+		var NodeWithChildren = class extends Node {
+			children;
+			/**
+			* @param children Children of the node. Only certain node types can have children.
+			*/
+			constructor(children) {
+				super();
+				this.children = children;
+			}
+			/** First child of the node. */
+			get firstChild() {
+				return this.children[0] ?? null;
+			}
+			/** Last child of the node. */
+			get lastChild() {
+				return this.children.length > 0 ? this.children[this.children.length - 1] : null;
+			}
+			/**
+			* Same as {@link children}.
+			* [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+			*/
+			get childNodes() {
+				return this.children;
+			}
+			set childNodes(children) {
+				this.children = children;
+			}
+		};
+		/**
+		* CDATA nodes.
+		*/
+		var CDATA = class extends NodeWithChildren {
+			type = require_index.ElementType.CDATA;
+			get nodeType() {
+				return 4;
+			}
+		};
+		/**
+		* The root node of the document.
+		*/
+		var Document = class extends NodeWithChildren {
+			type = require_index.ElementType.Root;
+			get nodeType() {
+				return 9;
+			}
+		};
+		/**
+		* An element within the DOM.
+		*/
+		var Element = class extends NodeWithChildren {
+			name;
+			attribs;
+			type;
+			/**
+			* @param name Name of the tag, eg. `div`, `span`.
+			* @param attribs Object mapping attribute names to attribute values.
+			* @param children Children of the node.
+			* @param type Node type used for the new node instance.
+			*/
+			constructor(name, attribs, children = [], type = name === "script" ? require_index.ElementType.Script : name === "style" ? require_index.ElementType.Style : require_index.ElementType.Tag) {
+				super(children);
+				this.name = name;
+				this.attribs = attribs;
+				this.type = type;
+			}
+			get nodeType() {
+				return 1;
+			}
+			/**
+			* Same as {@link name}.
+			* [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+			*/
+			get tagName() {
+				return this.name;
+			}
+			set tagName(name) {
+				this.name = name;
+			}
+			get attributes() {
+				return Object.keys(this.attribs).map((name) => ({
+					name,
+					value: this.attribs[name],
+					namespace: this["x-attribsNamespace"]?.[name],
+					prefix: this["x-attribsPrefix"]?.[name]
+				}));
+			}
+			/** Element namespace (parse5 only). */
+			namespace;
+			/** Element attribute namespaces (parse5 only). */
+			"x-attribsNamespace";
+			/** Element attribute namespace-related prefixes (parse5 only). */
+			"x-attribsPrefix";
+		};
+		/**
+		* Checks if `node` is an element node.
+		* @param node Node to check.
+		* @returns `true` if the node is an element node.
+		*/
+		function isTag(node) {
+			return require_index.isTag(node);
+		}
+		/**
+		* Checks if `node` is a CDATA node.
+		* @param node Node to check.
+		* @returns `true` if the node is a CDATA node.
+		*/
+		function isCDATA(node) {
+			return node.type === require_index.ElementType.CDATA;
+		}
+		/**
+		* Checks if `node` is a text node.
+		* @param node Node to check.
+		* @returns `true` if the node is a text node.
+		*/
+		function isText(node) {
+			return node.type === require_index.ElementType.Text;
+		}
+		/**
+		* Checks if `node` is a comment node.
+		* @param node Node to check.
+		* @returns `true` if the node is a comment node.
+		*/
+		function isComment(node) {
+			return node.type === require_index.ElementType.Comment;
+		}
+		/**
+		* Checks if `node` is a directive node.
+		* @param node Node to check.
+		* @returns `true` if the node is a directive node.
+		*/
+		function isDirective(node) {
+			return node.type === require_index.ElementType.Directive;
+		}
+		/**
+		* Checks if `node` is a document node.
+		* @param node Node to check.
+		* @returns `true` if the node is a document node.
+		*/
+		function isDocument(node) {
+			return node.type === require_index.ElementType.Root;
+		}
+		/**
+		* Clone a node, and optionally its children.
+		* @param node Node to clone.
+		* @param recursive Clone child nodes as well.
+		* @returns A clone of the node.
+		*/
+		function cloneNode(node, recursive = false) {
+			let result;
+			if (isText(node)) result = new Text(node.data);
+			else if (isComment(node)) result = new Comment(node.data);
+			else if (isTag(node)) {
+				const children = recursive ? cloneChildren(node.children) : [];
+				const clone = new Element(node.name, { ...node.attribs }, children);
+				for (const child of children) child.parent = clone;
+				if (node.namespace != null) clone.namespace = node.namespace;
+				if (node["x-attribsNamespace"]) clone["x-attribsNamespace"] = { ...node["x-attribsNamespace"] };
+				if (node["x-attribsPrefix"]) clone["x-attribsPrefix"] = { ...node["x-attribsPrefix"] };
+				result = clone;
+			} else if (isCDATA(node)) {
+				const children = recursive ? cloneChildren(node.children) : [];
+				const clone = new CDATA(children);
+				for (const child of children) child.parent = clone;
+				result = clone;
+			} else if (isDocument(node)) {
+				const children = recursive ? cloneChildren(node.children) : [];
+				const clone = new Document(children);
+				for (const child of children) child.parent = clone;
+				if (node["x-mode"]) clone["x-mode"] = node["x-mode"];
+				result = clone;
+			} else if (isDirective(node)) {
+				const instruction = new ProcessingInstruction(node.name, node.data);
+				if (node["x-name"] != null) {
+					instruction["x-name"] = node["x-name"];
+					instruction["x-publicId"] = node["x-publicId"];
+					instruction["x-systemId"] = node["x-systemId"];
+				}
+				result = instruction;
+			} else throw new Error(`Not implemented yet: ${node.type}`);
+			result.startIndex = node.startIndex;
+			result.endIndex = node.endIndex;
+			if (node.sourceCodeLocation != null) result.sourceCodeLocation = node.sourceCodeLocation;
+			return result;
+		}
+		/**
+		* Clone a list of child nodes.
+		* @param childs The child nodes to clone.
+		* @returns A list of cloned child nodes.
+		*/
+		function cloneChildren(childs) {
+			const children = childs.map((child) => cloneNode(child, true));
+			for (let index = 1; index < children.length; index++) {
+				children[index].prev = children[index - 1];
+				children[index - 1].next = children[index];
+			}
+			return children;
+		}
+		//#endregion
+		node.CDATA = CDATA;
+		node.Comment = Comment;
+		node.DataNode = DataNode;
+		node.Document = Document;
+		node.Element = Element;
+		node.Node = Node;
+		node.NodeWithChildren = NodeWithChildren;
+		node.ProcessingInstruction = ProcessingInstruction;
+		node.Text = Text;
+		node.cloneNode = cloneNode;
+		node.isCDATA = isCDATA;
+		node.isComment = isComment;
+		node.isDirective = isDirective;
+		node.isDocument = isDocument;
+		node.isTag = isTag;
+		node.isText = isText;
+
+		
+		return node;
+	}
+
 	var constants = {};
 
 	var hasRequiredConstants;
@@ -116,610 +524,13 @@
 		return constants;
 	}
 
-	/** Types of elements found in htmlparser2's DOM */
-	var ElementType;
-	(function (ElementType) {
-	    /** Type for the root element of a document */
-	    ElementType["Root"] = "root";
-	    /** Type for Text */
-	    ElementType["Text"] = "text";
-	    /** Type for <? ... ?> */
-	    ElementType["Directive"] = "directive";
-	    /** Type for <!-- ... --> */
-	    ElementType["Comment"] = "comment";
-	    /** Type for <script> tags */
-	    ElementType["Script"] = "script";
-	    /** Type for <style> tags */
-	    ElementType["Style"] = "style";
-	    /** Type for Any tag */
-	    ElementType["Tag"] = "tag";
-	    /** Type for <![CDATA[ ... ]]> */
-	    ElementType["CDATA"] = "cdata";
-	    /** Type for <!doctype ...> */
-	    ElementType["Doctype"] = "doctype";
-	})(ElementType || (ElementType = {}));
-	/**
-	 * Tests whether an element is a tag or not.
-	 * @param element Element to test
-	 * @param element.type Node type discriminator to check.
-	 */
-	function isTag$1(element) {
-	    return (element.type === ElementType.Tag ||
-	        element.type === ElementType.Script ||
-	        element.type === ElementType.Style);
-	}
-	// Exports for backwards compatibility
-	/** Type for the root element of a document */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Root;
-	/** Type for Text */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Text;
-	/** Type for <? ... ?> */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Directive;
-	/** Type for <!-- ... --> */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Comment;
-	/** Type for <script> tags */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Script;
-	/** Type for <style> tags */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Style;
-	/** Type for Any tag */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Tag;
-	/** Type for <![CDATA[ ... ]]> */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.CDATA;
-	/** Type for <!doctype ...> */
-	// eslint-disable-next-line prefer-destructuring
-	ElementType.Doctype;
-
-	/**
-	 * This object will be used as the prototype for Nodes when creating a
-	 * DOM-Level-1-compliant structure.
-	 */
-	class Node {
-	    /** Parent of the node */
-	    parent = null;
-	    /** Previous sibling */
-	    prev = null;
-	    /** Next sibling */
-	    next = null;
-	    /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
-	    startIndex = null;
-	    /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
-	    endIndex = null;
-	    // Read-write aliases for properties
-	    /**
-	     * Same as {@link parent}.
-	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-	     */
-	    get parentNode() {
-	        return this.parent;
-	    }
-	    set parentNode(parent) {
-	        this.parent = parent;
-	    }
-	    /**
-	     * Same as {@link prev}.
-	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-	     */
-	    get previousSibling() {
-	        return this.prev;
-	    }
-	    set previousSibling(previous) {
-	        this.prev = previous;
-	    }
-	    /**
-	     * Same as {@link next}.
-	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-	     */
-	    get nextSibling() {
-	        return this.next;
-	    }
-	    set nextSibling(next) {
-	        this.next = next;
-	    }
-	    /**
-	     * Clone this node, and optionally its children.
-	     * @param recursive Clone child nodes as well.
-	     * @returns A clone of the node.
-	     */
-	    cloneNode(recursive = false) {
-	        return cloneNode(this, recursive);
-	    }
-	}
-	/**
-	 * A node that contains some data.
-	 */
-	class DataNode extends Node {
-	    data;
-	    /**
-	     * @param data The content of the data node
-	     */
-	    constructor(data) {
-	        super();
-	        this.data = data;
-	    }
-	    /**
-	     * Same as {@link data}.
-	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-	     */
-	    get nodeValue() {
-	        return this.data;
-	    }
-	    set nodeValue(data) {
-	        this.data = data;
-	    }
-	}
-	/**
-	 * Text within the document.
-	 */
-	class Text extends DataNode {
-	    type = ElementType.Text;
-	    get nodeType() {
-	        return 3;
-	    }
-	}
-	/**
-	 * Comments within the document.
-	 */
-	class Comment extends DataNode {
-	    type = ElementType.Comment;
-	    get nodeType() {
-	        return 8;
-	    }
-	}
-	/**
-	 * Processing instructions, including doc types.
-	 */
-	class ProcessingInstruction extends DataNode {
-	    type = ElementType.Directive;
-	    name;
-	    constructor(name, data) {
-	        super(data);
-	        this.name = name;
-	    }
-	    get nodeType() {
-	        return 1;
-	    }
-	    /** If this is a doctype, the document type name (parse5 only). */
-	    "x-name";
-	    /** If this is a doctype, the document type public identifier (parse5 only). */
-	    "x-publicId";
-	    /** If this is a doctype, the document type system identifier (parse5 only). */
-	    "x-systemId";
-	}
-	/**
-	 * A node that can have children.
-	 */
-	class NodeWithChildren extends Node {
-	    children;
-	    /**
-	     * @param children Children of the node. Only certain node types can have children.
-	     */
-	    constructor(children) {
-	        super();
-	        this.children = children;
-	    }
-	    // Aliases
-	    /** First child of the node. */
-	    get firstChild() {
-	        return this.children[0] ?? null;
-	    }
-	    /** Last child of the node. */
-	    get lastChild() {
-	        return this.children.length > 0
-	            ? this.children[this.children.length - 1]
-	            : null;
-	    }
-	    /**
-	     * Same as {@link children}.
-	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-	     */
-	    get childNodes() {
-	        return this.children;
-	    }
-	    set childNodes(children) {
-	        this.children = children;
-	    }
-	}
-	/**
-	 * CDATA nodes.
-	 */
-	class CDATA extends NodeWithChildren {
-	    type = ElementType.CDATA;
-	    get nodeType() {
-	        return 4;
-	    }
-	}
-	/**
-	 * The root node of the document.
-	 */
-	class Document extends NodeWithChildren {
-	    type = ElementType.Root;
-	    get nodeType() {
-	        return 9;
-	    }
-	}
-	/**
-	 * An element within the DOM.
-	 */
-	class Element extends NodeWithChildren {
-	    name;
-	    attribs;
-	    type;
-	    /**
-	     * @param name Name of the tag, eg. `div`, `span`.
-	     * @param attribs Object mapping attribute names to attribute values.
-	     * @param children Children of the node.
-	     * @param type Node type used for the new node instance.
-	     */
-	    constructor(name, attribs, children = [], type = name === "script"
-	        ? ElementType.Script
-	        : name === "style"
-	            ? ElementType.Style
-	            : ElementType.Tag) {
-	        super(children);
-	        this.name = name;
-	        this.attribs = attribs;
-	        this.type = type;
-	    }
-	    get nodeType() {
-	        return 1;
-	    }
-	    // DOM Level 1 aliases
-	    /**
-	     * Same as {@link name}.
-	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-	     */
-	    get tagName() {
-	        return this.name;
-	    }
-	    set tagName(name) {
-	        this.name = name;
-	    }
-	    get attributes() {
-	        return Object.keys(this.attribs).map((name) => ({
-	            name,
-	            value: this.attribs[name],
-	            namespace: this["x-attribsNamespace"]?.[name],
-	            prefix: this["x-attribsPrefix"]?.[name],
-	        }));
-	    }
-	    /** Element namespace (parse5 only). */
-	    namespace;
-	    /** Element attribute namespaces (parse5 only). */
-	    "x-attribsNamespace";
-	    /** Element attribute namespace-related prefixes (parse5 only). */
-	    "x-attribsPrefix";
-	}
-	/**
-	 * Checks if `node` is an element node.
-	 * @param node Node to check.
-	 * @returns `true` if the node is an element node.
-	 */
-	function isTag(node) {
-	    return isTag$1(node);
-	}
-	/**
-	 * Checks if `node` is a CDATA node.
-	 * @param node Node to check.
-	 * @returns `true` if the node is a CDATA node.
-	 */
-	function isCDATA(node) {
-	    return node.type === ElementType.CDATA;
-	}
-	/**
-	 * Checks if `node` is a text node.
-	 * @param node Node to check.
-	 * @returns `true` if the node is a text node.
-	 */
-	function isText(node) {
-	    return node.type === ElementType.Text;
-	}
-	/**
-	 * Checks if `node` is a comment node.
-	 * @param node Node to check.
-	 * @returns `true` if the node is a comment node.
-	 */
-	function isComment(node) {
-	    return node.type === ElementType.Comment;
-	}
-	/**
-	 * Checks if `node` is a directive node.
-	 * @param node Node to check.
-	 * @returns `true` if the node is a directive node.
-	 */
-	function isDirective(node) {
-	    return node.type === ElementType.Directive;
-	}
-	/**
-	 * Checks if `node` is a document node.
-	 * @param node Node to check.
-	 * @returns `true` if the node is a document node.
-	 */
-	function isDocument(node) {
-	    return node.type === ElementType.Root;
-	}
-	/**
-	 * Checks if `node` has children.
-	 * @param node Node to check.
-	 * @returns `true` if the node has children.
-	 */
-	function hasChildren(node) {
-	    return Object.hasOwn(node, "children");
-	}
-	/**
-	 * Clone a node, and optionally its children.
-	 * @param node Node to clone.
-	 * @param recursive Clone child nodes as well.
-	 * @returns A clone of the node.
-	 */
-	function cloneNode(node, recursive = false) {
-	    let result;
-	    if (isText(node)) {
-	        result = new Text(node.data);
-	    }
-	    else if (isComment(node)) {
-	        result = new Comment(node.data);
-	    }
-	    else if (isTag(node)) {
-	        const children = recursive ? cloneChildren(node.children) : [];
-	        const clone = new Element(node.name, { ...node.attribs }, children);
-	        for (const child of children) {
-	            child.parent = clone;
-	        }
-	        if (node.namespace != null) {
-	            clone.namespace = node.namespace;
-	        }
-	        if (node["x-attribsNamespace"]) {
-	            clone["x-attribsNamespace"] = { ...node["x-attribsNamespace"] };
-	        }
-	        if (node["x-attribsPrefix"]) {
-	            clone["x-attribsPrefix"] = { ...node["x-attribsPrefix"] };
-	        }
-	        result = clone;
-	    }
-	    else if (isCDATA(node)) {
-	        const children = recursive ? cloneChildren(node.children) : [];
-	        const clone = new CDATA(children);
-	        for (const child of children) {
-	            child.parent = clone;
-	        }
-	        result = clone;
-	    }
-	    else if (isDocument(node)) {
-	        const children = recursive ? cloneChildren(node.children) : [];
-	        const clone = new Document(children);
-	        for (const child of children) {
-	            child.parent = clone;
-	        }
-	        if (node["x-mode"]) {
-	            clone["x-mode"] = node["x-mode"];
-	        }
-	        result = clone;
-	    }
-	    else if (isDirective(node)) {
-	        const instruction = new ProcessingInstruction(node.name, node.data);
-	        if (node["x-name"] != null) {
-	            instruction["x-name"] = node["x-name"];
-	            instruction["x-publicId"] = node["x-publicId"];
-	            instruction["x-systemId"] = node["x-systemId"];
-	        }
-	        result = instruction;
-	    }
-	    else {
-	        throw new Error(`Not implemented yet: ${node.type}`);
-	    }
-	    result.startIndex = node.startIndex;
-	    result.endIndex = node.endIndex;
-	    if (node.sourceCodeLocation != null) {
-	        result.sourceCodeLocation = node.sourceCodeLocation;
-	    }
-	    return result;
-	}
-	/**
-	 * Clone a list of child nodes.
-	 * @param childs The child nodes to clone.
-	 * @returns A list of cloned child nodes.
-	 */
-	function cloneChildren(childs) {
-	    const children = childs.map((child) => cloneNode(child, true));
-	    for (let index = 1; index < children.length; index++) {
-	        children[index].prev = children[index - 1];
-	        children[index - 1].next = children[index];
-	    }
-	    return children;
-	}
-
-	// Default options
-	const defaultOptions = {
-	    withStartIndices: false,
-	    withEndIndices: false,
-	    xmlMode: false,
-	};
-	/**
-	 * Event-based handler that builds a DOM tree from parser callbacks.
-	 */
-	class DomHandler {
-	    /** The elements of the DOM */
-	    dom = [];
-	    /** The root element for the DOM */
-	    root = new Document(this.dom);
-	    /** Called once parsing has completed. */
-	    callback;
-	    /** Settings for the handler. */
-	    options;
-	    /** Callback whenever a tag is closed. */
-	    elementCB;
-	    /** Indicated whether parsing has been completed. */
-	    done = false;
-	    /** Stack of open tags. */
-	    tagStack = [this.root];
-	    /** A data node that is still being written to. */
-	    lastNode = null;
-	    /** Reference to the parser instance. Used for location information. */
-	    parser = null;
-	    /**
-	     * @param callback Called once parsing has completed.
-	     * @param options Settings for the handler.
-	     * @param elementCB Callback whenever a tag is closed.
-	     */
-	    constructor(callback, options, elementCB) {
-	        // Make it possible to skip arguments, for backwards-compatibility
-	        if (typeof options === "function") {
-	            elementCB = options;
-	            options = defaultOptions;
-	        }
-	        if (typeof callback === "object") {
-	            options = callback;
-	            callback = undefined;
-	        }
-	        this.callback = callback ?? null;
-	        this.options = options ?? defaultOptions;
-	        this.elementCB = elementCB ?? null;
-	    }
-	    onparserinit(parser) {
-	        this.parser = parser;
-	    }
-	    // Resets the handler back to starting state
-	    onreset() {
-	        this.dom = [];
-	        this.root = new Document(this.dom);
-	        this.done = false;
-	        this.tagStack = [this.root];
-	        this.lastNode = null;
-	        this.parser = null;
-	    }
-	    // Signals the handler that parsing is done
-	    onend() {
-	        if (this.done)
-	            return;
-	        this.done = true;
-	        this.parser = null;
-	        this.handleCallback(null);
-	    }
-	    onerror(error) {
-	        this.handleCallback(error);
-	    }
-	    onclosetag() {
-	        this.lastNode = null;
-	        const element = this.tagStack.pop();
-	        if (this.options.withEndIndices && this.parser) {
-	            element.endIndex = this.parser.endIndex;
-	        }
-	        if (this.elementCB)
-	            this.elementCB(element);
-	    }
-	    onopentag(name, attribs) {
-	        const type = this.options.xmlMode ? ElementType.Tag : undefined;
-	        const element = new Element(name, attribs, undefined, type);
-	        this.addNode(element);
-	        this.tagStack.push(element);
-	    }
-	    ontext(data) {
-	        const { lastNode } = this;
-	        if (lastNode && lastNode.type === ElementType.Text) {
-	            lastNode.data += data;
-	            if (this.options.withEndIndices && this.parser) {
-	                lastNode.endIndex = this.parser.endIndex;
-	            }
-	        }
-	        else {
-	            const node = new Text(data);
-	            this.addNode(node);
-	            this.lastNode = node;
-	        }
-	    }
-	    oncomment(data) {
-	        if (this.lastNode && this.lastNode.type === ElementType.Comment) {
-	            this.lastNode.data += data;
-	            return;
-	        }
-	        const node = new Comment(data);
-	        this.addNode(node);
-	        this.lastNode = node;
-	    }
-	    oncommentend() {
-	        this.lastNode = null;
-	    }
-	    oncdatastart() {
-	        const text = new Text("");
-	        const node = new CDATA([text]);
-	        this.addNode(node);
-	        text.parent = node;
-	        this.lastNode = text;
-	    }
-	    oncdataend() {
-	        this.lastNode = null;
-	    }
-	    onprocessinginstruction(name, data) {
-	        const node = new ProcessingInstruction(name, data);
-	        this.addNode(node);
-	    }
-	    handleCallback(error) {
-	        if (typeof this.callback === "function") {
-	            this.callback(error, this.dom);
-	        }
-	        else if (error) {
-	            throw error;
-	        }
-	    }
-	    addNode(node) {
-	        const parent = this.tagStack[this.tagStack.length - 1];
-	        const previousSibling = parent.children[parent.children.length - 1];
-	        if (this.options.withStartIndices && this.parser) {
-	            node.startIndex = this.parser.startIndex;
-	        }
-	        if (this.options.withEndIndices && this.parser) {
-	            node.endIndex = this.parser.endIndex;
-	        }
-	        parent.children.push(node);
-	        if (previousSibling) {
-	            node.prev = previousSibling;
-	            previousSibling.next = node;
-	        }
-	        node.parent = parent;
-	        this.lastNode = null;
-	    }
-	}
-
-	var dist$1 = /*#__PURE__*/Object.freeze({
-		__proto__: null,
-		CDATA: CDATA,
-		Comment: Comment,
-		DataNode: DataNode,
-		Document: Document,
-		DomHandler: DomHandler,
-		Element: Element,
-		Node: Node,
-		NodeWithChildren: NodeWithChildren,
-		ProcessingInstruction: ProcessingInstruction,
-		Text: Text,
-		cloneNode: cloneNode,
-		default: DomHandler,
-		hasChildren: hasChildren,
-		isCDATA: isCDATA,
-		isComment: isComment,
-		isDirective: isDirective,
-		isDocument: isDocument,
-		isTag: isTag,
-		isText: isText
-	});
-
-	var require$$3 = /*@__PURE__*/getAugmentedNamespace(dist$1);
-
-	var hasRequiredUtilities$1;
+	var hasRequiredUtilities$1;
 
 	function requireUtilities$1 () {
 		if (hasRequiredUtilities$1) return utilities$1;
 		hasRequiredUtilities$1 = 1;
+		const require_node = requireNode();
 		const require_constants = requireConstants();
-		let domhandler = require$$3;
 		//#region src/client/utilities.ts
 		const CARRIAGE_RETURN = "\r";
 		const CARRIAGE_RETURN_REGEX = new RegExp(CARRIAGE_RETURN, "g");
@@ -813,16 +624,16 @@
 				switch (node.nodeType) {
 					case 1: {
 						const tagName = formatTagName(node.nodeName);
-						current = new domhandler.Element(tagName, formatAttributes(node.attributes));
+						current = new require_node.Element(tagName, formatAttributes(node.attributes));
 						current.children = formatDOM(tagName === "template" ? node.content.childNodes : node.childNodes, current);
 						break;
 					}
 					/* v8 ignore start */
 					case 3:
-						current = new domhandler.Text(revertEscapedCharacters(node.nodeValue ?? ""));
+						current = new require_node.Text(revertEscapedCharacters(node.nodeValue ?? ""));
 						break;
 					case 8:
-						current = new domhandler.Comment(node.nodeValue ?? "");
+						current = new require_node.Comment(node.nodeValue ?? "");
 						break;
 					/* v8 ignore stop */
 					default: continue;
@@ -835,7 +646,7 @@
 				domNodes.push(current);
 			}
 			if (directive) {
-				current = new domhandler.ProcessingInstruction(directive.substring(0, directive.indexOf(" ")).toLowerCase(), directive);
+				current = new require_node.ProcessingInstruction(directive.substring(0, directive.indexOf(" ")).toLowerCase(), directive);
 				current.next = domNodes[0] ?? null;
 				current.parent = parent;
 				domNodes.unshift(current);
@@ -2262,393 +2073,990 @@
 		    if (!prop) return;
 		    comment();
 
-		    // :
-		    if (!match(COLON_REGEX)) return error("property missing ':'");
+		    // :
+		    if (!match(COLON_REGEX)) return error("property missing ':'");
+
+		    // val
+		    var val = match(VALUE_REGEX);
+
+		    var ret = pos({
+		      type: TYPE_DECLARATION,
+		      property: prop[0].replace(COMMENT_REGEX, EMPTY_STRING).trim(),
+		      value: val
+		        ? val[0].replace(COMMENT_REGEX, EMPTY_STRING).trim()
+		        : EMPTY_STRING
+		    });
+
+		    // ;
+		    match(SEMICOLON_REGEX);
+
+		    return ret;
+		  }
+
+		  /**
+		   * Parse declarations.
+		   *
+		   * @return {Object[]}
+		   */
+		  function declarations() {
+		    var decls = [];
+
+		    comments(decls);
+
+		    // declarations
+		    var decl;
+		    while ((decl = declaration())) {
+		      decls.push(decl);
+		      comments(decls);
+		    }
+
+		    return decls;
+		  }
+
+		  whitespace();
+		  return declarations();
+		}
+
+		cjs$1 = index;
+		
+		return cjs$1;
+	}
+
+	var cjs;
+	var hasRequiredCjs;
+
+	function requireCjs () {
+		if (hasRequiredCjs) return cjs;
+		hasRequiredCjs = 1;
+		//#region \0rolldown/runtime.js
+		var __create = Object.create;
+		var __defProp = Object.defineProperty;
+		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+		var __getOwnPropNames = Object.getOwnPropertyNames;
+		var __getProtoOf = Object.getPrototypeOf;
+		var __hasOwnProp = Object.prototype.hasOwnProperty;
+		var __copyProps = (to, from, except, desc) => {
+			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+				key = keys[i];
+				if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+			return to;
+		};
+		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(!mod || !mod.__esModule ? __defProp(target, "default", {
+			value: mod,
+			enumerable: true
+		}) : target, mod));
+		//#endregion
+		let inline_style_parser = requireCjs$1();
+		inline_style_parser = __toESM(inline_style_parser);
+		//#region src/index.ts
+		/**
+		* Parses inline style to object.
+		*
+		* @param style - Inline style.
+		* @param iterator - Iterator.
+		* @returns - Style object or null.
+		*
+		* @example Parsing inline style to object:
+		*
+		* ```js
+		* import parse from 'style-to-object';
+		* parse('line-height: 42;'); // { 'line-height': '42' }
+		* ```
+		*/
+		function StyleToObject(style, iterator) {
+			let styleObject = null;
+			if (!style || typeof style !== "string") return styleObject;
+			const declarations = (0, inline_style_parser.default)(style);
+			const hasIterator = typeof iterator === "function";
+			declarations.forEach((declaration) => {
+				if (declaration.type !== "declaration") return;
+				const { property, value } = declaration;
+				if (hasIterator) iterator(property, value, declaration);
+				else if (value) {
+					styleObject = styleObject ?? {};
+					styleObject[property] = value;
+				}
+			});
+			return styleObject;
+		}
+		//#endregion
+		cjs = StyleToObject;
 
-		    // val
-		    var val = match(VALUE_REGEX);
+		
+		return cjs;
+	}
 
-		    var ret = pos({
-		      type: TYPE_DECLARATION,
-		      property: prop[0].replace(COMMENT_REGEX, EMPTY_STRING).trim(),
-		      value: val
-		        ? val[0].replace(COMMENT_REGEX, EMPTY_STRING).trim()
-		        : EMPTY_STRING
-		    });
+	var dist$1;
+	var hasRequiredDist;
 
-		    // ;
-		    match(SEMICOLON_REGEX);
+	function requireDist () {
+		if (hasRequiredDist) return dist$1;
+		hasRequiredDist = 1;
+		//#region \0rolldown/runtime.js
+		var __create = Object.create;
+		var __defProp = Object.defineProperty;
+		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+		var __getOwnPropNames = Object.getOwnPropertyNames;
+		var __getProtoOf = Object.getPrototypeOf;
+		var __hasOwnProp = Object.prototype.hasOwnProperty;
+		var __copyProps = (to, from, except, desc) => {
+			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+				key = keys[i];
+				if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+			return to;
+		};
+		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(!mod || !mod.__esModule ? __defProp(target, "default", {
+			value: mod,
+			enumerable: true
+		}) : target, mod));
+		//#endregion
+		let style_to_object = requireCjs();
+		style_to_object = __toESM(style_to_object);
+		//#region src/utilities.ts
+		const CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
+		const HYPHEN_REGEX = /-([a-z])/g;
+		const NO_HYPHEN_REGEX = /^[^-]+$/;
+		const VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
+		const MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
+		/**
+		* Checks whether to skip camelCase.
+		*/
+		const skipCamelCase = (property) => !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
+		/**
+		* Replacer that capitalizes first character.
+		*/
+		const capitalize = (match, character) => character.toUpperCase();
+		/**
+		* Replacer that removes beginning hyphen of vendor prefix property.
+		*/
+		const trimHyphen = (match, prefix) => `${prefix}-`;
+		/**
+		* CamelCases a CSS property.
+		*/
+		const camelCase = (property, options = {}) => {
+			if (skipCamelCase(property)) return property;
+			property = property.toLowerCase();
+			if (options.reactCompat) property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
+			else property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
+			return property.replace(HYPHEN_REGEX, capitalize);
+		};
+		//#endregion
+		//#region src/index.ts
+		/**
+		* Parses CSS inline style to JavaScript object (camelCased).
+		*/
+		function StyleToJS(style, options) {
+			const output = {};
+			if (!style || typeof style !== "string") return output;
+			(0, style_to_object.default)(style, (property, value) => {
+				if (property && value) output[camelCase(property, options)] = value;
+			});
+			return output;
+		}
+		//#endregion
+		dist$1 = StyleToJS;
 
-		    return ret;
-		  }
+		
+		return dist$1;
+	}
 
-		  /**
-		   * Parse declarations.
-		   *
-		   * @return {Object[]}
-		   */
-		  function declarations() {
-		    var decls = [];
+	var hasRequiredUtilities;
+
+	function requireUtilities () {
+		if (hasRequiredUtilities) return utilities;
+		hasRequiredUtilities = 1;
+		(function (exports) {
+			var __importDefault = (utilities && utilities.__importDefault) || function (mod) {
+			    return (mod && mod.__esModule) ? mod : { "default": mod };
+			};
+			Object.defineProperty(exports, "__esModule", { value: true });
+			exports.returnFirstArg = exports.canTextBeChildOfNode = exports.ELEMENTS_WITH_NO_TEXT_CHILDREN = exports.PRESERVE_CUSTOM_ATTRIBUTES = void 0;
+			exports.isCustomComponent = isCustomComponent;
+			exports.setStyleProp = setStyleProp;
+			const react_1 = require$$0;
+			const style_to_js_1 = __importDefault(requireDist());
+			const RESERVED_SVG_MATHML_ELEMENTS = new Set([
+			    'annotation-xml',
+			    'color-profile',
+			    'font-face',
+			    'font-face-src',
+			    'font-face-uri',
+			    'font-face-format',
+			    'font-face-name',
+			    'missing-glyph',
+			]);
+			/**
+			 * Check if a tag is a custom component.
+			 *
+			 * @see {@link https://github.com/facebook/react/blob/v16.6.3/packages/react-dom/src/shared/isCustomComponent.js}
+			 *
+			 * @param tagName - Tag name.
+			 * @param props - Props passed to the element.
+			 * @returns - Whether the tag is custom component.
+			 */
+			function isCustomComponent(tagName, props) {
+			    if (!tagName.includes('-')) {
+			        return Boolean(props && typeof props.is === 'string');
+			    }
+			    // These are reserved SVG and MathML elements.
+			    // We don't mind this whitelist too much because we expect it to never grow.
+			    // The alternative is to track the namespace in a few places which is convoluted.
+			    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
+			    if (RESERVED_SVG_MATHML_ELEMENTS.has(tagName)) {
+			        return false;
+			    }
+			    return true;
+			}
+			const styleOptions = {
+			    reactCompat: true,
+			};
+			/**
+			 * Sets style prop.
+			 *
+			 * @param style - Inline style.
+			 * @param props - Props object.
+			 */
+			function setStyleProp(style, props) {
+			    if (typeof style !== 'string') {
+			        return;
+			    }
+			    if (!style.trim()) {
+			        props.style = {};
+			        return;
+			    }
+			    try {
+			        props.style = (0, style_to_js_1.default)(style, styleOptions);
+			        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+			    }
+			    catch (error) {
+			        props.style = {};
+			    }
+			}
+			/**
+			 * @see https://reactjs.org/blog/2017/09/08/dom-attributes-in-react-16.html
+			 */
+			exports.PRESERVE_CUSTOM_ATTRIBUTES = Number(react_1.version.split('.')[0]) >= 16;
+			/**
+			 * @see https://github.com/facebook/react/blob/cae635054e17a6f107a39d328649137b83f25972/packages/react-dom/src/client/validateDOMNesting.js#L213
+			 */
+			exports.ELEMENTS_WITH_NO_TEXT_CHILDREN = new Set([
+			    'tr',
+			    'tbody',
+			    'thead',
+			    'tfoot',
+			    'colgroup',
+			    'table',
+			    'head',
+			    'html',
+			    'frameset',
+			]);
+			/**
+			 * Checks if the given node can contain text nodes
+			 *
+			 * @param node - Element node.
+			 * @returns - Whether the node can contain text nodes.
+			 */
+			const canTextBeChildOfNode = (node) => !exports.ELEMENTS_WITH_NO_TEXT_CHILDREN.has(node.name);
+			exports.canTextBeChildOfNode = canTextBeChildOfNode;
+			/**
+			 * Returns the first argument as is.
+			 *
+			 * @param arg - The argument to be returned.
+			 * @returns - The input argument `arg`.
+			 */
+			const returnFirstArg = (arg) => arg;
+			exports.returnFirstArg = returnFirstArg;
+			
+		} (utilities));
+		return utilities;
+	}
 
-		    comments(decls);
+	var hasRequiredAttributesToProps;
 
-		    // declarations
-		    var decl;
-		    while ((decl = declaration())) {
-		      decls.push(decl);
-		      comments(decls);
+	function requireAttributesToProps () {
+		if (hasRequiredAttributesToProps) return attributesToProps;
+		hasRequiredAttributesToProps = 1;
+		Object.defineProperty(attributesToProps, "__esModule", { value: true });
+		attributesToProps.default = attributesToProps$1;
+		const react_property_1 = requireLib$1();
+		const utilities_1 = requireUtilities();
+		// https://react.dev/learn/sharing-state-between-components#controlled-and-uncontrolled-components
+		// https://developer.mozilla.org/docs/Web/HTML/Attributes
+		const UNCONTROLLED_COMPONENT_ATTRIBUTES = ['checked', 'value'];
+		const UNCONTROLLED_COMPONENT_NAMES = ['input', 'select', 'textarea'];
+		const valueOnlyInputs = {
+		    reset: true,
+		    submit: true,
+		};
+		/**
+		 * Converts HTML/SVG DOM attributes to React props.
+		 *
+		 * @param attributes - HTML/SVG DOM attributes.
+		 * @param nodeName - DOM node name.
+		 * @returns - React props.
+		 */
+		function attributesToProps$1(attributes = {}, nodeName) {
+		    const props = {};
+		    const isInputValueOnly = Boolean(attributes.type && valueOnlyInputs[attributes.type]);
+		    for (const attributeName in attributes) {
+		        const attributeValue = attributes[attributeName];
+		        // ARIA (aria-*) or custom data (data-*) attribute
+		        if ((0, react_property_1.isCustomAttribute)(attributeName)) {
+		            props[attributeName] = attributeValue;
+		            continue;
+		        }
+		        // convert HTML/SVG attribute to React prop
+		        const attributeNameLowerCased = attributeName.toLowerCase();
+		        let propName = getPropName(attributeNameLowerCased);
+		        if (propName) {
+		            const propertyInfo = (0, react_property_1.getPropertyInfo)(propName);
+		            // convert attribute to uncontrolled component prop (e.g., `value` to `defaultValue`)
+		            if (UNCONTROLLED_COMPONENT_ATTRIBUTES.includes(propName) &&
+		                UNCONTROLLED_COMPONENT_NAMES.includes(nodeName) &&
+		                !isInputValueOnly) {
+		                propName = getPropName('default' + attributeNameLowerCased);
+		            }
+		            props[propName] = attributeValue;
+		            switch (propertyInfo === null || propertyInfo === void 0 ? void 0 : propertyInfo.type) {
+		                case react_property_1.BOOLEAN:
+		                    props[propName] = true;
+		                    break;
+		                case react_property_1.OVERLOADED_BOOLEAN:
+		                    if (attributeValue === '') {
+		                        props[propName] = true;
+		                    }
+		                    break;
+		            }
+		            continue;
+		        }
+		        // preserve custom attribute if React >=16
+		        if (utilities_1.PRESERVE_CUSTOM_ATTRIBUTES) {
+		            props[attributeName] = attributeValue;
+		        }
 		    }
+		    // transform inline style to object
+		    (0, utilities_1.setStyleProp)(attributes.style, props);
+		    return props;
+		}
+		/**
+		 * Gets prop name from lowercased attribute name.
+		 *
+		 * @param attributeName - Lowercased attribute name.
+		 * @returns - Prop name.
+		 */
+		function getPropName(attributeName) {
+		    return react_property_1.possibleStandardNames[attributeName];
+		}
+		
+		return attributesToProps;
+	}
 
-		    return decls;
-		  }
+	var domToReact = {};
 
-		  whitespace();
-		  return declarations();
-		}
+	/** Types of elements found in htmlparser2's DOM */
+	var ElementType;
+	(function (ElementType) {
+	    /** Type for the root element of a document */
+	    ElementType["Root"] = "root";
+	    /** Type for Text */
+	    ElementType["Text"] = "text";
+	    /** Type for <? ... ?> */
+	    ElementType["Directive"] = "directive";
+	    /** Type for <!-- ... --> */
+	    ElementType["Comment"] = "comment";
+	    /** Type for <script> tags */
+	    ElementType["Script"] = "script";
+	    /** Type for <style> tags */
+	    ElementType["Style"] = "style";
+	    /** Type for Any tag */
+	    ElementType["Tag"] = "tag";
+	    /** Type for <![CDATA[ ... ]]> */
+	    ElementType["CDATA"] = "cdata";
+	    /** Type for <!doctype ...> */
+	    ElementType["Doctype"] = "doctype";
+	})(ElementType || (ElementType = {}));
+	/**
+	 * Tests whether an element is a tag or not.
+	 * @param element Element to test
+	 * @param element.type Node type discriminator to check.
+	 */
+	function isTag$1(element) {
+	    return (element.type === ElementType.Tag ||
+	        element.type === ElementType.Script ||
+	        element.type === ElementType.Style);
+	}
+	// Exports for backwards compatibility
+	/** Type for the root element of a document */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Root;
+	/** Type for Text */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Text;
+	/** Type for <? ... ?> */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Directive;
+	/** Type for <!-- ... --> */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Comment;
+	/** Type for <script> tags */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Script;
+	/** Type for <style> tags */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Style;
+	/** Type for Any tag */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Tag;
+	/** Type for <![CDATA[ ... ]]> */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.CDATA;
+	/** Type for <!doctype ...> */
+	// eslint-disable-next-line prefer-destructuring
+	ElementType.Doctype;
 
-		cjs$1 = index;
-		
-		return cjs$1;
+	/**
+	 * This object will be used as the prototype for Nodes when creating a
+	 * DOM-Level-1-compliant structure.
+	 */
+	class Node {
+	    /** Parent of the node */
+	    parent = null;
+	    /** Previous sibling */
+	    prev = null;
+	    /** Next sibling */
+	    next = null;
+	    /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
+	    startIndex = null;
+	    /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
+	    endIndex = null;
+	    // Read-write aliases for properties
+	    /**
+	     * Same as {@link parent}.
+	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+	     */
+	    get parentNode() {
+	        return this.parent;
+	    }
+	    set parentNode(parent) {
+	        this.parent = parent;
+	    }
+	    /**
+	     * Same as {@link prev}.
+	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+	     */
+	    get previousSibling() {
+	        return this.prev;
+	    }
+	    set previousSibling(previous) {
+	        this.prev = previous;
+	    }
+	    /**
+	     * Same as {@link next}.
+	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+	     */
+	    get nextSibling() {
+	        return this.next;
+	    }
+	    set nextSibling(next) {
+	        this.next = next;
+	    }
+	    /**
+	     * Clone this node, and optionally its children.
+	     * @param recursive Clone child nodes as well.
+	     * @returns A clone of the node.
+	     */
+	    cloneNode(recursive = false) {
+	        return cloneNode(this, recursive);
+	    }
+	}
+	/**
+	 * A node that contains some data.
+	 */
+	class DataNode extends Node {
+	    data;
+	    /**
+	     * @param data The content of the data node
+	     */
+	    constructor(data) {
+	        super();
+	        this.data = data;
+	    }
+	    /**
+	     * Same as {@link data}.
+	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+	     */
+	    get nodeValue() {
+	        return this.data;
+	    }
+	    set nodeValue(data) {
+	        this.data = data;
+	    }
+	}
+	/**
+	 * Text within the document.
+	 */
+	class Text extends DataNode {
+	    type = ElementType.Text;
+	    get nodeType() {
+	        return 3;
+	    }
+	}
+	/**
+	 * Comments within the document.
+	 */
+	class Comment extends DataNode {
+	    type = ElementType.Comment;
+	    get nodeType() {
+	        return 8;
+	    }
 	}
-
-	var cjs;
-	var hasRequiredCjs;
-
-	function requireCjs () {
-		if (hasRequiredCjs) return cjs;
-		hasRequiredCjs = 1;
-		//#region \0rolldown/runtime.js
-		var __create = Object.create;
-		var __defProp = Object.defineProperty;
-		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-		var __getOwnPropNames = Object.getOwnPropertyNames;
-		var __getProtoOf = Object.getPrototypeOf;
-		var __hasOwnProp = Object.prototype.hasOwnProperty;
-		var __copyProps = (to, from, except, desc) => {
-			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-				key = keys[i];
-				if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-			return to;
-		};
-		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(!mod || !mod.__esModule ? __defProp(target, "default", {
-			value: mod,
-			enumerable: true
-		}) : target, mod));
-		//#endregion
-		let inline_style_parser = requireCjs$1();
-		inline_style_parser = __toESM(inline_style_parser);
-		//#region src/index.ts
-		/**
-		* Parses inline style to object.
-		*
-		* @param style - Inline style.
-		* @param iterator - Iterator.
-		* @returns - Style object or null.
-		*
-		* @example Parsing inline style to object:
-		*
-		* ```js
-		* import parse from 'style-to-object';
-		* parse('line-height: 42;'); // { 'line-height': '42' }
-		* ```
-		*/
-		function StyleToObject(style, iterator) {
-			let styleObject = null;
-			if (!style || typeof style !== "string") return styleObject;
-			const declarations = (0, inline_style_parser.default)(style);
-			const hasIterator = typeof iterator === "function";
-			declarations.forEach((declaration) => {
-				if (declaration.type !== "declaration") return;
-				const { property, value } = declaration;
-				if (hasIterator) iterator(property, value, declaration);
-				else if (value) {
-					styleObject = styleObject ?? {};
-					styleObject[property] = value;
-				}
-			});
-			return styleObject;
-		}
-		//#endregion
-		cjs = StyleToObject;
-
-		
-		return cjs;
+	/**
+	 * Processing instructions, including doc types.
+	 */
+	class ProcessingInstruction extends DataNode {
+	    type = ElementType.Directive;
+	    name;
+	    constructor(name, data) {
+	        super(data);
+	        this.name = name;
+	    }
+	    get nodeType() {
+	        return 1;
+	    }
+	    /** If this is a doctype, the document type name (parse5 only). */
+	    "x-name";
+	    /** If this is a doctype, the document type public identifier (parse5 only). */
+	    "x-publicId";
+	    /** If this is a doctype, the document type system identifier (parse5 only). */
+	    "x-systemId";
 	}
-
-	var dist;
-	var hasRequiredDist;
-
-	function requireDist () {
-		if (hasRequiredDist) return dist;
-		hasRequiredDist = 1;
-		//#region \0rolldown/runtime.js
-		var __create = Object.create;
-		var __defProp = Object.defineProperty;
-		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-		var __getOwnPropNames = Object.getOwnPropertyNames;
-		var __getProtoOf = Object.getPrototypeOf;
-		var __hasOwnProp = Object.prototype.hasOwnProperty;
-		var __copyProps = (to, from, except, desc) => {
-			if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-				key = keys[i];
-				if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-			return to;
-		};
-		var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(!mod || !mod.__esModule ? __defProp(target, "default", {
-			value: mod,
-			enumerable: true
-		}) : target, mod));
-		//#endregion
-		let style_to_object = requireCjs();
-		style_to_object = __toESM(style_to_object);
-		//#region src/utilities.ts
-		const CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9_-]+$/;
-		const HYPHEN_REGEX = /-([a-z])/g;
-		const NO_HYPHEN_REGEX = /^[^-]+$/;
-		const VENDOR_PREFIX_REGEX = /^-(webkit|moz|ms|o|khtml)-/;
-		const MS_VENDOR_PREFIX_REGEX = /^-(ms)-/;
-		/**
-		* Checks whether to skip camelCase.
-		*/
-		const skipCamelCase = (property) => !property || NO_HYPHEN_REGEX.test(property) || CUSTOM_PROPERTY_REGEX.test(property);
-		/**
-		* Replacer that capitalizes first character.
-		*/
-		const capitalize = (match, character) => character.toUpperCase();
-		/**
-		* Replacer that removes beginning hyphen of vendor prefix property.
-		*/
-		const trimHyphen = (match, prefix) => `${prefix}-`;
-		/**
-		* CamelCases a CSS property.
-		*/
-		const camelCase = (property, options = {}) => {
-			if (skipCamelCase(property)) return property;
-			property = property.toLowerCase();
-			if (options.reactCompat) property = property.replace(MS_VENDOR_PREFIX_REGEX, trimHyphen);
-			else property = property.replace(VENDOR_PREFIX_REGEX, trimHyphen);
-			return property.replace(HYPHEN_REGEX, capitalize);
-		};
-		//#endregion
-		//#region src/index.ts
-		/**
-		* Parses CSS inline style to JavaScript object (camelCased).
-		*/
-		function StyleToJS(style, options) {
-			const output = {};
-			if (!style || typeof style !== "string") return output;
-			(0, style_to_object.default)(style, (property, value) => {
-				if (property && value) output[camelCase(property, options)] = value;
-			});
-			return output;
-		}
-		//#endregion
-		dist = StyleToJS;
-
-		
-		return dist;
+	/**
+	 * A node that can have children.
+	 */
+	class NodeWithChildren extends Node {
+	    children;
+	    /**
+	     * @param children Children of the node. Only certain node types can have children.
+	     */
+	    constructor(children) {
+	        super();
+	        this.children = children;
+	    }
+	    // Aliases
+	    /** First child of the node. */
+	    get firstChild() {
+	        return this.children[0] ?? null;
+	    }
+	    /** Last child of the node. */
+	    get lastChild() {
+	        return this.children.length > 0
+	            ? this.children[this.children.length - 1]
+	            : null;
+	    }
+	    /**
+	     * Same as {@link children}.
+	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+	     */
+	    get childNodes() {
+	        return this.children;
+	    }
+	    set childNodes(children) {
+	        this.children = children;
+	    }
+	}
+	/**
+	 * CDATA nodes.
+	 */
+	class CDATA extends NodeWithChildren {
+	    type = ElementType.CDATA;
+	    get nodeType() {
+	        return 4;
+	    }
+	}
+	/**
+	 * The root node of the document.
+	 */
+	class Document extends NodeWithChildren {
+	    type = ElementType.Root;
+	    get nodeType() {
+	        return 9;
+	    }
+	}
+	/**
+	 * An element within the DOM.
+	 */
+	class Element extends NodeWithChildren {
+	    name;
+	    attribs;
+	    type;
+	    /**
+	     * @param name Name of the tag, eg. `div`, `span`.
+	     * @param attribs Object mapping attribute names to attribute values.
+	     * @param children Children of the node.
+	     * @param type Node type used for the new node instance.
+	     */
+	    constructor(name, attribs, children = [], type = name === "script"
+	        ? ElementType.Script
+	        : name === "style"
+	            ? ElementType.Style
+	            : ElementType.Tag) {
+	        super(children);
+	        this.name = name;
+	        this.attribs = attribs;
+	        this.type = type;
+	    }
+	    get nodeType() {
+	        return 1;
+	    }
+	    // DOM Level 1 aliases
+	    /**
+	     * Same as {@link name}.
+	     * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
+	     */
+	    get tagName() {
+	        return this.name;
+	    }
+	    set tagName(name) {
+	        this.name = name;
+	    }
+	    get attributes() {
+	        return Object.keys(this.attribs).map((name) => ({
+	            name,
+	            value: this.attribs[name],
+	            namespace: this["x-attribsNamespace"]?.[name],
+	            prefix: this["x-attribsPrefix"]?.[name],
+	        }));
+	    }
+	    /** Element namespace (parse5 only). */
+	    namespace;
+	    /** Element attribute namespaces (parse5 only). */
+	    "x-attribsNamespace";
+	    /** Element attribute namespace-related prefixes (parse5 only). */
+	    "x-attribsPrefix";
 	}
-
-	var hasRequiredUtilities;
-
-	function requireUtilities () {
-		if (hasRequiredUtilities) return utilities;
-		hasRequiredUtilities = 1;
-		(function (exports) {
-			var __importDefault = (utilities && utilities.__importDefault) || function (mod) {
-			    return (mod && mod.__esModule) ? mod : { "default": mod };
-			};
-			Object.defineProperty(exports, "__esModule", { value: true });
-			exports.returnFirstArg = exports.canTextBeChildOfNode = exports.ELEMENTS_WITH_NO_TEXT_CHILDREN = exports.PRESERVE_CUSTOM_ATTRIBUTES = void 0;
-			exports.isCustomComponent = isCustomComponent;
-			exports.setStyleProp = setStyleProp;
-			const react_1 = require$$0;
-			const style_to_js_1 = __importDefault(requireDist());
-			const RESERVED_SVG_MATHML_ELEMENTS = new Set([
-			    'annotation-xml',
-			    'color-profile',
-			    'font-face',
-			    'font-face-src',
-			    'font-face-uri',
-			    'font-face-format',
-			    'font-face-name',
-			    'missing-glyph',
-			]);
-			/**
-			 * Check if a tag is a custom component.
-			 *
-			 * @see {@link https://github.com/facebook/react/blob/v16.6.3/packages/react-dom/src/shared/isCustomComponent.js}
-			 *
-			 * @param tagName - Tag name.
-			 * @param props - Props passed to the element.
-			 * @returns - Whether the tag is custom component.
-			 */
-			function isCustomComponent(tagName, props) {
-			    if (!tagName.includes('-')) {
-			        return Boolean(props && typeof props.is === 'string');
-			    }
-			    // These are reserved SVG and MathML elements.
-			    // We don't mind this whitelist too much because we expect it to never grow.
-			    // The alternative is to track the namespace in a few places which is convoluted.
-			    // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts
-			    if (RESERVED_SVG_MATHML_ELEMENTS.has(tagName)) {
-			        return false;
-			    }
-			    return true;
-			}
-			const styleOptions = {
-			    reactCompat: true,
-			};
-			/**
-			 * Sets style prop.
-			 *
-			 * @param style - Inline style.
-			 * @param props - Props object.
-			 */
-			function setStyleProp(style, props) {
-			    if (typeof style !== 'string') {
-			        return;
-			    }
-			    if (!style.trim()) {
-			        props.style = {};
-			        return;
-			    }
-			    try {
-			        props.style = (0, style_to_js_1.default)(style, styleOptions);
-			        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-			    }
-			    catch (error) {
-			        props.style = {};
-			    }
-			}
-			/**
-			 * @see https://reactjs.org/blog/2017/09/08/dom-attributes-in-react-16.html
-			 */
-			exports.PRESERVE_CUSTOM_ATTRIBUTES = Number(react_1.version.split('.')[0]) >= 16;
-			/**
-			 * @see https://github.com/facebook/react/blob/cae635054e17a6f107a39d328649137b83f25972/packages/react-dom/src/client/validateDOMNesting.js#L213
-			 */
-			exports.ELEMENTS_WITH_NO_TEXT_CHILDREN = new Set([
-			    'tr',
-			    'tbody',
-			    'thead',
-			    'tfoot',
-			    'colgroup',
-			    'table',
-			    'head',
-			    'html',
-			    'frameset',
-			]);
-			/**
-			 * Checks if the given node can contain text nodes
-			 *
-			 * @param node - Element node.
-			 * @returns - Whether the node can contain text nodes.
-			 */
-			const canTextBeChildOfNode = (node) => !exports.ELEMENTS_WITH_NO_TEXT_CHILDREN.has(node.name);
-			exports.canTextBeChildOfNode = canTextBeChildOfNode;
-			/**
-			 * Returns the first argument as is.
-			 *
-			 * @param arg - The argument to be returned.
-			 * @returns - The input argument `arg`.
-			 */
-			const returnFirstArg = (arg) => arg;
-			exports.returnFirstArg = returnFirstArg;
-			
-		} (utilities));
-		return utilities;
+	/**
+	 * Checks if `node` is an element node.
+	 * @param node Node to check.
+	 * @returns `true` if the node is an element node.
+	 */
+	function isTag(node) {
+	    return isTag$1(node);
+	}
+	/**
+	 * Checks if `node` is a CDATA node.
+	 * @param node Node to check.
+	 * @returns `true` if the node is a CDATA node.
+	 */
+	function isCDATA(node) {
+	    return node.type === ElementType.CDATA;
+	}
+	/**
+	 * Checks if `node` is a text node.
+	 * @param node Node to check.
+	 * @returns `true` if the node is a text node.
+	 */
+	function isText(node) {
+	    return node.type === ElementType.Text;
+	}
+	/**
+	 * Checks if `node` is a comment node.
+	 * @param node Node to check.
+	 * @returns `true` if the node is a comment node.
+	 */
+	function isComment(node) {
+	    return node.type === ElementType.Comment;
+	}
+	/**
+	 * Checks if `node` is a directive node.
+	 * @param node Node to check.
+	 * @returns `true` if the node is a directive node.
+	 */
+	function isDirective(node) {
+	    return node.type === ElementType.Directive;
+	}
+	/**
+	 * Checks if `node` is a document node.
+	 * @param node Node to check.
+	 * @returns `true` if the node is a document node.
+	 */
+	function isDocument(node) {
+	    return node.type === ElementType.Root;
+	}
+	/**
+	 * Checks if `node` has children.
+	 * @param node Node to check.
+	 * @returns `true` if the node has children.
+	 */
+	function hasChildren(node) {
+	    return Object.hasOwn(node, "children");
+	}
+	/**
+	 * Clone a node, and optionally its children.
+	 * @param node Node to clone.
+	 * @param recursive Clone child nodes as well.
+	 * @returns A clone of the node.
+	 */
+	function cloneNode(node, recursive = false) {
+	    let result;
+	    if (isText(node)) {
+	        result = new Text(node.data);
+	    }
+	    else if (isComment(node)) {
+	        result = new Comment(node.data);
+	    }
+	    else if (isTag(node)) {
+	        const children = recursive ? cloneChildren(node.children) : [];
+	        const clone = new Element(node.name, { ...node.attribs }, children);
+	        for (const child of children) {
+	            child.parent = clone;
+	        }
+	        if (node.namespace != null) {
+	            clone.namespace = node.namespace;
+	        }
+	        if (node["x-attribsNamespace"]) {
+	            clone["x-attribsNamespace"] = { ...node["x-attribsNamespace"] };
+	        }
+	        if (node["x-attribsPrefix"]) {
+	            clone["x-attribsPrefix"] = { ...node["x-attribsPrefix"] };
+	        }
+	        result = clone;
+	    }
+	    else if (isCDATA(node)) {
+	        const children = recursive ? cloneChildren(node.children) : [];
+	        const clone = new CDATA(children);
+	        for (const child of children) {
+	            child.parent = clone;
+	        }
+	        result = clone;
+	    }
+	    else if (isDocument(node)) {
+	        const children = recursive ? cloneChildren(node.children) : [];
+	        const clone = new Document(children);
+	        for (const child of children) {
+	            child.parent = clone;
+	        }
+	        if (node["x-mode"]) {
+	            clone["x-mode"] = node["x-mode"];
+	        }
+	        result = clone;
+	    }
+	    else if (isDirective(node)) {
+	        const instruction = new ProcessingInstruction(node.name, node.data);
+	        if (node["x-name"] != null) {
+	            instruction["x-name"] = node["x-name"];
+	            instruction["x-publicId"] = node["x-publicId"];
+	            instruction["x-systemId"] = node["x-systemId"];
+	        }
+	        result = instruction;
+	    }
+	    else {
+	        throw new Error(`Not implemented yet: ${node.type}`);
+	    }
+	    result.startIndex = node.startIndex;
+	    result.endIndex = node.endIndex;
+	    if (node.sourceCodeLocation != null) {
+	        result.sourceCodeLocation = node.sourceCodeLocation;
+	    }
+	    return result;
+	}
+	/**
+	 * Clone a list of child nodes.
+	 * @param childs The child nodes to clone.
+	 * @returns A list of cloned child nodes.
+	 */
+	function cloneChildren(childs) {
+	    const children = childs.map((child) => cloneNode(child, true));
+	    for (let index = 1; index < children.length; index++) {
+	        children[index].prev = children[index - 1];
+	        children[index - 1].next = children[index];
+	    }
+	    return children;
 	}
 
-	var hasRequiredAttributesToProps;
-
-	function requireAttributesToProps () {
-		if (hasRequiredAttributesToProps) return attributesToProps;
-		hasRequiredAttributesToProps = 1;
-		Object.defineProperty(attributesToProps, "__esModule", { value: true });
-		attributesToProps.default = attributesToProps$1;
-		const react_property_1 = requireLib$1();
-		const utilities_1 = requireUtilities();
-		// https://react.dev/learn/sharing-state-between-components#controlled-and-uncontrolled-components
-		// https://developer.mozilla.org/docs/Web/HTML/Attributes
-		const UNCONTROLLED_COMPONENT_ATTRIBUTES = ['checked', 'value'];
-		const UNCONTROLLED_COMPONENT_NAMES = ['input', 'select', 'textarea'];
-		const valueOnlyInputs = {
-		    reset: true,
-		    submit: true,
-		};
-		/**
-		 * Converts HTML/SVG DOM attributes to React props.
-		 *
-		 * @param attributes - HTML/SVG DOM attributes.
-		 * @param nodeName - DOM node name.
-		 * @returns - React props.
-		 */
-		function attributesToProps$1(attributes = {}, nodeName) {
-		    const props = {};
-		    const isInputValueOnly = Boolean(attributes.type && valueOnlyInputs[attributes.type]);
-		    for (const attributeName in attributes) {
-		        const attributeValue = attributes[attributeName];
-		        // ARIA (aria-*) or custom data (data-*) attribute
-		        if ((0, react_property_1.isCustomAttribute)(attributeName)) {
-		            props[attributeName] = attributeValue;
-		            continue;
-		        }
-		        // convert HTML/SVG attribute to React prop
-		        const attributeNameLowerCased = attributeName.toLowerCase();
-		        let propName = getPropName(attributeNameLowerCased);
-		        if (propName) {
-		            const propertyInfo = (0, react_property_1.getPropertyInfo)(propName);
-		            // convert attribute to uncontrolled component prop (e.g., `value` to `defaultValue`)
-		            if (UNCONTROLLED_COMPONENT_ATTRIBUTES.includes(propName) &&
-		                UNCONTROLLED_COMPONENT_NAMES.includes(nodeName) &&
-		                !isInputValueOnly) {
-		                propName = getPropName('default' + attributeNameLowerCased);
-		            }
-		            props[propName] = attributeValue;
-		            switch (propertyInfo === null || propertyInfo === void 0 ? void 0 : propertyInfo.type) {
-		                case react_property_1.BOOLEAN:
-		                    props[propName] = true;
-		                    break;
-		                case react_property_1.OVERLOADED_BOOLEAN:
-		                    if (attributeValue === '') {
-		                        props[propName] = true;
-		                    }
-		                    break;
-		            }
-		            continue;
-		        }
-		        // preserve custom attribute if React >=16
-		        if (utilities_1.PRESERVE_CUSTOM_ATTRIBUTES) {
-		            props[attributeName] = attributeValue;
-		        }
-		    }
-		    // transform inline style to object
-		    (0, utilities_1.setStyleProp)(attributes.style, props);
-		    return props;
-		}
-		/**
-		 * Gets prop name from lowercased attribute name.
-		 *
-		 * @param attributeName - Lowercased attribute name.
-		 * @returns - Prop name.
-		 */
-		function getPropName(attributeName) {
-		    return react_property_1.possibleStandardNames[attributeName];
-		}
-		
-		return attributesToProps;
+	// Default options
+	const defaultOptions = {
+	    withStartIndices: false,
+	    withEndIndices: false,
+	    xmlMode: false,
+	};
+	/**
+	 * Event-based handler that builds a DOM tree from parser callbacks.
+	 */
+	class DomHandler {
+	    /** The elements of the DOM */
+	    dom = [];
+	    /** The root element for the DOM */
+	    root = new Document(this.dom);
+	    /** Called once parsing has completed. */
+	    callback;
+	    /** Settings for the handler. */
+	    options;
+	    /** Callback whenever a tag is closed. */
+	    elementCB;
+	    /** Indicated whether parsing has been completed. */
+	    done = false;
+	    /** Stack of open tags. */
+	    tagStack = [this.root];
+	    /** A data node that is still being written to. */
+	    lastNode = null;
+	    /** Reference to the parser instance. Used for location information. */
+	    parser = null;
+	    /**
+	     * @param callback Called once parsing has completed.
+	     * @param options Settings for the handler.
+	     * @param elementCB Callback whenever a tag is closed.
+	     */
+	    constructor(callback, options, elementCB) {
+	        // Make it possible to skip arguments, for backwards-compatibility
+	        if (typeof options === "function") {
+	            elementCB = options;
+	            options = defaultOptions;
+	        }
+	        if (typeof callback === "object") {
+	            options = callback;
+	            callback = undefined;
+	        }
+	        this.callback = callback ?? null;
+	        this.options = options ?? defaultOptions;
+	        this.elementCB = elementCB ?? null;
+	    }
+	    onparserinit(parser) {
+	        this.parser = parser;
+	    }
+	    // Resets the handler back to starting state
+	    onreset() {
+	        this.dom = [];
+	        this.root = new Document(this.dom);
+	        this.done = false;
+	        this.tagStack = [this.root];
+	        this.lastNode = null;
+	        this.parser = null;
+	    }
+	    // Signals the handler that parsing is done
+	    onend() {
+	        if (this.done)
+	            return;
+	        this.done = true;
+	        this.parser = null;
+	        this.handleCallback(null);
+	    }
+	    onerror(error) {
+	        this.handleCallback(error);
+	    }
+	    onclosetag() {
+	        this.lastNode = null;
+	        const element = this.tagStack.pop();
+	        if (this.options.withEndIndices && this.parser) {
+	            element.endIndex = this.parser.endIndex;
+	        }
+	        if (this.elementCB)
+	            this.elementCB(element);
+	    }
+	    onopentag(name, attribs) {
+	        const type = this.options.xmlMode ? ElementType.Tag : undefined;
+	        const element = new Element(name, attribs, undefined, type);
+	        this.addNode(element);
+	        this.tagStack.push(element);
+	    }
+	    ontext(data) {
+	        const { lastNode } = this;
+	        if (lastNode && lastNode.type === ElementType.Text) {
+	            lastNode.data += data;
+	            if (this.options.withEndIndices && this.parser) {
+	                lastNode.endIndex = this.parser.endIndex;
+	            }
+	        }
+	        else {
+	            const node = new Text(data);
+	            this.addNode(node);
+	            this.lastNode = node;
+	        }
+	    }
+	    oncomment(data) {
+	        if (this.lastNode && this.lastNode.type === ElementType.Comment) {
+	            this.lastNode.data += data;
+	            return;
+	        }
+	        const node = new Comment(data);
+	        this.addNode(node);
+	        this.lastNode = node;
+	    }
+	    oncommentend() {
+	        this.lastNode = null;
+	    }
+	    oncdatastart() {
+	        const text = new Text("");
+	        const node = new CDATA([text]);
+	        this.addNode(node);
+	        text.parent = node;
+	        this.lastNode = text;
+	    }
+	    oncdataend() {
+	        this.lastNode = null;
+	    }
+	    onprocessinginstruction(name, data) {
+	        const node = new ProcessingInstruction(name, data);
+	        this.addNode(node);
+	    }
+	    handleCallback(error) {
+	        if (typeof this.callback === "function") {
+	            this.callback(error, this.dom);
+	        }
+	        else if (error) {
+	            throw error;
+	        }
+	    }
+	    addNode(node) {
+	        const parent = this.tagStack[this.tagStack.length - 1];
+	        const previousSibling = parent.children[parent.children.length - 1];
+	        if (this.options.withStartIndices && this.parser) {
+	            node.startIndex = this.parser.startIndex;
+	        }
+	        if (this.options.withEndIndices && this.parser) {
+	            node.endIndex = this.parser.endIndex;
+	        }
+	        parent.children.push(node);
+	        if (previousSibling) {
+	            node.prev = previousSibling;
+	            previousSibling.next = node;
+	        }
+	        node.parent = parent;
+	        this.lastNode = null;
+	    }
 	}
 
-	var domToReact = {};
+	var dist = /*#__PURE__*/Object.freeze({
+		__proto__: null,
+		CDATA: CDATA,
+		Comment: Comment,
+		DataNode: DataNode,
+		Document: Document,
+		DomHandler: DomHandler,
+		Element: Element,
+		Node: Node,
+		NodeWithChildren: NodeWithChildren,
+		ProcessingInstruction: ProcessingInstruction,
+		Text: Text,
+		cloneNode: cloneNode,
+		default: DomHandler,
+		hasChildren: hasChildren,
+		isCDATA: isCDATA,
+		isComment: isComment,
+		isDirective: isDirective,
+		isDocument: isDocument,
+		isTag: isTag,
+		isText: isText
+	});
+
+	var require$$3 = /*@__PURE__*/getAugmentedNamespace(dist);
 
 	var hasRequiredDomToReact;
 
@@ -2770,11 +3178,19 @@
 		}
 		function normalizeDOMNodes(nodes) {
 		    for (const node of nodes) {
-		        if (node.type === 'tag' ||
-		            node.type === 'script' ||
-		            node.type === 'style') {
-		            Object.setPrototypeOf(node, domhandler_1.Element.prototype);
-		            normalizeDOMNodes(node.children);
+		        switch (node.type) {
+		            case 'tag':
+		            case 'script':
+		            case 'style':
+		                Object.setPrototypeOf(node, domhandler_1.Element.prototype);
+		                normalizeDOMNodes(node.children);
+		                break;
+		            case 'text':
+		                Object.setPrototypeOf(node, domhandler_1.Text.prototype);
+		                break;
+		            case 'comment':
+		                Object.setPrototypeOf(node, domhandler_1.Comment.prototype);
+		                break;
 		        }
 		    }
 		}