happy-dom 15.11.6 → 16.0.0

package/cjs/xml-parser/XMLParser.cjs

@@ -28,11 +28,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const PropertySymbol = __importStar(require("../PropertySymbol.cjs"));
 const NamespaceURI_js_1 = __importDefault(require("../config/NamespaceURI.cjs"));
-const HTMLElementConfig_js_1 = __importDefault(require("../config/HTMLElementConfig.cjs"));
-const Entities = __importStar(require("entities"));
-const HTMLElementConfigContentModelEnum_js_1 = __importDefault(require("../config/HTMLElementConfigContentModelEnum.cjs"));
-const SVGElementConfig_js_1 = __importDefault(require("../config/SVGElementConfig.cjs"));
-const StringUtility_js_1 = __importDefault(require("../StringUtility.cjs"));
+const Node_js_1 = __importDefault(require("../nodes/node/Node.cjs"));
+const XMLEncodeUtility_js_1 = __importDefault(require("../utilities/XMLEncodeUtility.cjs"));
 /**
  * Markup RegExp.
  *
@@ -45,283 +42,571 @@ const StringUtility_js_1 = __importDefault(require("../StringUtility.cjs"));
  * Group 7: End of self closing start tag (e.g. "/>" in "<img/>").
  * Group 8: End of start tag (e.g. ">" in "<div>").
  */
-const MARKUP_REGEXP = /<([^\s/!>?]+)|<\/([^\s/!>?]+)\s*>|<!--([^-]+)-->|<!--([^>]+)>|<!([^>]*)>|<\?([^>]+)>|(\/>)|(>)/gm;
+const MARKUP_REGEXP = /<([^\s/!>?]+)|<\/([^\s/!>?]+)\s*>|(<!--)|(-->)|(<!)|(<\?)|(\/>)|(>)/gm;
 /**
  * Attribute RegExp.
  *
  * Group 1: Attribute name when the attribute has a value using double apostrophe (e.g. "name" in "<div name="value">").
  * Group 2: Attribute value when the attribute has a value using double apostrophe (e.g. "value" in "<div name="value">").
- * Group 3: Attribute name when the attribute has a value using double apostrophe (e.g. "name" in "<div name="value">").
- * Group 4: Attribute value when the attribute has a value using double apostrophe (e.g. "value" in "<div name="value">").
- * Group 5: Attribute end apostrophe when the attribute has a value using double apostrophe (e.g. '"' in "<div name="value">").
- * Group 6: Attribute name when the attribute has a value using single apostrophe (e.g. "name" in "<div name='value'>").
- * Group 7: Attribute value when the attribute has a value using single apostrophe (e.g. "value" in "<div name='value'>").
- * Group 8: Attribute end apostrophe when the attribute has a value using single apostrophe (e.g. "'" in "<div name='value'>").
- * Group 9: Attribute name when the attribute has no value (e.g. "disabled" in "<div disabled>").
+ * Group 3: Attribute end apostrophe when the attribute has a value using double apostrophe (e.g. '"' in "<div name="value">").
+ * Group 4: Attribute name when the attribute has a value using single apostrophe (e.g. "name" in "<div name='value'>").
+ * Group 5: Attribute value when the attribute has a value using single apostrophe (e.g. "value" in "<div name='value'>").
+ * Group 6: Attribute end apostrophe when the attribute has a value using single apostrophe (e.g. "'" in "<div name='value'>").
+ * Group 7: Attribute name when the attribute has no value (e.g. "disabled" in "<div disabled>").
  */
-const ATTRIBUTE_REGEXP = /\s*([a-zA-Z0-9-_:.$@?\\]+) *= *([a-zA-Z0-9-_:.$@?{}/]+)|\s*([a-zA-Z0-9-_:.$@?\\]+) *= *"([^"]*)("{0,1})|\s*([a-zA-Z0-9-_:.$@?\\]+) *= *'([^']*)('{0,1})|\s*([a-zA-Z0-9-_:.$@?\\]+)/gm;
-var MarkupReadStateEnum;
-(function (MarkupReadStateEnum) {
-    MarkupReadStateEnum["startOrEndTag"] = "startOrEndTag";
-    MarkupReadStateEnum["insideStartTag"] = "insideStartTag";
-    MarkupReadStateEnum["plainTextContent"] = "plainTextContent";
-})(MarkupReadStateEnum || (MarkupReadStateEnum = {}));
+const ATTRIBUTE_REGEXP = /\s*([a-zA-Z0-9-_:]+)\s*=\s*"([^"]*)("{0,1})|\s*([a-zA-Z0-9-_:]+)\s*=\s*'([^']*)('{0,1})/gm;
+/**
+ * Attribute without value RegExp.
+ */
+const ATTRIBUTE_WITHOUT_VALUE_REGEXP = /^\s*([a-zA-Z0-9-_:]+)$/;
+/**
+ * XML processing instruction version RegExp.
+ */
+const XML_PROCESSING_INSTRUCTION_VERSION_REGEXP = /version="[^"]+"/;
 /**
  * Document type attribute RegExp.
  *
  * Group 1: Attribute value.
  */
 const DOCUMENT_TYPE_ATTRIBUTE_REGEXP = /"([^"]+)"/gm;
+/**
+ * Space RegExp.
+ */
+const SPACE_REGEXP = /\s+/;
+/**
+ * New line RegExp.
+ */
+const NEW_LINE_REGEXP = /\n/g;
+/**
+ * Markup read state (which state the parser is in).
+ */
+var MarkupReadStateEnum;
+(function (MarkupReadStateEnum) {
+    MarkupReadStateEnum["any"] = "any";
+    MarkupReadStateEnum["startTag"] = "startTag";
+    MarkupReadStateEnum["comment"] = "comment";
+    MarkupReadStateEnum["documentType"] = "documentType";
+    MarkupReadStateEnum["processingInstruction"] = "processingInstruction";
+    MarkupReadStateEnum["error"] = "error";
+})(MarkupReadStateEnum || (MarkupReadStateEnum = {}));
+const NAMESPACE_URIS = Object.values(NamespaceURI_js_1.default);
 /**
  * XML parser.
- *
- * @see https://html.spec.whatwg.org/multipage/indices.html
  */
 class XMLParser {
+    window;
+    rootNode = null;
+    nodeStack = [];
+    tagNameStack = [];
+    defaultNamespaceStack = null;
+    namespacePrefixStack = null;
+    startTagIndex = 0;
+    markupRegExp = null;
+    lastIndex = 0;
+    errorIndex = 0;
+    nextElement = null;
+    nextTagName = null;
+    currentNode = null;
+    readState = MarkupReadStateEnum.any;
+    errorMessage = null;
     /**
-     * Parses XML/HTML and returns a root element.
+     * Constructor.
      *
-     * @param document Document.
-     * @param xml XML/HTML string.
+     * @param window Window.
      * @param [options] Options.
-     * @param [options.rootNode] Node to append elements to. Otherwise a new DocumentFragment is created.
-     * @param [options.evaluateScripts = false] Set to "true" to enable script execution.
-     * @returns Root node.
+     * @param [options.mode] Mode. Defaults to "htmlFragment".
+     * @param [options.evaluateScripts] Set to "true" to enable script execution
      */
-    static parse(document, xml, options) {
-        const root = options && options.rootNode ? options.rootNode : document.createDocumentFragment();
-        const nodeStack = [root];
-        const localNameStack = [null];
-        const markupRegexp = new RegExp(MARKUP_REGEXP, 'gm');
-        const { evaluateScripts = false } = options || {};
-        let newNode = null;
-        let currentNode = root;
+    constructor(window) {
+        this.window = window;
+    }
+    /**
+     * Parses XML and returns an XML document containing nodes found.
+     *
+     * @param xml XML string.
+     * @returns XML document.
+     */
+    parse(xml) {
+        this.rootNode = new this.window.XMLDocument();
+        this.nodeStack = [this.rootNode];
+        this.tagNameStack = [null];
+        this.currentNode = this.rootNode;
+        this.readState = MarkupReadStateEnum.any;
+        this.defaultNamespaceStack = [null];
+        this.namespacePrefixStack = [null];
+        this.startTagIndex = 0;
+        this.errorIndex = 0;
+        this.errorMessage = null;
+        this.markupRegExp = new RegExp(MARKUP_REGEXP, 'gm');
+        this.lastIndex = 0;
         let match;
-        let readState = MarkupReadStateEnum.startOrEndTag;
-        let startTagIndex = 0;
-        let lastIndex = 0;
-        if (xml !== null && xml !== undefined) {
-            xml = String(xml);
-            while ((match = markupRegexp.exec(xml))) {
-                switch (readState) {
-                    case MarkupReadStateEnum.startOrEndTag:
-                        if (match.index !== lastIndex &&
-                            (match[1] || match[2] || match[3] || match[4] || match[5] !== undefined || match[6])) {
-                            // Plain text between tags.
-                            currentNode[PropertySymbol.appendChild](document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex, match.index))), true);
-                        }
-                        if (match[1]) {
-                            // Start tag.
-                            const name = StringUtility_js_1.default.asciiLowerCase(match[1]);
-                            // NamespaceURI is inherited from the parent element.
-                            // NamespaceURI should be SVG for SVGSVGElement.
-                            const namespaceURI = name === 'svg'
-                                ? NamespaceURI_js_1.default.svg
-                                : currentNode[PropertySymbol.namespaceURI] || NamespaceURI_js_1.default.html;
-                            // SVG elements are resolved to their local name during parsing.
-                            // This should probably be handled in an XML document.
-                            const qualifiedName = namespaceURI === NamespaceURI_js_1.default.svg && SVGElementConfig_js_1.default[name]
-                                ? SVGElementConfig_js_1.default[name].localName
-                                : name;
-                            // Create a new element.
-                            newNode = document.createElementNS(namespaceURI, qualifiedName);
-                            readState = MarkupReadStateEnum.insideStartTag;
-                            startTagIndex = markupRegexp.lastIndex;
+        this.rootNode[PropertySymbol.defaultView] = this.window;
+        xml = String(xml);
+        while ((match = this.markupRegExp.exec(xml))) {
+            switch (this.readState) {
+                case MarkupReadStateEnum.any:
+                    if (match.index !== this.lastIndex &&
+                        (match[1] || match[2] || match[3] || match[4] || match[5] !== undefined || match[6])) {
+                        // Plain text between tags.
+                        this.parsePlainText(xml.substring(this.lastIndex, match.index));
+                    }
+                    if (match[1]) {
+                        // Start tag.
+                        this.parseStartTag(match[1]);
+                    }
+                    else if (match[2]) {
+                        // End tag.
+                        if (!this.parseEndTag(match[2])) {
+                            this.errorMessage = `Opening and ending tag mismatch: ${this.tagNameStack[this.tagNameStack.length - 1]} line ${xml.substring(0, this.startTagIndex).split('\n').length} and ${match[2]}\n`;
+                            this.errorIndex = this.markupRegExp.lastIndex;
+                            this.readState = MarkupReadStateEnum.error;
+                            this.removeOverflowingTextNodes();
                         }
-                        else if (match[2]) {
-                            // End tag.
-                            // We close all tags up until the first tag that matches the end tag.
-                            const localName = StringUtility_js_1.default.asciiLowerCase(match[2]);
-                            const index = localNameStack.lastIndexOf(localName);
-                            if (index !== -1) {
-                                nodeStack.splice(index, nodeStack.length - index);
-                                localNameStack.splice(index, localNameStack.length - index);
-                                currentNode = nodeStack[nodeStack.length - 1] || root;
-                            }
-                        }
-                        else if (match[3] ||
-                            match[4] ||
-                            (match[6] &&
-                                currentNode[PropertySymbol.namespaceURI] === NamespaceURI_js_1.default.html)) {
-                            // Comment.
-                            let comment;
-                            if (match[3]) {
-                                comment = match[3];
-                            }
-                            else if (match[4]) {
-                                comment = match[4].endsWith('--') ? match[4].slice(0, -2) : match[4];
-                            }
-                            else {
-                                comment = '?' + match[6];
+                    }
+                    else if (match[3]) {
+                        // Comment.
+                        this.startTagIndex = this.markupRegExp.lastIndex;
+                        this.readState = MarkupReadStateEnum.comment;
+                    }
+                    else if (match[5] !== undefined) {
+                        // Document type
+                        this.startTagIndex = this.markupRegExp.lastIndex;
+                        this.readState = MarkupReadStateEnum.documentType;
+                    }
+                    else if (match[6]) {
+                        // Processing instruction.
+                        this.startTagIndex = this.markupRegExp.lastIndex;
+                        this.readState = MarkupReadStateEnum.processingInstruction;
+                    }
+                    else {
+                        // Plain text between tags, including the matched tag as it is not a valid start or end tag.
+                        this.parsePlainText(xml.substring(this.lastIndex, this.markupRegExp.lastIndex));
+                    }
+                    break;
+                case MarkupReadStateEnum.startTag:
+                    // End of start tag
+                    // match[7] is matching "/>" (e.g. "<img/>").
+                    // match[8] is matching ">" (e.g. "<div>").
+                    if (match[7] || match[8]) {
+                        const attributeString = xml.substring(this.startTagIndex, match[2] ? this.markupRegExp.lastIndex - 1 : match.index);
+                        const isSelfClosed = !!match[7];
+                        this.parseEndOfStartTag(attributeString, isSelfClosed);
+                    }
+                    else {
+                        this.errorMessage =
+                            match[2] && this.lastIndex !== this.startTagIndex
+                                ? `Unescaped '&lt;' not allowed in attributes values\n`
+                                : 'error parsing attribute name\n';
+                        this.errorIndex = match.index;
+                        this.readState = MarkupReadStateEnum.error;
+                        this.removeOverflowingTextNodes();
+                    }
+                    break;
+                case MarkupReadStateEnum.comment:
+                    // Comment end tag.
+                    if (match[4]) {
+                        this.parseComment(xml.substring(this.startTagIndex, match.index));
+                    }
+                    break;
+                case MarkupReadStateEnum.documentType:
+                    // Document type end tag.
+                    if (match[7] || match[8]) {
+                        this.parseDocumentType(xml.substring(this.startTagIndex, match.index));
+                    }
+                    break;
+                case MarkupReadStateEnum.processingInstruction:
+                    // Processing instruction end tag.
+                    if (match[7] || match[8]) {
+                        this.parseProcessingInstruction(xml.substring(this.startTagIndex, match.index));
+                    }
+                    break;
+                case MarkupReadStateEnum.error:
+                    this.parseError(xml.slice(0, this.errorIndex), this.errorMessage);
+                    return this.rootNode;
+            }
+            this.lastIndex = this.markupRegExp.lastIndex;
+        }
+        if (this.readState === MarkupReadStateEnum.error) {
+            this.parseError(xml.slice(0, this.errorIndex), this.errorMessage);
+            return this.rootNode;
+        }
+        if (this.readState === MarkupReadStateEnum.comment) {
+            this.parseError(xml, 'Comment not terminated\n');
+            this.removeOverflowingTextNodes();
+            return this.rootNode;
+        }
+        // Missing start tag (e.g. when parsing just a string like "Test").
+        if (this.rootNode[PropertySymbol.elementArray].length === 0) {
+            this.parseError('', `Start tag expected, '&lt;' not found`);
+            return this.rootNode;
+        }
+        // Plain text after tags.
+        if (this.lastIndex !== xml.length && this.currentNode) {
+            this.parsePlainText(xml.substring(this.lastIndex));
+        }
+        // Missing end tag.
+        if (this.nodeStack.length !== 1) {
+            this.parseError(xml, this.nextElement
+                ? 'attributes construct error\n'
+                : 'Premature end of data in tag article line 1\n');
+            return this.rootNode;
+        }
+        return this.rootNode;
+    }
+    /**
+     * Parses plain text.
+     *
+     * @param text Text.
+     */
+    parsePlainText(text) {
+        if (this.currentNode === this.rootNode) {
+            const xmlText = text.replace(SPACE_REGEXP, '');
+            if (xmlText) {
+                this.errorMessage = 'Extra content at the end of the document\n';
+                this.errorIndex = this.lastIndex;
+                this.readState = MarkupReadStateEnum.error;
+            }
+        }
+        else if (text.includes('&nbsp;')) {
+            this.errorMessage = `Entity 'nbsp' not defined\n`;
+            this.errorIndex = this.lastIndex + text.indexOf('&nbsp;') + 6;
+            this.readState = MarkupReadStateEnum.error;
+        }
+        else {
+            this.currentNode[PropertySymbol.appendChild](this.rootNode.createTextNode(XMLEncodeUtility_js_1.default.decodeXMLEntities(text)), true);
+        }
+    }
+    /**
+     * Parses processing instruction.
+     *
+     * @param text Text.
+     */
+    parseProcessingInstruction(text) {
+        const parts = text.split(SPACE_REGEXP);
+        const endsWithQuestionMark = text[text.length - 1] === '?';
+        if (parts[0] === 'xml') {
+            if (this.currentNode !== this.rootNode ||
+                this.rootNode[PropertySymbol.nodeArray].length !== 0 ||
+                parts.length === 1) {
+                this.errorMessage = 'XML declaration allowed only at the start of the document\n';
+                this.errorIndex = this.markupRegExp.lastIndex - text.length + 2;
+                this.readState = MarkupReadStateEnum.error;
+                this.removeOverflowingTextNodes();
+            }
+            else if (!XML_PROCESSING_INSTRUCTION_VERSION_REGEXP.test(parts[1])) {
+                this.errorMessage = 'Malformed declaration expecting version\n';
+                this.errorIndex = this.markupRegExp.lastIndex - text.length + 3;
+                this.readState = MarkupReadStateEnum.error;
+            }
+            else if (!endsWithQuestionMark) {
+                this.errorMessage = 'Blank needed here\n';
+                this.errorIndex = this.markupRegExp.lastIndex - 1;
+                this.readState = MarkupReadStateEnum.error;
+            }
+            else {
+                // When the processing instruction has "xml" as target, we should not add it as a child node.
+                // Instead we will store the state on the root node, so that it is added when serializing the document with XMLSerializer.
+                // TODO: We need to handle validation of encoding.
+                const name = parts[0];
+                // We need to remove the ending "?".
+                const content = parts.slice(1).join(' ').slice(0, -1);
+                this.rootNode[PropertySymbol.xmlProcessingInstruction] =
+                    this.rootNode.createProcessingInstruction(name, content);
+                this.readState = MarkupReadStateEnum.any;
+            }
+        }
+        else {
+            if (parts.length === 1 && !endsWithQuestionMark) {
+                this.errorMessage = 'ParsePI: PI processing-instruction space expected\n';
+                this.errorIndex = this.markupRegExp.lastIndex - 1;
+                this.readState = MarkupReadStateEnum.error;
+            }
+            else if (parts.length > 1 && !endsWithQuestionMark) {
+                this.errorMessage = 'ParsePI: PI processing-instruction never end ...\n';
+                this.errorIndex = this.markupRegExp.lastIndex - 1;
+                this.readState = MarkupReadStateEnum.error;
+            }
+            else {
+                const name = parts[0];
+                // We need to remove the ending "?".
+                const content = parts.slice(1).join(' ').slice(0, -1);
+                this.currentNode[PropertySymbol.appendChild](this.rootNode.createProcessingInstruction(name, content), true);
+                this.readState = MarkupReadStateEnum.any;
+            }
+        }
+    }
+    /**
+     * Parses comment.
+     *
+     * @param comment Comment.
+     */
+    parseComment(comment) {
+        // Comments are not allowed in the root when parsing XML.
+        if (this.currentNode !== this.rootNode) {
+            this.currentNode[PropertySymbol.appendChild](this.rootNode.createComment(XMLEncodeUtility_js_1.default.decodeXMLEntities(comment)), true);
+        }
+        this.readState = MarkupReadStateEnum.any;
+    }
+    /**
+     * Parses document type.
+     *
+     * @param text Text.
+     */
+    parseDocumentType(text) {
+        if (this.currentNode === this.rootNode &&
+            this.rootNode[PropertySymbol.nodeArray].length === 0) {
+            const documentType = this.getDocumentType(XMLEncodeUtility_js_1.default.decodeXMLEntities(text));
+            if (documentType?.name) {
+                this.rootNode[PropertySymbol.appendChild](this.window.document.implementation.createDocumentType(documentType.name, documentType.publicId, documentType.systemId), true);
+                this.readState = MarkupReadStateEnum.any;
+            }
+            else if (documentType) {
+                this.errorMessage = 'xmlParseDocTypeDecl : no DOCTYPE name\n';
+                this.errorIndex = this.markupRegExp.lastIndex - text.length - 2;
+                this.readState = MarkupReadStateEnum.error;
+            }
+            else {
+                this.errorMessage = 'StartTag: invalid element name\n';
+                this.errorIndex = this.markupRegExp.lastIndex - text.length - 2;
+                this.readState = MarkupReadStateEnum.error;
+            }
+        }
+        else if (this.currentNode === this.rootNode &&
+            this.rootNode[PropertySymbol.elementArray].length === 1) {
+            this.errorMessage = 'Extra content at the end of the document\n';
+            this.errorIndex = this.markupRegExp.lastIndex - text.length - 2;
+            this.readState = MarkupReadStateEnum.error;
+        }
+        else {
+            this.errorMessage = 'StartTag: invalid element name\n';
+            this.errorIndex = this.markupRegExp.lastIndex - text.length - 2;
+            this.readState = MarkupReadStateEnum.error;
+        }
+    }
+    /**
+     * Parses start tag.
+     *
+     * @param tagName Tag name.
+     */
+    parseStartTag(tagName) {
+        const parts = tagName.split(':');
+        if (parts.length > 1) {
+            this.nextElement = this.rootNode.createElementNS(this.namespacePrefixStack[this.namespacePrefixStack.length - 1]?.get(parts[0]) || null, tagName);
+        }
+        else {
+            this.nextElement = this.rootNode.createElementNS(this.defaultNamespaceStack[this.defaultNamespaceStack.length - 1] || null, tagName);
+        }
+        this.namespacePrefixStack.push(new Map(this.namespacePrefixStack[this.namespacePrefixStack.length - 1]));
+        this.nextTagName = tagName;
+        this.startTagIndex = this.markupRegExp.lastIndex;
+        this.readState = MarkupReadStateEnum.startTag;
+    }
+    /**
+     * Parses end of start tag.
+     *
+     * @param attributeString Attribute string.
+     * @param isSelfClosed Is self closed.
+     */
+    parseEndOfStartTag(attributeString, isSelfClosed) {
+        const namespacePrefix = this.namespacePrefixStack[this.namespacePrefixStack.length - 1];
+        if (attributeString) {
+            const attributeRegexp = new RegExp(ATTRIBUTE_REGEXP, 'gm');
+            let attributeMatch;
+            let lastIndex = 0;
+            while ((attributeMatch = attributeRegexp.exec(attributeString))) {
+                const textBetweenAttributes = attributeString
+                    .substring(lastIndex, attributeMatch.index)
+                    .replace(SPACE_REGEXP, '');
+                // If there is text between attributes, the text did not match a valid attribute.
+                if (textBetweenAttributes.length) {
+                    const match = textBetweenAttributes.match(ATTRIBUTE_WITHOUT_VALUE_REGEXP);
+                    this.errorMessage = match
+                        ? `Specification mandates value for attribute ${match[1]}\n`
+                        : 'attributes construct error\n';
+                    this.errorIndex = this.startTagIndex;
+                    this.readState = MarkupReadStateEnum.error;
+                    this.removeOverflowingTextNodes();
+                    return;
+                }
+                if ((attributeMatch[1] && attributeMatch[3] === '"') ||
+                    (attributeMatch[4] && attributeMatch[6] === "'")) {
+                    // Valid attribute name and value.
+                    const name = attributeMatch[1] ?? attributeMatch[4];
+                    const rawValue = attributeMatch[2] ?? attributeMatch[5];
+                    // In XML, new line characters should be replaced with a space.
+                    const value = rawValue
+                        ? XMLEncodeUtility_js_1.default.decodeAttributeValue(rawValue.replace(NEW_LINE_REGEXP, ' '))
+                        : '';
+                    const attributes = this.nextElement[PropertySymbol.attributes];
+                    const nameParts = name.split(':');
+                    if (nameParts.length > 2 ||
+                        (nameParts.length === 2 && (!nameParts[0] || !nameParts[1]))) {
+                        this.errorMessage = `Failed to parse QName '${name}'\n`;
+                        this.errorIndex =
+                            this.startTagIndex + attributeMatch.index + attributeMatch[0].split('=')[0].length;
+                        this.readState = MarkupReadStateEnum.error;
+                        return;
+                    }
+                    // In XML, attributes prefixed with "xmlns:" or named "xmlns" should be set to the "http://www.w3.org/2000/xmlns/" namespace.
+                    const namespaceURI = nameParts[0] === 'xmlns' ? NamespaceURI_js_1.default.xmlns : null;
+                    if (!attributes.getNamedItemNS(namespaceURI, name)) {
+                        const attributeItem = this.rootNode.createAttributeNS(namespaceURI, name);
+                        attributeItem[PropertySymbol.value] = value;
+                        attributes[PropertySymbol.setNamedItem](attributeItem);
+                        // Attributes prefixed with "xmlns:" should be added to the namespace prefix map, so that the prefix can be added as namespaceURI to elements using the prefix.
+                        if (attributeItem[PropertySymbol.prefix] === 'xmlns') {
+                            namespacePrefix.set(attributeItem[PropertySymbol.localName], value);
+                            // If the prefix matches the current element, we should set the namespace URI of the element to the value of the attribute.
+                            // We don't need to upgrade the element, as there are no defined element types using a prefix.
+                            if (this.nextElement[PropertySymbol.prefix] === attributeItem[PropertySymbol.localName]) {
+                                this.nextElement[PropertySymbol.namespaceURI] = value;
                             }
-                            currentNode[PropertySymbol.appendChild](document.createComment(Entities.decodeHTML(comment)), true);
-                        }
-                        else if (match[5] !== undefined) {
-                            // Exclamation mark comment.
-                            // Document type node or comment.
-                            const exclamationComment = Entities.decodeHTML(match[5]);
-                            currentNode[PropertySymbol.appendChild](this.getDocumentTypeNode(document, exclamationComment) ||
-                                document.createComment(exclamationComment), true);
-                        }
-                        else if (match[6]) {
-                            // Processing instruction (not supported by HTML).
-                            // TODO: Add support for processing instructions.
-                        }
-                        else {
-                            // Plain text between tags, including the match as it is not a valid start or end tag.
-                            currentNode[PropertySymbol.appendChild](document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex, markupRegexp.lastIndex))), true);
                         }
-                        break;
-                    case MarkupReadStateEnum.insideStartTag:
-                        // End of start tag
-                        if (match[7] || match[8]) {
-                            // Attribute name and value.
-                            const attributeString = xml.substring(startTagIndex, match.index);
-                            let hasAttributeStringEnded = true;
-                            if (!!attributeString) {
-                                const attributeRegexp = new RegExp(ATTRIBUTE_REGEXP, 'gm');
-                                let attributeMatch;
-                                while ((attributeMatch = attributeRegexp.exec(attributeString))) {
-                                    if ((attributeMatch[1] && attributeMatch[2]) ||
-                                        (attributeMatch[3] && attributeMatch[5] === '"') ||
-                                        (attributeMatch[6] && attributeMatch[8] === "'") ||
-                                        attributeMatch[9]) {
-                                        // Valid attribute name and value.
-                                        const name = attributeMatch[1] ||
-                                            attributeMatch[3] ||
-                                            attributeMatch[6] ||
-                                            attributeMatch[9] ||
-                                            '';
-                                        const rawValue = attributeMatch[2] || attributeMatch[4] || attributeMatch[7] || '';
-                                        const value = rawValue ? Entities.decodeHTMLAttribute(rawValue) : '';
-                                        if (newNode[PropertySymbol.namespaceURI] === NamespaceURI_js_1.default.svg) {
-                                            // In XML and SVG namespaces, the attribute "xmlns" should be set to the "http://www.w3.org/2000/xmlns/" namespace.
-                                            const attributeItem = document.createAttributeNS(name === 'xmlns' ? NamespaceURI_js_1.default.xmlns : null, name);
-                                            attributeItem[PropertySymbol.value] = value;
-                                            newNode[PropertySymbol.attributes][PropertySymbol.setNamedItem](attributeItem);
-                                        }
-                                        else {
-                                            const attributeItem = document.createAttribute(name);
-                                            attributeItem[PropertySymbol.value] = value;
-                                            newNode[PropertySymbol.attributes][PropertySymbol.setNamedItem](attributeItem);
-                                        }
-                                        startTagIndex += attributeMatch[0].length;
-                                    }
-                                    else if (!attributeMatch[1] &&
-                                        ((attributeMatch[3] && !attributeMatch[5]) ||
-                                            (attributeMatch[6] && !attributeMatch[8]))) {
-                                        // End attribute apostrophe is missing (e.g. "attr='value" or 'attr="value').
-                                        hasAttributeStringEnded = false;
-                                        break;
-                                    }
+                        // If the attribute is "xmlns", we should upgrade the element to an element created using the namespace URI.
+                        else if (name === 'xmlns' && !this.nextElement[PropertySymbol.prefix]) {
+                            // We only need to create a new instance if it is a known namespace URI.
+                            if (NAMESPACE_URIS.includes(value)) {
+                                this.nextElement = this.rootNode.createElementNS(value, this.nextElement[PropertySymbol.tagName]);
+                                this.nextElement[PropertySymbol.attributes] = attributes;
+                                attributes[PropertySymbol.ownerElement] = this.nextElement;
+                                for (const attr of attributes[PropertySymbol.namespaceItems].values()) {
+                                    attr[PropertySymbol.ownerElement] = this.nextElement;
                                 }
                             }
-                            // We need to check if the attribute string is read completely.
-                            // The attribute string can potentially contain "/>" or ">".
-                            if (hasAttributeStringEnded) {
-                                const config = HTMLElementConfig_js_1.default[newNode[PropertySymbol.localName]];
-                                const localName = StringUtility_js_1.default.asciiLowerCase(newNode[PropertySymbol.localName]);
-                                // Some elements are not allowed to be nested (e.g. "<a><a></a></a>" is not allowed.).
-                                // Therefore we need to auto-close the tag, so that it become valid (e.g. "<a></a><a></a>").
-                                if (config?.contentModel ===
-                                    HTMLElementConfigContentModelEnum_js_1.default.noFirstLevelSelfDescendants &&
-                                    localNameStack[localNameStack.length - 1] === localName) {
-                                    nodeStack.pop();
-                                    localNameStack.pop();
-                                    currentNode = nodeStack[nodeStack.length - 1] || root;
-                                }
-                                else if (config?.contentModel === HTMLElementConfigContentModelEnum_js_1.default.noSelfDescendants &&
-                                    localNameStack.includes(localName)) {
-                                    while (currentNode !== root) {
-                                        if (currentNode[PropertySymbol.localName] === localName) {
-                                            nodeStack.pop();
-                                            localNameStack.pop();
-                                            currentNode = nodeStack[nodeStack.length - 1] || root;
-                                            break;
-                                        }
-                                        nodeStack.pop();
-                                        localNameStack.pop();
-                                        currentNode = nodeStack[nodeStack.length - 1] || root;
-                                    }
-                                }
-                                // Appends the new node to its parent and sets is as current node.
-                                currentNode[PropertySymbol.appendChild](newNode, true);
-                                currentNode = newNode;
-                                nodeStack.push(currentNode);
-                                localNameStack.push(localName);
-                                newNode = null;
-                                // Checks if the tag is a self closing tag (ends with "/>") or void element.
-                                // When it is a self closing tag or void element it should be closed immediately.
-                                // Self closing tags are not allowed in the HTML namespace, but the parser should still allow it for void elements.
-                                // Self closing tags is supported in the SVG namespace.
-                                if (config?.contentModel === HTMLElementConfigContentModelEnum_js_1.default.noDescendants ||
-                                    // SVG tag is self closing (<svg/>).
-                                    (match[7] &&
-                                        currentNode[PropertySymbol.namespaceURI] === NamespaceURI_js_1.default.svg)) {
-                                    nodeStack.pop();
-                                    localNameStack.pop();
-                                    currentNode = nodeStack[nodeStack.length - 1] || root;
-                                    readState = MarkupReadStateEnum.startOrEndTag;
-                                }
-                                else {
-                                    readState =
-                                        config?.contentModel === HTMLElementConfigContentModelEnum_js_1.default.rawText
-                                            ? MarkupReadStateEnum.plainTextContent
-                                            : MarkupReadStateEnum.startOrEndTag;
-                                }
-                                startTagIndex = markupRegexp.lastIndex;
-                            }
-                        }
-                        break;
-                    case MarkupReadStateEnum.plainTextContent:
-                        const localName = currentNode[PropertySymbol.localName];
-                        if (localName && match[2] && StringUtility_js_1.default.asciiLowerCase(match[2]) === localName) {
-                            // End of plain text tag.
-                            // Scripts are not allowed to be executed when they are parsed using innerHTML, outerHTML, replaceWith() etc.
-                            // However, they are allowed to be executed when document.write() is used.
-                            // See: https://developer.mozilla.org/en-US/docs/Web/API/HTMLScriptElement
-                            if (localName === 'script') {
-                                currentNode[PropertySymbol.evaluateScript] = evaluateScripts;
-                            }
-                            else if (localName === 'link') {
-                                // An assumption that the same rule should be applied for the HTMLLinkElement is made here.
-                                currentNode[PropertySymbol.evaluateCSS] = evaluateScripts;
+                            else {
+                                this.nextElement[PropertySymbol.namespaceURI] = value;
                             }
-                            // Plain text elements such as <script> and <style> should only contain text.
-                            currentNode[PropertySymbol.appendChild](document.createTextNode(Entities.decodeHTML(xml.substring(startTagIndex, match.index))), true);
-                            nodeStack.pop();
-                            localNameStack.pop();
-                            currentNode = nodeStack[nodeStack.length - 1] || root;
-                            readState = MarkupReadStateEnum.startOrEndTag;
                         }
-                        break;
+                    }
+                    else {
+                        this.errorMessage = `Attribute ${name} redefined\n`;
+                        this.errorIndex = this.startTagIndex;
+                        this.readState = MarkupReadStateEnum.error;
+                    }
+                    this.startTagIndex += attributeMatch[0].length;
+                }
+                else if ((attributeMatch[1] && attributeMatch[3] !== '"') ||
+                    (attributeMatch[4] && attributeMatch[6] !== "'")) {
+                    // End attribute apostrophe is missing (e.g. "attr='value" or 'attr="value').
+                    // We should continue to the next end of start tag match.
+                    return;
+                }
+                lastIndex = attributeRegexp.lastIndex;
+            }
+            const attributeStringEnd = attributeString.substring(lastIndex).replace(SPACE_REGEXP, '');
+            if (attributeStringEnd.length) {
+                const match = attributeStringEnd.match(ATTRIBUTE_WITHOUT_VALUE_REGEXP);
+                if (match) {
+                    this.errorMessage = `Specification mandates value for attribute ${match[1]}\n`;
+                    this.errorIndex = this.markupRegExp.lastIndex - 2;
+                }
+                else {
+                    this.errorMessage = 'attributes construct error\n';
+                    this.errorIndex = this.startTagIndex;
                 }
-                lastIndex = markupRegexp.lastIndex;
+                this.readState = MarkupReadStateEnum.error;
+                this.removeOverflowingTextNodes();
+                return;
             }
-            // We expected the "newNode" to be null if the start tag was closed correctly.
-            // We should append the last node to the current node to correct it.
-            if (newNode && currentNode) {
-                currentNode[PropertySymbol.appendChild](newNode, true);
+        }
+        // Prefixed elements need to have a namespace URI defined by a prefixed "xmlns:" attribute either by a parent or in the current element.
+        if (this.nextElement[PropertySymbol.prefix] && !this.nextElement[PropertySymbol.namespaceURI]) {
+            this.errorMessage = `Namespace prefix ${this.nextElement[PropertySymbol.prefix]} on name is not defined\n`;
+            this.errorIndex = this.lastIndex;
+            this.readState = MarkupReadStateEnum.error;
+            return;
+        }
+        // Only one document element is allowed in the document.
+        if (this.currentNode === this.rootNode &&
+            this.rootNode[PropertySymbol.elementArray].length !== 0) {
+            this.errorMessage = 'Extra content at the end of the document\n';
+            this.errorIndex = this.lastIndex - this.nextElement[PropertySymbol.tagName].length - 1;
+            this.readState = MarkupReadStateEnum.error;
+            return;
+        }
+        this.currentNode[PropertySymbol.appendChild](this.nextElement, true);
+        // Sets the new element as the current node.
+        // XML nodes can be self closed using "/>"
+        if (!isSelfClosed) {
+            this.currentNode = this.nextElement;
+            this.nodeStack.push(this.currentNode);
+            this.tagNameStack.push(this.nextTagName);
+            if (this.currentNode[PropertySymbol.namespaceURI] &&
+                !this.currentNode[PropertySymbol.prefix]) {
+                this.defaultNamespaceStack.push(this.currentNode[PropertySymbol.namespaceURI]);
+            }
+            else {
+                this.defaultNamespaceStack.push(this.defaultNamespaceStack[this.defaultNamespaceStack.length - 1]);
             }
-            if (lastIndex !== xml.length) {
-                // Plain text after tags.
-                currentNode[PropertySymbol.appendChild](document.createTextNode(Entities.decodeHTML(xml.substring(lastIndex))), true);
+        }
+        this.nextElement = null;
+        this.nextTagName = null;
+        this.readState = MarkupReadStateEnum.any;
+        this.startTagIndex = this.markupRegExp.lastIndex;
+    }
+    /**
+     * Parses end tag.
+     *
+     * @param tagName Tag name.
+     * @returns True if the end tag was parsed, false otherwise.
+     */
+    parseEndTag(tagName) {
+        if (this.tagNameStack[this.tagNameStack.length - 1] === tagName) {
+            this.nodeStack.pop();
+            this.tagNameStack.pop();
+            this.namespacePrefixStack.pop();
+            this.defaultNamespaceStack.pop();
+            this.currentNode = this.nodeStack[this.nodeStack.length - 1] || this.rootNode;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Parses XML document error.
+     *
+     * @param readXML XML that has been read.
+     * @param errorMessage Error message.
+     */
+    parseError(readXML, errorMessage) {
+        let errorRoot = this.rootNode.documentElement;
+        if (!errorRoot) {
+            const documentElement = this.rootNode.createElementNS(NamespaceURI_js_1.default.html, 'html');
+            const body = this.rootNode.createElementNS(NamespaceURI_js_1.default.html, 'body');
+            documentElement.appendChild(body);
+            errorRoot = body;
+            this.rootNode[PropertySymbol.appendChild](documentElement, true);
+        }
+        const rows = readXML.split('\n');
+        const column = rows[rows.length - 1].length + 1;
+        const error = `error on line ${rows.length} at column ${column}: ${errorMessage}`;
+        const errorElement = this.rootNode.createElementNS(NamespaceURI_js_1.default.html, 'parsererror');
+        errorElement.setAttribute('style', 'display: block; white-space: pre; border: 2px solid #c77; padding: 0 1em 0 1em; margin: 1em; background-color: #fdd; color: black');
+        errorElement.innerHTML = `<h3>This page contains the following errors:</h3><div style="font-family:monospace;font-size:12px">${error}</div><h3>Below is a rendering of the page up to the first error.</h3>`;
+        errorRoot.insertBefore(errorElement, errorRoot.firstChild);
+    }
+    /**
+     * Removes overflowing text nodes in the current node.
+     *
+     * This needs to be done for some errors.
+     */
+    removeOverflowingTextNodes() {
+        if (this.currentNode && this.currentNode !== this.rootNode) {
+            while (this.currentNode.lastChild?.[PropertySymbol.nodeType] === Node_js_1.default.TEXT_NODE) {
+                this.currentNode.removeChild(this.currentNode.lastChild);
             }
         }
-        return root;
     }
     /**
-     * Returns document type node.
+     * Returns document type.
      *
-     * @param document Document.
      * @param value Value.
-     * @returns Document type node.
+     * @returns Document type.
      */
-    static getDocumentTypeNode(document, value) {
+    getDocumentType(value) {
         if (!value.toUpperCase().startsWith('DOCTYPE')) {
             return null;
         }
-        const docTypeSplit = value.split(' ');
+        const docTypeSplit = value.split(SPACE_REGEXP);
         if (docTypeSplit.length <= 1) {
             return null;
         }
@@ -335,7 +620,11 @@ class XMLParser {
         }
         const publicId = isPublic ? attributes[0] || '' : '';
         const systemId = isPublic ? attributes[1] || '' : attributes[0] || '';
-        return document.implementation.createDocumentType(docTypeSplit[1].toLowerCase(), publicId, systemId);
+        return {
+            name: docTypeSplit[1].toLowerCase(),
+            publicId,
+            systemId
+        };
     }
 }
 exports.default = XMLParser;