parse5 8.0.1 → 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

@@ -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,21 +129,35 @@ 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;
+    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.
+     */
+    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;
     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;
@@ -152,19 +166,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;