parse5 8.0.1 → 8.1.1

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;
@@ -25,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

@@ -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;
@@ -59,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
@@ -79,14 +84,22 @@ 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()) {
-            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 - 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 > keep)
+                this._addGap();
         }
     }
     write(chunk, isLastChunk) {

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/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.1",
     "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"
+    }
 }