parse5-sax-parser 7.0.0 → 8.0.1

package/README.md

@@ -16,9 +16,25 @@
 <br>
 
 <p align="center">
-  📖 <a href="https://parse5.js.org/modules/parse5_sax_parser.html"><b>Documentation</b></a> 📖
+  📖 <a href="https://parse5.js.org/modules/parse5-sax-parser.html"><b>Documentation</b></a> 📖
 </p>
 
+## Usage
+
+Handle HTML tokens as they arrive, without building a document tree.
+
+```js
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { SAXParser } from 'parse5-sax-parser';
+
+const parser = new SAXParser();
+const text = [];
+parser.on('text', (token) => text.push(token.text));
+await pipeline(Readable.from(['<p>Hello, <b>world!</b></p>']), parser);
+console.log(text.join('')); // Hello, world!
+```
+
 ---
 
 <p align="center">

package/dist/dev-null-stream.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="node" />
 import { Writable } from 'node:stream';
 export declare class DevNullStream extends Writable {
     _write(_chunk: string, _encoding: string, cb: () => void): void;
 }
-//# sourceMappingURL=dev-null-stream.d.ts.map

package/dist/dev-null-stream.js

@@ -4,4 +4,3 @@ export class DevNullStream extends Writable {
         cb();
     }
 }
-//# sourceMappingURL=dev-null-stream.js.map

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Transform } from 'node:stream';
 import type { Tokenizer, TokenHandler, Token } from 'parse5';
 import { ParserFeedbackSimulator } from './parser-feedback-simulator.js';
@@ -39,6 +38,7 @@ export interface SAXParserOptions {
  */
 export declare class SAXParser extends Transform implements TokenHandler {
     protected options: SAXParserOptions;
+    /** @internal */
     protected parserFeedbackSimulator: ParserFeedbackSimulator;
     private pendingText;
     private lastChunkWritten;
@@ -151,4 +151,3 @@ export interface SAXParser {
      */
     on(event: string, handler: (...args: any[]) => void): this;
 }
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -95,11 +95,17 @@ export class SAXParser extends Transform {
     _transformChunk(chunk) {
         if (!this.stopped) {
             this.tokenizer.write(chunk, this.lastChunkWritten);
+            this.tokenizer.flushCurrentCharacterToken();
         }
         return chunk;
     }
     /** @internal */
     onCharacter({ chars, location }) {
+        // After a chunk-boundary flush the tokenizer continues with an empty text token, which arrives here without
+        // characters. It is dropped unless its source range covers something (CDATA delimiters, a tag dropped at
+        // EOF), which the rewriting stream still has to forward.
+        if (chars.length === 0 && (!location || location.startOffset === location.endOffset))
+            return;
         if (this.pendingText === null) {
             this.pendingText = { text: chars, sourceCodeLocation: location };
         }
@@ -189,4 +195,3 @@ export class SAXParser extends Transform {
         }
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/parser-feedback-simulator.d.ts

@@ -5,6 +5,13 @@ import { Tokenizer, type TokenizerOptions, type TokenHandler, Token } from 'pars
 export declare class ParserFeedbackSimulator implements TokenHandler {
     private handler;
     private namespaceStack;
+    /** The name of the tag that opened each namespace frame, lowercase as in end tags; its end tag closes the frame. */
+    private frameTags;
+    /**
+     * Above 0 while the current node is the element that opened the last frame; each further count is a frame below
+     * whose element is the parent of the next frame's, so the current node stays known as the frames close.
+     */
+    private directFrames;
     inForeignContent: boolean;
     skipNextNewLine: boolean;
     tokenizer: Tokenizer;
@@ -29,4 +36,3 @@ export declare class ParserFeedbackSimulator implements TokenHandler {
     /** @internal */
     onEndTag(token: Token.TagToken): void;
 }
-//# sourceMappingURL=parser-feedback-simulator.d.ts.map

package/dist/parser-feedback-simulator.js

@@ -9,10 +9,17 @@ export class ParserFeedbackSimulator {
     constructor(options, handler) {
         this.handler = handler;
         this.namespaceStack = [];
+        /** The name of the tag that opened each namespace frame, lowercase as in end tags; its end tag closes the frame. */
+        this.frameTags = [];
+        /**
+         * Above 0 while the current node is the element that opened the last frame; each further count is a frame below
+         * whose element is the parent of the next frame's, so the current node stays known as the frames close.
+         */
+        this.directFrames = 0;
         this.inForeignContent = false;
         this.skipNextNewLine = false;
         this.tokenizer = new Tokenizer(options, this);
-        this._enterNamespace(html.NS.HTML);
+        this._enterNamespace(html.NS.HTML, '');
     }
     /** @internal */
     onNullCharacter(token) {
@@ -30,8 +37,9 @@ export class ParserFeedbackSimulator {
     }
     /** @internal */
     onWhitespaceCharacter(token) {
-        if (this.skipNextNewLine && token.chars.charCodeAt(0) === LINE_FEED_CODE_POINT) {
-            this.skipNextNewLine = false;
+        const { skipNextNewLine } = this;
+        this.skipNextNewLine = false;
+        if (skipNextNewLine && token.chars.charCodeAt(0) === LINE_FEED_CODE_POINT) {
             if (token.chars.length === 1) {
                 return;
             }
@@ -60,14 +68,19 @@ export class ParserFeedbackSimulator {
         this.handler.onEof(token);
     }
     //Namespace stack mutations
-    _enterNamespace(namespace) {
-        this.namespaceStack.unshift(namespace);
+    _enterNamespace(namespace, tagName) {
+        this.namespaceStack.push(namespace);
+        this.frameTags.push(tagName);
+        this.directFrames++;
         this.inForeignContent = namespace !== html.NS.HTML;
         this.tokenizer.inForeignNode = this.inForeignContent;
     }
     _leaveCurrentNamespace() {
-        this.namespaceStack.shift();
-        this.inForeignContent = this.namespaceStack[0] !== html.NS.HTML;
+        this.namespaceStack.pop();
+        this.frameTags.pop();
+        if (this.directFrames > 0)
+            this.directFrames--;
+        this.inForeignContent = this.namespaceStack[this.namespaceStack.length - 1] !== html.NS.HTML;
         this.tokenizer.inForeignNode = this.inForeignContent;
     }
     //Token handlers
@@ -102,13 +115,31 @@ export class ParserFeedbackSimulator {
     /** @internal */
     onStartTag(token) {
         let tn = token.tagID;
+        const frames = this.namespaceStack.length;
+        const ns = this.namespaceStack[frames - 1];
         switch (tn) {
-            case $.SVG: {
-                this._enterNamespace(html.NS.SVG);
+            case $.SVG:
+            case $.MATH: {
+                const target = tn === $.SVG ? html.NS.SVG : html.NS.MATHML;
+                // Foreign content keeps these in its namespace, except svg in annotation-xml. Unless the current node is
+                // the frame's element, it may be annotation-xml or outside the frame: switch, as a guess nothing builds on.
+                if (ns === html.NS.HTML || ns === target) {
+                    this._enterNamespace(target, token.tagName);
+                }
+                else if (this.directFrames === 0) {
+                    this._enterNamespace(target, token.tagName);
+                    this.directFrames = 0;
+                }
                 break;
             }
-            case $.MATH: {
-                this._enterNamespace(html.NS.MATHML);
+            case $.MGLYPH:
+            case $.MALIGNMARK: {
+                // A MathML text integration point keeps these children in MathML.
+                if (this.directFrames > 0 &&
+                    this.namespaceStack[frames - 2] === html.NS.MATHML &&
+                    foreignContent.isIntegrationPoint(html.getTagID(this.frameTags[frames - 1]), html.NS.MATHML, [], html.NS.MATHML)) {
+                    this._enterNamespace(html.NS.MATHML, token.tagName);
+                }
                 break;
             }
             default:
@@ -116,10 +147,14 @@ export class ParserFeedbackSimulator {
         }
         if (this.inForeignContent) {
             if (foreignContent.causesExit(token)) {
-                this._leaveCurrentNamespace();
+                // Tree construction pops foreign elements up to an HTML element or integration point.
+                while (this.inForeignContent)
+                    this._leaveCurrentNamespace();
+                this.directFrames = 0;
             }
             else {
-                const currentNs = this.namespaceStack[0];
+                const { tagName } = token;
+                const currentNs = this.namespaceStack[this.namespaceStack.length - 1];
                 if (currentNs === html.NS.MATHML) {
                     foreignContent.adjustTokenMathMLAttrs(token);
                 }
@@ -129,12 +164,25 @@ export class ParserFeedbackSimulator {
                 }
                 foreignContent.adjustTokenXMLAttrs(token);
                 tn = token.tagID;
-                if (!token.selfClosing && foreignContent.isIntegrationPoint(tn, currentNs, token.attrs)) {
-                    this._enterNamespace(html.NS.HTML);
+                // Unless the switch above opened a frame for it, the element is an integration point or a new current node.
+                if (!token.selfClosing && this.namespaceStack.length === frames) {
+                    if (foreignContent.isIntegrationPoint(tn, currentNs, token.attrs)) {
+                        this._enterNamespace(html.NS.HTML, tagName);
+                    }
+                    else {
+                        this.directFrames = 0;
+                    }
                 }
             }
         }
         else {
+            // An HTML element named like the integration point closes before it does, so it gets a frame of its own.
+            if (token.tagName === this.frameTags[frames - 1]) {
+                this._enterNamespace(html.NS.HTML, token.tagName);
+            }
+            else {
+                this.directFrames = 0;
+            }
             switch (tn) {
                 case $.PRE:
                 case $.TEXTAREA:
@@ -152,33 +200,50 @@ export class ParserFeedbackSimulator {
             }
             this._ensureTokenizerMode(tn);
         }
+        // Tree construction pops a self-closing foreign element at once, so a frame it opened ends with the tag.
+        if (token.selfClosing && this.inForeignContent && this.namespaceStack.length > frames) {
+            this._leaveCurrentNamespace();
+        }
         this.handler.onStartTag(token);
     }
     /** @internal */
     onEndTag(token) {
-        let tn = token.tagID;
+        const tn = token.tagID;
+        const frames = this.frameTags.length;
         if (!this.inForeignContent) {
-            const previousNs = this.namespaceStack[1];
-            if (previousNs === html.NS.SVG) {
-                const adjustedTagName = foreignContent.SVG_TAG_NAMES_ADJUSTMENT_MAP.get(token.tagName);
-                if (adjustedTagName) {
-                    tn = html.getTagID(adjustedTagName);
-                }
-            }
-            //NOTE: check for exit from integration point
-            if (foreignContent.isIntegrationPoint(tn, previousNs, token.attrs)) {
+            // Leaving an integration point: only the end tag of the element that opened the HTML frame closes it.
+            if (token.tagName === this.frameTags[frames - 1]) {
                 this._leaveCurrentNamespace();
             }
+            else {
+                this.directFrames = 0;
+            }
         }
-        else if ((tn === $.SVG && this.namespaceStack[0] === html.NS.SVG) ||
-            (tn === $.MATH && this.namespaceStack[0] === html.NS.MATHML)) {
-            this._leaveCurrentNamespace();
+        else if (tn === $.P || tn === $.BR) {
+            // These end tags leave foreign content, as the start tags of `causesExit` do.
+            while (this.inForeignContent)
+                this._leaveCurrentNamespace();
+        }
+        else {
+            // The frame's own end tag closes it; an mglyph or malignmark frame sits directly in its text integration
+            // point, a MathML element, so the end tags of that element and of the next frame's below close it too.
+            const tag = this.frameTags[frames - 1];
+            const last = tag === html.TAG_NAMES.MGLYPH || tag === html.TAG_NAMES.MALIGNMARK ? frames - 3 : frames - 1;
+            let i = frames - 1;
+            while (i >= last && token.tagName !== this.frameTags[i])
+                i--;
+            if (i >= last) {
+                while (this.frameTags.length > i)
+                    this._leaveCurrentNamespace();
+            }
+            else {
+                this.directFrames = 0;
+            }
         }
         // NOTE: adjust end tag name as well for consistency
-        if (this.namespaceStack[0] === html.NS.SVG) {
+        if (this.namespaceStack[this.namespaceStack.length - 1] === html.NS.SVG) {
             foreignContent.adjustTokenSVGTagName(token);
         }
         this.handler.onEndTag(token);
     }
 }
-//# sourceMappingURL=parser-feedback-simulator.js.map

package/package.json

@@ -2,10 +2,15 @@
     "name": "parse5-sax-parser",
     "type": "module",
     "description": "Streaming SAX-style HTML parser.",
-    "version": "7.0.0",
+    "version": "8.0.1",
     "author": "Ivan Nikulin <ifaaan@gmail.com> (https://github.com/inikulin)",
-    "contributors": "https://github.com/inikulin/parse5/graphs/contributors",
-    "homepage": "https://github.com/inikulin/parse5",
+    "contributors": [
+        "James Garbutt (https://github.com/43081j)",
+        "Felix Boehm (https://github.com/fb55)",
+        "Ivan Nikulin (https://github.com/inikulin)",
+        "Titus (https://github.com/wooorm)"
+    ],
+    "homepage": "https://parse5.js.org",
     "funding": "https://github.com/inikulin/parse5?sponsor=1",
     "keywords": [
         "parse5",
@@ -18,16 +23,23 @@
     "main": "dist/index.js",
     "module": "dist/index.js",
     "types": "dist/index.d.ts",
-    "exports": "./dist/index.js",
+    "exports": {
+        ".": {
+            "default": "./dist/index.js"
+        }
+    },
     "dependencies": {
-        "parse5": "^7.0.0"
+        "parse5": "^8.1.1"
     },
     "repository": {
         "type": "git",
         "url": "git://github.com/inikulin/parse5.git"
     },
     "files": [
-        "dist",
-        "!*.map"
-    ]
+        "dist/**/*.js",
+        "dist/**/*.d.ts"
+    ],
+    "devDependencies": {
+        "parse5-test-utils": "1.0.0"
+    }
 }