html-react-parser 5.2.16 → 6.0.0

package/dist/html-react-parser.js

@@ -23,7 +23,36 @@
 		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 	}
 
-	var lib$3 = {};
+	function getAugmentedNamespace(n) {
+	  if (Object.prototype.hasOwnProperty.call(n, '__esModule')) return n;
+	  var f = n.default;
+		if (typeof f == "function") {
+			var a = function a () {
+				var isInstance = false;
+	      try {
+	        isInstance = this instanceof a;
+	      } catch {}
+				if (isInstance) {
+	        return Reflect.construct(f, arguments, this.constructor);
+				}
+				return f.apply(this, arguments);
+			};
+			a.prototype = f.prototype;
+	  } else a = {};
+	  Object.defineProperty(a, '__esModule', {value: true});
+		Object.keys(n).forEach(function (k) {
+			var d = Object.getOwnPropertyDescriptor(n, k);
+			Object.defineProperty(a, k, d.get ? d : {
+				enumerable: true,
+				get: function () {
+					return n[k];
+				}
+			});
+		});
+		return a;
+	}
+
+	var lib$1 = {};
 
 	var htmlToDom = {};
 
@@ -31,731 +60,603 @@
 
 	var utilities$2 = {};
 
-	var lib$2 = {};
-
-	var lib$1 = {};
-
-	var hasRequiredLib$3;
-
-	function requireLib$3 () {
-		if (hasRequiredLib$3) return lib$1;
-		hasRequiredLib$3 = 1;
-		(function (exports$1) {
-			Object.defineProperty(exports$1, "__esModule", { value: true });
-			exports$1.Doctype = exports$1.CDATA = exports$1.Tag = exports$1.Style = exports$1.Script = exports$1.Comment = exports$1.Directive = exports$1.Text = exports$1.Root = exports$1.isTag = exports$1.ElementType = void 0;
-			/** 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 = exports$1.ElementType || (exports$1.ElementType = {}));
-			/**
-			 * Tests whether an element is a tag or not.
-			 *
-			 * @param elem Element to test
-			 */
-			function isTag(elem) {
-			    return (elem.type === ElementType.Tag ||
-			        elem.type === ElementType.Script ||
-			        elem.type === ElementType.Style);
-			}
-			exports$1.isTag = isTag;
-			// Exports for backwards compatibility
-			/** Type for the root element of a document */
-			exports$1.Root = ElementType.Root;
-			/** Type for Text */
-			exports$1.Text = ElementType.Text;
-			/** Type for <? ... ?> */
-			exports$1.Directive = ElementType.Directive;
-			/** Type for <!-- ... --> */
-			exports$1.Comment = ElementType.Comment;
-			/** Type for <script> tags */
-			exports$1.Script = ElementType.Script;
-			/** Type for <style> tags */
-			exports$1.Style = ElementType.Style;
-			/** Type for Any tag */
-			exports$1.Tag = ElementType.Tag;
-			/** Type for <![CDATA[ ... ]]> */
-			exports$1.CDATA = ElementType.CDATA;
-			/** Type for <!doctype ...> */
-			exports$1.Doctype = ElementType.Doctype; 
-		} (lib$1));
-		return lib$1;
+	/** 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);
 	}
-
-	var node = {};
-
-	var hasRequiredNode;
-
-	function requireNode () {
-		if (hasRequiredNode) return node;
-		hasRequiredNode = 1;
-		var __extends = (node && node.__extends) || (function () {
-		    var extendStatics = function (d, b) {
-		        extendStatics = Object.setPrototypeOf ||
-		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-		        return extendStatics(d, b);
-		    };
-		    return function (d, b) {
-		        if (typeof b !== "function" && b !== null)
-		            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-		        extendStatics(d, b);
-		        function __() { this.constructor = d; }
-		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-		    };
-		})();
-		var __assign = (node && node.__assign) || function () {
-		    __assign = Object.assign || function(t) {
-		        for (var s, i = 1, n = arguments.length; i < n; i++) {
-		            s = arguments[i];
-		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-		                t[p] = s[p];
-		        }
-		        return t;
-		    };
-		    return __assign.apply(this, arguments);
-		};
-		Object.defineProperty(node, "__esModule", { value: true });
-		node.cloneNode = node.hasChildren = node.isDocument = node.isDirective = node.isComment = node.isText = node.isCDATA = node.isTag = node.Element = node.Document = node.CDATA = node.NodeWithChildren = node.ProcessingInstruction = node.Comment = node.Text = node.DataNode = node.Node = void 0;
-		var domelementtype_1 = /*@__PURE__*/ requireLib$3();
-		/**
-		 * This object will be used as the prototype for Nodes when creating a
-		 * DOM-Level-1-compliant structure.
-		 */
-		var Node = /** @class */ (function () {
-		    function Node() {
-		        /** Parent of the node */
-		        this.parent = null;
-		        /** Previous sibling */
-		        this.prev = null;
-		        /** Next sibling */
-		        this.next = null;
-		        /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
-		        this.startIndex = null;
-		        /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
-		        this.endIndex = null;
-		    }
-		    Object.defineProperty(Node.prototype, "parentNode", {
-		        // Read-write aliases for properties
-		        /**
-		         * Same as {@link parent}.
-		         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-		         */
-		        get: function () {
-		            return this.parent;
-		        },
-		        set: function (parent) {
-		            this.parent = parent;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    Object.defineProperty(Node.prototype, "previousSibling", {
-		        /**
-		         * Same as {@link prev}.
-		         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-		         */
-		        get: function () {
-		            return this.prev;
-		        },
-		        set: function (prev) {
-		            this.prev = prev;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    Object.defineProperty(Node.prototype, "nextSibling", {
-		        /**
-		         * Same as {@link next}.
-		         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-		         */
-		        get: function () {
-		            return this.next;
-		        },
-		        set: function (next) {
-		            this.next = next;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    /**
-		     * Clone this node, and optionally its children.
-		     *
-		     * @param recursive Clone child nodes as well.
-		     * @returns A clone of the node.
-		     */
-		    Node.prototype.cloneNode = function (recursive) {
-		        if (recursive === void 0) { recursive = false; }
-		        return cloneNode(this, recursive);
-		    };
-		    return Node;
-		}());
-		node.Node = Node;
-		/**
-		 * A node that contains some data.
-		 */
-		var DataNode = /** @class */ (function (_super) {
-		    __extends(DataNode, _super);
-		    /**
-		     * @param data The content of the data node
-		     */
-		    function DataNode(data) {
-		        var _this = _super.call(this) || this;
-		        _this.data = data;
-		        return _this;
-		    }
-		    Object.defineProperty(DataNode.prototype, "nodeValue", {
-		        /**
-		         * Same as {@link data}.
-		         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-		         */
-		        get: function () {
-		            return this.data;
-		        },
-		        set: function (data) {
-		            this.data = data;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return DataNode;
-		}(Node));
-		node.DataNode = DataNode;
-		/**
-		 * Text within the document.
-		 */
-		var Text = /** @class */ (function (_super) {
-		    __extends(Text, _super);
-		    function Text() {
-		        var _this = _super !== null && _super.apply(this, arguments) || this;
-		        _this.type = domelementtype_1.ElementType.Text;
-		        return _this;
-		    }
-		    Object.defineProperty(Text.prototype, "nodeType", {
-		        get: function () {
-		            return 3;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return Text;
-		}(DataNode));
-		node.Text = Text;
-		/**
-		 * Comments within the document.
-		 */
-		var Comment = /** @class */ (function (_super) {
-		    __extends(Comment, _super);
-		    function Comment() {
-		        var _this = _super !== null && _super.apply(this, arguments) || this;
-		        _this.type = domelementtype_1.ElementType.Comment;
-		        return _this;
-		    }
-		    Object.defineProperty(Comment.prototype, "nodeType", {
-		        get: function () {
-		            return 8;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return Comment;
-		}(DataNode));
-		node.Comment = Comment;
-		/**
-		 * Processing instructions, including doc types.
-		 */
-		var ProcessingInstruction = /** @class */ (function (_super) {
-		    __extends(ProcessingInstruction, _super);
-		    function ProcessingInstruction(name, data) {
-		        var _this = _super.call(this, data) || this;
-		        _this.name = name;
-		        _this.type = domelementtype_1.ElementType.Directive;
-		        return _this;
-		    }
-		    Object.defineProperty(ProcessingInstruction.prototype, "nodeType", {
-		        get: function () {
-		            return 1;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return ProcessingInstruction;
-		}(DataNode));
-		node.ProcessingInstruction = ProcessingInstruction;
-		/**
-		 * A `Node` that can have children.
-		 */
-		var NodeWithChildren = /** @class */ (function (_super) {
-		    __extends(NodeWithChildren, _super);
-		    /**
-		     * @param children Children of the node. Only certain node types can have children.
-		     */
-		    function NodeWithChildren(children) {
-		        var _this = _super.call(this) || this;
-		        _this.children = children;
-		        return _this;
-		    }
-		    Object.defineProperty(NodeWithChildren.prototype, "firstChild", {
-		        // Aliases
-		        /** First child of the node. */
-		        get: function () {
-		            var _a;
-		            return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    Object.defineProperty(NodeWithChildren.prototype, "lastChild", {
-		        /** Last child of the node. */
-		        get: function () {
-		            return this.children.length > 0
-		                ? this.children[this.children.length - 1]
-		                : null;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    Object.defineProperty(NodeWithChildren.prototype, "childNodes", {
-		        /**
-		         * Same as {@link children}.
-		         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-		         */
-		        get: function () {
-		            return this.children;
-		        },
-		        set: function (children) {
-		            this.children = children;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return NodeWithChildren;
-		}(Node));
-		node.NodeWithChildren = NodeWithChildren;
-		var CDATA = /** @class */ (function (_super) {
-		    __extends(CDATA, _super);
-		    function CDATA() {
-		        var _this = _super !== null && _super.apply(this, arguments) || this;
-		        _this.type = domelementtype_1.ElementType.CDATA;
-		        return _this;
-		    }
-		    Object.defineProperty(CDATA.prototype, "nodeType", {
-		        get: function () {
-		            return 4;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return CDATA;
-		}(NodeWithChildren));
-		node.CDATA = CDATA;
-		/**
-		 * The root node of the document.
-		 */
-		var Document = /** @class */ (function (_super) {
-		    __extends(Document, _super);
-		    function Document() {
-		        var _this = _super !== null && _super.apply(this, arguments) || this;
-		        _this.type = domelementtype_1.ElementType.Root;
-		        return _this;
-		    }
-		    Object.defineProperty(Document.prototype, "nodeType", {
-		        get: function () {
-		            return 9;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return Document;
-		}(NodeWithChildren));
-		node.Document = Document;
-		/**
-		 * An element within the DOM.
-		 */
-		var Element = /** @class */ (function (_super) {
-		    __extends(Element, _super);
-		    /**
-		     * @param name Name of the tag, eg. `div`, `span`.
-		     * @param attribs Object mapping attribute names to attribute values.
-		     * @param children Children of the node.
-		     */
-		    function Element(name, attribs, children, type) {
-		        if (children === void 0) { children = []; }
-		        if (type === void 0) { type = name === "script"
-		            ? domelementtype_1.ElementType.Script
-		            : name === "style"
-		                ? domelementtype_1.ElementType.Style
-		                : domelementtype_1.ElementType.Tag; }
-		        var _this = _super.call(this, children) || this;
-		        _this.name = name;
-		        _this.attribs = attribs;
-		        _this.type = type;
-		        return _this;
-		    }
-		    Object.defineProperty(Element.prototype, "nodeType", {
-		        get: function () {
-		            return 1;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    Object.defineProperty(Element.prototype, "tagName", {
-		        // DOM Level 1 aliases
-		        /**
-		         * Same as {@link name}.
-		         * [DOM spec](https://dom.spec.whatwg.org)-compatible alias.
-		         */
-		        get: function () {
-		            return this.name;
-		        },
-		        set: function (name) {
-		            this.name = name;
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    Object.defineProperty(Element.prototype, "attributes", {
-		        get: function () {
-		            var _this = this;
-		            return Object.keys(this.attribs).map(function (name) {
-		                var _a, _b;
-		                return ({
-		                    name: name,
-		                    value: _this.attribs[name],
-		                    namespace: (_a = _this["x-attribsNamespace"]) === null || _a === void 0 ? void 0 : _a[name],
-		                    prefix: (_b = _this["x-attribsPrefix"]) === null || _b === void 0 ? void 0 : _b[name],
-		                });
-		            });
-		        },
-		        enumerable: false,
-		        configurable: true
-		    });
-		    return Element;
-		}(NodeWithChildren));
-		node.Element = Element;
-		/**
-		 * @param node Node to check.
-		 * @returns `true` if the node is a `Element`, `false` otherwise.
-		 */
-		function isTag(node) {
-		    return (0, domelementtype_1.isTag)(node);
-		}
-		node.isTag = isTag;
-		/**
-		 * @param node Node to check.
-		 * @returns `true` if the node has the type `CDATA`, `false` otherwise.
-		 */
-		function isCDATA(node) {
-		    return node.type === domelementtype_1.ElementType.CDATA;
-		}
-		node.isCDATA = isCDATA;
-		/**
-		 * @param node Node to check.
-		 * @returns `true` if the node has the type `Text`, `false` otherwise.
-		 */
-		function isText(node) {
-		    return node.type === domelementtype_1.ElementType.Text;
-		}
-		node.isText = isText;
-		/**
-		 * @param node Node to check.
-		 * @returns `true` if the node has the type `Comment`, `false` otherwise.
-		 */
-		function isComment(node) {
-		    return node.type === domelementtype_1.ElementType.Comment;
-		}
-		node.isComment = isComment;
-		/**
-		 * @param node Node to check.
-		 * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.
-		 */
-		function isDirective(node) {
-		    return node.type === domelementtype_1.ElementType.Directive;
-		}
-		node.isDirective = isDirective;
-		/**
-		 * @param node Node to check.
-		 * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.
-		 */
-		function isDocument(node) {
-		    return node.type === domelementtype_1.ElementType.Root;
-		}
-		node.isDocument = isDocument;
-		/**
-		 * @param node Node to check.
-		 * @returns `true` if the node has children, `false` otherwise.
-		 */
-		function hasChildren(node) {
-		    return Object.prototype.hasOwnProperty.call(node, "children");
-		}
-		node.hasChildren = hasChildren;
-		/**
-		 * Clone a node, and optionally its children.
-		 *
-		 * @param recursive Clone child nodes as well.
-		 * @returns A clone of the node.
-		 */
-		function cloneNode(node, recursive) {
-		    if (recursive === void 0) { recursive = false; }
-		    var result;
-		    if (isText(node)) {
-		        result = new Text(node.data);
-		    }
-		    else if (isComment(node)) {
-		        result = new Comment(node.data);
-		    }
-		    else if (isTag(node)) {
-		        var children = recursive ? cloneChildren(node.children) : [];
-		        var clone_1 = new Element(node.name, __assign({}, node.attribs), children);
-		        children.forEach(function (child) { return (child.parent = clone_1); });
-		        if (node.namespace != null) {
-		            clone_1.namespace = node.namespace;
-		        }
-		        if (node["x-attribsNamespace"]) {
-		            clone_1["x-attribsNamespace"] = __assign({}, node["x-attribsNamespace"]);
-		        }
-		        if (node["x-attribsPrefix"]) {
-		            clone_1["x-attribsPrefix"] = __assign({}, node["x-attribsPrefix"]);
-		        }
-		        result = clone_1;
-		    }
-		    else if (isCDATA(node)) {
-		        var children = recursive ? cloneChildren(node.children) : [];
-		        var clone_2 = new CDATA(children);
-		        children.forEach(function (child) { return (child.parent = clone_2); });
-		        result = clone_2;
-		    }
-		    else if (isDocument(node)) {
-		        var children = recursive ? cloneChildren(node.children) : [];
-		        var clone_3 = new Document(children);
-		        children.forEach(function (child) { return (child.parent = clone_3); });
-		        if (node["x-mode"]) {
-		            clone_3["x-mode"] = node["x-mode"];
-		        }
-		        result = clone_3;
-		    }
-		    else if (isDirective(node)) {
-		        var 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: ".concat(node.type));
-		    }
-		    result.startIndex = node.startIndex;
-		    result.endIndex = node.endIndex;
-		    if (node.sourceCodeLocation != null) {
-		        result.sourceCodeLocation = node.sourceCodeLocation;
-		    }
-		    return result;
-		}
-		node.cloneNode = cloneNode;
-		function cloneChildren(childs) {
-		    var children = childs.map(function (child) { return cloneNode(child, true); });
-		    for (var i = 1; i < children.length; i++) {
-		        children[i].prev = children[i - 1];
-		        children[i - 1].next = children[i];
-		    }
-		    return children;
-		}
-		return node;
+	// 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;
 	}
 
-	var hasRequiredLib$2;
-
-	function requireLib$2 () {
-		if (hasRequiredLib$2) return lib$2;
-		hasRequiredLib$2 = 1;
-		(function (exports$1) {
-			var __createBinding = (lib$2 && lib$2.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-			    if (k2 === undefined) k2 = k;
-			    var desc = Object.getOwnPropertyDescriptor(m, k);
-			    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-			      desc = { enumerable: true, get: function() { return m[k]; } };
-			    }
-			    Object.defineProperty(o, k2, desc);
-			}) : (function(o, m, k, k2) {
-			    if (k2 === undefined) k2 = k;
-			    o[k2] = m[k];
-			}));
-			var __exportStar = (lib$2 && lib$2.__exportStar) || function(m, exports$1) {
-			    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
-			};
-			Object.defineProperty(exports$1, "__esModule", { value: true });
-			exports$1.DomHandler = void 0;
-			var domelementtype_1 = /*@__PURE__*/ requireLib$3();
-			var node_js_1 = /*@__PURE__*/ requireNode();
-			__exportStar(/*@__PURE__*/ requireNode(), exports$1);
-			// Default options
-			var defaultOpts = {
-			    withStartIndices: false,
-			    withEndIndices: false,
-			    xmlMode: false,
-			};
-			var DomHandler = /** @class */ (function () {
-			    /**
-			     * @param callback Called once parsing has completed.
-			     * @param options Settings for the handler.
-			     * @param elementCB Callback whenever a tag is closed.
-			     */
-			    function DomHandler(callback, options, elementCB) {
-			        /** The elements of the DOM */
-			        this.dom = [];
-			        /** The root element for the DOM */
-			        this.root = new node_js_1.Document(this.dom);
-			        /** Indicated whether parsing has been completed. */
-			        this.done = false;
-			        /** Stack of open tags. */
-			        this.tagStack = [this.root];
-			        /** A data node that is still being written to. */
-			        this.lastNode = null;
-			        /** Reference to the parser instance. Used for location information. */
-			        this.parser = null;
-			        // Make it possible to skip arguments, for backwards-compatibility
-			        if (typeof options === "function") {
-			            elementCB = options;
-			            options = defaultOpts;
-			        }
-			        if (typeof callback === "object") {
-			            options = callback;
-			            callback = undefined;
-			        }
-			        this.callback = callback !== null && callback !== void 0 ? callback : null;
-			        this.options = options !== null && options !== void 0 ? options : defaultOpts;
-			        this.elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;
-			    }
-			    DomHandler.prototype.onparserinit = function (parser) {
-			        this.parser = parser;
-			    };
-			    // Resets the handler back to starting state
-			    DomHandler.prototype.onreset = function () {
-			        this.dom = [];
-			        this.root = new node_js_1.Document(this.dom);
-			        this.done = false;
-			        this.tagStack = [this.root];
-			        this.lastNode = null;
-			        this.parser = null;
-			    };
-			    // Signals the handler that parsing is done
-			    DomHandler.prototype.onend = function () {
-			        if (this.done)
-			            return;
-			        this.done = true;
-			        this.parser = null;
-			        this.handleCallback(null);
-			    };
-			    DomHandler.prototype.onerror = function (error) {
-			        this.handleCallback(error);
-			    };
-			    DomHandler.prototype.onclosetag = function () {
-			        this.lastNode = null;
-			        var elem = this.tagStack.pop();
-			        if (this.options.withEndIndices) {
-			            elem.endIndex = this.parser.endIndex;
-			        }
-			        if (this.elementCB)
-			            this.elementCB(elem);
-			    };
-			    DomHandler.prototype.onopentag = function (name, attribs) {
-			        var type = this.options.xmlMode ? domelementtype_1.ElementType.Tag : undefined;
-			        var element = new node_js_1.Element(name, attribs, undefined, type);
-			        this.addNode(element);
-			        this.tagStack.push(element);
-			    };
-			    DomHandler.prototype.ontext = function (data) {
-			        var lastNode = this.lastNode;
-			        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {
-			            lastNode.data += data;
-			            if (this.options.withEndIndices) {
-			                lastNode.endIndex = this.parser.endIndex;
-			            }
-			        }
-			        else {
-			            var node = new node_js_1.Text(data);
-			            this.addNode(node);
-			            this.lastNode = node;
-			        }
-			    };
-			    DomHandler.prototype.oncomment = function (data) {
-			        if (this.lastNode && this.lastNode.type === domelementtype_1.ElementType.Comment) {
-			            this.lastNode.data += data;
-			            return;
-			        }
-			        var node = new node_js_1.Comment(data);
-			        this.addNode(node);
-			        this.lastNode = node;
-			    };
-			    DomHandler.prototype.oncommentend = function () {
-			        this.lastNode = null;
-			    };
-			    DomHandler.prototype.oncdatastart = function () {
-			        var text = new node_js_1.Text("");
-			        var node = new node_js_1.CDATA([text]);
-			        this.addNode(node);
-			        text.parent = node;
-			        this.lastNode = text;
-			    };
-			    DomHandler.prototype.oncdataend = function () {
-			        this.lastNode = null;
-			    };
-			    DomHandler.prototype.onprocessinginstruction = function (name, data) {
-			        var node = new node_js_1.ProcessingInstruction(name, data);
-			        this.addNode(node);
-			    };
-			    DomHandler.prototype.handleCallback = function (error) {
-			        if (typeof this.callback === "function") {
-			            this.callback(error, this.dom);
-			        }
-			        else if (error) {
-			            throw error;
-			        }
-			    };
-			    DomHandler.prototype.addNode = function (node) {
-			        var parent = this.tagStack[this.tagStack.length - 1];
-			        var previousSibling = parent.children[parent.children.length - 1];
-			        if (this.options.withStartIndices) {
-			            node.startIndex = this.parser.startIndex;
-			        }
-			        if (this.options.withEndIndices) {
-			            node.endIndex = this.parser.endIndex;
-			        }
-			        parent.children.push(node);
-			        if (previousSibling) {
-			            node.prev = previousSibling;
-			            previousSibling.next = node;
-			        }
-			        node.parent = parent;
-			        this.lastNode = null;
-			    };
-			    return DomHandler;
-			}());
-			exports$1.DomHandler = DomHandler;
-			exports$1.default = DomHandler; 
-		} (lib$2));
-		return lib$2;
+	// 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 = /*#__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 constants = {};
 
 	var hasRequiredConstants;
@@ -765,7 +666,7 @@
 		hasRequiredConstants = 1;
 		(function (exports$1) {
 			Object.defineProperty(exports$1, "__esModule", { value: true });
-			exports$1.CARRIAGE_RETURN_PLACEHOLDER_REGEX = exports$1.CARRIAGE_RETURN_PLACEHOLDER = exports$1.CARRIAGE_RETURN_REGEX = exports$1.CARRIAGE_RETURN = exports$1.CASE_SENSITIVE_TAG_NAMES_MAP = exports$1.CASE_SENSITIVE_TAG_NAMES = void 0;
+			exports$1.CASE_SENSITIVE_TAG_NAMES_MAP = exports$1.CASE_SENSITIVE_TAG_NAMES = void 0;
 			/**
 			 * SVG elements are case-sensitive.
 			 *
@@ -808,10 +709,6 @@
 			    accumulator[tagName.toLowerCase()] = tagName;
 			    return accumulator;
 			}, {});
-			exports$1.CARRIAGE_RETURN = '\r';
-			exports$1.CARRIAGE_RETURN_REGEX = new RegExp(exports$1.CARRIAGE_RETURN, 'g');
-			exports$1.CARRIAGE_RETURN_PLACEHOLDER = "__HTML_DOM_PARSER_CARRIAGE_RETURN_PLACEHOLDER_".concat(Date.now().toString(), "__");
-			exports$1.CARRIAGE_RETURN_PLACEHOLDER_REGEX = new RegExp(exports$1.CARRIAGE_RETURN_PLACEHOLDER, 'g');
 			
 		} (constants));
 		return constants;
@@ -823,12 +720,16 @@
 		if (hasRequiredUtilities$2) return utilities$2;
 		hasRequiredUtilities$2 = 1;
 		Object.defineProperty(utilities$2, "__esModule", { value: true });
-		utilities$2.formatAttributes = formatAttributes;
+		utilities$2.hasOpenTag = hasOpenTag;
 		utilities$2.escapeSpecialCharacters = escapeSpecialCharacters;
 		utilities$2.revertEscapedCharacters = revertEscapedCharacters;
 		utilities$2.formatDOM = formatDOM;
-		var domhandler_1 = /*@__PURE__*/ requireLib$2();
+		var domhandler_1 = require$$3;
 		var constants_1 = requireConstants();
+		var CARRIAGE_RETURN = '\r';
+		var CARRIAGE_RETURN_REGEX = new RegExp(CARRIAGE_RETURN, 'g');
+		var CARRIAGE_RETURN_PLACEHOLDER = "__HTML_DOM_PARSER_CARRIAGE_RETURN_PLACEHOLDER_".concat(Date.now().toString(), "__");
+		var CARRIAGE_RETURN_PLACEHOLDER_REGEX = new RegExp(CARRIAGE_RETURN_PLACEHOLDER, 'g');
 		/**
 		 * Gets case-sensitive tag name.
 		 *
@@ -870,6 +771,28 @@
 		    }
 		    return tagName;
 		}
+		/**
+		 * Checks if an HTML string contains an opening tag (case-insensitive).
+		 *
+		 * @param html - HTML string.
+		 * @param tagName - Tag name to search for (e.g., 'head' or 'body').
+		 * @returns - Whether the tag is found.
+		 */
+		function hasOpenTag(html, tagName) {
+		    var openTag = '<' + tagName;
+		    var index = html.toLowerCase().indexOf(openTag);
+		    if (index === -1) {
+		        return false;
+		    }
+		    var char = html[index + openTag.length];
+		    // the character after the tag name must be '>' or whitespace (for attributes)
+		    return (char === '>' ||
+		        char === ' ' ||
+		        char === '\t' ||
+		        char === '\n' ||
+		        char === '\r' ||
+		        char === '/');
+		}
 		/**
 		 * Escapes special characters before parsing.
 		 *
@@ -877,7 +800,7 @@
 		 * @returns - HTML string with escaped special characters.
 		 */
 		function escapeSpecialCharacters(html) {
-		    return html.replace(constants_1.CARRIAGE_RETURN_REGEX, constants_1.CARRIAGE_RETURN_PLACEHOLDER);
+		    return html.replace(CARRIAGE_RETURN_REGEX, CARRIAGE_RETURN_PLACEHOLDER);
 		}
 		/**
 		 * Reverts escaped special characters back to actual characters.
@@ -886,7 +809,7 @@
 		 * @returns - Text with escaped characters reverted.
 		 */
 		function revertEscapedCharacters(text) {
-		    return text.replace(constants_1.CARRIAGE_RETURN_PLACEHOLDER_REGEX, constants_1.CARRIAGE_RETURN);
+		    return text.replace(CARRIAGE_RETURN_PLACEHOLDER_REGEX, CARRIAGE_RETURN);
 		}
 		/**
 		 * Transforms DOM nodes to `domhandler` nodes.
@@ -918,14 +841,14 @@
 		                    : node.childNodes, current);
 		                break;
 		            }
+		            /* v8 ignore start */
 		            case 3:
-		                /* istanbul ignore next */
 		                current = new domhandler_1.Text(revertEscapedCharacters((_a = node.nodeValue) !== null && _a !== void 0 ? _a : ''));
 		                break;
 		            case 8:
-		                /* istanbul ignore next */
 		                current = new domhandler_1.Comment((_b = node.nodeValue) !== null && _b !== void 0 ? _b : '');
 		                break;
+		            /* v8 ignore stop */
 		            default:
 		                continue;
 		        }
@@ -969,18 +892,13 @@
 		var HEAD = 'head';
 		var BODY = 'body';
 		var FIRST_TAG_REGEX = /<([a-zA-Z]+[0-9]?)/; // e.g., <h1>
-		// match-all-characters in case of newlines (DOTALL)
-		var HEAD_TAG_REGEX = /<head[^]*>/i;
-		var BODY_TAG_REGEX = /<body[^]*>/i;
 		// falls back to `parseFromString` if `createHTMLDocument` cannot be used
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		/* eslint-disable @typescript-eslint/no-unused-vars */
+		/* v8 ignore start */
 		var parseFromDocument = function (html, tagName) {
-		    /* istanbul ignore next */
 		    throw new Error('This browser does not support `document.implementation.createHTMLDocument`');
 		};
-		// eslint-disable-next-line @typescript-eslint/no-unused-vars
 		var parseFromString = function (html, tagName) {
-		    /* istanbul ignore next */
 		    throw new Error('This browser does not support `DOMParser.prototype.parseFromString`');
 		};
 		var DOMParser = typeof window === 'object' && window.DOMParser;
@@ -1000,7 +918,6 @@
 		     * @returns - Document.
 		     */
 		    parseFromString = function (html, tagName) {
-		        /* istanbul ignore if */
 		        if (tagName) {
 		            html = "<".concat(tagName, ">").concat(html, "</").concat(tagName, ">");
 		        }
@@ -1024,7 +941,6 @@
 		     * @returns - Document
 		     */
 		    parseFromDocument = function (html, tagName) {
-		        /* istanbul ignore if */
 		        if (tagName) {
 		            var element = htmlDocument_1.documentElement.querySelector(tagName);
 		            if (element) {
@@ -1056,8 +972,8 @@
 		        return template.content.childNodes;
 		    };
 		}
-		/* istanbul ignore next */
 		var createNodeList = function () { return document.createDocumentFragment().childNodes; };
+		/* v8 ignore stop */
 		/**
 		 * Parses HTML string to DOM nodes.
 		 *
@@ -1075,14 +991,12 @@
 		            var doc = parseFromString(html);
 		            // the created document may come with filler head/body elements,
 		            // so make sure to remove them if they don't actually exist
-		            if (!HEAD_TAG_REGEX.test(html)) {
+		            if (!(0, utilities_1.hasOpenTag)(html, HEAD)) {
 		                var element = doc.querySelector(HEAD);
-		                /* istanbul ignore next */
 		                (_b = element === null || element === void 0 ? void 0 : element.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(element);
 		            }
-		            if (!BODY_TAG_REGEX.test(html)) {
+		            if (!(0, utilities_1.hasOpenTag)(html, BODY)) {
 		                var element = doc.querySelector(BODY);
-		                /* istanbul ignore next */
 		                (_c = element === null || element === void 0 ? void 0 : element.parentNode) === null || _c === void 0 ? void 0 : _c.removeChild(element);
 		            }
 		            return doc.querySelectorAll(HTML);
@@ -1091,23 +1005,23 @@
 		        case BODY: {
 		            var elements = parseFromDocument(html).querySelectorAll(firstTagName);
 		            // if there's a sibling element, then return both elements
-		            if (BODY_TAG_REGEX.test(html) && HEAD_TAG_REGEX.test(html)) {
-		                /* istanbul ignore next */
+		            /* v8 ignore next */
+		            if ((0, utilities_1.hasOpenTag)(html, BODY) && (0, utilities_1.hasOpenTag)(html, HEAD)) {
 		                return (_e = (_d = elements[0].parentNode) === null || _d === void 0 ? void 0 : _d.childNodes) !== null && _e !== void 0 ? _e : createNodeList();
 		            }
 		            return elements;
 		        }
 		        // low-level tag or text
+		        /* v8 ignore start */
 		        default: {
 		            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
 		            if (parseFromTemplate) {
 		                return parseFromTemplate(html);
 		            }
-		            /* istanbul ignore next */
 		            var element = parseFromDocument(html, BODY).querySelector(BODY);
-		            /* istanbul ignore next */
 		            return (_f = element === null || element === void 0 ? void 0 : element.childNodes) !== null && _f !== void 0 ? _f : createNodeList();
 		        }
+		        /* v8 ignore stop */
 		    }
 		}
 		
@@ -2610,9 +2524,9 @@
 			exports$1.returnFirstArg = exports$1.canTextBeChildOfNode = exports$1.ELEMENTS_WITH_NO_TEXT_CHILDREN = exports$1.PRESERVE_CUSTOM_ATTRIBUTES = void 0;
 			exports$1.isCustomComponent = isCustomComponent;
 			exports$1.setStyleProp = setStyleProp;
-			var react_1 = require$$0;
-			var style_to_js_1 = __importDefault(requireCjs());
-			var RESERVED_SVG_MATHML_ELEMENTS = new Set([
+			const react_1 = require$$0;
+			const style_to_js_1 = __importDefault(requireCjs());
+			const RESERVED_SVG_MATHML_ELEMENTS = new Set([
 			    'annotation-xml',
 			    'color-profile',
 			    'font-face',
@@ -2644,7 +2558,7 @@
 			    }
 			    return true;
 			}
-			var styleOptions = {
+			const styleOptions = {
 			    reactCompat: true,
 			};
 			/**
@@ -2693,9 +2607,7 @@
 			 * @param node - Element node.
 			 * @returns - Whether the node can contain text nodes.
 			 */
-			var canTextBeChildOfNode = function (node) {
-			    return !exports$1.ELEMENTS_WITH_NO_TEXT_CHILDREN.has(node.name);
-			};
+			const canTextBeChildOfNode = (node) => !exports$1.ELEMENTS_WITH_NO_TEXT_CHILDREN.has(node.name);
 			exports$1.canTextBeChildOfNode = canTextBeChildOfNode;
 			/**
 			 * Returns the first argument as is.
@@ -2703,7 +2615,7 @@
 			 * @param arg - The argument to be returned.
 			 * @returns - The input argument `arg`.
 			 */
-			var returnFirstArg = function (arg) { return arg; };
+			const returnFirstArg = (arg) => arg;
 			exports$1.returnFirstArg = returnFirstArg;
 			
 		} (utilities$1));
@@ -2717,13 +2629,13 @@
 		hasRequiredAttributesToProps = 1;
 		Object.defineProperty(attributesToProps, "__esModule", { value: true });
 		attributesToProps.default = attributesToProps$1;
-		var react_property_1 = requireLib$1();
-		var utilities_1 = requireUtilities();
+		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
-		var UNCONTROLLED_COMPONENT_ATTRIBUTES = ['checked', 'value'];
-		var UNCONTROLLED_COMPONENT_NAMES = ['input', 'select', 'textarea'];
-		var valueOnlyInputs = {
+		const UNCONTROLLED_COMPONENT_ATTRIBUTES = ['checked', 'value'];
+		const UNCONTROLLED_COMPONENT_NAMES = ['input', 'select', 'textarea'];
+		const valueOnlyInputs = {
 		    reset: true,
 		    submit: true,
 		};
@@ -2734,22 +2646,21 @@
 		 * @param nodeName - DOM node name.
 		 * @returns - React props.
 		 */
-		function attributesToProps$1(attributes, nodeName) {
-		    if (attributes === void 0) { attributes = {}; }
-		    var props = {};
-		    var isInputValueOnly = Boolean(attributes.type && valueOnlyInputs[attributes.type]);
-		    for (var attributeName in attributes) {
-		        var attributeValue = attributes[attributeName];
+		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
-		        var attributeNameLowerCased = attributeName.toLowerCase();
-		        var propName = getPropName(attributeNameLowerCased);
+		        const attributeNameLowerCased = attributeName.toLowerCase();
+		        let propName = getPropName(attributeNameLowerCased);
 		        if (propName) {
-		            var propertyInfo = (0, react_property_1.getPropertyInfo)(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) &&
@@ -2804,10 +2715,10 @@
 		};
 		Object.defineProperty(domToReact, "__esModule", { value: true });
 		domToReact.default = domToReact$1;
-		var react_1 = require$$0;
-		var attributes_to_props_1 = __importDefault(requireAttributesToProps());
-		var utilities_1 = requireUtilities();
-		var React = {
+		const react_1 = require$$0;
+		const attributes_to_props_1 = __importDefault(requireAttributesToProps());
+		const utilities_1 = requireUtilities();
+		const React = {
 		    cloneElement: react_1.cloneElement,
 		    createElement: react_1.createElement,
 		    isValidElement: react_1.isValidElement,
@@ -2819,19 +2730,18 @@
 		 * @param options - Options.
 		 * @returns - String or JSX element(s).
 		 */
-		function domToReact$1(nodes, options) {
+		function domToReact$1(nodes, options = {}) {
 		    var _a, _b, _c, _d, _e;
-		    if (options === void 0) { options = {}; }
-		    var reactElements = [];
-		    var hasReplace = typeof options.replace === 'function';
-		    var transform = (_a = options.transform) !== null && _a !== void 0 ? _a : utilities_1.returnFirstArg;
-		    var _f = (_b = options.library) !== null && _b !== void 0 ? _b : React, cloneElement = _f.cloneElement, createElement = _f.createElement, isValidElement = _f.isValidElement;
-		    var nodesLength = nodes.length;
-		    for (var index = 0; index < nodesLength; index++) {
-		        var node = nodes[index];
+		    const reactElements = [];
+		    const hasReplace = typeof options.replace === 'function';
+		    const transform = (_a = options.transform) !== null && _a !== void 0 ? _a : utilities_1.returnFirstArg;
+		    const { cloneElement, createElement, isValidElement } = (_b = options.library) !== null && _b !== void 0 ? _b : React;
+		    const nodesLength = nodes.length;
+		    for (let index = 0; index < nodesLength; index++) {
+		        const node = nodes[index];
 		        // replace with custom React element (if present)
 		        if (hasReplace) {
-		            var replaceElement = (_c = options.replace) === null || _c === void 0 ? void 0 : _c.call(options, node, index);
+		            let replaceElement = (_c = options.replace) === null || _c === void 0 ? void 0 : _c.call(options, node, index);
 		            if (isValidElement(replaceElement)) {
 		                // set "key" prop for sibling elements
 		                // https://react.dev/learn/rendering-lists#rules-of-keys
@@ -2845,7 +2755,7 @@
 		            }
 		        }
 		        if (node.type === 'text') {
-		            var isWhitespace = !node.data.trim().length;
+		            const isWhitespace = !node.data.trim().length;
 		            // We have a whitespace node that can't be nested in its parent
 		            // so skip it
 		            if (isWhitespace &&
@@ -2863,8 +2773,8 @@
 		            reactElements.push(transform(node.data, node, index));
 		            continue;
 		        }
-		        var element = node;
-		        var props = {};
+		        const element = node;
+		        let props = {};
 		        if (skipAttributesToProps(element)) {
 		            (0, utilities_1.setStyleProp)(element.attribs.style, element.attribs);
 		            props = element.attribs;
@@ -2873,7 +2783,7 @@
 		        else if (element.attribs) {
 		            props = (0, attributes_to_props_1.default)(element.attribs, element.name);
 		        }
-		        var children = void 0;
+		        let children;
 		        switch (node.type) {
 		            case 'script':
 		            case 'style':
@@ -2929,27 +2839,27 @@
 	var hasRequiredLib;
 
 	function requireLib () {
-		if (hasRequiredLib) return lib$3;
+		if (hasRequiredLib) return lib$1;
 		hasRequiredLib = 1;
 		(function (exports$1) {
-			var __importDefault = (lib$3 && lib$3.__importDefault) || function (mod) {
+			var __importDefault = (lib$1 && lib$1.__importDefault) || function (mod) {
 			    return (mod && mod.__esModule) ? mod : { "default": mod };
 			};
 			Object.defineProperty(exports$1, "__esModule", { value: true });
 			exports$1.htmlToDOM = exports$1.domToReact = exports$1.attributesToProps = exports$1.Text = exports$1.ProcessingInstruction = exports$1.Element = exports$1.Comment = void 0;
 			exports$1.default = HTMLReactParser;
-			var html_dom_parser_1 = __importDefault(requireHtmlToDom());
+			const html_dom_parser_1 = __importDefault(requireHtmlToDom());
 			exports$1.htmlToDOM = html_dom_parser_1.default;
-			var attributes_to_props_1 = __importDefault(requireAttributesToProps());
+			const attributes_to_props_1 = __importDefault(requireAttributesToProps());
 			exports$1.attributesToProps = attributes_to_props_1.default;
-			var dom_to_react_1 = __importDefault(requireDomToReact());
+			const dom_to_react_1 = __importDefault(requireDomToReact());
 			exports$1.domToReact = dom_to_react_1.default;
-			var domhandler_1 = /*@__PURE__*/ requireLib$2();
+			var domhandler_1 = require$$3;
 			Object.defineProperty(exports$1, "Comment", { enumerable: true, get: function () { return domhandler_1.Comment; } });
 			Object.defineProperty(exports$1, "Element", { enumerable: true, get: function () { return domhandler_1.Element; } });
 			Object.defineProperty(exports$1, "ProcessingInstruction", { enumerable: true, get: function () { return domhandler_1.ProcessingInstruction; } });
 			Object.defineProperty(exports$1, "Text", { enumerable: true, get: function () { return domhandler_1.Text; } });
-			var domParserOptions = { lowerCaseAttributeNames: false };
+			const domParserOptions = { lowerCaseAttributeNames: false };
 			/**
 			 * Converts HTML string to React elements.
 			 *
@@ -2968,8 +2878,8 @@
 			    return (0, dom_to_react_1.default)((0, html_dom_parser_1.default)(html, (_a = options === null || options === void 0 ? void 0 : options.htmlparser2) !== null && _a !== void 0 ? _a : domParserOptions), options);
 			}
 			
-		} (lib$3));
-		return lib$3;
+		} (lib$1));
+		return lib$1;
 	}
 
 	var libExports = requireLib();