vite 6.0.0-beta.1 → 6.0.0-beta.10

package/dist/node/chunks/{dep-D-7KCb9p.js → dep-DnSxfB-q.js}

@@ -1,11 +1,3 @@
-import { fileURLToPath as __cjs_fileURLToPath } from 'node:url';
-import { dirname as __cjs_dirname } from 'node:path';
-import { createRequire as __cjs_createRequire } from 'node:module';
-
-const __filename = __cjs_fileURLToPath(import.meta.url);
-const __dirname = __cjs_dirname(__filename);
-const require = __cjs_createRequire(import.meta.url);
-const __require = require;
 const UNDEFINED_CODE_POINTS = new Set([
     65534, 65535, 131070, 131071, 196606, 196607, 262142, 262143, 327678, 327679, 393214,
     393215, 458750, 458751, 524286, 524287, 589822, 589823, 655358, 655359, 720894,
@@ -24,7 +16,6 @@ var CODE_POINTS;
     CODE_POINTS[CODE_POINTS["SPACE"] = 32] = "SPACE";
     CODE_POINTS[CODE_POINTS["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK";
     CODE_POINTS[CODE_POINTS["QUOTATION_MARK"] = 34] = "QUOTATION_MARK";
-    CODE_POINTS[CODE_POINTS["NUMBER_SIGN"] = 35] = "NUMBER_SIGN";
     CODE_POINTS[CODE_POINTS["AMPERSAND"] = 38] = "AMPERSAND";
     CODE_POINTS[CODE_POINTS["APOSTROPHE"] = 39] = "APOSTROPHE";
     CODE_POINTS[CODE_POINTS["HYPHEN_MINUS"] = 45] = "HYPHEN_MINUS";
@@ -37,17 +28,12 @@ var CODE_POINTS;
     CODE_POINTS[CODE_POINTS["GREATER_THAN_SIGN"] = 62] = "GREATER_THAN_SIGN";
     CODE_POINTS[CODE_POINTS["QUESTION_MARK"] = 63] = "QUESTION_MARK";
     CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_A"] = 65] = "LATIN_CAPITAL_A";
-    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_F"] = 70] = "LATIN_CAPITAL_F";
-    CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_X"] = 88] = "LATIN_CAPITAL_X";
     CODE_POINTS[CODE_POINTS["LATIN_CAPITAL_Z"] = 90] = "LATIN_CAPITAL_Z";
     CODE_POINTS[CODE_POINTS["RIGHT_SQUARE_BRACKET"] = 93] = "RIGHT_SQUARE_BRACKET";
     CODE_POINTS[CODE_POINTS["GRAVE_ACCENT"] = 96] = "GRAVE_ACCENT";
     CODE_POINTS[CODE_POINTS["LATIN_SMALL_A"] = 97] = "LATIN_SMALL_A";
-    CODE_POINTS[CODE_POINTS["LATIN_SMALL_F"] = 102] = "LATIN_SMALL_F";
-    CODE_POINTS[CODE_POINTS["LATIN_SMALL_X"] = 120] = "LATIN_SMALL_X";
     CODE_POINTS[CODE_POINTS["LATIN_SMALL_Z"] = 122] = "LATIN_SMALL_Z";
-    CODE_POINTS[CODE_POINTS["REPLACEMENT_CHARACTER"] = 65533] = "REPLACEMENT_CHARACTER";
-})(CODE_POINTS = CODE_POINTS || (CODE_POINTS = {}));
+})(CODE_POINTS || (CODE_POINTS = {}));
 const SEQUENCES = {
     DASH_DASH: '--',
     CDATA_START: '[CDATA[',
@@ -137,7 +123,7 @@ var ERR;
     ERR["misplacedStartTagForHeadElement"] = "misplaced-start-tag-for-head-element";
     ERR["nestedNoscriptInHead"] = "nested-noscript-in-head";
     ERR["eofInElementThatCanContainOnlyText"] = "eof-in-element-that-can-contain-only-text";
-})(ERR = ERR || (ERR = {}));
+})(ERR || (ERR = {}));
 
 //Const
 const DEFAULT_BUFFER_WATERLINE = 1 << 16;
@@ -170,22 +156,24 @@ class Preprocessor {
     get offset() {
         return this.droppedBufferSize + this.pos;
     }
-    getError(code) {
+    getError(code, cpOffset) {
         const { line, col, offset } = this;
+        const startCol = col + cpOffset;
+        const startOffset = offset + cpOffset;
         return {
             code,
             startLine: line,
             endLine: line,
-            startCol: col,
-            endCol: col,
-            startOffset: offset,
-            endOffset: offset,
+            startCol,
+            endCol: startCol,
+            startOffset,
+            endOffset: startOffset,
         };
     }
     _err(code) {
         if (this.handler.onParseError && this.lastErrOffset !== this.offset) {
             this.lastErrOffset = this.offset;
-            this.handler.onParseError(this.getError(code));
+            this.handler.onParseError(this.getError(code, 0));
         }
     }
     _addGap() {
@@ -343,7 +331,7 @@ var TokenType;
     TokenType[TokenType["DOCTYPE"] = 6] = "DOCTYPE";
     TokenType[TokenType["EOF"] = 7] = "EOF";
     TokenType[TokenType["HIBERNATION"] = 8] = "HIBERNATION";
-})(TokenType = TokenType || (TokenType = {}));
+})(TokenType || (TokenType = {}));
 function getTokenAttr(token, attrName) {
     for (let i = token.attrs.length - 1; i >= 0; i--) {
         if (token.attrs[i].name === attrName) {
@@ -367,6 +355,51 @@ new Uint16Array(
     .split("")
     .map((c) => c.charCodeAt(0)));
 
+// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
+const decodeMap = new Map([
+    [0, 65533],
+    // C1 Unicode control character reference replacements
+    [128, 8364],
+    [130, 8218],
+    [131, 402],
+    [132, 8222],
+    [133, 8230],
+    [134, 8224],
+    [135, 8225],
+    [136, 710],
+    [137, 8240],
+    [138, 352],
+    [139, 8249],
+    [140, 338],
+    [142, 381],
+    [145, 8216],
+    [146, 8217],
+    [147, 8220],
+    [148, 8221],
+    [149, 8226],
+    [150, 8211],
+    [151, 8212],
+    [152, 732],
+    [153, 8482],
+    [154, 353],
+    [155, 8250],
+    [156, 339],
+    [158, 382],
+    [159, 376],
+]);
+/**
+ * Replace the given code point with a replacement character if it is a
+ * surrogate or is outside the valid range. Otherwise return the code
+ * point unchanged.
+ */
+function replaceCodePoint(codePoint) {
+    var _a;
+    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+        return 0xfffd;
+    }
+    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
+}
+
 var CharCodes;
 (function (CharCodes) {
     CharCodes[CharCodes["NUM"] = 35] = "NUM";
@@ -382,12 +415,35 @@ var CharCodes;
     CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
     CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
 })(CharCodes || (CharCodes = {}));
+/** Bit that needs to be set to convert an upper case ASCII character to lower case */
+const TO_LOWER_BIT = 0b100000;
 var BinTrieFlags;
 (function (BinTrieFlags) {
     BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
     BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
     BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
 })(BinTrieFlags || (BinTrieFlags = {}));
+function isNumber(code) {
+    return code >= CharCodes.ZERO && code <= CharCodes.NINE;
+}
+function isHexadecimalCharacter(code) {
+    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F) ||
+        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F));
+}
+function isAsciiAlphaNumeric$1(code) {
+    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z) ||
+        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z) ||
+        isNumber(code));
+}
+/**
+ * Checks if the given character is a valid end character for an entity in an attribute.
+ *
+ * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
+ * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+ */
+function isEntityInAttributeInvalidEnd(code) {
+    return code === CharCodes.EQUALS || isAsciiAlphaNumeric$1(code);
+}
 var EntityDecoderState;
 (function (EntityDecoderState) {
     EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
@@ -405,6 +461,320 @@ var DecodingMode;
     /** Entities in attributes have limitations on ending characters. */
     DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
 })(DecodingMode || (DecodingMode = {}));
+/**
+ * Token decoder with support of writing partial entities.
+ */
+class EntityDecoder {
+    constructor(
+    /** The tree used to decode entities. */
+    decodeTree, 
+    /**
+     * The function that is called when a codepoint is decoded.
+     *
+     * For multi-byte named entities, this will be called multiple times,
+     * with the second codepoint, and the same `consumed` value.
+     *
+     * @param codepoint The decoded codepoint.
+     * @param consumed The number of bytes consumed by the decoder.
+     */
+    emitCodePoint, 
+    /** An object that is used to produce errors. */
+    errors) {
+        this.decodeTree = decodeTree;
+        this.emitCodePoint = emitCodePoint;
+        this.errors = errors;
+        /** The current state of the decoder. */
+        this.state = EntityDecoderState.EntityStart;
+        /** Characters that were consumed while parsing an entity. */
+        this.consumed = 1;
+        /**
+         * The result of the entity.
+         *
+         * Either the result index of a numeric entity, or the codepoint of a
+         * numeric entity.
+         */
+        this.result = 0;
+        /** The current index in the decode tree. */
+        this.treeIndex = 0;
+        /** The number of characters that were consumed in excess. */
+        this.excess = 1;
+        /** The mode in which the decoder is operating. */
+        this.decodeMode = DecodingMode.Strict;
+    }
+    /** Resets the instance to make it reusable. */
+    startEntity(decodeMode) {
+        this.decodeMode = decodeMode;
+        this.state = EntityDecoderState.EntityStart;
+        this.result = 0;
+        this.treeIndex = 0;
+        this.excess = 1;
+        this.consumed = 1;
+    }
+    /**
+     * Write an entity to the decoder. This can be called multiple times with partial entities.
+     * If the entity is incomplete, the decoder will return -1.
+     *
+     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
+     * entity is incomplete, and resume when the next string is written.
+     *
+     * @param string The string containing the entity (or a continuation of the entity).
+     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    write(str, offset) {
+        switch (this.state) {
+            case EntityDecoderState.EntityStart: {
+                if (str.charCodeAt(offset) === CharCodes.NUM) {
+                    this.state = EntityDecoderState.NumericStart;
+                    this.consumed += 1;
+                    return this.stateNumericStart(str, offset + 1);
+                }
+                this.state = EntityDecoderState.NamedEntity;
+                return this.stateNamedEntity(str, offset);
+            }
+            case EntityDecoderState.NumericStart: {
+                return this.stateNumericStart(str, offset);
+            }
+            case EntityDecoderState.NumericDecimal: {
+                return this.stateNumericDecimal(str, offset);
+            }
+            case EntityDecoderState.NumericHex: {
+                return this.stateNumericHex(str, offset);
+            }
+            case EntityDecoderState.NamedEntity: {
+                return this.stateNamedEntity(str, offset);
+            }
+        }
+    }
+    /**
+     * Switches between the numeric decimal and hexadecimal states.
+     *
+     * Equivalent to the `Numeric character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNumericStart(str, offset) {
+        if (offset >= str.length) {
+            return -1;
+        }
+        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+            this.state = EntityDecoderState.NumericHex;
+            this.consumed += 1;
+            return this.stateNumericHex(str, offset + 1);
+        }
+        this.state = EntityDecoderState.NumericDecimal;
+        return this.stateNumericDecimal(str, offset);
+    }
+    addToNumericResult(str, start, end, base) {
+        if (start !== end) {
+            const digitCount = end - start;
+            this.result =
+                this.result * Math.pow(base, digitCount) +
+                    parseInt(str.substr(start, digitCount), base);
+            this.consumed += digitCount;
+        }
+    }
+    /**
+     * Parses a hexadecimal numeric entity.
+     *
+     * Equivalent to the `Hexademical character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNumericHex(str, offset) {
+        const startIdx = offset;
+        while (offset < str.length) {
+            const char = str.charCodeAt(offset);
+            if (isNumber(char) || isHexadecimalCharacter(char)) {
+                offset += 1;
+            }
+            else {
+                this.addToNumericResult(str, startIdx, offset, 16);
+                return this.emitNumericEntity(char, 3);
+            }
+        }
+        this.addToNumericResult(str, startIdx, offset, 16);
+        return -1;
+    }
+    /**
+     * Parses a decimal numeric entity.
+     *
+     * Equivalent to the `Decimal character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNumericDecimal(str, offset) {
+        const startIdx = offset;
+        while (offset < str.length) {
+            const char = str.charCodeAt(offset);
+            if (isNumber(char)) {
+                offset += 1;
+            }
+            else {
+                this.addToNumericResult(str, startIdx, offset, 10);
+                return this.emitNumericEntity(char, 2);
+            }
+        }
+        this.addToNumericResult(str, startIdx, offset, 10);
+        return -1;
+    }
+    /**
+     * Validate and emit a numeric entity.
+     *
+     * Implements the logic from the `Hexademical character reference start
+     * state` and `Numeric character reference end state` in the HTML spec.
+     *
+     * @param lastCp The last code point of the entity. Used to see if the
+     *               entity was terminated with a semicolon.
+     * @param expectedLength The minimum number of characters that should be
+     *                       consumed. Used to validate that at least one digit
+     *                       was consumed.
+     * @returns The number of characters that were consumed.
+     */
+    emitNumericEntity(lastCp, expectedLength) {
+        var _a;
+        // Ensure we consumed at least one digit.
+        if (this.consumed <= expectedLength) {
+            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+            return 0;
+        }
+        // Figure out if this is a legit end of the entity
+        if (lastCp === CharCodes.SEMI) {
+            this.consumed += 1;
+        }
+        else if (this.decodeMode === DecodingMode.Strict) {
+            return 0;
+        }
+        this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+        if (this.errors) {
+            if (lastCp !== CharCodes.SEMI) {
+                this.errors.missingSemicolonAfterCharacterReference();
+            }
+            this.errors.validateNumericCharacterReference(this.result);
+        }
+        return this.consumed;
+    }
+    /**
+     * Parses a named entity.
+     *
+     * Equivalent to the `Named character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNamedEntity(str, offset) {
+        const { decodeTree } = this;
+        let current = decodeTree[this.treeIndex];
+        // The mask is the number of bytes of the value, including the current byte.
+        let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+        for (; offset < str.length; offset++, this.excess++) {
+            const char = str.charCodeAt(offset);
+            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
+            if (this.treeIndex < 0) {
+                return this.result === 0 ||
+                    // If we are parsing an attribute
+                    (this.decodeMode === DecodingMode.Attribute &&
+                        // We shouldn't have consumed any characters after the entity,
+                        (valueLength === 0 ||
+                            // And there should be no invalid characters.
+                            isEntityInAttributeInvalidEnd(char)))
+                    ? 0
+                    : this.emitNotTerminatedNamedEntity();
+            }
+            current = decodeTree[this.treeIndex];
+            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+            // If the branch is a value, store it and continue
+            if (valueLength !== 0) {
+                // If the entity is terminated by a semicolon, we are done.
+                if (char === CharCodes.SEMI) {
+                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+                }
+                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.
+                if (this.decodeMode !== DecodingMode.Strict) {
+                    this.result = this.treeIndex;
+                    this.consumed += this.excess;
+                    this.excess = 0;
+                }
+            }
+        }
+        return -1;
+    }
+    /**
+     * Emit a named entity that was not terminated with a semicolon.
+     *
+     * @returns The number of characters consumed.
+     */
+    emitNotTerminatedNamedEntity() {
+        var _a;
+        const { result, decodeTree } = this;
+        const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+        this.emitNamedEntityData(result, valueLength, this.consumed);
+        (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();
+        return this.consumed;
+    }
+    /**
+     * Emit a named entity.
+     *
+     * @param result The index of the entity in the decode tree.
+     * @param valueLength The number of bytes in the entity.
+     * @param consumed The number of characters consumed.
+     *
+     * @returns The number of characters consumed.
+     */
+    emitNamedEntityData(result, valueLength, consumed) {
+        const { decodeTree } = this;
+        this.emitCodePoint(valueLength === 1
+            ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH
+            : decodeTree[result + 1], consumed);
+        if (valueLength === 3) {
+            // For multi-byte values, we need to emit the second byte.
+            this.emitCodePoint(decodeTree[result + 2], consumed);
+        }
+        return consumed;
+    }
+    /**
+     * Signal to the parser that the end of the input was reached.
+     *
+     * Remaining data will be emitted and relevant errors will be produced.
+     *
+     * @returns The number of characters consumed.
+     */
+    end() {
+        var _a;
+        switch (this.state) {
+            case EntityDecoderState.NamedEntity: {
+                // Emit a named entity if we have one.
+                return this.result !== 0 &&
+                    (this.decodeMode !== DecodingMode.Attribute ||
+                        this.result === this.treeIndex)
+                    ? this.emitNotTerminatedNamedEntity()
+                    : 0;
+            }
+            // Otherwise, emit a numeric entity if we have one.
+            case EntityDecoderState.NumericDecimal: {
+                return this.emitNumericEntity(0, 2);
+            }
+            case EntityDecoderState.NumericHex: {
+                return this.emitNumericEntity(0, 3);
+            }
+            case EntityDecoderState.NumericStart: {
+                (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+                return 0;
+            }
+            case EntityDecoderState.EntityStart: {
+                // Return 0 if we have no entity.
+                return 0;
+            }
+        }
+    }
+}
 /**
  * Determines the branch of the current node that is taken given the current
  * character. This function is used to traverse the trie.
@@ -458,7 +828,7 @@ var NS;
     NS["XLINK"] = "http://www.w3.org/1999/xlink";
     NS["XML"] = "http://www.w3.org/XML/1998/namespace";
     NS["XMLNS"] = "http://www.w3.org/2000/xmlns/";
-})(NS = NS || (NS = {}));
+})(NS || (NS = {}));
 var ATTRS;
 (function (ATTRS) {
     ATTRS["TYPE"] = "type";
@@ -469,7 +839,7 @@ var ATTRS;
     ATTRS["COLOR"] = "color";
     ATTRS["FACE"] = "face";
     ATTRS["SIZE"] = "size";
-})(ATTRS = ATTRS || (ATTRS = {}));
+})(ATTRS || (ATTRS = {}));
 /**
  * The mode of the document.
  *
@@ -480,7 +850,7 @@ var DOCUMENT_MODE;
     DOCUMENT_MODE["NO_QUIRKS"] = "no-quirks";
     DOCUMENT_MODE["QUIRKS"] = "quirks";
     DOCUMENT_MODE["LIMITED_QUIRKS"] = "limited-quirks";
-})(DOCUMENT_MODE = DOCUMENT_MODE || (DOCUMENT_MODE = {}));
+})(DOCUMENT_MODE || (DOCUMENT_MODE = {}));
 var TAG_NAMES;
 (function (TAG_NAMES) {
     TAG_NAMES["A"] = "a";
@@ -576,6 +946,7 @@ var TAG_NAMES;
     TAG_NAMES["RUBY"] = "ruby";
     TAG_NAMES["S"] = "s";
     TAG_NAMES["SCRIPT"] = "script";
+    TAG_NAMES["SEARCH"] = "search";
     TAG_NAMES["SECTION"] = "section";
     TAG_NAMES["SELECT"] = "select";
     TAG_NAMES["SOURCE"] = "source";
@@ -605,7 +976,7 @@ var TAG_NAMES;
     TAG_NAMES["VAR"] = "var";
     TAG_NAMES["WBR"] = "wbr";
     TAG_NAMES["XMP"] = "xmp";
-})(TAG_NAMES = TAG_NAMES || (TAG_NAMES = {}));
+})(TAG_NAMES || (TAG_NAMES = {}));
 /**
  * Tag IDs are numeric IDs for known tag names.
  *
@@ -707,36 +1078,37 @@ var TAG_ID;
     TAG_ID[TAG_ID["RUBY"] = 91] = "RUBY";
     TAG_ID[TAG_ID["S"] = 92] = "S";
     TAG_ID[TAG_ID["SCRIPT"] = 93] = "SCRIPT";
-    TAG_ID[TAG_ID["SECTION"] = 94] = "SECTION";
-    TAG_ID[TAG_ID["SELECT"] = 95] = "SELECT";
-    TAG_ID[TAG_ID["SOURCE"] = 96] = "SOURCE";
-    TAG_ID[TAG_ID["SMALL"] = 97] = "SMALL";
-    TAG_ID[TAG_ID["SPAN"] = 98] = "SPAN";
-    TAG_ID[TAG_ID["STRIKE"] = 99] = "STRIKE";
-    TAG_ID[TAG_ID["STRONG"] = 100] = "STRONG";
-    TAG_ID[TAG_ID["STYLE"] = 101] = "STYLE";
-    TAG_ID[TAG_ID["SUB"] = 102] = "SUB";
-    TAG_ID[TAG_ID["SUMMARY"] = 103] = "SUMMARY";
-    TAG_ID[TAG_ID["SUP"] = 104] = "SUP";
-    TAG_ID[TAG_ID["TABLE"] = 105] = "TABLE";
-    TAG_ID[TAG_ID["TBODY"] = 106] = "TBODY";
-    TAG_ID[TAG_ID["TEMPLATE"] = 107] = "TEMPLATE";
-    TAG_ID[TAG_ID["TEXTAREA"] = 108] = "TEXTAREA";
-    TAG_ID[TAG_ID["TFOOT"] = 109] = "TFOOT";
-    TAG_ID[TAG_ID["TD"] = 110] = "TD";
-    TAG_ID[TAG_ID["TH"] = 111] = "TH";
-    TAG_ID[TAG_ID["THEAD"] = 112] = "THEAD";
-    TAG_ID[TAG_ID["TITLE"] = 113] = "TITLE";
-    TAG_ID[TAG_ID["TR"] = 114] = "TR";
-    TAG_ID[TAG_ID["TRACK"] = 115] = "TRACK";
-    TAG_ID[TAG_ID["TT"] = 116] = "TT";
-    TAG_ID[TAG_ID["U"] = 117] = "U";
-    TAG_ID[TAG_ID["UL"] = 118] = "UL";
-    TAG_ID[TAG_ID["SVG"] = 119] = "SVG";
-    TAG_ID[TAG_ID["VAR"] = 120] = "VAR";
-    TAG_ID[TAG_ID["WBR"] = 121] = "WBR";
-    TAG_ID[TAG_ID["XMP"] = 122] = "XMP";
-})(TAG_ID = TAG_ID || (TAG_ID = {}));
+    TAG_ID[TAG_ID["SEARCH"] = 94] = "SEARCH";
+    TAG_ID[TAG_ID["SECTION"] = 95] = "SECTION";
+    TAG_ID[TAG_ID["SELECT"] = 96] = "SELECT";
+    TAG_ID[TAG_ID["SOURCE"] = 97] = "SOURCE";
+    TAG_ID[TAG_ID["SMALL"] = 98] = "SMALL";
+    TAG_ID[TAG_ID["SPAN"] = 99] = "SPAN";
+    TAG_ID[TAG_ID["STRIKE"] = 100] = "STRIKE";
+    TAG_ID[TAG_ID["STRONG"] = 101] = "STRONG";
+    TAG_ID[TAG_ID["STYLE"] = 102] = "STYLE";
+    TAG_ID[TAG_ID["SUB"] = 103] = "SUB";
+    TAG_ID[TAG_ID["SUMMARY"] = 104] = "SUMMARY";
+    TAG_ID[TAG_ID["SUP"] = 105] = "SUP";
+    TAG_ID[TAG_ID["TABLE"] = 106] = "TABLE";
+    TAG_ID[TAG_ID["TBODY"] = 107] = "TBODY";
+    TAG_ID[TAG_ID["TEMPLATE"] = 108] = "TEMPLATE";
+    TAG_ID[TAG_ID["TEXTAREA"] = 109] = "TEXTAREA";
+    TAG_ID[TAG_ID["TFOOT"] = 110] = "TFOOT";
+    TAG_ID[TAG_ID["TD"] = 111] = "TD";
+    TAG_ID[TAG_ID["TH"] = 112] = "TH";
+    TAG_ID[TAG_ID["THEAD"] = 113] = "THEAD";
+    TAG_ID[TAG_ID["TITLE"] = 114] = "TITLE";
+    TAG_ID[TAG_ID["TR"] = 115] = "TR";
+    TAG_ID[TAG_ID["TRACK"] = 116] = "TRACK";
+    TAG_ID[TAG_ID["TT"] = 117] = "TT";
+    TAG_ID[TAG_ID["U"] = 118] = "U";
+    TAG_ID[TAG_ID["UL"] = 119] = "UL";
+    TAG_ID[TAG_ID["SVG"] = 120] = "SVG";
+    TAG_ID[TAG_ID["VAR"] = 121] = "VAR";
+    TAG_ID[TAG_ID["WBR"] = 122] = "WBR";
+    TAG_ID[TAG_ID["XMP"] = 123] = "XMP";
+})(TAG_ID || (TAG_ID = {}));
 const TAG_NAME_TO_ID = new Map([
     [TAG_NAMES.A, TAG_ID.A],
     [TAG_NAMES.ADDRESS, TAG_ID.ADDRESS],
@@ -831,6 +1203,7 @@ const TAG_NAME_TO_ID = new Map([
     [TAG_NAMES.RUBY, TAG_ID.RUBY],
     [TAG_NAMES.S, TAG_ID.S],
     [TAG_NAMES.SCRIPT, TAG_ID.SCRIPT],
+    [TAG_NAMES.SEARCH, TAG_ID.SEARCH],
     [TAG_NAMES.SECTION, TAG_ID.SECTION],
     [TAG_NAMES.SELECT, TAG_ID.SELECT],
     [TAG_NAMES.SOURCE, TAG_ID.SOURCE],
@@ -956,40 +1329,8 @@ const SPECIAL_ELEMENTS = {
     [NS.XML]: new Set(),
     [NS.XMLNS]: new Set(),
 };
-function isNumberedHeader(tn) {
-    return tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6;
-}
+const NUMBERED_HEADERS = new Set([$.H1, $.H2, $.H3, $.H4, $.H5, $.H6]);
 
-//C1 Unicode control character reference replacements
-const C1_CONTROLS_REFERENCE_REPLACEMENTS = new Map([
-    [0x80, 8364],
-    [0x82, 8218],
-    [0x83, 402],
-    [0x84, 8222],
-    [0x85, 8230],
-    [0x86, 8224],
-    [0x87, 8225],
-    [0x88, 710],
-    [0x89, 8240],
-    [0x8a, 352],
-    [0x8b, 8249],
-    [0x8c, 338],
-    [0x8e, 381],
-    [0x91, 8216],
-    [0x92, 8217],
-    [0x93, 8220],
-    [0x94, 8221],
-    [0x95, 8226],
-    [0x96, 8211],
-    [0x97, 8212],
-    [0x98, 732],
-    [0x99, 8482],
-    [0x9a, 353],
-    [0x9b, 8250],
-    [0x9c, 339],
-    [0x9e, 382],
-    [0x9f, 376],
-]);
 //States
 var State;
 (function (State) {
@@ -1065,13 +1406,7 @@ var State;
     State[State["CDATA_SECTION_BRACKET"] = 69] = "CDATA_SECTION_BRACKET";
     State[State["CDATA_SECTION_END"] = 70] = "CDATA_SECTION_END";
     State[State["CHARACTER_REFERENCE"] = 71] = "CHARACTER_REFERENCE";
-    State[State["NAMED_CHARACTER_REFERENCE"] = 72] = "NAMED_CHARACTER_REFERENCE";
-    State[State["AMBIGUOUS_AMPERSAND"] = 73] = "AMBIGUOUS_AMPERSAND";
-    State[State["NUMERIC_CHARACTER_REFERENCE"] = 74] = "NUMERIC_CHARACTER_REFERENCE";
-    State[State["HEXADEMICAL_CHARACTER_REFERENCE_START"] = 75] = "HEXADEMICAL_CHARACTER_REFERENCE_START";
-    State[State["HEXADEMICAL_CHARACTER_REFERENCE"] = 76] = "HEXADEMICAL_CHARACTER_REFERENCE";
-    State[State["DECIMAL_CHARACTER_REFERENCE"] = 77] = "DECIMAL_CHARACTER_REFERENCE";
-    State[State["NUMERIC_CHARACTER_REFERENCE_END"] = 78] = "NUMERIC_CHARACTER_REFERENCE_END";
+    State[State["AMBIGUOUS_AMPERSAND"] = 72] = "AMBIGUOUS_AMPERSAND";
 })(State || (State = {}));
 //Tokenizer initial states for different modes
 const TokenizerMode = {
@@ -1101,27 +1436,33 @@ function isAsciiLetter(cp) {
 function isAsciiAlphaNumeric(cp) {
     return isAsciiLetter(cp) || isAsciiDigit(cp);
 }
-function isAsciiUpperHexDigit(cp) {
-    return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_F;
-}
-function isAsciiLowerHexDigit(cp) {
-    return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_F;
-}
-function isAsciiHexDigit(cp) {
-    return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
-}
 function toAsciiLower(cp) {
     return cp + 32;
 }
 function isWhitespace(cp) {
     return cp === CODE_POINTS.SPACE || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.TABULATION || cp === CODE_POINTS.FORM_FEED;
 }
-function isEntityInAttributeInvalidEnd(nextCp) {
-    return nextCp === CODE_POINTS.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
-}
 function isScriptDataDoubleEscapeSequenceEnd(cp) {
     return isWhitespace(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN;
 }
+function getErrorForNumericCharacterReference(code) {
+    if (code === CODE_POINTS.NULL) {
+        return ERR.nullCharacterReference;
+    }
+    else if (code > 1114111) {
+        return ERR.characterReferenceOutsideUnicodeRange;
+    }
+    else if (isSurrogate(code)) {
+        return ERR.surrogateCharacterReference;
+    }
+    else if (isUndefinedCodePoint(code)) {
+        return ERR.noncharacterCharacterReference;
+    }
+    else if (isControlCodePoint(code) || code === CODE_POINTS.CARRIAGE_RETURN) {
+        return ERR.controlCharacterReference;
+    }
+    return null;
+}
 //Tokenizer
 class Tokenizer {
     constructor(options, handler) {
@@ -1141,18 +1482,38 @@ class Tokenizer {
         this.active = false;
         this.state = State.DATA;
         this.returnState = State.DATA;
-        this.charRefCode = -1;
+        this.entityStartPos = 0;
         this.consumedAfterSnapshot = -1;
         this.currentCharacterToken = null;
         this.currentToken = null;
         this.currentAttr = { name: '', value: '' };
         this.preprocessor = new Preprocessor(handler);
         this.currentLocation = this.getCurrentLocation(-1);
+        this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp, consumed) => {
+            // Note: Set `pos` _before_ flushing, as flushing might drop
+            // the current chunk and invalidate `entityStartPos`.
+            this.preprocessor.pos = this.entityStartPos + consumed - 1;
+            this._flushCodePointConsumedAsCharacterReference(cp);
+        }, handler.onParseError
+            ? {
+                missingSemicolonAfterCharacterReference: () => {
+                    this._err(ERR.missingSemicolonAfterCharacterReference, 1);
+                },
+                absenceOfDigitsInNumericCharacterReference: (consumed) => {
+                    this._err(ERR.absenceOfDigitsInNumericCharacterReference, this.entityStartPos - this.preprocessor.pos + consumed);
+                },
+                validateNumericCharacterReference: (code) => {
+                    const error = getErrorForNumericCharacterReference(code);
+                    if (error)
+                        this._err(error, 1);
+                },
+            }
+            : undefined);
     }
     //Errors
-    _err(code) {
+    _err(code, cpOffset = 0) {
         var _a, _b;
-        (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code));
+        (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code, cpOffset));
     }
     // NOTE: `offset` may never run across line boundaries.
     getCurrentLocation(offset) {
@@ -1214,7 +1575,8 @@ class Tokenizer {
     //Hibernation
     _ensureHibernation() {
         if (this.preprocessor.endOfChunkHit) {
-            this._unconsume(this.consumedAfterSnapshot);
+            this.preprocessor.retreat(this.consumedAfterSnapshot);
+            this.consumedAfterSnapshot = 0;
             this.active = false;
             return true;
         }
@@ -1225,14 +1587,6 @@ class Tokenizer {
         this.consumedAfterSnapshot++;
         return this.preprocessor.advance();
     }
-    _unconsume(count) {
-        this.consumedAfterSnapshot -= count;
-        this.preprocessor.retreat(count);
-    }
-    _reconsumeInState(state, cp) {
-        this.state = state;
-        this._callState(cp);
-    }
     _advanceBy(count) {
         this.consumedAfterSnapshot += count;
         for (let i = 0; i < count; i++) {
@@ -1404,7 +1758,7 @@ class Tokenizer {
         this.active = false;
     }
     //Characters emission
-    //OPTIMIZATION: specification uses only one type of character tokens (one token per character).
+    //OPTIMIZATION: The specification uses only one type of character token (one token per character).
     //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
     //If we have a sequence of characters that belong to the same group, the parser can process it
     //as a single solid character token.
@@ -1414,15 +1768,15 @@ class Tokenizer {
     //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
     _appendCharToCurrentCharacterToken(type, ch) {
         if (this.currentCharacterToken) {
-            if (this.currentCharacterToken.type !== type) {
+            if (this.currentCharacterToken.type === type) {
+                this.currentCharacterToken.chars += ch;
+                return;
+            }
+            else {
                 this.currentLocation = this.getCurrentLocation(0);
                 this._emitCurrentCharacterToken(this.currentLocation);
                 this.preprocessor.dropParsedChunk();
             }
-            else {
-                this.currentCharacterToken.chars += ch;
-                return;
-            }
         }
         this._createCharacterToken(type, ch);
     }
@@ -1440,59 +1794,11 @@ class Tokenizer {
         this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch);
     }
     // Character reference helpers
-    _matchNamedCharacterReference(cp) {
-        let result = null;
-        let excess = 0;
-        let withoutSemicolon = false;
-        for (let i = 0, current = htmlDecodeTree[0]; i >= 0; cp = this._consume()) {
-            i = determineBranch(htmlDecodeTree, current, i + 1, cp);
-            if (i < 0)
-                break;
-            excess += 1;
-            current = htmlDecodeTree[i];
-            const masked = current & BinTrieFlags.VALUE_LENGTH;
-            // If the branch is a value, store it and continue
-            if (masked) {
-                // The mask is the number of bytes of the value, including the current byte.
-                const valueLength = (masked >> 14) - 1;
-                // Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
-                // See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
-                if (cp !== CODE_POINTS.SEMICOLON &&
-                    this._isCharacterReferenceInAttribute() &&
-                    isEntityInAttributeInvalidEnd(this.preprocessor.peek(1))) {
-                    //NOTE: we don't flush all consumed code points here, and instead switch back to the original state after
-                    //emitting an ampersand. This is fine, as alphanumeric characters won't be parsed differently in attributes.
-                    result = [CODE_POINTS.AMPERSAND];
-                    // Skip over the value.
-                    i += valueLength;
-                }
-                else {
-                    // If this is a surrogate pair, consume the next two bytes.
-                    result =
-                        valueLength === 0
-                            ? [htmlDecodeTree[i] & ~BinTrieFlags.VALUE_LENGTH]
-                            : valueLength === 1
-                                ? [htmlDecodeTree[++i]]
-                                : [htmlDecodeTree[++i], htmlDecodeTree[++i]];
-                    excess = 0;
-                    withoutSemicolon = cp !== CODE_POINTS.SEMICOLON;
-                }
-                if (valueLength === 0) {
-                    // If the value is zero-length, we're done.
-                    this._consume();
-                    break;
-                }
-            }
-        }
-        this._unconsume(excess);
-        if (withoutSemicolon && !this.preprocessor.endOfChunkHit) {
-            this._err(ERR.missingSemicolonAfterCharacterReference);
-        }
-        // We want to emit the error above on the code point after the entity.
-        // We always consume one code point too many in the loop, and we wait to
-        // unconsume it until after the error is emitted.
-        this._unconsume(1);
-        return result;
+    _startCharacterReference() {
+        this.returnState = this.state;
+        this.state = State.CHARACTER_REFERENCE;
+        this.entityStartPos = this.preprocessor.pos;
+        this.entityDecoder.startEntity(this._isCharacterReferenceInAttribute() ? DecodingMode.Attribute : DecodingMode.Legacy);
     }
     _isCharacterReferenceInAttribute() {
         return (this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED ||
@@ -1795,37 +2101,13 @@ class Tokenizer {
                 break;
             }
             case State.CHARACTER_REFERENCE: {
-                this._stateCharacterReference(cp);
-                break;
-            }
-            case State.NAMED_CHARACTER_REFERENCE: {
-                this._stateNamedCharacterReference(cp);
+                this._stateCharacterReference();
                 break;
             }
             case State.AMBIGUOUS_AMPERSAND: {
                 this._stateAmbiguousAmpersand(cp);
                 break;
             }
-            case State.NUMERIC_CHARACTER_REFERENCE: {
-                this._stateNumericCharacterReference(cp);
-                break;
-            }
-            case State.HEXADEMICAL_CHARACTER_REFERENCE_START: {
-                this._stateHexademicalCharacterReferenceStart(cp);
-                break;
-            }
-            case State.HEXADEMICAL_CHARACTER_REFERENCE: {
-                this._stateHexademicalCharacterReference(cp);
-                break;
-            }
-            case State.DECIMAL_CHARACTER_REFERENCE: {
-                this._stateDecimalCharacterReference(cp);
-                break;
-            }
-            case State.NUMERIC_CHARACTER_REFERENCE_END: {
-                this._stateNumericCharacterReferenceEnd(cp);
-                break;
-            }
             default: {
                 throw new Error('Unknown state');
             }
@@ -1841,8 +2123,7 @@ class Tokenizer {
                 break;
             }
             case CODE_POINTS.AMPERSAND: {
-                this.returnState = State.DATA;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case CODE_POINTS.NULL: {
@@ -1864,8 +2145,7 @@ class Tokenizer {
     _stateRcdata(cp) {
         switch (cp) {
             case CODE_POINTS.AMPERSAND: {
-                this.returnState = State.RCDATA;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case CODE_POINTS.LESS_THAN_SIGN: {
@@ -2634,8 +2914,7 @@ class Tokenizer {
                 break;
             }
             case CODE_POINTS.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case CODE_POINTS.NULL: {
@@ -2662,8 +2941,7 @@ class Tokenizer {
                 break;
             }
             case CODE_POINTS.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case CODE_POINTS.NULL: {
@@ -2694,8 +2972,7 @@ class Tokenizer {
                 break;
             }
             case CODE_POINTS.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case CODE_POINTS.GREATER_THAN_SIGN: {
@@ -3711,35 +3988,35 @@ class Tokenizer {
     }
     // Character reference state
     //------------------------------------------------------------------
-    _stateCharacterReference(cp) {
-        if (cp === CODE_POINTS.NUMBER_SIGN) {
-            this.state = State.NUMERIC_CHARACTER_REFERENCE;
-        }
-        else if (isAsciiAlphaNumeric(cp)) {
-            this.state = State.NAMED_CHARACTER_REFERENCE;
-            this._stateNamedCharacterReference(cp);
+    _stateCharacterReference() {
+        let length = this.entityDecoder.write(this.preprocessor.html, this.preprocessor.pos);
+        if (length < 0) {
+            if (this.preprocessor.lastChunkWritten) {
+                length = this.entityDecoder.end();
+            }
+            else {
+                // Wait for the rest of the entity.
+                this.active = false;
+                // Mark the entire buffer as read.
+                this.preprocessor.pos = this.preprocessor.html.length - 1;
+                this.consumedAfterSnapshot = 0;
+                this.preprocessor.endOfChunkHit = true;
+                return;
+            }
         }
-        else {
+        if (length === 0) {
+            // This was not a valid entity. Go back to the beginning, and
+            // figure out what to do.
+            this.preprocessor.pos = this.entityStartPos;
             this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
-            this._reconsumeInState(this.returnState, cp);
-        }
-    }
-    // Named character reference state
-    //------------------------------------------------------------------
-    _stateNamedCharacterReference(cp) {
-        const matchResult = this._matchNamedCharacterReference(cp);
-        //NOTE: Matching can be abrupted by hibernation. In that case, match
-        //results are no longer valid and we will need to start over.
-        if (this._ensureHibernation()) ;
-        else if (matchResult) {
-            for (let i = 0; i < matchResult.length; i++) {
-                this._flushCodePointConsumedAsCharacterReference(matchResult[i]);
-            }
-            this.state = this.returnState;
+            this.state =
+                !this._isCharacterReferenceInAttribute() && isAsciiAlphaNumeric(this.preprocessor.peek(1))
+                    ? State.AMBIGUOUS_AMPERSAND
+                    : this.returnState;
         }
         else {
-            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
-            this.state = State.AMBIGUOUS_AMPERSAND;
+            // We successfully parsed an entity. Switch to the return state.
+            this.state = this.returnState;
         }
     }
     // Ambiguos ampersand state
@@ -3752,107 +4029,10 @@ class Tokenizer {
             if (cp === CODE_POINTS.SEMICOLON) {
                 this._err(ERR.unknownNamedCharacterReference);
             }
-            this._reconsumeInState(this.returnState, cp);
-        }
-    }
-    // Numeric character reference state
-    //------------------------------------------------------------------
-    _stateNumericCharacterReference(cp) {
-        this.charRefCode = 0;
-        if (cp === CODE_POINTS.LATIN_SMALL_X || cp === CODE_POINTS.LATIN_CAPITAL_X) {
-            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE_START;
-        }
-        // Inlined decimal character reference start state
-        else if (isAsciiDigit(cp)) {
-            this.state = State.DECIMAL_CHARACTER_REFERENCE;
-            this._stateDecimalCharacterReference(cp);
-        }
-        else {
-            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
-            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
-            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN);
-            this._reconsumeInState(this.returnState, cp);
-        }
-    }
-    // Hexademical character reference start state
-    //------------------------------------------------------------------
-    _stateHexademicalCharacterReferenceStart(cp) {
-        if (isAsciiHexDigit(cp)) {
-            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE;
-            this._stateHexademicalCharacterReference(cp);
-        }
-        else {
-            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
-            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND);
-            this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN);
-            this._unconsume(2);
             this.state = this.returnState;
+            this._callState(cp);
         }
     }
-    // Hexademical character reference state
-    //------------------------------------------------------------------
-    _stateHexademicalCharacterReference(cp) {
-        if (isAsciiUpperHexDigit(cp)) {
-            this.charRefCode = this.charRefCode * 16 + cp - 0x37;
-        }
-        else if (isAsciiLowerHexDigit(cp)) {
-            this.charRefCode = this.charRefCode * 16 + cp - 0x57;
-        }
-        else if (isAsciiDigit(cp)) {
-            this.charRefCode = this.charRefCode * 16 + cp - 0x30;
-        }
-        else if (cp === CODE_POINTS.SEMICOLON) {
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-        }
-        else {
-            this._err(ERR.missingSemicolonAfterCharacterReference);
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-            this._stateNumericCharacterReferenceEnd(cp);
-        }
-    }
-    // Decimal character reference state
-    //------------------------------------------------------------------
-    _stateDecimalCharacterReference(cp) {
-        if (isAsciiDigit(cp)) {
-            this.charRefCode = this.charRefCode * 10 + cp - 0x30;
-        }
-        else if (cp === CODE_POINTS.SEMICOLON) {
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-        }
-        else {
-            this._err(ERR.missingSemicolonAfterCharacterReference);
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-            this._stateNumericCharacterReferenceEnd(cp);
-        }
-    }
-    // Numeric character reference end state
-    //------------------------------------------------------------------
-    _stateNumericCharacterReferenceEnd(cp) {
-        if (this.charRefCode === CODE_POINTS.NULL) {
-            this._err(ERR.nullCharacterReference);
-            this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER;
-        }
-        else if (this.charRefCode > 1114111) {
-            this._err(ERR.characterReferenceOutsideUnicodeRange);
-            this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER;
-        }
-        else if (isSurrogate(this.charRefCode)) {
-            this._err(ERR.surrogateCharacterReference);
-            this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER;
-        }
-        else if (isUndefinedCodePoint(this.charRefCode)) {
-            this._err(ERR.noncharacterCharacterReference);
-        }
-        else if (isControlCodePoint(this.charRefCode) || this.charRefCode === CODE_POINTS.CARRIAGE_RETURN) {
-            this._err(ERR.controlCharacterReference);
-            const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS.get(this.charRefCode);
-            if (replacement !== undefined) {
-                this.charRefCode = replacement;
-            }
-        }
-        this._flushCodePointConsumedAsCharacterReference(this.charRefCode);
-        this._reconsumeInState(this.returnState, cp);
-    }
 }
 
 //Element utils
@@ -3868,31 +4048,25 @@ const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([
     TAG_ID.THEAD,
     TAG_ID.TR,
 ]);
-const SCOPING_ELEMENT_NS = new Map([
-    [TAG_ID.APPLET, NS.HTML],
-    [TAG_ID.CAPTION, NS.HTML],
-    [TAG_ID.HTML, NS.HTML],
-    [TAG_ID.MARQUEE, NS.HTML],
-    [TAG_ID.OBJECT, NS.HTML],
-    [TAG_ID.TABLE, NS.HTML],
-    [TAG_ID.TD, NS.HTML],
-    [TAG_ID.TEMPLATE, NS.HTML],
-    [TAG_ID.TH, NS.HTML],
-    [TAG_ID.ANNOTATION_XML, NS.MATHML],
-    [TAG_ID.MI, NS.MATHML],
-    [TAG_ID.MN, NS.MATHML],
-    [TAG_ID.MO, NS.MATHML],
-    [TAG_ID.MS, NS.MATHML],
-    [TAG_ID.MTEXT, NS.MATHML],
-    [TAG_ID.DESC, NS.SVG],
-    [TAG_ID.FOREIGN_OBJECT, NS.SVG],
-    [TAG_ID.TITLE, NS.SVG],
+const SCOPING_ELEMENTS_HTML = new Set([
+    TAG_ID.APPLET,
+    TAG_ID.CAPTION,
+    TAG_ID.HTML,
+    TAG_ID.MARQUEE,
+    TAG_ID.OBJECT,
+    TAG_ID.TABLE,
+    TAG_ID.TD,
+    TAG_ID.TEMPLATE,
+    TAG_ID.TH,
 ]);
-const NAMED_HEADERS = [TAG_ID.H1, TAG_ID.H2, TAG_ID.H3, TAG_ID.H4, TAG_ID.H5, TAG_ID.H6];
-const TABLE_ROW_CONTEXT = [TAG_ID.TR, TAG_ID.TEMPLATE, TAG_ID.HTML];
-const TABLE_BODY_CONTEXT = [TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TEMPLATE, TAG_ID.HTML];
-const TABLE_CONTEXT = [TAG_ID.TABLE, TAG_ID.TEMPLATE, TAG_ID.HTML];
-const TABLE_CELLS = [TAG_ID.TD, TAG_ID.TH];
+const SCOPING_ELEMENTS_HTML_LIST = new Set([...SCOPING_ELEMENTS_HTML, TAG_ID.OL, TAG_ID.UL]);
+const SCOPING_ELEMENTS_HTML_BUTTON = new Set([...SCOPING_ELEMENTS_HTML, TAG_ID.BUTTON]);
+const SCOPING_ELEMENTS_MATHML = new Set([TAG_ID.ANNOTATION_XML, TAG_ID.MI, TAG_ID.MN, TAG_ID.MO, TAG_ID.MS, TAG_ID.MTEXT]);
+const SCOPING_ELEMENTS_SVG = new Set([TAG_ID.DESC, TAG_ID.FOREIGN_OBJECT, TAG_ID.TITLE]);
+const TABLE_ROW_CONTEXT = new Set([TAG_ID.TR, TAG_ID.TEMPLATE, TAG_ID.HTML]);
+const TABLE_BODY_CONTEXT = new Set([TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TEMPLATE, TAG_ID.HTML]);
+const TABLE_CONTEXT = new Set([TAG_ID.TABLE, TAG_ID.TEMPLATE, TAG_ID.HTML]);
+const TABLE_CELLS = new Set([TAG_ID.TD, TAG_ID.TH]);
 //Stack of open elements
 class OpenElementStack {
     get currentTmplContentOrNode() {
@@ -3985,7 +4159,7 @@ class OpenElementStack {
         this.shortenToLength(idx < 0 ? 0 : idx);
     }
     popUntilNumberedHeaderPopped() {
-        this.popUntilPopped(NAMED_HEADERS, NS.HTML);
+        this.popUntilPopped(NUMBERED_HEADERS, NS.HTML);
     }
     popUntilTableCellPopped() {
         this.popUntilPopped(TABLE_CELLS, NS.HTML);
@@ -3998,7 +4172,7 @@ class OpenElementStack {
     }
     _indexOfTagNames(tagNames, namespace) {
         for (let i = this.stackTop; i >= 0; i--) {
-            if (tagNames.includes(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) {
+            if (tagNames.has(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) {
                 return i;
             }
         }
@@ -4048,102 +4222,117 @@ class OpenElementStack {
         return this.stackTop === 0 && this.tagIDs[0] === TAG_ID.HTML;
     }
     //Element in scope
-    hasInScope(tagName) {
+    hasInDynamicScope(tagName, htmlScope) {
         for (let i = this.stackTop; i >= 0; i--) {
             const tn = this.tagIDs[i];
-            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
-            if (tn === tagName && ns === NS.HTML) {
-                return true;
-            }
-            if (SCOPING_ELEMENT_NS.get(tn) === ns) {
-                return false;
+            switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
+                case NS.HTML: {
+                    if (tn === tagName)
+                        return true;
+                    if (htmlScope.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.SVG: {
+                    if (SCOPING_ELEMENTS_SVG.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.MATHML: {
+                    if (SCOPING_ELEMENTS_MATHML.has(tn))
+                        return false;
+                    break;
+                }
             }
         }
         return true;
     }
-    hasNumberedHeaderInScope() {
-        for (let i = this.stackTop; i >= 0; i--) {
-            const tn = this.tagIDs[i];
-            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
-            if (isNumberedHeader(tn) && ns === NS.HTML) {
-                return true;
-            }
-            if (SCOPING_ELEMENT_NS.get(tn) === ns) {
-                return false;
-            }
-        }
-        return true;
+    hasInScope(tagName) {
+        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML);
     }
     hasInListItemScope(tagName) {
-        for (let i = this.stackTop; i >= 0; i--) {
-            const tn = this.tagIDs[i];
-            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
-            if (tn === tagName && ns === NS.HTML) {
-                return true;
-            }
-            if (((tn === TAG_ID.UL || tn === TAG_ID.OL) && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {
-                return false;
-            }
-        }
-        return true;
+        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_LIST);
     }
     hasInButtonScope(tagName) {
+        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_BUTTON);
+    }
+    hasNumberedHeaderInScope() {
         for (let i = this.stackTop; i >= 0; i--) {
             const tn = this.tagIDs[i];
-            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
-            if (tn === tagName && ns === NS.HTML) {
-                return true;
-            }
-            if ((tn === TAG_ID.BUTTON && ns === NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {
-                return false;
+            switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
+                case NS.HTML: {
+                    if (NUMBERED_HEADERS.has(tn))
+                        return true;
+                    if (SCOPING_ELEMENTS_HTML.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.SVG: {
+                    if (SCOPING_ELEMENTS_SVG.has(tn))
+                        return false;
+                    break;
+                }
+                case NS.MATHML: {
+                    if (SCOPING_ELEMENTS_MATHML.has(tn))
+                        return false;
+                    break;
+                }
             }
         }
         return true;
     }
     hasInTableScope(tagName) {
         for (let i = this.stackTop; i >= 0; i--) {
-            const tn = this.tagIDs[i];
-            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
-            if (ns !== NS.HTML) {
+            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
                 continue;
             }
-            if (tn === tagName) {
-                return true;
-            }
-            if (tn === TAG_ID.TABLE || tn === TAG_ID.TEMPLATE || tn === TAG_ID.HTML) {
-                return false;
+            switch (this.tagIDs[i]) {
+                case tagName: {
+                    return true;
+                }
+                case TAG_ID.TABLE:
+                case TAG_ID.HTML: {
+                    return false;
+                }
             }
         }
         return true;
     }
     hasTableBodyContextInTableScope() {
         for (let i = this.stackTop; i >= 0; i--) {
-            const tn = this.tagIDs[i];
-            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
-            if (ns !== NS.HTML) {
+            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
                 continue;
             }
-            if (tn === TAG_ID.TBODY || tn === TAG_ID.THEAD || tn === TAG_ID.TFOOT) {
-                return true;
-            }
-            if (tn === TAG_ID.TABLE || tn === TAG_ID.HTML) {
-                return false;
+            switch (this.tagIDs[i]) {
+                case TAG_ID.TBODY:
+                case TAG_ID.THEAD:
+                case TAG_ID.TFOOT: {
+                    return true;
+                }
+                case TAG_ID.TABLE:
+                case TAG_ID.HTML: {
+                    return false;
+                }
             }
         }
         return true;
     }
     hasInSelectScope(tagName) {
         for (let i = this.stackTop; i >= 0; i--) {
-            const tn = this.tagIDs[i];
-            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
-            if (ns !== NS.HTML) {
+            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
                 continue;
             }
-            if (tn === tagName) {
-                return true;
-            }
-            if (tn !== TAG_ID.OPTION && tn !== TAG_ID.OPTGROUP) {
-                return false;
+            switch (this.tagIDs[i]) {
+                case tagName: {
+                    return true;
+                }
+                case TAG_ID.OPTION:
+                case TAG_ID.OPTGROUP: {
+                    break;
+                }
+                default: {
+                    return false;
+                }
             }
         }
         return true;
@@ -4172,7 +4361,7 @@ var EntryType;
 (function (EntryType) {
     EntryType[EntryType["Marker"] = 0] = "Marker";
     EntryType[EntryType["Element"] = 1] = "Element";
-})(EntryType = EntryType || (EntryType = {}));
+})(EntryType || (EntryType = {}));
 const MARKER = { type: EntryType.Marker };
 //List of formatting elements
 class FormattingElementList {
@@ -4277,13 +4466,6 @@ class FormattingElementList {
     }
 }
 
-function createTextNode(value) {
-    return {
-        nodeName: '#text',
-        value,
-        parentNode: null,
-    };
-}
 const defaultTreeAdapter = {
     //Node construction
     createDocument() {
@@ -4316,6 +4498,13 @@ const defaultTreeAdapter = {
             parentNode: null,
         };
     },
+    createTextNode(value) {
+        return {
+            nodeName: '#text',
+            value,
+            parentNode: null,
+        };
+    },
     //Tree mutation
     appendChild(parentNode, newNode) {
         parentNode.childNodes.push(newNode);
@@ -4371,7 +4560,7 @@ const defaultTreeAdapter = {
                 return;
             }
         }
-        defaultTreeAdapter.appendChild(parentNode, createTextNode(text));
+        defaultTreeAdapter.appendChild(parentNode, defaultTreeAdapter.createTextNode(text));
     },
     insertTextBefore(parentNode, text, referenceNode) {
         const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
@@ -4379,7 +4568,7 @@ const defaultTreeAdapter = {
             prevNode.value += text;
         }
         else {
-            defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode);
+            defaultTreeAdapter.insertBefore(parentNode, defaultTreeAdapter.createTextNode(text), referenceNode);
         }
     },
     adoptAttributes(recipient, attrs) {
@@ -4640,7 +4829,6 @@ const XML_ATTRS_ADJUSTMENT_MAP = new Map([
     ['xlink:show', { prefix: 'xlink', name: 'show', namespace: NS.XLINK }],
     ['xlink:title', { prefix: 'xlink', name: 'title', namespace: NS.XLINK }],
     ['xlink:type', { prefix: 'xlink', name: 'type', namespace: NS.XLINK }],
-    ['xml:base', { prefix: 'xml', name: 'base', namespace: NS.XML }],
     ['xml:lang', { prefix: 'xml', name: 'lang', namespace: NS.XML }],
     ['xml:space', { prefix: 'xml', name: 'space', namespace: NS.XML }],
     ['xmlns', { prefix: '', name: 'xmlns', namespace: NS.XMLNS }],
@@ -4842,26 +5030,41 @@ const defaultParserOptions = {
 };
 //Parser
 class Parser {
-    constructor(options, document, fragmentContext = null, scriptHandler = null) {
+    constructor(options, document, 
+    /** @internal */
+    fragmentContext = null, 
+    /** @internal */
+    scriptHandler = null) {
         this.fragmentContext = fragmentContext;
         this.scriptHandler = scriptHandler;
         this.currentToken = null;
         this.stopped = false;
+        /** @internal */
         this.insertionMode = InsertionMode.INITIAL;
+        /** @internal */
         this.originalInsertionMode = InsertionMode.INITIAL;
+        /** @internal */
         this.headElement = null;
+        /** @internal */
         this.formElement = null;
         /** Indicates that the current node is not an element in the HTML namespace */
         this.currentNotInHTML = false;
         /**
          * The template insertion mode stack is maintained from the left.
          * Ie. the topmost element will always have index 0.
+         *
+         * @internal
          */
         this.tmplInsertionModeStack = [];
+        /** @internal */
         this.pendingCharacterTokens = [];
+        /** @internal */
         this.hasNonWhitespacePendingCharacterToken = false;
+        /** @internal */
         this.framesetOk = true;
+        /** @internal */
         this.skipNextNewLine = false;
+        /** @internal */
         this.fosterParentingEnabled = false;
         this.options = {
             ...defaultParserOptions,
@@ -4915,6 +5118,7 @@ class Parser {
         return fragment;
     }
     //Errors
+    /** @internal */
     _err(token, code, beforeToken) {
         var _a;
         if (!this.onParseError)
@@ -4932,12 +5136,14 @@ class Parser {
         this.onParseError(err);
     }
     //Stack events
+    /** @internal */
     onItemPush(node, tid, isTop) {
         var _a, _b;
         (_b = (_a = this.treeAdapter).onItemPush) === null || _b === void 0 ? void 0 : _b.call(_a, node);
         if (isTop && this.openElements.stackTop > 0)
             this._setContextModes(node, tid);
     }
+    /** @internal */
     onItemPop(node, isTop) {
         var _a, _b;
         if (this.options.sourceCodeLocationInfo) {
@@ -4962,6 +5168,7 @@ class Parser {
         this.currentNotInHTML = !isHTML;
         this.tokenizer.inForeignNode = !isHTML && !this._isIntegrationPoint(tid, current);
     }
+    /** @protected */
     _switchToTextParsing(currentToken, nextTokenizerState) {
         this._insertElement(currentToken, NS.HTML);
         this.tokenizer.state = nextTokenizerState;
@@ -4974,11 +5181,13 @@ class Parser {
         this.tokenizer.state = TokenizerMode.PLAINTEXT;
     }
     //Fragment parsing
+    /** @protected */
     _getAdjustedCurrentElement() {
         return this.openElements.stackTop === 0 && this.fragmentContext
             ? this.fragmentContext
             : this.openElements.current;
     }
+    /** @protected */
     _findFormInFragmentContext() {
         let node = this.fragmentContext;
         while (node) {
@@ -5020,6 +5229,7 @@ class Parser {
         }
     }
     //Tree mutation
+    /** @protected */
     _setDocumentType(token) {
         const name = token.name || '';
         const publicId = token.publicId || '';
@@ -5033,6 +5243,7 @@ class Parser {
             }
         }
     }
+    /** @protected */
     _attachElementToTree(element, location) {
         if (this.options.sourceCodeLocationInfo) {
             const loc = location && {
@@ -5049,20 +5260,28 @@ class Parser {
             this.treeAdapter.appendChild(parent, element);
         }
     }
+    /**
+     * For self-closing tags. Add an element to the tree, but skip adding it
+     * to the stack.
+     */
+    /** @protected */
     _appendElement(token, namespaceURI) {
         const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
         this._attachElementToTree(element, token.location);
     }
+    /** @protected */
     _insertElement(token, namespaceURI) {
         const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
         this._attachElementToTree(element, token.location);
         this.openElements.push(element, token.tagID);
     }
+    /** @protected */
     _insertFakeElement(tagName, tagID) {
         const element = this.treeAdapter.createElement(tagName, NS.HTML, []);
         this._attachElementToTree(element, null);
         this.openElements.push(element, tagID);
     }
+    /** @protected */
     _insertTemplate(token) {
         const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
         const content = this.treeAdapter.createDocumentFragment();
@@ -5072,6 +5291,7 @@ class Parser {
         if (this.options.sourceCodeLocationInfo)
             this.treeAdapter.setNodeSourceCodeLocation(content, null);
     }
+    /** @protected */
     _insertFakeRootElement() {
         const element = this.treeAdapter.createElement(TAG_NAMES.HTML, NS.HTML, []);
         if (this.options.sourceCodeLocationInfo)
@@ -5079,6 +5299,7 @@ class Parser {
         this.treeAdapter.appendChild(this.openElements.current, element);
         this.openElements.push(element, TAG_ID.HTML);
     }
+    /** @protected */
     _appendCommentNode(token, parent) {
         const commentNode = this.treeAdapter.createCommentNode(token.data);
         this.treeAdapter.appendChild(parent, commentNode);
@@ -5086,6 +5307,7 @@ class Parser {
             this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);
         }
     }
+    /** @protected */
     _insertCharacters(token) {
         let parent;
         let beforeElement;
@@ -5117,12 +5339,14 @@ class Parser {
             this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);
         }
     }
+    /** @protected */
     _adoptNodes(donor, recipient) {
         for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {
             this.treeAdapter.detachNode(child);
             this.treeAdapter.appendChild(recipient, child);
         }
     }
+    /** @protected */
     _setEndLocation(element, closingToken) {
         if (this.treeAdapter.getNodeSourceCodeLocation(element) && closingToken.location) {
             const ctLoc = closingToken.location;
@@ -5172,6 +5396,7 @@ class Parser {
             ((token.tagID === TAG_ID.MGLYPH || token.tagID === TAG_ID.MALIGNMARK) &&
                 !this._isIntegrationPoint(currentTagId, current, NS.HTML)));
     }
+    /** @protected */
     _processToken(token) {
         switch (token.type) {
             case TokenType.CHARACTER: {
@@ -5209,12 +5434,14 @@ class Parser {
         }
     }
     //Integration points
+    /** @protected */
     _isIntegrationPoint(tid, element, foreignNS) {
         const ns = this.treeAdapter.getNamespaceURI(element);
         const attrs = this.treeAdapter.getAttrList(element);
         return isIntegrationPoint(tid, ns, attrs, foreignNS);
     }
     //Active formatting elements reconstruction
+    /** @protected */
     _reconstructActiveFormattingElements() {
         const listLength = this.activeFormattingElements.entries.length;
         if (listLength) {
@@ -5228,17 +5455,20 @@ class Parser {
         }
     }
     //Close elements
+    /** @protected */
     _closeTableCell() {
         this.openElements.generateImpliedEndTags();
         this.openElements.popUntilTableCellPopped();
         this.activeFormattingElements.clearToLastMarker();
         this.insertionMode = InsertionMode.IN_ROW;
     }
+    /** @protected */
     _closePElement() {
         this.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.P);
         this.openElements.popUntilTagNamePopped(TAG_ID.P);
     }
     //Insertion modes
+    /** @protected */
     _resetInsertionMode() {
         for (let i = this.openElements.stackTop; i >= 0; i--) {
             //Insertion mode reset map
@@ -5304,6 +5534,7 @@ class Parser {
         }
         this.insertionMode = InsertionMode.IN_BODY;
     }
+    /** @protected */
     _resetInsertionModeForSelect(selectIdx) {
         if (selectIdx > 0) {
             for (let i = selectIdx - 1; i > 0; i--) {
@@ -5320,12 +5551,15 @@ class Parser {
         this.insertionMode = InsertionMode.IN_SELECT;
     }
     //Foster parenting
+    /** @protected */
     _isElementCausesFosterParenting(tn) {
         return TABLE_STRUCTURE_TAGS.has(tn);
     }
+    /** @protected */
     _shouldFosterParentOnInsertion() {
         return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.currentTagId);
     }
+    /** @protected */
     _findFosterParentingLocation() {
         for (let i = this.openElements.stackTop; i >= 0; i--) {
             const openElement = this.openElements.items[i];
@@ -5348,6 +5582,7 @@ class Parser {
         }
         return { parent: this.openElements.items[0], beforeElement: null };
     }
+    /** @protected */
     _fosterParentElement(element) {
         const location = this._findFosterParentingLocation();
         if (location.beforeElement) {
@@ -5358,10 +5593,12 @@ class Parser {
         }
     }
     //Special elements
+    /** @protected */
     _isSpecialElement(element, id) {
         const ns = this.treeAdapter.getNamespaceURI(element);
         return SPECIAL_ELEMENTS[ns].has(id);
     }
+    /** @internal */
     onCharacter(token) {
         this.skipNextNewLine = false;
         if (this.tokenizer.inForeignNode) {
@@ -5431,6 +5668,7 @@ class Parser {
             // Do nothing
         }
     }
+    /** @internal */
     onNullCharacter(token) {
         this.skipNextNewLine = false;
         if (this.tokenizer.inForeignNode) {
@@ -5487,6 +5725,7 @@ class Parser {
             // Do nothing
         }
     }
+    /** @internal */
     onComment(token) {
         this.skipNextNewLine = false;
         if (this.currentNotInHTML) {
@@ -5531,6 +5770,7 @@ class Parser {
             // Do nothing
         }
     }
+    /** @internal */
     onDoctype(token) {
         this.skipNextNewLine = false;
         switch (this.insertionMode) {
@@ -5552,6 +5792,7 @@ class Parser {
             // Do nothing
         }
     }
+    /** @internal */
     onStartTag(token) {
         this.skipNextNewLine = false;
         this.currentToken = token;
@@ -5569,6 +5810,7 @@ class Parser {
      * for nested calls.
      *
      * @param token The token to process.
+     * @protected
      */
     _processStartTag(token) {
         if (this.shouldProcessStartTagTokenInForeignContent(token)) {
@@ -5578,6 +5820,7 @@ class Parser {
             this._startTagOutsideForeignContent(token);
         }
     }
+    /** @protected */
     _startTagOutsideForeignContent(token) {
         switch (this.insertionMode) {
             case InsertionMode.INITIAL: {
@@ -5671,6 +5914,7 @@ class Parser {
             // Do nothing
         }
     }
+    /** @internal */
     onEndTag(token) {
         this.skipNextNewLine = false;
         this.currentToken = token;
@@ -5681,6 +5925,7 @@ class Parser {
             this._endTagOutsideForeignContent(token);
         }
     }
+    /** @protected */
     _endTagOutsideForeignContent(token) {
         switch (this.insertionMode) {
             case InsertionMode.INITIAL: {
@@ -5774,6 +6019,7 @@ class Parser {
             // Do nothing
         }
     }
+    /** @internal */
     onEof(token) {
         switch (this.insertionMode) {
             case InsertionMode.INITIAL: {
@@ -5835,6 +6081,7 @@ class Parser {
             // Do nothing
         }
     }
+    /** @internal */
     onWhitespaceCharacter(token) {
         if (this.skipNextNewLine) {
             this.skipNextNewLine = false;
@@ -6405,7 +6652,7 @@ function numberedHeaderStartTagInBody(p, token) {
     if (p.openElements.hasInButtonScope(TAG_ID.P)) {
         p._closePElement();
     }
-    if (isNumberedHeader(p.openElements.currentTagId)) {
+    if (NUMBERED_HEADERS.has(p.openElements.currentTagId)) {
         p.openElements.pop();
     }
     p._insertElement(token, NS.HTML);
@@ -6567,9 +6814,9 @@ function iframeStartTagInBody(p, token) {
     p.framesetOk = false;
     p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
 }
-//NOTE: here we assume that we always act as an user agent with enabled plugins, so we parse
-//<noembed> as rawtext.
-function noembedStartTagInBody(p, token) {
+//NOTE: here we assume that we always act as a user agent with enabled plugins/frames, so we parse
+//<noembed>/<noframes> as rawtext.
+function rawTextStartTagInBody(p, token) {
     p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
 }
 function selectStartTagInBody(p, token) {
@@ -6681,6 +6928,7 @@ function startTagInBody(p, token) {
         case TAG_ID.DETAILS:
         case TAG_ID.ADDRESS:
         case TAG_ID.ARTICLE:
+        case TAG_ID.SEARCH:
         case TAG_ID.SECTION:
         case TAG_ID.SUMMARY:
         case TAG_ID.FIELDSET:
@@ -6804,8 +7052,9 @@ function startTagInBody(p, token) {
             optgroupStartTagInBody(p, token);
             break;
         }
-        case TAG_ID.NOEMBED: {
-            noembedStartTagInBody(p, token);
+        case TAG_ID.NOEMBED:
+        case TAG_ID.NOFRAMES: {
+            rawTextStartTagInBody(p, token);
             break;
         }
         case TAG_ID.FRAMESET: {
@@ -6818,7 +7067,7 @@ function startTagInBody(p, token) {
         }
         case TAG_ID.NOSCRIPT: {
             if (p.options.scriptingEnabled) {
-                noembedStartTagInBody(p, token);
+                rawTextStartTagInBody(p, token);
             }
             else {
                 genericStartTagInBody(p, token);
@@ -6990,6 +7239,7 @@ function endTagInBody(p, token) {
         case TAG_ID.ADDRESS:
         case TAG_ID.ARTICLE:
         case TAG_ID.DETAILS:
+        case TAG_ID.SEARCH:
         case TAG_ID.SECTION:
         case TAG_ID.SUMMARY:
         case TAG_ID.LISTING:
@@ -7590,6 +7840,17 @@ function startTagInSelect(p, token) {
             p._insertElement(token, NS.HTML);
             break;
         }
+        case TAG_ID.HR: {
+            if (p.openElements.currentTagId === TAG_ID.OPTION) {
+                p.openElements.pop();
+            }
+            if (p.openElements.currentTagId === TAG_ID.OPTGROUP) {
+                p.openElements.pop();
+            }
+            p._appendElement(token, NS.HTML);
+            token.ackSelfClosing = true;
+            break;
+        }
         case TAG_ID.INPUT:
         case TAG_ID.KEYGEN:
         case TAG_ID.TEXTAREA: