parse5 8.1.0 → 8.1.1

package/dist/serializer/index.js

@@ -51,11 +51,19 @@ const defaultOpts = { treeAdapter: defaultTreeAdapter, scriptingEnabled: true };
  * @param options Serialization options.
  */
 export function serialize(node, options) {
+    var _a;
     const opts = { ...defaultOpts, ...options };
     if (isVoidElement(node, opts)) {
         return '';
     }
-    return serializeChildNodes(node, opts);
+    const { treeAdapter } = opts;
+    // A template's children are those of its content fragment.
+    const container = treeAdapter.isElementNode(node) &&
+        treeAdapter.getTagName(node) === $.TEMPLATE &&
+        treeAdapter.getNamespaceURI(node) === NS.HTML
+        ? treeAdapter.getTemplateContent(node)
+        : node;
+    return serializeNodes((_a = treeAdapter.getChildNodes(container)) !== null && _a !== void 0 ? _a : [], opts);
 }
 /**
  * Serializes an AST element node to an HTML string, including the element node.
@@ -78,43 +86,49 @@ export function serialize(node, options) {
  */
 export function serializeOuter(node, options) {
     const opts = { ...defaultOpts, ...options };
-    return serializeNode(node, opts);
+    return serializeNodes([node], opts);
 }
-function serializeChildNodes(parentNode, options) {
+function serializeNodes(nodes, options) {
+    var _a;
+    const { treeAdapter } = options;
+    // The depth of the tree is not bounded, so the open elements (their
+    // remaining siblings and end tags) are kept on explicit stacks.
+    const stack = [];
     let html = '';
-    // Get container of the child nodes
-    const container = options.treeAdapter.isElementNode(parentNode) &&
-        options.treeAdapter.getTagName(parentNode) === $.TEMPLATE &&
-        options.treeAdapter.getNamespaceURI(parentNode) === NS.HTML
-        ? options.treeAdapter.getTemplateContent(parentNode)
-        : parentNode;
-    const childNodes = options.treeAdapter.getChildNodes(container);
-    if (childNodes) {
-        for (const currentNode of childNodes) {
-            html += serializeNode(currentNode, options);
+    let index = 0;
+    for (;;) {
+        if (index < nodes.length) {
+            const node = nodes[index++];
+            if (treeAdapter.isElementNode(node)) {
+                const tn = treeAdapter.getTagName(node);
+                html += `<${tn}${serializeAttributes(node, options)}>`;
+                const isHtml = treeAdapter.getNamespaceURI(node) === NS.HTML;
+                if (!(isHtml && VOID_ELEMENTS.has(tn))) {
+                    stack.push({ nodes, index, endTag: `</${tn}>` });
+                    nodes =
+                        (_a = treeAdapter.getChildNodes(isHtml && tn === $.TEMPLATE ? treeAdapter.getTemplateContent(node) : node)) !== null && _a !== void 0 ? _a : [];
+                    index = 0;
+                }
+            }
+            else if (treeAdapter.isTextNode(node)) {
+                html += serializeTextNode(node, options);
+            }
+            else if (treeAdapter.isCommentNode(node)) {
+                html += serializeCommentNode(node, options);
+            }
+            else if (treeAdapter.isDocumentTypeNode(node)) {
+                html += serializeDocumentTypeNode(node, options);
+            }
+        }
+        else {
+            const parent = stack.pop();
+            if (!parent) {
+                return html;
+            }
+            html += parent.endTag;
+            ({ nodes, index } = parent);
         }
     }
-    return html;
-}
-function serializeNode(node, options) {
-    if (options.treeAdapter.isElementNode(node)) {
-        return serializeElement(node, options);
-    }
-    if (options.treeAdapter.isTextNode(node)) {
-        return serializeTextNode(node, options);
-    }
-    if (options.treeAdapter.isCommentNode(node)) {
-        return serializeCommentNode(node, options);
-    }
-    if (options.treeAdapter.isDocumentTypeNode(node)) {
-        return serializeDocumentTypeNode(node, options);
-    }
-    // Return an empty string for unknown nodes
-    return '';
-}
-function serializeElement(node, options) {
-    const tn = options.treeAdapter.getTagName(node);
-    return `<${tn}${serializeAttributes(node, options)}>${isVoidElement(node, options) ? '' : `${serializeChildNodes(node, options)}</${tn}>`}`;
 }
 function serializeAttributes(node, { treeAdapter }) {
     let html = '';

package/dist/tokenizer/index.d.ts

@@ -137,6 +137,7 @@ export declare class Tokenizer {
     protected currentToken: Token | null;
     protected currentAttr: Attribute;
     private currentAttrLocation;
+    private currentAttrNames;
     /**
      * `[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.
@@ -155,6 +156,8 @@ export declare class Tokenizer {
     resume(writeCallback?: () => void): void;
     write(chunk: string, isLastChunk: boolean, writeCallback?: () => void): void;
     insertHtmlAtCurrentPos(chunk: string): void;
+    /** @internal Flush completed streaming text without splitting an unfinished token. */
+    flushCurrentCharacterToken(): void;
     protected _ensureHibernation(): boolean;
     protected _consume(): number;
     protected _advanceBy(count: number): void;

package/dist/tokenizer/index.js

@@ -4,6 +4,9 @@ import { TokenType, getTokenAttr, } from '../common/token.js';
 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) {
@@ -161,6 +164,7 @@ export class Tokenizer {
         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.
@@ -181,6 +185,9 @@ export class Tokenizer {
                         : 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: () => {
@@ -352,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) {
@@ -452,7 +486,26 @@ export class Tokenizer {
         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.currentAttrLocation) {
                 const attrLocations = ((_a = (_b = token.location).attrs) !== null && _a !== void 0 ? _a : (_b.attrs = Object.create(null)));
@@ -461,9 +514,6 @@ export class Tokenizer {
                 this._leaveAttrValue();
             }
         }
-        else {
-            this._err(ERR.duplicateAttribute);
-        }
     }
     _leaveAttrValue() {
         if (this.currentAttrLocation) {
@@ -545,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) {
@@ -600,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;
     }

package/dist/tokenizer/preprocessor.d.ts

@@ -28,7 +28,11 @@ export declare class Preprocessor {
     private _addGap;
     private _processSurrogate;
     willDropParsedChunk(): boolean;
-    dropParsedChunk(): void;
+    /**
+     * Drop the parsed input, except for the current code point and the `keep` code units before it. The gap history is
+     * reset, so the kept units must contain no preprocessing gap.
+     */
+    dropParsedChunk(keep?: number): void;
     write(chunk: string, isLastChunk: boolean): void;
     insertHtmlAtCurrentPos(chunk: string): void;
     startsWith(pattern: string, caseSensitive: boolean): boolean;

package/dist/tokenizer/preprocessor.js

@@ -64,7 +64,7 @@ export class Preprocessor {
         //NOTE: try to peek a surrogate pair
         if (this.pos !== this.html.length - 1) {
             const nextCp = this.html.charCodeAt(this.pos + 1);
-            if (isSurrogatePair(nextCp)) {
+            if (!isSurrogatePair(cp) && isSurrogatePair(nextCp)) {
                 //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.
                 this.pos++;
                 //NOTE: add a gap that should be avoided during retreat
@@ -84,17 +84,21 @@ export class Preprocessor {
     willDropParsedChunk() {
         return this.pos > this.bufferWaterline;
     }
-    dropParsedChunk() {
+    /**
+     * Drop the parsed input, except for the current code point and the `keep` code units before it. The gap history is
+     * reset, so the kept units must contain no preprocessing gap.
+     */
+    dropParsedChunk(keep = 0) {
         if (this.willDropParsedChunk()) {
             // Retain the entire current code point, including both units of a surrogate pair.
-            const droppedSize = this.offset - this.droppedBufferSize;
+            const droppedSize = this.offset - this.droppedBufferSize - keep;
             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)
+            if (this.pos > keep)
                 this._addGap();
         }
     }

package/dist/tree-adapters/default.js

@@ -1,4 +1,6 @@
 import { DOCUMENT_MODE } from '../common/html.js';
+/** The position of each name in the attribute lists `adoptAttributes` merged into, kept for the next merge into that list. */
+const attrListIndexes = new WeakMap();
 export const defaultTreeAdapter = {
     //Node construction
     createDocument() {
@@ -44,8 +46,12 @@ export const defaultTreeAdapter = {
         newNode.parentNode = parentNode;
     },
     insertBefore(parentNode, newNode, referenceNode) {
-        const insertionIdx = parentNode.childNodes.indexOf(referenceNode);
-        parentNode.childNodes.splice(insertionIdx, 0, newNode);
+        const { childNodes } = parentNode;
+        // The reference is usually the last child (fostered content precedes the table), so check that first.
+        const insertionIdx = childNodes[childNodes.length - 1] === referenceNode
+            ? childNodes.length - 1
+            : childNodes.indexOf(referenceNode);
+        childNodes.splice(insertionIdx, 0, newNode);
         newNode.parentNode = parentNode;
     },
     setTemplateContent(templateElement, contentElement) {
@@ -80,8 +86,10 @@ export const defaultTreeAdapter = {
     },
     detachNode(node) {
         if (node.parentNode) {
-            const idx = node.parentNode.childNodes.indexOf(node);
-            node.parentNode.childNodes.splice(idx, 1);
+            const { childNodes } = node.parentNode;
+            // The parser detaches from the end when it moves children, so check the last child first.
+            const idx = childNodes[childNodes.length - 1] === node ? childNodes.length - 1 : childNodes.indexOf(node);
+            childNodes.splice(idx, 1);
             node.parentNode = null;
         }
     },
@@ -96,7 +104,11 @@ export const defaultTreeAdapter = {
         defaultTreeAdapter.appendChild(parentNode, defaultTreeAdapter.createTextNode(text));
     },
     insertTextBefore(parentNode, text, referenceNode) {
-        const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
+        const { childNodes } = parentNode;
+        const referenceIdx = childNodes[childNodes.length - 1] === referenceNode
+            ? childNodes.length - 1
+            : childNodes.indexOf(referenceNode);
+        const prevNode = childNodes[referenceIdx - 1];
         if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) {
             prevNode.value += text;
         }
@@ -104,13 +116,45 @@ export const defaultTreeAdapter = {
             defaultTreeAdapter.insertBefore(parentNode, defaultTreeAdapter.createTextNode(text), referenceNode);
         }
     },
+    /**
+     * Keeps the recipient's names between merges as a map from name to position. The map is rebuilt when the list changed
+     * length or has a repeated name, or when a merged name it holds no longer names the entry at that position. A name that
+     * other code gives an existing entry between two merges is missed otherwise, and merging it appends it a second time.
+     */
     adoptAttributes(recipient, attrs) {
-        const recipientAttrsMap = new Set(recipient.attrs.map((attr) => attr.name));
+        // Merging a list into itself adds nothing: every name is already present.
+        if (attrs.length === 0 || attrs === recipient.attrs)
+            return;
+        const cached = attrListIndexes.get(recipient.attrs);
+        const isIndexed = (cached === null || cached === void 0 ? void 0 : cached.size) === recipient.attrs.length &&
+            attrs.every(({ name }) => {
+                var _a;
+                const index = cached.get(name);
+                return index === undefined || ((_a = recipient.attrs[index]) === null || _a === void 0 ? void 0 : _a.name) === name;
+            });
+        const recipientAttrsMap = isIndexed ? cached : new Map();
+        if (!isIndexed) {
+            for (let i = 0; i < recipient.attrs.length; i++) {
+                const attr = recipient.attrs[i];
+                // A sparse list is indexed again on every merge, as its size never matches its length.
+                if (attr !== undefined)
+                    recipientAttrsMap.set(attr.name, i);
+            }
+            attrListIndexes.set(recipient.attrs, recipientAttrsMap);
+        }
+        const adoptedFrom = recipient.attrs.length;
         for (let j = 0; j < attrs.length; j++) {
             if (!recipientAttrsMap.has(attrs[j].name)) {
                 recipient.attrs.push(attrs[j]);
             }
         }
+        for (let j = adoptedFrom; j < recipient.attrs.length; j++) {
+            recipientAttrsMap.set(recipient.attrs[j].name, j);
+        }
+        // A list with a repeated name is indexed again on the next merge.
+        if (recipientAttrsMap.size !== recipient.attrs.length) {
+            attrListIndexes.delete(recipient.attrs);
+        }
     },
     //Tree traversing
     getFirstChild(node) {

package/package.json

@@ -2,7 +2,7 @@
     "name": "parse5",
     "type": "module",
     "description": "HTML parser and serializer.",
-    "version": "8.1.0",
+    "version": "8.1.1",
     "author": "Ivan Nikulin <ifaaan@gmail.com> (https://github.com/inikulin)",
     "contributors": [
         "James Garbutt (https://github.com/43081j)",