parse5 8.0.1 → 8.1.1

package/dist/tokenizer/index.js

@@ -1,9 +1,12 @@
 import { Preprocessor } from './preprocessor.js';
 import { CODE_POINTS as $, SEQUENCES as $$, REPLACEMENT_CHARACTER, isSurrogate, isUndefinedCodePoint, isControlCodePoint, } from '../common/unicode.js';
 import { TokenType, getTokenAttr, } from '../common/token.js';
-import { htmlDecodeTree, EntityDecoder, DecodingMode } from 'entities/decode';
+import { HtmlEntityDecoder, DecodingMode } from 'entities/decode';
 import { ERR } from '../common/error-codes.js';
 import { TAG_ID, getTagID } from '../common/html.js';
+// The few attributes a tag usually has are scanned for a duplicate name; from this many on, the names are
+// collected in a Set instead, so that the check doesn't get quadratic in the number of attributes.
+const ATTR_NAME_SET_THRESHOLD = 64;
 //States
 var State;
 (function (State) {
@@ -113,7 +116,7 @@ function toAsciiLower(cp) {
     return cp + 32;
 }
 function isWhitespace(cp) {
-    return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;
+    return (cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED || cp === $.CARRIAGE_RETURN);
 }
 function isScriptDataDoubleEscapeSequenceEnd(cp) {
     return isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN;
@@ -160,13 +163,31 @@ export class Tokenizer {
         this.currentCharacterToken = null;
         this.currentToken = null;
         this.currentAttr = { name: '', value: '' };
+        this.currentAttrLocation = null;
+        this.currentAttrNames = null;
+        /**
+         * `[start, end)` of `preprocessor.html` still to be appended to the attribute value, comment data or character
+         * token being built (`_flushRun`): input that is used as is is appended as one slice, not a code point at a time.
+         */
+        this.runStart = 0;
+        this.runEnd = 0;
         this.preprocessor = new Preprocessor(handler);
         this.currentLocation = this.getCurrentLocation(-1);
-        this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp, consumed) => {
+        this.entityDecoder = new HtmlEntityDecoder((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);
+            if (!this._isCharacterReferenceInAttribute()) {
+                this._ensureCharacterToken(isWhitespace(cp)
+                    ? TokenType.WHITESPACE_CHARACTER
+                    : cp === $.NULL
+                        ? TokenType.NULL_CHARACTER
+                        : TokenType.CHARACTER);
+            }
+            this._extendRunWith(String.fromCodePoint(cp), 0);
+            // This callback runs twice for references that decode to two
+            // code points; keep `entityStartPos` valid if the chunk was dropped.
+            this.entityStartPos = this.preprocessor.pos - consumed + 1;
         }, handler.onParseError
             ? {
                 missingSemicolonAfterCharacterReference: () => {
@@ -216,6 +237,99 @@ export class Tokenizer {
         this.inLoop = false;
     }
     //API
+    /** Emit buffered character tokens without completing the current token or emitting EOF. */
+    flushCharacters() {
+        var _a;
+        if (this.inLoop) {
+            throw new Error('Cannot flush characters from a tokenizer callback');
+        }
+        const location = (_a = this.currentCharacterToken) === null || _a === void 0 ? void 0 : _a.location;
+        let nextLocation = null;
+        if (location) {
+            nextLocation = this.getCharacterTokenEndLocation(location);
+            this.currentLocation = nextLocation;
+        }
+        this.inLoop = true;
+        try {
+            this._emitCurrentCharacterToken(nextLocation);
+        }
+        finally {
+            this.inLoop = false;
+        }
+        this._runParsingLoop();
+    }
+    getCharacterTokenEndLocation(location) {
+        const endOffset = this.getCharacterTokenEndOffset();
+        const html = this.preprocessor.html.slice(location.startOffset - this.preprocessor.droppedBufferSize, endOffset - this.preprocessor.droppedBufferSize);
+        let line = location.startLine;
+        let lastLineBreak = -1;
+        for (let i = html.indexOf('\n'); i !== -1; i = html.indexOf('\n', i + 1)) {
+            line++;
+            lastLineBreak = i;
+        }
+        for (let i = html.indexOf('\r'); i !== -1; i = html.indexOf('\r', i + 1)) {
+            // Count CRLF as one line break by counting its LF only.
+            if (html.charCodeAt(i + 1) !== $.LINE_FEED) {
+                line++;
+                lastLineBreak = Math.max(lastLineBreak, i);
+            }
+        }
+        return {
+            startLine: line,
+            startCol: lastLineBreak === -1 ? location.startCol + html.length : html.length - lastLineBreak,
+            startOffset: endOffset,
+            endLine: -1,
+            endCol: -1,
+            endOffset: -1,
+        };
+    }
+    // Return the input boundary before any unfinished token or buffered delimiter.
+    getCharacterTokenEndOffset() {
+        var _a;
+        const end = this.preprocessor.droppedBufferSize + this.preprocessor.pos + 1;
+        const tokenLocation = (_a = this.currentToken) === null || _a === void 0 ? void 0 : _a.location;
+        switch (this.state) {
+            case State.TAG_OPEN:
+            case State.RCDATA_LESS_THAN_SIGN:
+            case State.RAWTEXT_LESS_THAN_SIGN:
+            case State.SCRIPT_DATA_LESS_THAN_SIGN:
+            case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN:
+            case State.CDATA_SECTION_BRACKET: {
+                return end - 1;
+            }
+            case State.END_TAG_OPEN:
+            case State.MARKUP_DECLARATION_OPEN:
+            case State.RCDATA_END_TAG_OPEN:
+            case State.RCDATA_END_TAG_NAME:
+            case State.RAWTEXT_END_TAG_OPEN:
+            case State.RAWTEXT_END_TAG_NAME:
+            case State.SCRIPT_DATA_END_TAG_OPEN:
+            case State.SCRIPT_DATA_END_TAG_NAME:
+            case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN:
+            case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME:
+            case State.CDATA_SECTION_END: {
+                return end - 2;
+            }
+            case State.CHARACTER_REFERENCE: {
+                return this._isCharacterReferenceInAttribute() && tokenLocation
+                    ? tokenLocation.startOffset
+                    : this.preprocessor.droppedBufferSize + this.entityStartPos;
+            }
+            case State.DOCTYPE:
+            case State.BEFORE_DOCTYPE_NAME: {
+                return this.currentLocation.startOffset;
+            }
+            default: {
+                if (tokenLocation &&
+                    (this.state === State.TAG_NAME ||
+                        (this.state >= State.BEFORE_ATTRIBUTE_NAME && this.state <= State.BOGUS_COMMENT) ||
+                        (this.state >= State.COMMENT_START && this.state <= State.BOGUS_DOCTYPE))) {
+                    return tokenLocation.startOffset;
+                }
+                return end;
+            }
+        }
+    }
     pause() {
         this.paused = true;
     }
@@ -245,6 +359,33 @@ export class Tokenizer {
         this.preprocessor.insertHtmlAtCurrentPos(chunk);
         this._runParsingLoop();
     }
+    /** @internal Flush completed streaming text without splitting an unfinished token. */
+    flushCurrentCharacterToken() {
+        // Only completed text is flushed: an unfinished token stays intact, including a doctype that has no token yet.
+        if (this.paused ||
+            this.active ||
+            !this.currentCharacterToken ||
+            this.currentToken ||
+            this.state === State.DOCTYPE ||
+            this.state === State.BEFORE_DOCTYPE_NAME ||
+            !this.preprocessor.willDropParsedChunk()) {
+            return;
+        }
+        // The last `pending` code units, a delimiter or character reference, are not text yet and stay buffered. They
+        // are ASCII, so they hold no preprocessing gap and no line break that the dropped gap history would have to keep.
+        const pending = this.preprocessor.droppedBufferSize + this.preprocessor.pos + 1 - this.getCharacterTokenEndOffset();
+        // Hibernation left us before the next code point (possibly an incomplete surrogate).
+        this.preprocessor.advance();
+        this.currentLocation = this.getCurrentLocation(pending);
+        this.preprocessor.retreat(1);
+        this._emitCurrentCharacterToken(this.currentLocation);
+        // Keep a source range for CDATA delimiters or a later tag discarded at EOF. An empty null-character token
+        // would become a replacement character in foreign content.
+        this._createCharacterToken(TokenType.CHARACTER);
+        this.preprocessor.dropParsedChunk(Math.max(pending - 1, 0));
+        // Keep `entityStartPos` valid for a pending character reference.
+        this.entityStartPos = this.preprocessor.pos + 1 - pending;
+    }
     //Hibernation
     _ensureHibernation() {
         if (this.preprocessor.endOfChunkHit) {
@@ -276,6 +417,7 @@ export class Tokenizer {
     }
     //Token creation
     _createStartTagToken() {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.START_TAG,
             tagName: '',
@@ -287,6 +429,7 @@ export class Tokenizer {
         };
     }
     _createEndTagToken() {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.END_TAG,
             tagName: '',
@@ -298,6 +441,7 @@ export class Tokenizer {
         };
     }
     _createCommentToken(offset) {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.COMMENT,
             data: '',
@@ -305,6 +449,7 @@ export class Tokenizer {
         };
     }
     _createDoctypeToken(initialName) {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.DOCTYPE,
             name: initialName,
@@ -314,44 +459,128 @@ export class Tokenizer {
             location: this.currentLocation,
         };
     }
-    _createCharacterToken(type, chars) {
+    _createCharacterToken(type) {
+        if (this.currentLocation) {
+            const start = this.currentLocation.startOffset - this.preprocessor.droppedBufferSize;
+            // A flushed CR already advanced the line; exclude its ignored LF from the next token's range.
+            if (this.preprocessor.html[start] === '\n' && this.preprocessor.html[start - 1] === '\r') {
+                this.currentLocation.startOffset++;
+            }
+        }
         this.currentCharacterToken = {
             type,
-            chars,
+            chars: '',
             location: this.currentLocation,
         };
     }
     //Tag attributes
     _createAttr(attrNameFirstCh) {
+        this._flushRun('');
         this.currentAttr = {
             name: attrNameFirstCh,
             value: '',
         };
-        this.currentLocation = this.getCurrentLocation(0);
+        this.currentAttrLocation = this.getCurrentLocation(0);
     }
     _leaveAttrName() {
         var _a;
         var _b;
         const token = this.currentToken;
-        if (getTokenAttr(token, this.currentAttr.name) === null) {
+        const { name } = this.currentAttr;
+        const names = this.currentAttrNames;
+        let duplicate;
+        if (names === null) {
+            duplicate = getTokenAttr(token, name) !== null;
+            // Build the name set only once a new (65th) name is accepted, so a tag with 64 names and many
+            // duplicates does not build it.
+            if (!duplicate && token.attrs.length === ATTR_NAME_SET_THRESHOLD) {
+                this.currentAttrNames = new Set(token.attrs.map((attr) => attr.name)).add(name);
+            }
+        }
+        else {
+            duplicate = names.has(name);
+            if (!duplicate)
+                names.add(name);
+        }
+        if (duplicate) {
+            this._err(ERR.duplicateAttribute);
+        }
+        else {
             token.attrs.push(this.currentAttr);
-            if (token.location && this.currentLocation) {
+            if (token.location && this.currentAttrLocation) {
                 const attrLocations = ((_a = (_b = token.location).attrs) !== null && _a !== void 0 ? _a : (_b.attrs = Object.create(null)));
-                attrLocations[this.currentAttr.name] = this.currentLocation;
+                attrLocations[this.currentAttr.name] = this.currentAttrLocation;
                 // Set end location
                 this._leaveAttrValue();
             }
         }
+    }
+    _leaveAttrValue() {
+        if (this.currentAttrLocation) {
+            this.currentAttrLocation.endLine = this.preprocessor.line;
+            this.currentAttrLocation.endCol = this.preprocessor.col;
+            this.currentAttrLocation.endOffset = this.preprocessor.offset;
+        }
+    }
+    /**
+     * Append the pending run and `text` to the attribute value, comment data or character token being built.
+     * The run is a string of its own: V8 copies a slice of fewer than 13 characters but lets a longer one share
+     * the input's buffer, which would keep that buffer alive for as long as any attribute value or text cut from
+     * it is; a concatenation is flattened into a buffer of its own when it is sliced.
+     */
+    _flushRun(text) {
+        if (this.runEnd === this.runStart && text.length === 0) {
+            return;
+        }
+        const slice = this.preprocessor.html.slice(this.runStart, this.runEnd);
+        const run = (slice.length < 13 ? slice : ` ${slice}`.slice(1)) + text;
+        const token = this.currentToken;
+        this.runStart = this.runEnd;
+        if (token === null) {
+            this.currentCharacterToken.chars += run;
+        }
+        else if (token.type === TokenType.COMMENT) {
+            token.data += run;
+        }
         else {
-            this._err(ERR.duplicateAttribute);
+            this.currentAttr.value += run;
         }
     }
-    _leaveAttrValue() {
-        if (this.currentLocation) {
-            this.currentLocation.endLine = this.preprocessor.line;
-            this.currentLocation.endCol = this.preprocessor.col;
-            this.currentLocation.endOffset = this.preprocessor.offset;
+    /** Extend the pending run by the current input code point, read as `cp`, or flush it and start a new one. */
+    _extendRun(cp) {
+        const { preprocessor } = this;
+        //NOTE: a CR is read as LF, which is then not in the input.
+        if (cp === $.LINE_FEED && preprocessor.html.charCodeAt(preprocessor.pos) !== $.LINE_FEED) {
+            this._flushRun('\n');
+            this.runStart = preprocessor.pos + 1;
+        }
+        else {
+            const start = preprocessor.pos - Number(cp > 65535);
+            if (start !== this.runEnd) {
+                this._flushRun('');
+                this.runStart = start;
+            }
+        }
+        this.runEnd = preprocessor.pos + 1;
+    }
+    /**
+     * Extend the pending run by `text`, the input that ends `cpOffset` code points after the current one, or flush
+     * the run and append `text` where the input differs (a NUL replacement, a decoded reference, a dropped chunk).
+     */
+    _extendRunWith(text, cpOffset) {
+        const { preprocessor } = this;
+        const start = preprocessor.codePointStart + 1 + cpOffset - text.length;
+        if (start >= 0 && preprocessor.html.startsWith(text, start)) {
+            if (start !== this.runEnd) {
+                this._flushRun('');
+                this.runStart = start;
+            }
         }
+        else {
+            this._flushRun(text);
+            this.runStart = start + text.length;
+        }
+        this.runEnd = start + text.length;
     }
     //Token emission
     prepareToken(ct) {
@@ -366,6 +595,7 @@ export class Tokenizer {
     }
     emitCurrentTagToken() {
         const ct = this.currentToken;
+        this.currentAttrNames = null;
         this.prepareToken(ct);
         ct.tagID = getTagID(ct.tagName);
         if (ct.type === TokenType.START_TAG) {
@@ -394,6 +624,7 @@ export class Tokenizer {
         this.preprocessor.dropParsedChunk();
     }
     _emitCurrentCharacterToken(nextLocation) {
+        this._flushRun('');
         if (this.currentCharacterToken) {
             //NOTE: if we have a pending character token, make it's end location equal to the
             //current token's start location.
@@ -420,13 +651,16 @@ export class Tokenizer {
         }
     }
     _emitEOFToken() {
+        var _a, _b;
         const location = this.getCurrentLocation(0);
         if (location) {
             location.endLine = location.startLine;
             location.endCol = location.startCol;
             location.endOffset = location.startOffset;
         }
-        this._emitCurrentCharacterToken(location);
+        // A token that is still open at EOF (eof-in-tag) is dropped. Pending
+        // characters end where that token started, rather than at EOF.
+        this._emitCurrentCharacterToken((_b = (_a = this.currentToken) === null || _a === void 0 ? void 0 : _a.location) !== null && _b !== void 0 ? _b : location);
         this.handler.onEof({ type: TokenType.EOF, location });
         this.active = false;
     }
@@ -439,34 +673,48 @@ export class Tokenizer {
     //1)TokenType.NULL_CHARACTER - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
     //2)TokenType.WHITESPACE_CHARACTER - any whitespace/new-line character sequences (e.g. '\n  \r\t   \f')
     //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
-    _appendCharToCurrentCharacterToken(type, ch) {
+    /** Make the current character token one of `type`, emitting the current one if it has another type. */
+    _ensureCharacterToken(type) {
         if (this.currentCharacterToken) {
             if (this.currentCharacterToken.type === type) {
-                this.currentCharacterToken.chars += ch;
                 return;
             }
-            else {
-                this.currentLocation = this.getCurrentLocation(0);
-                this._emitCurrentCharacterToken(this.currentLocation);
-                this.preprocessor.dropParsedChunk();
-            }
+            this.currentLocation = this.getCurrentLocation(0);
+            this._emitCurrentCharacterToken(this.currentLocation);
+            this.preprocessor.dropParsedChunk();
         }
-        this._createCharacterToken(type, ch);
+        this._createCharacterToken(type);
     }
+    /** Emit the current input code point, read as `cp`. */
     _emitCodePoint(cp) {
         const type = isWhitespace(cp)
             ? TokenType.WHITESPACE_CHARACTER
             : cp === $.NULL
                 ? TokenType.NULL_CHARACTER
                 : TokenType.CHARACTER;
-        // OPTIMIZATION: Use String.fromCharCode for BMP characters (< 0x10000) which is faster
-        // than String.fromCodePoint. Characters outside BMP are rare in HTML.
-        this._appendCharToCurrentCharacterToken(type, cp < 65536 ? String.fromCharCode(cp) : String.fromCodePoint(cp));
+        const token = this.currentCharacterToken;
+        if (token === null || token.type !== type) {
+            this._ensureCharacterToken(type);
+        }
+        this._extendRun(cp);
     }
     //NOTE: used when we emit characters explicitly.
     //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks.
-    _emitChars(ch) {
-        this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch);
+    // Negative `cpOffset` values locate text emitted before the current input character.
+    _emitChars(ch, cpOffset = 0) {
+        if (this.options.sourceCodeLocationInfo &&
+            cpOffset !== 0 &&
+            this.currentCharacterToken &&
+            this.currentCharacterToken.type !== TokenType.CHARACTER) {
+            this.currentLocation = this.getCurrentLocation(ch.length - 1 - cpOffset);
+            this._emitCurrentCharacterToken(this.currentLocation);
+            // Keep source characters that precede the lookahead available for a subsequent flush.
+            this._createCharacterToken(TokenType.CHARACTER);
+        }
+        else {
+            this._ensureCharacterToken(TokenType.CHARACTER);
+        }
+        this._extendRunWith(ch, cpOffset);
     }
     // Character reference helpers
     _startCharacterReference() {
@@ -482,7 +730,7 @@ export class Tokenizer {
     }
     _flushCodePointConsumedAsCharacterReference(cp) {
         if (this._isCharacterReferenceInAttribute()) {
-            this.currentAttr.value += String.fromCodePoint(cp);
+            this._extendRun(cp);
         }
         else {
             this._emitCodePoint(cp);
@@ -930,13 +1178,13 @@ export class Tokenizer {
                 }
                 case $.EOF: {
                     this._err(ERR.eofBeforeTagName);
-                    this._emitChars('<');
+                    this._emitChars('<', -1);
                     this._emitEOFToken();
                     break;
                 }
                 default: {
                     this._err(ERR.invalidFirstCharacterOfTagName);
-                    this._emitChars('<');
+                    this._emitChars('<', -1);
                     this.state = State.DATA;
                     this._stateData(cp);
                 }
@@ -959,7 +1207,7 @@ export class Tokenizer {
                 }
                 case $.EOF: {
                     this._err(ERR.eofBeforeTagName);
-                    this._emitChars('</');
+                    this._emitChars('</', -1);
                     this._emitEOFToken();
                     break;
                 }
@@ -1014,7 +1262,7 @@ export class Tokenizer {
             this.state = State.RCDATA_END_TAG_OPEN;
         }
         else {
-            this._emitChars('<');
+            this._emitChars('<', -1);
             this.state = State.RCDATA;
             this._stateRcdata(cp);
         }
@@ -1027,7 +1275,7 @@ export class Tokenizer {
             this._stateRcdataEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RCDATA;
             this._stateRcdata(cp);
         }
@@ -1061,6 +1309,8 @@ export class Tokenizer {
                 return false;
             }
             default: {
+                //NOTE: the end tag is text after all, so no token is being built.
+                this.currentToken = null;
                 return !this._ensureHibernation();
             }
         }
@@ -1069,7 +1319,7 @@ export class Tokenizer {
     //------------------------------------------------------------------
     _stateRcdataEndTagName(cp) {
         if (this.handleSpecialEndTag(cp)) {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RCDATA;
             this._stateRcdata(cp);
         }
@@ -1081,7 +1331,7 @@ export class Tokenizer {
             this.state = State.RAWTEXT_END_TAG_OPEN;
         }
         else {
-            this._emitChars('<');
+            this._emitChars('<', -1);
             this.state = State.RAWTEXT;
             this._stateRawtext(cp);
         }
@@ -1094,7 +1344,7 @@ export class Tokenizer {
             this._stateRawtextEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RAWTEXT;
             this._stateRawtext(cp);
         }
@@ -1103,7 +1353,7 @@ export class Tokenizer {
     //------------------------------------------------------------------
     _stateRawtextEndTagName(cp) {
         if (this.handleSpecialEndTag(cp)) {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RAWTEXT;
             this._stateRawtext(cp);
         }
@@ -1122,7 +1372,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this._emitChars('<');
+                this._emitChars('<', -1);
                 this.state = State.SCRIPT_DATA;
                 this._stateScriptData(cp);
             }
@@ -1136,7 +1386,7 @@ export class Tokenizer {
             this._stateScriptDataEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.SCRIPT_DATA;
             this._stateScriptData(cp);
         }
@@ -1145,7 +1395,7 @@ export class Tokenizer {
     //------------------------------------------------------------------
     _stateScriptDataEndTagName(cp) {
         if (this.handleSpecialEndTag(cp)) {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.SCRIPT_DATA;
             this._stateScriptData(cp);
         }
@@ -1273,12 +1523,12 @@ export class Tokenizer {
             this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN;
         }
         else if (isAsciiLetter(cp)) {
-            this._emitChars('<');
+            this._emitChars('<', -1);
             this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START;
             this._stateScriptDataDoubleEscapeStart(cp);
         }
         else {
-            this._emitChars('<');
+            this._emitChars('<', -1);
             this.state = State.SCRIPT_DATA_ESCAPED;
             this._stateScriptDataEscaped(cp);
         }
@@ -1291,7 +1541,7 @@ export class Tokenizer {
             this._stateScriptDataEscapedEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.SCRIPT_DATA_ESCAPED;
             this._stateScriptDataEscaped(cp);
         }
@@ -1300,7 +1550,7 @@ export class Tokenizer {
     //------------------------------------------------------------------
     _stateScriptDataEscapedEndTagName(cp) {
         if (this.handleSpecialEndTag(cp)) {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.SCRIPT_DATA_ESCAPED;
             this._stateScriptDataEscaped(cp);
         }
@@ -1594,7 +1844,7 @@ export class Tokenizer {
             }
             case $.NULL: {
                 this._err(ERR.unexpectedNullCharacter);
-                this.currentAttr.value += REPLACEMENT_CHARACTER;
+                this._extendRunWith(REPLACEMENT_CHARACTER, 0);
                 break;
             }
             case $.EOF: {
@@ -1603,7 +1853,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this.currentAttr.value += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
@@ -1621,7 +1871,7 @@ export class Tokenizer {
             }
             case $.NULL: {
                 this._err(ERR.unexpectedNullCharacter);
-                this.currentAttr.value += REPLACEMENT_CHARACTER;
+                this._extendRunWith(REPLACEMENT_CHARACTER, 0);
                 break;
             }
             case $.EOF: {
@@ -1630,7 +1880,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this.currentAttr.value += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
@@ -1658,7 +1908,7 @@ export class Tokenizer {
             }
             case $.NULL: {
                 this._err(ERR.unexpectedNullCharacter);
-                this.currentAttr.value += REPLACEMENT_CHARACTER;
+                this._extendRunWith(REPLACEMENT_CHARACTER, 0);
                 break;
             }
             case $.QUOTATION_MARK:
@@ -1667,7 +1917,7 @@ export class Tokenizer {
             case $.EQUALS_SIGN:
             case $.GRAVE_ACCENT: {
                 this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
-                this.currentAttr.value += String.fromCodePoint(cp);
+                this._extendRun(cp);
                 break;
             }
             case $.EOF: {
@@ -1676,7 +1926,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this.currentAttr.value += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
@@ -1710,6 +1960,7 @@ export class Tokenizer {
             }
             default: {
                 this._err(ERR.missingWhitespaceBetweenAttributes);
+                this._leaveAttrValue();
                 this.state = State.BEFORE_ATTRIBUTE_NAME;
                 this._stateBeforeAttributeName(cp);
             }
@@ -1755,11 +2006,11 @@ export class Tokenizer {
             }
             case $.NULL: {
                 this._err(ERR.unexpectedNullCharacter);
-                token.data += REPLACEMENT_CHARACTER;
+                this._extendRunWith(REPLACEMENT_CHARACTER, 0);
                 break;
             }
             default: {
-                token.data += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
@@ -1838,7 +2089,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '-';
+                this._extendRunWith('-', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -1854,13 +2105,13 @@ export class Tokenizer {
                 break;
             }
             case $.LESS_THAN_SIGN: {
-                token.data += '<';
+                this._extendRunWith('<', 0);
                 this.state = State.COMMENT_LESS_THAN_SIGN;
                 break;
             }
             case $.NULL: {
                 this._err(ERR.unexpectedNullCharacter);
-                token.data += REPLACEMENT_CHARACTER;
+                this._extendRunWith(REPLACEMENT_CHARACTER, 0);
                 break;
             }
             case $.EOF: {
@@ -1870,22 +2121,21 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
     // Comment less-than sign state
     //------------------------------------------------------------------
     _stateCommentLessThanSign(cp) {
-        const token = this.currentToken;
         switch (cp) {
             case $.EXCLAMATION_MARK: {
-                token.data += '!';
+                this._extendRunWith('!', 0);
                 this.state = State.COMMENT_LESS_THAN_SIGN_BANG;
                 break;
             }
             case $.LESS_THAN_SIGN: {
-                token.data += '<';
+                this._extendRunWith('<', 0);
                 break;
             }
             default: {
@@ -1941,7 +2191,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '-';
+                this._extendRunWith('-', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -1962,7 +2212,7 @@ export class Tokenizer {
                 break;
             }
             case $.HYPHEN_MINUS: {
-                token.data += '-';
+                this._extendRunWith('-', -2);
                 break;
             }
             case $.EOF: {
@@ -1972,7 +2222,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '--';
+                this._extendRunWith('--', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -1984,7 +2234,7 @@ export class Tokenizer {
         const token = this.currentToken;
         switch (cp) {
             case $.HYPHEN_MINUS: {
-                token.data += '--!';
+                this._extendRunWith('--!', -1);
                 this.state = State.COMMENT_END_DASH;
                 break;
             }
@@ -2001,7 +2251,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '--!';
+                this._extendRunWith('--!', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -2638,7 +2888,7 @@ export class Tokenizer {
             this.state = State.CDATA_SECTION_END;
         }
         else {
-            this._emitChars(']');
+            this._emitChars(']', -1);
             this.state = State.CDATA_SECTION;
             this._stateCdataSection(cp);
         }
@@ -2652,11 +2902,11 @@ export class Tokenizer {
                 break;
             }
             case $.RIGHT_SQUARE_BRACKET: {
-                this._emitChars(']');
+                this._emitChars(']', -2);
                 break;
             }
             default: {
-                this._emitChars(']]');
+                this._emitChars(']]', -1);
                 this.state = State.CDATA_SECTION;
                 this._stateCdataSection(cp);
             }