parse5 8.0.1 → 8.1.1

package/README.md

@@ -19,6 +19,18 @@
   📖 <a href="https://parse5.js.org/modules/parse5.html"><b>Documentation</b></a> 📖
 </p>
 
+## Usage
+
+Parse HTML into a document tree and serialize it back to HTML.
+
+```js
+import { parse, serialize } from 'parse5';
+
+const document = parse('<p>Hello, world!</p>');
+console.log(serialize(document));
+// <html><head></head><body><p>Hello, world!</p></body></html>
+```
+
 ---
 
 <p align="center">

package/dist/common/foreign-content.d.ts

@@ -6,4 +6,4 @@ export declare function adjustTokenMathMLAttrs(token: TagToken): void;
 export declare function adjustTokenSVGAttrs(token: TagToken): void;
 export declare function adjustTokenXMLAttrs(token: TagToken): void;
 export declare function adjustTokenSVGTagName(token: TagToken): void;
-export declare function isIntegrationPoint(tn: $, ns: NS, attrs: Attribute[], foreignNS?: NS): boolean;
+export declare function isIntegrationPoint(tn: $, ns: NS, attrs: readonly Attribute[], foreignNS?: NS): boolean;

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/formatting-element-list.d.ts

@@ -1,29 +1,57 @@
 import type { TagToken } from '../common/token.js';
-import type { TreeAdapter, TreeAdapterTypeMap } from '../tree-adapters/interface.js';
+import type { TreeAdapterTypeMap } from '../tree-adapters/interface.js';
 export declare enum EntryType {
     Marker = 0,
     Element = 1
 }
-interface MarkerEntry {
+interface MarkerEntry<T extends TreeAdapterTypeMap> {
     type: EntryType.Marker;
+    older: Entry<T> | null;
+    newer: Entry<T> | null;
+    /** The index of the entries before this marker. */
+    outerIndex: RegionIndex<T> | null;
 }
-export interface ElementEntry<T extends TreeAdapterTypeMap> {
+/** The entries with one tag name after one marker are chained from a head, newest first. */
+interface SameTagLink<T extends TreeAdapterTypeMap> {
+    olderSameTag: ElementEntry<T> | null;
+}
+export interface ElementEntry<T extends TreeAdapterTypeMap> extends SameTagLink<T> {
     type: EntryType.Element;
     element: T['element'];
     token: TagToken;
+    older: Entry<T> | null;
+    newer: Entry<T> | null;
+    /** The entry's group of entries with the same tag name and attributes; null until indexed. */
+    ark: Ark<T> | null;
+    /** The next newer entry with the same tag name, or the chain's head; null until indexed. */
+    newerSameTag: SameTagLink<T> | null;
+}
+export type Entry<T extends TreeAdapterTypeMap> = MarkerEntry<T> | ElementEntry<T>;
+/** The entries after one marker with one tag name and attributes, oldest first, and their key in the region's arks. */
+interface Ark<T extends TreeAdapterTypeMap> {
+    entries: ElementEntry<T>[];
+    key: string;
+}
+/** The entries after one marker by tag name and attributes, and the newest of them by tag name. */
+interface RegionIndex<T extends TreeAdapterTypeMap> {
+    arks: Map<string, Ark<T>>;
+    tagNames: Map<string, SameTagLink<T>>;
 }
-export type Entry<T extends TreeAdapterTypeMap> = MarkerEntry | ElementEntry<T>;
 export declare class FormattingElementList<T extends TreeAdapterTypeMap> {
-    private treeAdapter;
-    entries: Entry<T>[];
+    newest: Entry<T> | null;
     bookmark: Entry<T> | null;
-    constructor(treeAdapter: TreeAdapter<T>);
-    private _getNoahArkConditionCandidates;
-    private _ensureNoahArkCondition;
+    /** The index of the entries after the last marker; null only while there are at most NOAH_ARK_CAPACITY of them. */
+    private index;
+    /** The entries by element, except possibly those after the last marker while they are not indexed. */
+    private elementEntries;
+    /** Returns the entry's ark, or null if the entries after the last marker are not indexed. */
+    private _insertElementEntry;
+    private _addToIndex;
     insertMarker(): void;
     pushElement(element: T['element'], token: TagToken): void;
     insertElementAfterBookmark(element: T['element'], token: TagToken): void;
-    removeEntry(entry: Entry<T>): void;
+    removeEntry(entry: ElementEntry<T>): void;
+    replaceElement(entry: ElementEntry<T>, element: T['element']): void;
     /**
      * Clears the list of formatting elements up to the last marker.
      *

package/dist/parser/formatting-element-list.js

@@ -5,85 +5,151 @@ export var EntryType;
     EntryType[EntryType["Marker"] = 0] = "Marker";
     EntryType[EntryType["Element"] = 1] = "Element";
 })(EntryType || (EntryType = {}));
-const MARKER = { type: EntryType.Marker };
 //List of formatting elements
 export class FormattingElementList {
-    constructor(treeAdapter) {
-        this.treeAdapter = treeAdapter;
-        this.entries = [];
+    constructor() {
+        this.newest = null;
         this.bookmark = null;
+        /** The index of the entries after the last marker; null only while there are at most NOAH_ARK_CAPACITY of them. */
+        this.index = null;
+        /** The entries by element, except possibly those after the last marker while they are not indexed. */
+        this.elementEntries = new Map();
     }
-    //Noah Ark's condition
-    //OPTIMIZATION: at first we try to find possible candidates for exclusion using
-    //lightweight heuristics without thorough attributes check.
-    _getNoahArkConditionCandidates(newElement, neAttrs) {
-        const candidates = [];
-        const neAttrsLength = neAttrs.length;
-        const neTagName = this.treeAdapter.getTagName(newElement);
-        const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);
-        for (let i = 0; i < this.entries.length; i++) {
-            const entry = this.entries[i];
-            if (entry.type === EntryType.Marker) {
-                break;
-            }
-            const { element } = entry;
-            if (this.treeAdapter.getTagName(element) === neTagName &&
-                this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) {
-                const elementAttrs = this.treeAdapter.getAttrList(element);
-                if (elementAttrs.length === neAttrsLength) {
-                    candidates.push({ idx: i, attrs: elementAttrs });
-                }
-            }
+    /** Returns the entry's ark, or null if the entries after the last marker are not indexed. */
+    _insertElementEntry(element, token, older) {
+        const newer = older === null ? null : older.newer;
+        const entry = {
+            type: EntryType.Element,
+            element,
+            token,
+            older,
+            newer,
+            ark: null,
+            olderSameTag: null,
+            newerSameTag: null,
+        };
+        if (newer === null) {
+            this.newest = entry;
         }
-        return candidates;
+        else {
+            newer.older = entry;
+        }
+        if (older !== null) {
+            older.newer = entry;
+        }
+        return this.index === null ? null : this._addToIndex(this.index, entry);
     }
-    _ensureNoahArkCondition(newElement) {
-        if (this.entries.length < NOAH_ARK_CAPACITY)
-            return;
-        const neAttrs = this.treeAdapter.getAttrList(newElement);
-        const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs);
-        if (candidates.length < NOAH_ARK_CAPACITY)
-            return;
-        //NOTE: build attrs map for the new element, so we can perform fast lookups
-        const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value]));
-        let validCandidates = 0;
-        //NOTE: remove bottommost candidates, until Noah's Ark condition will not be met
-        for (let i = 0; i < candidates.length; i++) {
-            const candidate = candidates[i];
-            // We know that `candidate.attrs.length === neAttrs.length`
-            if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) {
-                validCandidates += 1;
-                if (validCandidates >= NOAH_ARK_CAPACITY) {
-                    this.entries.splice(candidate.idx, 1);
-                }
-            }
+    _addToIndex(index, entry) {
+        const { tagName, attrs } = entry.token;
+        // Names are unique and the tokenizer replaces NUL, so the sorted pairs identify the attribute set.
+        // Sorting costs O(k log k) comparisons for a tag with k attributes.
+        const key = tagName +
+            attrs
+                .map(({ name, value }) => `\0${name}\0${value}`)
+                .sort()
+                .join('');
+        let ark = index.arks.get(key);
+        if (ark === undefined) {
+            ark = { entries: [], key };
+            index.arks.set(key, ark);
+        }
+        ark.entries.push(entry);
+        entry.ark = ark;
+        this.elementEntries.set(entry.element, entry);
+        let head = index.tagNames.get(tagName);
+        if (head === undefined) {
+            head = { olderSameTag: null };
+            index.tagNames.set(tagName, head);
+        }
+        entry.olderSameTag = head.olderSameTag;
+        entry.newerSameTag = head;
+        if (head.olderSameTag !== null) {
+            head.olderSameTag.newerSameTag = entry;
         }
+        head.olderSameTag = entry;
+        return ark;
     }
     //Mutations
     insertMarker() {
-        this.entries.unshift(MARKER);
+        if (this.index === null) {
+            for (let entry = this.newest; entry !== null && entry.type === EntryType.Element; entry = entry.older) {
+                this.elementEntries.set(entry.element, entry);
+            }
+        }
+        const marker = {
+            type: EntryType.Marker,
+            older: this.newest,
+            newer: null,
+            outerIndex: this.index,
+        };
+        if (this.newest !== null) {
+            this.newest.newer = marker;
+        }
+        this.newest = marker;
+        this.index = null;
     }
     pushElement(element, token) {
-        this._ensureNoahArkCondition(element);
-        this.entries.unshift({
-            type: EntryType.Element,
-            element,
-            token,
-        });
+        if (this.index === null) {
+            let oldest = null;
+            let count = 0;
+            for (let entry = this.newest; entry !== null && entry.type === EntryType.Element; entry = entry.older) {
+                oldest = entry;
+                count++;
+            }
+            if (count >= NOAH_ARK_CAPACITY) {
+                this.index = { arks: new Map(), tagNames: new Map() };
+                for (let entry = oldest; entry !== null && entry.type === EntryType.Element; entry = entry.newer) {
+                    this._addToIndex(this.index, entry);
+                }
+            }
+        }
+        const ark = this._insertElementEntry(element, token, this.newest);
+        if (ark !== null && ark.entries.length > NOAH_ARK_CAPACITY) {
+            this.removeEntry(ark.entries[0]);
+        }
     }
     insertElementAfterBookmark(element, token) {
-        const bookmarkIdx = this.entries.indexOf(this.bookmark);
-        this.entries.splice(bookmarkIdx, 0, {
-            type: EntryType.Element,
-            element,
-            token,
-        });
+        // Like the formatting element's entry that it replaces, this entry is the newest with its tag name. The bookmark
+        // is used once per adoption-agency step and released here, so it does not keep a cleared region reachable.
+        const { bookmark } = this;
+        this.bookmark = null;
+        this._insertElementEntry(element, token, bookmark);
     }
     removeEntry(entry) {
-        const entryIndex = this.entries.indexOf(entry);
-        if (entryIndex !== -1) {
-            this.entries.splice(entryIndex, 1);
+        var _a;
+        // An `a` start tag removes its entry even when the adoption agency already has, so skip unlinked entries.
+        if (entry.newer === null ? this.newest !== entry : entry.newer.older !== entry) {
+            return;
+        }
+        this.elementEntries.delete(entry.element);
+        if (entry.newer === null) {
+            this.newest = entry.older;
+        }
+        else {
+            entry.newer.older = entry.older;
+        }
+        if (entry.older !== null) {
+            entry.older.newer = entry.newer;
+        }
+        if (entry.ark !== null) {
+            const { entries, key } = entry.ark;
+            entries.splice(entries.indexOf(entry), 1);
+            // Entries are removed only after the last marker, so an emptied ark is dropped from the last region's index.
+            if (entries.length === 0)
+                (_a = this.index) === null || _a === void 0 ? void 0 : _a.arks.delete(key);
         }
+        if (entry.newerSameTag !== null) {
+            entry.newerSameTag.olderSameTag = entry.olderSameTag;
+            if (entry.olderSameTag !== null) {
+                entry.olderSameTag.newerSameTag = entry.newerSameTag;
+            }
+        }
+    }
+    replaceElement(entry, element) {
+        if (this.elementEntries.delete(entry.element)) {
+            this.elementEntries.set(element, entry);
+        }
+        entry.element = element;
     }
     /**
      * Clears the list of formatting elements up to the last marker.
@@ -91,20 +157,37 @@ export class FormattingElementList {
      * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
      */
     clearToLastMarker() {
-        const markerIdx = this.entries.indexOf(MARKER);
-        if (markerIdx === -1) {
-            this.entries.length = 0;
+        let marker = this.newest;
+        for (; marker !== null && marker.type === EntryType.Element; marker = marker.older) {
+            this.elementEntries.delete(marker.element);
         }
-        else {
-            this.entries.splice(0, markerIdx + 1);
+        this.newest = marker === null ? null : marker.older;
+        this.index = marker === null ? null : marker.outerIndex;
+        if (this.newest !== null) {
+            this.newest.newer = null;
         }
     }
     //Search
     getElementEntryInScopeWithTagName(tagName) {
-        const entry = this.entries.find((entry) => entry.type === EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName);
-        return entry && entry.type === EntryType.Element ? entry : null;
+        var _a, _b;
+        if (this.index !== null) {
+            return (_b = (_a = this.index.tagNames.get(tagName)) === null || _a === void 0 ? void 0 : _a.olderSameTag) !== null && _b !== void 0 ? _b : null;
+        }
+        for (let entry = this.newest; entry !== null && entry.type === EntryType.Element; entry = entry.older) {
+            if (entry.token.tagName === tagName) {
+                return entry;
+            }
+        }
+        return null;
     }
     getElementEntry(element) {
-        return this.entries.find((entry) => entry.type === EntryType.Element && entry.element === element);
+        if (this.index === null) {
+            for (let entry = this.newest; entry !== null && entry.type === EntryType.Element; entry = entry.older) {
+                if (entry.element === element) {
+                    return entry;
+                }
+            }
+        }
+        return this.elementEntries.get(element);
     }
 }

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
@@ -100,8 +104,7 @@ export declare class Parser<T extends TreeAdapterTypeMap> implements TokenHandle
     /** Indicates that the current node is not an element in the HTML namespace */
     protected currentNotInHTML: boolean;
     /**
-     * The template insertion mode stack is maintained from the left.
-     * Ie. the topmost element will always have index 0.
+     * The topmost template insertion mode is the last element.
      *
      * @internal
      */
@@ -134,7 +137,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.
@@ -160,6 +167,11 @@ export declare class Parser<T extends TreeAdapterTypeMap> implements TokenHandle
     protected shouldProcessStartTagTokenInForeignContent(token: TagToken): boolean;
     /** @protected */
     _processToken(token: Token): void;
+    /**
+     * Whether each open MathML `annotation-xml` element, or the fragment context, is an HTML integration point. The
+     * standard decides this by the element's start tag, so its attributes are read once; `onItemPop` drops the entry.
+     */
+    private annotationXmlIntegrationPoints;
     /** @protected */
     _isIntegrationPoint(tid: $, element: T['element'], foreignNS?: NS): boolean;
     /** @protected */
@@ -177,10 +189,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 */