@node-core/utils 7.2.1 → 7.2.2

package/node_modules/htmlparser2/src/Parser.ts

@@ -1,5 +1,6 @@
+const { fromCodePoint } = String;
+
 import Tokenizer, { type Callbacks, QuoteType } from "./Tokenizer.js";
-import { fromCodePoint } from "entities/decode";
 
 const formTags = new Set([
     "input",
@@ -11,6 +12,7 @@ const formTags = new Set([
     "textarea",
 ]);
 const pTag = new Set(["p"]);
+const headingTags = new Set(["h1", "h2", "h3", "h4", "h5", "h6", "p"]);
 const tableSectionTags = new Set(["thead", "tbody"]);
 const ddtTags = new Set(["dd", "dt"]);
 const rtpTags = new Set(["rt", "rp"]);
@@ -20,14 +22,15 @@ const openImpliesClose = new Map<string, Set<string>>([
     ["th", new Set(["th"])],
     ["td", new Set(["thead", "th", "td"])],
     ["body", new Set(["head", "link", "script"])],
+    ["a", new Set(["a"])],
     ["li", new Set(["li"])],
     ["p", pTag],
-    ["h1", pTag],
-    ["h2", pTag],
-    ["h3", pTag],
-    ["h4", pTag],
-    ["h5", pTag],
-    ["h6", pTag],
+    ["h1", headingTags],
+    ["h2", headingTags],
+    ["h3", headingTags],
+    ["h4", headingTags],
+    ["h5", headingTags],
+    ["h6", headingTags],
     ["select", formTags],
     ["input", formTags],
     ["output", formTags],
@@ -65,6 +68,8 @@ const openImpliesClose = new Map<string, Set<string>>([
     ["tfoot", tableSectionTags],
 ]);
 
+const DOCUMENT_TYPE = "doctype";
+
 const voidElements = new Set([
     "area",
     "base",
@@ -89,6 +94,12 @@ const voidElements = new Set([
 
 const foreignContextElements = new Set(["math", "svg"]);
 
+/**
+ * Elements that can be used to integrate HTML content within foreign namespaces (e.g., SVG or MathML).
+ *
+ * Entries must use the SVG-adjusted casing (e.g. "foreignObject" not
+ * "foreignobject") since they are compared against adjusted tag names.
+ */
 const htmlIntegrationElements = new Set([
     "mi",
     "mo",
@@ -96,39 +107,84 @@ const htmlIntegrationElements = new Set([
     "ms",
     "mtext",
     "annotation-xml",
-    "foreignobject",
+    "foreignObject",
     "desc",
     "title",
 ]);
 
+const svgTagNameAdjustments = new Map<string, string>([
+    ["altglyph", "altGlyph"],
+    ["altglyphdef", "altGlyphDef"],
+    ["altglyphitem", "altGlyphItem"],
+    ["animatecolor", "animateColor"],
+    ["animatemotion", "animateMotion"],
+    ["animatetransform", "animateTransform"],
+    ["clippath", "clipPath"],
+    ["feblend", "feBlend"],
+    ["fecolormatrix", "feColorMatrix"],
+    ["fecomponenttransfer", "feComponentTransfer"],
+    ["fecomposite", "feComposite"],
+    ["feconvolvematrix", "feConvolveMatrix"],
+    ["fediffuselighting", "feDiffuseLighting"],
+    ["fedisplacementmap", "feDisplacementMap"],
+    ["fedistantlight", "feDistantLight"],
+    ["fedropshadow", "feDropShadow"],
+    ["feflood", "feFlood"],
+    ["fefunca", "feFuncA"],
+    ["fefuncb", "feFuncB"],
+    ["fefuncg", "feFuncG"],
+    ["fefuncr", "feFuncR"],
+    ["fegaussianblur", "feGaussianBlur"],
+    ["feimage", "feImage"],
+    ["femerge", "feMerge"],
+    ["femergenode", "feMergeNode"],
+    ["femorphology", "feMorphology"],
+    ["feoffset", "feOffset"],
+    ["fepointlight", "fePointLight"],
+    ["fespecularlighting", "feSpecularLighting"],
+    ["fespotlight", "feSpotLight"],
+    ["fetile", "feTile"],
+    ["feturbulence", "feTurbulence"],
+    ["foreignobject", "foreignObject"],
+    ["glyphref", "glyphRef"],
+    ["lineargradient", "linearGradient"],
+    ["radialgradient", "radialGradient"],
+    ["textpath", "textPath"],
+]);
+
+const enum ForeignContext {
+    None,
+    Svg,
+    MathML,
+}
+
+/**
+ * Options for the streaming HTML/XML parser.
+ */
 export interface ParserOptions {
     /**
      * Indicates whether special tags (`<script>`, `<style>`, and `<title>`) should get special treatment
      * and if "empty" tags (eg. `<br>`) can have children.  If `false`, the content of special tags
      * will be text only. For feeds and other XML content (documents that don't consist of HTML),
      * set this to `true`.
-     *
      * @default false
      */
     xmlMode?: boolean;
 
     /**
      * Decode entities within the document.
-     *
      * @default true
      */
     decodeEntities?: boolean;
 
     /**
      * If set to true, all tags will be lowercased.
-     *
      * @default !xmlMode
      */
     lowerCaseTags?: boolean;
 
     /**
      * If set to `true`, all attribute names will be lowercased. This has noticeable impact on speed.
-     *
      * @default !xmlMode
      */
     lowerCaseAttributeNames?: boolean;
@@ -136,7 +192,6 @@ export interface ParserOptions {
     /**
      * If set to true, CDATA sections will be recognized as text even if the xmlMode option is not enabled.
      * NOTE: If xmlMode is set to `true` then CDATA sections will always be recognized as text.
-     *
      * @default xmlMode
      */
     recognizeCDATA?: boolean;
@@ -144,7 +199,6 @@ export interface ParserOptions {
     /**
      * If set to `true`, self-closing tags will trigger the onclosetag event even if xmlMode is not set to `true`.
      * NOTE: If xmlMode is set to `true` then self-closing tags will always be recognized.
-     *
      * @default xmlMode
      */
     recognizeSelfClosing?: boolean;
@@ -155,6 +209,9 @@ export interface ParserOptions {
     Tokenizer?: typeof Tokenizer;
 }
 
+/**
+ * Parser callback interface used by the tokenizer.
+ */
 export interface Handler {
     onparserinit(parser: Parser): void;
 
@@ -196,11 +253,14 @@ export interface Handler {
 
 const reNameEnd = /\s|\//;
 
+/**
+ * Incremental parser implementation.
+ */
 export class Parser implements Callbacks {
     /** The start index of the last event. */
-    public startIndex = 0;
+    startIndex = 0;
     /** The end index of the last event. */
-    public endIndex = 0;
+    endIndex = 0;
     /**
      * Store the start index of the current open tag,
      * so we can update the start index for attributes.
@@ -212,8 +272,7 @@ export class Parser implements Callbacks {
     private attribvalue = "";
     private attribs: null | { [key: string]: string } = null;
     private readonly stack: string[] = [];
-    /** Determines whether self-closing tags are recognized. */
-    private readonly foreignContext: boolean[];
+    private readonly foreignContext: ForeignContext[];
     private readonly cbs: Partial<Handler>;
     private readonly lowerCaseTagNames: boolean;
     private readonly lowerCaseAttributeNames: boolean;
@@ -244,13 +303,17 @@ export class Parser implements Callbacks {
             this.options,
             this,
         );
-        this.foreignContext = [!this.htmlMode];
+        this.foreignContext = [ForeignContext.None];
         this.cbs.onparserinit?.(this);
     }
 
     // Tokenizer event handlers
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     ontext(start: number, endIndex: number): void {
         const data = this.getSlice(start, endIndex);
         this.endIndex = endIndex - 1;
@@ -258,54 +321,116 @@ export class Parser implements Callbacks {
         this.startIndex = endIndex;
     }
 
-    /** @internal */
+    /**
+     * @param cp Current Unicode code point.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     ontextentity(cp: number, endIndex: number): void {
         this.endIndex = endIndex - 1;
         this.cbs.ontext?.(fromCodePoint(cp));
         this.startIndex = endIndex;
     }
 
+    /** @internal */
+    isInForeignContext(): boolean {
+        return this.foreignContext[0] !== ForeignContext.None;
+    }
+
     /**
      * Checks if the current tag is a void element. Override this if you want
      * to specify your own additional void elements.
+     * @param name Name of the pseudo selector.
      */
     protected isVoidElement(name: string): boolean {
         return this.htmlMode && voidElements.has(name);
     }
 
-    /** @internal */
-    onopentagname(start: number, endIndex: number): void {
-        this.endIndex = endIndex;
+    /**
+     * Read a tag name from the buffer.
+     *
+     * When `lowerCaseTagNames` is enabled (the default in HTML mode), the name
+     * is lowercased and may be adjusted for SVG casing or the `image` → `img`
+     * alias.
+     * @param start Start index of the tag name in the buffer.
+     * @param endIndex End index of the tag name in the buffer.
+     */
+    private readTagName(start: number, endIndex: number): string {
+        const name = this.lowerCaseTagNames
+            ? this.getSlice(start, endIndex).toLowerCase()
+            : this.getSlice(start, endIndex);
 
-        let name = this.getSlice(start, endIndex);
+        if (!(this.lowerCaseTagNames && this.htmlMode)) {
+            return name;
+        }
 
-        if (this.lowerCaseTagNames) {
-            name = name.toLowerCase();
+        if (this.foreignContext[0] === ForeignContext.Svg) {
+            return svgTagNameAdjustments.get(name) ?? name;
         }
 
-        this.emitOpenTag(name);
+        /*
+         * Closing tags for SVG elements inside HTML integration points
+         * (e.g. </foreignObject> while inside its own content) need case
+         * adjustment so the name matches what was pushed to the stack.
+         * `foreignContext.length > 1` means a foreign ancestor exists —
+         * the base [None] entry plus at least one pushed context.
+         */
+        if (this.foreignContext.length > 1) {
+            const adjusted = svgTagNameAdjustments.get(name);
+            if (adjusted !== undefined && this.stack.includes(adjusted)) {
+                return adjusted;
+            }
+        }
+
+        if (!this.isInForeignContext()) {
+            return name === "image" ? "img" : name;
+        }
+
+        return name;
+    }
+
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
+    onopentagname(start: number, endIndex: number): void {
+        this.endIndex = endIndex;
+        this.emitOpenTag(this.readTagName(start, endIndex));
     }
 
     private emitOpenTag(name: string) {
         this.openTagStart = this.startIndex;
         this.tagname = name;
 
+        /*
+         * The spec ignores a second <form> when one is already open.
+         * Setting tagname to "" suppresses all downstream effects: attribs
+         * stays null so endOpenTag is a no-op, and closeCurrentTag can't
+         * match "" on the stack.
+         */
+        if (this.htmlMode && name === "form" && this.stack.includes("form")) {
+            this.tagname = "";
+            return;
+        }
+
         const impliesClose = this.htmlMode && openImpliesClose.get(name);
 
         if (impliesClose) {
             while (this.stack.length > 0 && impliesClose.has(this.stack[0])) {
-                const element = this.stack.shift()!;
-                this.cbs.onclosetag?.(element, true);
+                this.popElement(true);
             }
         }
         if (!this.isVoidElement(name)) {
             this.stack.unshift(name);
 
             if (this.htmlMode) {
-                if (foreignContextElements.has(name)) {
-                    this.foreignContext.unshift(true);
+                if (name === "svg") {
+                    this.foreignContext.unshift(ForeignContext.Svg);
+                } else if (name === "math") {
+                    this.foreignContext.unshift(ForeignContext.MathML);
                 } else if (htmlIntegrationElements.has(name)) {
-                    this.foreignContext.unshift(false);
+                    this.foreignContext.unshift(ForeignContext.None);
                 }
             }
         }
@@ -327,7 +452,10 @@ export class Parser implements Callbacks {
         this.tagname = "";
     }
 
-    /** @internal */
+    /**
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     onopentagend(endIndex: number): void {
         this.endIndex = endIndex;
         this.endOpenTag(false);
@@ -336,32 +464,22 @@ export class Parser implements Callbacks {
         this.startIndex = endIndex + 1;
     }
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     onclosetag(start: number, endIndex: number): void {
         this.endIndex = endIndex;
-
-        let name = this.getSlice(start, endIndex);
-
-        if (this.lowerCaseTagNames) {
-            name = name.toLowerCase();
-        }
-
-        if (
-            this.htmlMode &&
-            (foreignContextElements.has(name) ||
-                htmlIntegrationElements.has(name))
-        ) {
-            this.foreignContext.shift();
-        }
+        const name = this.readTagName(start, endIndex);
 
         if (!this.isVoidElement(name)) {
             const pos = this.stack.indexOf(name);
             if (pos !== -1) {
-                for (let index = 0; index <= pos; index++) {
-                    const element = this.stack.shift()!;
-                    // We know the stack has sufficient elements.
-                    this.cbs.onclosetag?.(element, index !== pos);
+                for (let index = 0; index < pos; index++) {
+                    this.popElement(true);
                 }
+                this.popElement(false);
             } else if (this.htmlMode && name === "p") {
                 // Implicit open before close
                 this.emitOpenTag("p");
@@ -378,10 +496,13 @@ export class Parser implements Callbacks {
         this.startIndex = endIndex + 1;
     }
 
-    /** @internal */
+    /**
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     onselfclosingtag(endIndex: number): void {
         this.endIndex = endIndex;
-        if (this.recognizeSelfClosing || this.foreignContext[0]) {
+        if (this.recognizeSelfClosing || this.isInForeignContext()) {
             this.closeCurrentTag(false);
 
             // Set `startIndex` for next node
@@ -392,19 +513,39 @@ export class Parser implements Callbacks {
         }
     }
 
+    /**
+     * Pop the top element off the stack, emit a close event, and maintain
+     * the foreign context stack.
+     * @param implied Whether this close is implied (not from an explicit end tag).
+     */
+    private popElement(implied: boolean): void {
+        // biome-ignore lint/style/noNonNullAssertion: The element is guaranteed to exist.
+        const element = this.stack.shift()!;
+        if (
+            this.htmlMode &&
+            (foreignContextElements.has(element) ||
+                htmlIntegrationElements.has(element))
+        ) {
+            this.foreignContext.shift();
+        }
+        this.cbs.onclosetag?.(element, implied);
+    }
+
     private closeCurrentTag(isOpenImplied: boolean) {
         const name = this.tagname;
         this.endOpenTag(isOpenImplied);
 
         // Self-closing tags will be on the top of the stack
         if (this.stack[0] === name) {
-            // If the opening tag isn't implied, the closing tag has to be implied.
-            this.cbs.onclosetag?.(name, !isOpenImplied);
-            this.stack.shift();
+            this.popElement(!isOpenImplied);
         }
     }
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     onattribname(start: number, endIndex: number): void {
         this.startIndex = start;
         const name = this.getSlice(start, endIndex);
@@ -414,17 +555,28 @@ export class Parser implements Callbacks {
             : name;
     }
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     onattribdata(start: number, endIndex: number): void {
         this.attribvalue += this.getSlice(start, endIndex);
     }
 
-    /** @internal */
+    /**
+     * @param cp Current Unicode code point.
+     * @internal
+     */
     onattribentity(cp: number): void {
         this.attribvalue += fromCodePoint(cp);
     }
 
-    /** @internal */
+    /**
+     * @param quote Quote type used for the current attribute.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     onattribend(quote: QuoteType, endIndex: number): void {
         this.endIndex = endIndex;
 
@@ -440,10 +592,7 @@ export class Parser implements Callbacks {
                     : null,
         );
 
-        if (
-            this.attribs &&
-            !Object.prototype.hasOwnProperty.call(this.attribs, this.attribname)
-        ) {
+        if (this.attribs && !Object.hasOwn(this.attribs, this.attribname)) {
             this.attribs[this.attribname] = this.attribvalue;
         }
         this.attribvalue = "";
@@ -460,13 +609,25 @@ export class Parser implements Callbacks {
         return name;
     }
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     ondeclaration(start: number, endIndex: number): void {
         this.endIndex = endIndex;
         const value = this.getSlice(start, endIndex);
 
         if (this.cbs.onprocessinginstruction) {
-            const name = this.getInstructionName(value);
+            /*
+             * In HTML mode, ondeclaration is only reached for DOCTYPE
+             * (the tokenizer routes everything else to bogus comments).
+             */
+            const name = this.htmlMode
+                ? this.lowerCaseTagNames
+                    ? DOCUMENT_TYPE
+                    : value.slice(0, DOCUMENT_TYPE.length)
+                : this.getInstructionName(value);
             this.cbs.onprocessinginstruction(`!${name}`, `!${value}`);
         }
 
@@ -474,7 +635,11 @@ export class Parser implements Callbacks {
         this.startIndex = endIndex + 1;
     }
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @internal
+     */
     onprocessinginstruction(start: number, endIndex: number): void {
         this.endIndex = endIndex;
         const value = this.getSlice(start, endIndex);
@@ -488,7 +653,12 @@ export class Parser implements Callbacks {
         this.startIndex = endIndex + 1;
     }
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @param offset Offset applied when computing parser indices.
+     * @internal
+     */
     oncomment(start: number, endIndex: number, offset: number): void {
         this.endIndex = endIndex;
 
@@ -499,7 +669,12 @@ export class Parser implements Callbacks {
         this.startIndex = endIndex + 1;
     }
 
-    /** @internal */
+    /**
+     * @param start Start index for the current parser event.
+     * @param endIndex End index for the current parser event.
+     * @param offset Offset applied when computing parser indices.
+     * @internal
+     */
     oncdata(start: number, endIndex: number, offset: number): void {
         this.endIndex = endIndex;
         const value = this.getSlice(start, endIndex - offset);
@@ -508,6 +683,8 @@ export class Parser implements Callbacks {
             this.cbs.oncdatastart?.();
             this.cbs.ontext?.(value);
             this.cbs.oncdataend?.();
+        } else if (this.isInForeignContext()) {
+            this.cbs.ontext?.(value);
         } else {
             this.cbs.oncomment?.(`[CDATA[${value}]]`);
             this.cbs.oncommentend?.();
@@ -532,11 +709,12 @@ export class Parser implements Callbacks {
     /**
      * Resets the parser to a blank state, ready to parse a new HTML document
      */
-    public reset(): void {
+    reset(): void {
         this.cbs.onreset?.();
         this.tokenizer.reset();
         this.tagname = "";
         this.attribname = "";
+        this.attribvalue = "";
         this.attribs = null;
         this.stack.length = 0;
         this.startIndex = 0;
@@ -544,7 +722,7 @@ export class Parser implements Callbacks {
         this.cbs.onparserinit?.(this);
         this.buffers.length = 0;
         this.foreignContext.length = 0;
-        this.foreignContext.unshift(!this.htmlMode);
+        this.foreignContext.unshift(ForeignContext.None);
         this.bufferOffset = 0;
         this.writeIndex = 0;
         this.ended = false;
@@ -553,15 +731,18 @@ export class Parser implements Callbacks {
     /**
      * Resets the parser, then parses a complete document and
      * pushes it to the handler.
-     *
      * @param data Document to parse.
      */
-    public parseComplete(data: string): void {
+    parseComplete(data: string): void {
         this.reset();
         this.end(data);
     }
 
     private getSlice(start: number, end: number) {
+        if (start === end) {
+            return "";
+        }
+
         while (start - this.bufferOffset >= this.buffers[0].length) {
             this.shiftBuffer();
         }
@@ -587,10 +768,9 @@ export class Parser implements Callbacks {
 
     /**
      * Parses a chunk of data and calls the corresponding callbacks.
-     *
      * @param chunk Chunk to parse.
      */
-    public write(chunk: string): void {
+    write(chunk: string): void {
         if (this.ended) {
             this.cbs.onerror?.(new Error(".write() after done!"));
             return;
@@ -605,10 +785,9 @@ export class Parser implements Callbacks {
 
     /**
      * Parses the end of the buffer and clears the stack, calls onend.
-     *
      * @param chunk Optional final chunk to parse.
      */
-    public end(chunk?: string): void {
+    end(chunk?: string): void {
         if (this.ended) {
             this.cbs.onerror?.(new Error(".end() after done!"));
             return;
@@ -622,14 +801,14 @@ export class Parser implements Callbacks {
     /**
      * Pauses parsing. The parser won't emit events until `resume` is called.
      */
-    public pause(): void {
+    pause(): void {
         this.tokenizer.pause();
     }
 
     /**
      * Resumes parsing after `pause` was called.
      */
-    public resume(): void {
+    resume(): void {
         this.tokenizer.resume();
 
         while (
@@ -641,23 +820,4 @@ export class Parser implements Callbacks {
 
         if (this.ended) this.tokenizer.end();
     }
-
-    /**
-     * Alias of `write`, for backwards compatibility.
-     *
-     * @param chunk Chunk to parse.
-     * @deprecated
-     */
-    public parseChunk(chunk: string): void {
-        this.write(chunk);
-    }
-    /**
-     * Alias of `end`, for backwards compatibility.
-     *
-     * @param chunk Optional final chunk to parse.
-     * @deprecated
-     */
-    public done(chunk?: string): void {
-        this.end(chunk);
-    }
 }