parse5 8.0.1 → 8.1.0

package/dist/index.d.ts

@@ -16,8 +16,8 @@ export declare namespace DefaultTreeAdapterTypes {
     type Node = DefaultTreeAdapter.Node;
     type DefaultTreeAdapterMap = DefaultTreeAdapter.DefaultTreeAdapterMap;
 }
-export type { TreeAdapter, TreeAdapterTypeMap } from './tree-adapters/interface.js';
-export { type ParserOptions, /** @internal */ Parser } from './parser/index.js';
+export type { ElementCreationContext, TreeAdapter, TreeAdapterTypeMap } from './tree-adapters/interface.js';
+export { type ParserOptions, /** @internal */ Parser, InsertionMode } from './parser/index.js';
 export { serialize, serializeOuter, type SerializerOptions } from './serializer/index.js';
 export { ERR as ErrorCodes, type ParserError, type ParserErrorHandler } from './common/error-codes.js';
 /** @internal */

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Parser } from './parser/index.js';
 export { defaultTreeAdapter } from './tree-adapters/default.js';
-export { /** @internal */ Parser } from './parser/index.js';
+export { /** @internal */ Parser, InsertionMode } from './parser/index.js';
 export { serialize, serializeOuter } from './serializer/index.js';
 export { ERR as ErrorCodes } from './common/error-codes.js';
 /** @internal */

package/dist/parser/index.d.ts

@@ -4,8 +4,8 @@ import { FormattingElementList } from './formatting-element-list.js';
 import { ERR, type ParserErrorHandler } from '../common/error-codes.js';
 import { TAG_ID as $, NS } from '../common/html.js';
 import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface.js';
-import { type Token, type CommentToken, type CharacterToken, type TagToken, type DoctypeToken, type EOFToken, type LocationWithAttributes } from '../common/token.js';
-declare enum InsertionMode {
+import { type Token, type CommentToken, type CharacterToken, type TagToken, type DoctypeToken, type EOFToken, type LocationWithAttributes, type Attribute } from '../common/token.js';
+export declare enum InsertionMode {
     INITIAL = 0,
     BEFORE_HTML = 1,
     BEFORE_HEAD = 2,
@@ -30,6 +30,10 @@ declare enum InsertionMode {
     AFTER_AFTER_BODY = 21,
     AFTER_AFTER_FRAMESET = 22
 }
+interface InsertionLocation<T extends TreeAdapterTypeMap> {
+    parent: T['parentNode'];
+    beforeElement: T['element'] | null;
+}
 export interface ParserOptions<T extends TreeAdapterTypeMap> {
     /**
      * The [scripting flag](https://html.spec.whatwg.org/multipage/parsing.html#scripting-flag). If set
@@ -134,7 +138,11 @@ export declare class Parser<T extends TreeAdapterTypeMap> implements TokenHandle
     /** @protected */
     _setDocumentType(token: DoctypeToken): void;
     /** @protected */
-    _attachElementToTree(element: T['element'], location: LocationWithAttributes | null): void;
+    _attachElementToTree(element: T['element'], location: LocationWithAttributes | null, insertionLocation: InsertionLocation<T>): void;
+    /** @protected */
+    _getInsertionLocation(): InsertionLocation<T>;
+    /** @protected */
+    _createElement(tagName: string, namespaceURI: NS, attrs: Attribute[], intendedParent: T['parentNode']): T['element'];
     /**
      * For self-closing tags. Add an element to the tree, but skip adding it
      * to the stack.
@@ -177,10 +185,7 @@ export declare class Parser<T extends TreeAdapterTypeMap> implements TokenHandle
     /** @protected */
     _shouldFosterParentOnInsertion(): boolean;
     /** @protected */
-    _findFosterParentingLocation(): {
-        parent: T['parentNode'];
-        beforeElement: T['element'] | null;
-    };
+    _findFosterParentingLocation(): InsertionLocation<T>;
     /** @protected */
     _fosterParentElement(element: T['element']): void;
     /** @protected */

package/dist/parser/index.js

@@ -14,7 +14,7 @@ const HIDDEN_INPUT_TYPE = 'hidden';
 const AA_OUTER_LOOP_ITER = 8;
 const AA_INNER_LOOP_ITER = 3;
 //Insertion modes
-var InsertionMode;
+export var InsertionMode;
 (function (InsertionMode) {
     InsertionMode[InsertionMode["INITIAL"] = 0] = "INITIAL";
     InsertionMode[InsertionMode["BEFORE_HTML"] = 1] = "BEFORE_HTML";
@@ -273,7 +273,7 @@ export class Parser {
         }
     }
     /** @protected */
-    _attachElementToTree(element, location) {
+    _attachElementToTree(element, location, insertionLocation) {
         if (this.options.sourceCodeLocationInfo) {
             const loc = location && {
                 ...location,
@@ -281,13 +281,34 @@ export class Parser {
             };
             this.treeAdapter.setNodeSourceCodeLocation(element, loc);
         }
-        if (this._shouldFosterParentOnInsertion()) {
-            this._fosterParentElement(element);
+        if (insertionLocation.beforeElement) {
+            this.treeAdapter.insertBefore(insertionLocation.parent, element, insertionLocation.beforeElement);
         }
         else {
-            const parent = this.openElements.currentTmplContentOrNode;
-            this.treeAdapter.appendChild(parent !== null && parent !== void 0 ? parent : this.document, element);
+            this.treeAdapter.appendChild(insertionLocation.parent, element);
+        }
+    }
+    /** @protected */
+    _getInsertionLocation() {
+        var _a;
+        if (this._shouldFosterParentOnInsertion()) {
+            return this._findFosterParentingLocation();
         }
+        return {
+            parent: (_a = this.openElements.currentTmplContentOrNode) !== null && _a !== void 0 ? _a : this.document,
+            beforeElement: null,
+        };
+    }
+    /** @protected */
+    _createElement(tagName, namespaceURI, attrs, intendedParent) {
+        var _a, _b;
+        const element = this.treeAdapter.createElement(tagName, namespaceURI, attrs);
+        (_b = (_a = this.treeAdapter).onElementCreated) === null || _b === void 0 ? void 0 : _b.call(_a, element, {
+            intendedParent,
+            formElement: this.formElement,
+            isInTemplate: this.openElements.tmplCount > 0,
+        });
+        return element;
     }
     /**
      * For self-closing tags. Add an element to the tree, but skip adding it
@@ -295,37 +316,41 @@ export class Parser {
      */
     /** @protected */
     _appendElement(token, namespaceURI) {
-        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
-        this._attachElementToTree(element, token.location);
+        const insertionLocation = this._getInsertionLocation();
+        const element = this._createElement(token.tagName, namespaceURI, token.attrs, insertionLocation.parent);
+        this._attachElementToTree(element, token.location, insertionLocation);
     }
     /** @protected */
     _insertElement(token, namespaceURI) {
-        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
-        this._attachElementToTree(element, token.location);
+        const insertionLocation = this._getInsertionLocation();
+        const element = this._createElement(token.tagName, namespaceURI, token.attrs, insertionLocation.parent);
+        this._attachElementToTree(element, token.location, insertionLocation);
         this.openElements.push(element, token.tagID);
     }
     /** @protected */
     _insertFakeElement(tagName, tagID) {
-        const element = this.treeAdapter.createElement(tagName, NS.HTML, []);
-        this._attachElementToTree(element, null);
+        const insertionLocation = this._getInsertionLocation();
+        const element = this._createElement(tagName, NS.HTML, [], insertionLocation.parent);
+        this._attachElementToTree(element, null, insertionLocation);
         this.openElements.push(element, tagID);
     }
     /** @protected */
     _insertTemplate(token) {
-        const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
+        const insertionLocation = this._getInsertionLocation();
+        const tmpl = this._createElement(token.tagName, NS.HTML, token.attrs, insertionLocation.parent);
         const content = this.treeAdapter.createDocumentFragment();
         this.treeAdapter.setTemplateContent(tmpl, content);
-        this._attachElementToTree(tmpl, token.location);
+        this._attachElementToTree(tmpl, token.location, insertionLocation);
         this.openElements.push(tmpl, token.tagID);
         if (this.options.sourceCodeLocationInfo)
             this.treeAdapter.setNodeSourceCodeLocation(content, null);
     }
     /** @protected */
     _insertFakeRootElement() {
-        const element = this.treeAdapter.createElement(TN.HTML, NS.HTML, []);
+        const element = this._createElement(TN.HTML, NS.HTML, [], this.document);
         if (this.options.sourceCodeLocationInfo)
             this.treeAdapter.setNodeSourceCodeLocation(element, null);
-        this.treeAdapter.appendChild(this.openElements.current, element);
+        this.treeAdapter.appendChild(this.document, element);
         this.openElements.push(element, $.HTML);
     }
     /** @protected */
@@ -1217,6 +1242,7 @@ function aaObtainFurthestBlock(p, formattingElementEntry) {
 function aaInnerLoop(p, furthestBlock, formattingElement) {
     let lastElement = furthestBlock;
     let nextElement = p.openElements.getCommonAncestor(furthestBlock);
+    const intendedParent = p.openElements.getCommonAncestor(formattingElement);
     for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
         //NOTE: store the next element for the next loop iteration (it may be deleted from the stack by step 9.5)
         nextElement = p.openElements.getCommonAncestor(element);
@@ -1230,7 +1256,7 @@ function aaInnerLoop(p, furthestBlock, formattingElement) {
             p.openElements.remove(element);
         }
         else {
-            element = aaRecreateElementFromEntry(p, elementEntry);
+            element = aaRecreateElementFromEntry(p, elementEntry, intendedParent);
             if (lastElement === furthestBlock) {
                 p.activeFormattingElements.bookmark = elementEntry;
             }
@@ -1242,9 +1268,9 @@ function aaInnerLoop(p, furthestBlock, formattingElement) {
     return lastElement;
 }
 //Step 13.7 of the algorithm
-function aaRecreateElementFromEntry(p, elementEntry) {
+function aaRecreateElementFromEntry(p, elementEntry, intendedParent) {
     const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);
-    const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);
+    const newElement = p._createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs, intendedParent);
     p.openElements.replace(elementEntry.element, newElement);
     elementEntry.element = newElement;
     return newElement;
@@ -1268,7 +1294,7 @@ function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
 function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
     const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);
     const { token } = formattingElementEntry;
-    const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);
+    const newElement = p._createElement(token.tagName, ns, token.attrs, furthestBlock);
     p._adoptNodes(furthestBlock, newElement);
     p.treeAdapter.appendChild(furthestBlock, newElement);
     p.activeFormattingElements.insertElementAfterBookmark(newElement, token);
@@ -2227,7 +2253,10 @@ function genericEndTagInBody(p, token) {
         const element = p.openElements.items[i];
         const elementId = p.openElements.tagIDs[i];
         // Compare the tag name here, as the tag might not be a known tag with an ID.
-        if (tid === elementId && (tid !== $.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) {
+        // Only HTML elements match; a foreign element falls through to the special-element check.
+        if (tid === elementId &&
+            p.treeAdapter.getNamespaceURI(element) === NS.HTML &&
+            (tid !== $.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) {
             p.openElements.generateImpliedEndTagsWithExclusion(tid);
             if (p.openElements.stackTop >= i)
                 p.openElements.shortenToLength(i);

package/dist/tokenizer/index.d.ts

@@ -1,6 +1,6 @@
 import { Preprocessor } from './preprocessor.js';
 import { type Token, type CharacterToken, type DoctypeToken, type TagToken, type EOFToken, type CommentToken, type Attribute, type Location } from '../common/token.js';
-import { EntityDecoder } from 'entities/decode';
+import { HtmlEntityDecoder } from 'entities/decode';
 import { ERR, type ParserErrorHandler } from '../common/error-codes.js';
 declare const enum State {
     DATA = 0,
@@ -118,9 +118,9 @@ export declare class Tokenizer {
     state: State;
     protected returnState: State;
     /**
-     * We use `entities`' `EntityDecoder` to parse character references.
+     * We use `entities`' `HtmlEntityDecoder` to parse character references.
      *
-     * All of the following states are handled by the `EntityDecoder`:
+     * All of the following states are handled by the `HtmlEntityDecoder`:
      *
      * - Named character reference state
      * - Numeric character reference state
@@ -129,17 +129,28 @@ export declare class Tokenizer {
      * - Decimal character reference state
      * - Numeric character reference end state
      */
-    protected entityDecoder: EntityDecoder;
+    protected entityDecoder: HtmlEntityDecoder;
     protected entityStartPos: number;
     protected consumedAfterSnapshot: number;
     protected currentLocation: Location | null;
     protected currentCharacterToken: CharacterToken | null;
     protected currentToken: Token | null;
     protected currentAttr: Attribute;
+    private currentAttrLocation;
+    /**
+     * `[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.
+     */
+    protected runStart: number;
+    protected runEnd: number;
     constructor(options: TokenizerOptions, handler: TokenHandler);
     protected _err(code: ERR, cpOffset?: number): void;
     protected getCurrentLocation(offset: number): Location | null;
     protected _runParsingLoop(): void;
+    /** Emit buffered character tokens without completing the current token or emitting EOF. */
+    flushCharacters(): void;
+    private getCharacterTokenEndLocation;
+    private getCharacterTokenEndOffset;
     pause(): void;
     resume(writeCallback?: () => void): void;
     write(chunk: string, isLastChunk: boolean, writeCallback?: () => void): void;
@@ -152,19 +163,35 @@ export declare class Tokenizer {
     protected _createEndTagToken(): void;
     protected _createCommentToken(offset: number): void;
     protected _createDoctypeToken(initialName: string | null): void;
-    protected _createCharacterToken(type: CharacterToken['type'], chars: string): void;
+    protected _createCharacterToken(type: CharacterToken['type']): void;
     protected _createAttr(attrNameFirstCh: string): void;
     protected _leaveAttrName(): void;
     protected _leaveAttrValue(): void;
+    /**
+     * 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.
+     */
+    protected _flushRun(text: string): void;
+    /** Extend the pending run by the current input code point, read as `cp`, or flush it and start a new one. */
+    protected _extendRun(cp: number): void;
+    /**
+     * 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).
+     */
+    protected _extendRunWith(text: string, cpOffset: number): void;
     protected prepareToken(ct: Token): void;
     protected emitCurrentTagToken(): void;
     protected emitCurrentComment(ct: CommentToken): void;
     protected emitCurrentDoctype(ct: DoctypeToken): void;
     protected _emitCurrentCharacterToken(nextLocation: Location | null): void;
     protected _emitEOFToken(): void;
-    protected _appendCharToCurrentCharacterToken(type: CharacterToken['type'], ch: string): void;
+    /** Make the current character token one of `type`, emitting the current one if it has another type. */
+    protected _ensureCharacterToken(type: CharacterToken['type']): void;
+    /** Emit the current input code point, read as `cp`. */
     protected _emitCodePoint(cp: number): void;
-    protected _emitChars(ch: string): void;
+    protected _emitChars(ch: string, cpOffset?: number): void;
     protected _startCharacterReference(): void;
     protected _isCharacterReferenceInAttribute(): boolean;
     protected _flushCodePointConsumedAsCharacterReference(cp: number): void;

package/dist/tokenizer/index.js

@@ -1,7 +1,7 @@
 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';
 //States
@@ -113,7 +113,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 +160,27 @@ export class Tokenizer {
         this.currentCharacterToken = null;
         this.currentToken = null;
         this.currentAttr = { name: '', value: '' };
+        this.currentAttrLocation = 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);
         }, handler.onParseError
             ? {
                 missingSemicolonAfterCharacterReference: () => {
@@ -216,6 +230,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;
     }
@@ -276,6 +383,7 @@ export class Tokenizer {
     }
     //Token creation
     _createStartTagToken() {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.START_TAG,
             tagName: '',
@@ -287,6 +395,7 @@ export class Tokenizer {
         };
     }
     _createEndTagToken() {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.END_TAG,
             tagName: '',
@@ -298,6 +407,7 @@ export class Tokenizer {
         };
     }
     _createCommentToken(offset) {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.COMMENT,
             data: '',
@@ -305,6 +415,7 @@ export class Tokenizer {
         };
     }
     _createDoctypeToken(initialName) {
+        this._flushRun('');
         this.currentToken = {
             type: TokenType.DOCTYPE,
             name: initialName,
@@ -314,20 +425,28 @@ 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;
@@ -335,9 +454,9 @@ export class Tokenizer {
         const token = this.currentToken;
         if (getTokenAttr(token, this.currentAttr.name) === null) {
             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();
             }
@@ -347,11 +466,71 @@ export class Tokenizer {
         }
     }
     _leaveAttrValue() {
-        if (this.currentLocation) {
-            this.currentLocation.endLine = this.preprocessor.line;
-            this.currentLocation.endCol = this.preprocessor.col;
-            this.currentLocation.endOffset = this.preprocessor.offset;
+        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.currentAttr.value += run;
+        }
+    }
+    /** 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) {
@@ -394,6 +573,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.
@@ -439,34 +619,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 +676,7 @@ export class Tokenizer {
     }
     _flushCodePointConsumedAsCharacterReference(cp) {
         if (this._isCharacterReferenceInAttribute()) {
-            this.currentAttr.value += String.fromCodePoint(cp);
+            this._extendRun(cp);
         }
         else {
             this._emitCodePoint(cp);
@@ -930,13 +1124,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 +1153,7 @@ export class Tokenizer {
                 }
                 case $.EOF: {
                     this._err(ERR.eofBeforeTagName);
-                    this._emitChars('</');
+                    this._emitChars('</', -1);
                     this._emitEOFToken();
                     break;
                 }
@@ -1014,7 +1208,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 +1221,7 @@ export class Tokenizer {
             this._stateRcdataEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RCDATA;
             this._stateRcdata(cp);
         }
@@ -1061,6 +1255,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 +1265,7 @@ export class Tokenizer {
     //------------------------------------------------------------------
     _stateRcdataEndTagName(cp) {
         if (this.handleSpecialEndTag(cp)) {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RCDATA;
             this._stateRcdata(cp);
         }
@@ -1081,7 +1277,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 +1290,7 @@ export class Tokenizer {
             this._stateRawtextEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RAWTEXT;
             this._stateRawtext(cp);
         }
@@ -1103,7 +1299,7 @@ export class Tokenizer {
     //------------------------------------------------------------------
     _stateRawtextEndTagName(cp) {
         if (this.handleSpecialEndTag(cp)) {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.RAWTEXT;
             this._stateRawtext(cp);
         }
@@ -1122,7 +1318,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this._emitChars('<');
+                this._emitChars('<', -1);
                 this.state = State.SCRIPT_DATA;
                 this._stateScriptData(cp);
             }
@@ -1136,7 +1332,7 @@ export class Tokenizer {
             this._stateScriptDataEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.SCRIPT_DATA;
             this._stateScriptData(cp);
         }
@@ -1145,7 +1341,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 +1469,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 +1487,7 @@ export class Tokenizer {
             this._stateScriptDataEscapedEndTagName(cp);
         }
         else {
-            this._emitChars('</');
+            this._emitChars('</', -1);
             this.state = State.SCRIPT_DATA_ESCAPED;
             this._stateScriptDataEscaped(cp);
         }
@@ -1300,7 +1496,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 +1790,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 +1799,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this.currentAttr.value += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
@@ -1621,7 +1817,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 +1826,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this.currentAttr.value += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
@@ -1658,7 +1854,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 +1863,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 +1872,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                this.currentAttr.value += String.fromCodePoint(cp);
+                this._extendRun(cp);
             }
         }
     }
@@ -1710,6 +1906,7 @@ export class Tokenizer {
             }
             default: {
                 this._err(ERR.missingWhitespaceBetweenAttributes);
+                this._leaveAttrValue();
                 this.state = State.BEFORE_ATTRIBUTE_NAME;
                 this._stateBeforeAttributeName(cp);
             }
@@ -1755,11 +1952,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 +2035,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '-';
+                this._extendRunWith('-', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -1854,13 +2051,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 +2067,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 +2137,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '-';
+                this._extendRunWith('-', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -1962,7 +2158,7 @@ export class Tokenizer {
                 break;
             }
             case $.HYPHEN_MINUS: {
-                token.data += '-';
+                this._extendRunWith('-', -2);
                 break;
             }
             case $.EOF: {
@@ -1972,7 +2168,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '--';
+                this._extendRunWith('--', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -1984,7 +2180,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 +2197,7 @@ export class Tokenizer {
                 break;
             }
             default: {
-                token.data += '--!';
+                this._extendRunWith('--!', -1);
                 this.state = State.COMMENT;
                 this._stateComment(cp);
             }
@@ -2638,7 +2834,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 +2848,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);
             }

package/dist/tokenizer/preprocessor.d.ts

@@ -18,6 +18,9 @@ export declare class Preprocessor {
     });
     /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */
     get col(): number;
+    /** The index in `html` at which the current code point starts (the high surrogate of a pair). */
+    get codePointStart(): number;
+    /** The offset of the current code point, before the second unit of a surrogate pair. */
     get offset(): number;
     getError(code: ERR, cpOffset: number): ParserError;
     private lastErrOffset;

package/dist/tokenizer/preprocessor.js

@@ -28,8 +28,13 @@ export class Preprocessor {
     get col() {
         return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos);
     }
+    /** The index in `html` at which the current code point starts (the high surrogate of a pair). */
+    get codePointStart() {
+        return this.pos - Number(this.lastGapPos === this.pos);
+    }
+    /** The offset of the current code point, before the second unit of a surrogate pair. */
     get offset() {
-        return this.droppedBufferSize + this.pos;
+        return this.droppedBufferSize + this.codePointStart;
     }
     getError(code, cpOffset) {
         const { line, col, offset } = this;
@@ -81,12 +86,16 @@ export class Preprocessor {
     }
     dropParsedChunk() {
         if (this.willDropParsedChunk()) {
-            this.html = this.html.substring(this.pos);
-            this.lineStartPos -= this.pos;
-            this.droppedBufferSize += this.pos;
-            this.pos = 0;
+            // Retain the entire current code point, including both units of a surrogate pair.
+            const droppedSize = this.offset - this.droppedBufferSize;
+            this.html = this.html.substring(droppedSize);
+            this.lineStartPos -= droppedSize;
+            this.droppedBufferSize += droppedSize;
+            this.pos -= droppedSize;
             this.lastGapPos = -2;
             this.gapStack.length = 0;
+            if (this.pos > 0)
+                this._addGap();
         }
     }
     write(chunk, isLastChunk) {

package/dist/tree-adapters/interface.d.ts

@@ -12,6 +12,15 @@ export interface TreeAdapterTypeMap<Node = unknown, ParentNode = unknown, ChildN
     template: Template;
     documentType: DocumentType;
 }
+/** Parser state needed to establish a form-associated element's parser-established form owner. */
+export interface ElementCreationContext<T extends TreeAdapterTypeMap = TreeAdapterTypeMap> {
+    /** The target parent from the appropriate place for inserting a node. */
+    intendedParent: T['parentNode'];
+    /** The element referenced by the parser's form element pointer, if any. */
+    formElement: T['element'] | null;
+    /** Whether the stack of open elements contains an HTML `template` element. */
+    isInTemplate: boolean;
+}
 /**
  * Tree adapter is a set of utility functions that provides minimal required abstraction layer beetween parser and a specific AST format.
  * Note that `TreeAdapter` is not designed to be a general purpose AST manipulation library. You can build such library
@@ -240,6 +249,14 @@ export interface TreeAdapter<T extends TreeAdapterTypeMap = TreeAdapterTypeMap>
      * @param contentElement -  Content element.
      */
     setTemplateContent(templateElement: T['template'], contentElement: T['documentFragment']): void;
+    /**
+     * Optional callback invoked after an element is created from a token and before it is inserted. This exposes the
+     * parser state needed to establish a form-associated element's parser-established form owner.
+     *
+     * @param element The created element.
+     * @param context Relevant parser state at the time of creation.
+     */
+    onElementCreated?: (element: T['element'], context: ElementCreationContext<T>) => void;
     /**
      * Optional callback for elements being pushed to the stack of open elements.
      *

package/package.json

@@ -2,7 +2,7 @@
     "name": "parse5",
     "type": "module",
     "description": "HTML parser and serializer.",
-    "version": "8.0.1",
+    "version": "8.1.0",
     "author": "Ivan Nikulin <ifaaan@gmail.com> (https://github.com/inikulin)",
     "contributors": [
         "James Garbutt (https://github.com/43081j)",
@@ -13,7 +13,7 @@
     "homepage": "https://parse5.js.org",
     "funding": "https://github.com/inikulin/parse5?sponsor=1",
     "dependencies": {
-        "entities": "^8.0.0"
+        "entities": "^9.0.0"
     },
     "keywords": [
         "html",
@@ -49,5 +49,9 @@
     "files": [
         "dist/**/*.js",
         "dist/**/*.d.ts"
-    ]
+    ],
+    "devDependencies": {
+        "parse5-htmlparser2-tree-adapter": "^8.0.0",
+        "parse5-test-utils": "1.0.0"
+    }
 }