From d17bbd3fe648b62d40bd23c818e438884e37bf27 Mon Sep 17 00:00:00 2001
From: Felix <188768+fb55@users.noreply.github.com>
Date: Thu, 19 Mar 2026 21:20:24 +0000
Subject: [PATCH 1/6] fix: align HTML parsing with the spec
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Tokenizer:
- Treat <iframe>, <noembed>, <noframes> as raw-text tags
- Treat <plaintext> as a permanent raw-text tag
- Parse RCDATA entities in <textarea> (not just <title>)
- Treat <?…> and non-DOCTYPE <!…> as bogus comments in HTML
- Match DOCTYPE case-insensitively via DeclarationSequence state
- Handle <!>, <!-->, <!--->, <!-> as spec-compliant comments
- Treat </> as an ignored token, </ x> as a bogus comment
- Emit bogus comments (not text) for all EOF-in-markup states
- Treat unclosed CDATA in HTML as a bogus comment at EOF
- Skip special-tag detection inside foreign (SVG/MathML) content
- Honor recognizeSelfClosing for raw-text tags (<script/> etc.)

Parser:
- Adjust SVG tag names to spec casing (foreignObject, clipPath, …)
- Alias <image> to <img> outside foreign content
- Treat CDATA as text (not a comment) in foreign content
- Headings (h1–h6) implicitly close other headings
- <a> implicitly closes a previous <a>
- Ignore nested <form> when one is already open
---
 src/Parser.events.spec.ts                    |   64 ++
 src/Parser.spec.ts                           |   32 +
 src/Parser.ts                                |  164 ++-
 src/Tokenizer.spec.ts                        |   84 +-
 src/Tokenizer.ts                             |  566 +++++++---
 src/__snapshots__/Parser.events.spec.ts.snap | 1049 +++++++++++++++++-
 src/__snapshots__/Tokenizer.spec.ts.snap     |  544 +++++++--
 src/__snapshots__/index.spec.ts.snap         |   33 +-
 src/index.spec.ts                            |    5 +
 9 files changed, 2155 insertions(+), 386 deletions(-)

diff --git a/src/Parser.events.spec.ts b/src/Parser.events.spec.ts
index b8836d92..3679d7fa 100644
--- a/src/Parser.events.spec.ts
+++ b/src/Parser.events.spec.ts
@@ -80,6 +80,12 @@ describe("Events", () => {
     it("end slash: non-void element ending with />, recognizeSelfClosing=true", () =>
         runTest("<xx / ><p>Hold the line.", { recognizeSelfClosing: true }));
 
+    it("end slash: special tag ending with />, recognizeSelfClosing=true", () =>
+        runTest("<script/><b>x</b>", { recognizeSelfClosing: true }));
+
+    it("end slash: plaintext tag ending with />, recognizeSelfClosing=true", () =>
+        runTest("<plaintext/><b>x</b>", { recognizeSelfClosing: true }));
+
     it("end slash: as part of attrib value of void element", () =>
         runTest("<img src=gif.com/123/><p>Hold the line."));
 
@@ -162,6 +168,60 @@ describe("Events", () => {
 
     it("Comment false ending", () => runTest("<!-- a-b-> -->"));
 
+    it("Short bang comment", () => runTest("<!--!>"));
+
+    it("Abruptly closed comment", () => runTest("<!--->text"));
+
+    it("Empty EOF comment", () => runTest("<!--"));
+
+    it("HTML bogus comments", () => runTest("<?foo><!foo>"));
+
+    it("Short HTML bogus comments", () => runTest("<!><!->"));
+
+    it("Bogus comment after </ and whitespace", () => runTest("<div></ div>"));
+
+    it("Empty closing tag", () => runTest("</>"));
+
+    it("Empty closing tag, xmlMode=true", () =>
+        runTest("</>", { xmlMode: true }));
+
+    it("Doctype without whitespace", () => runTest("<!DOCTYPEhtml>"));
+
+    it("Foreign CDATA in SVG", () => runTest("<svg><![CDATA[a<b]]></svg>"));
+
+    it("Foreign CDATA in MathML", () =>
+        runTest("<math><![CDATA[a<b]]></math>"));
+
+    it("SVG title is not HTML special", () =>
+        runTest("<svg><title>&amp;<b>x</b></title></svg>"));
+
+    it("SVG tag case adjustment", () =>
+        runTest("<svg><foreignObject><b>x</b></foreignObject></svg>"));
+
+    it("HTML image alias", () => runTest("<image></image>"));
+
+    it("SVG image is not aliased", () => runTest("<svg><image></image></svg>"));
+
+    it("EOF bogus comments", () => runTest("<!-"));
+
+    it("EOF empty bogus comment", () => runTest("<!"));
+
+    it("EOF partial doctype", () => runTest("<!DOC"));
+
+    it("EOF complete doctype", () => runTest("<!DOCTYPE"));
+
+    it("EOF incomplete doctype", () => runTest("<!DOCTYPE h"));
+
+    it("EOF processing instruction", () => runTest("<?"));
+
+    it("Partial CDATA match with >", () => runTest("<![CD>"));
+
+    it("Unclosed CDATA at EOF", () => runTest("<![CDATA[foo"));
+
+    it("Empty unclosed CDATA at EOF", () => runTest("<![CDATA["));
+
+    it("Partial CDATA at EOF", () => runTest("<![C"));
+
     it("Scripts ending with <", () => runTest("<script><</script>"));
 
     it("Special end tags ending with /> in script", () =>
@@ -191,9 +251,13 @@ describe("Events", () => {
 
     it("entity in title (#592)", () => runTest("<title>the &quot;title&quot"));
 
+    it("entity in textarea", () => runTest("<textarea>&amp;</textarea>"));
+
     it("entity in title - decodeEntities=false (#592)", () =>
         runTest("<title>the &quot;title&quot;", { decodeEntities: false }));
 
+    it("plaintext", () => runTest("<plaintext><b>hi</b>"));
+
     it("</title> in <script> (#745)", () =>
         runTest("<script>'</title>'</script>"));
 
diff --git a/src/Parser.spec.ts b/src/Parser.spec.ts
index 2d24dc3d..fe3fb89b 100644
--- a/src/Parser.spec.ts
+++ b/src/Parser.spec.ts
@@ -110,6 +110,38 @@ describe("API", () => {
         expect(onclosetag).toHaveBeenNthCalledWith(2, "hr", 9);
     });
 
+    it("should preserve declaration names outside of HTML mode", () => {
+        const onprocessinginstruction = vi.fn();
+
+        new Parser(
+            {
+                onprocessinginstruction,
+            },
+            { xmlMode: true },
+        ).end("<!DOCTYPEhtml>");
+
+        expect(onprocessinginstruction).toHaveBeenCalledWith(
+            "!DOCTYPEhtml",
+            "!DOCTYPEhtml",
+        );
+    });
+
+    it("should preserve declaration casing when lowerCaseTags is disabled", () => {
+        const onprocessinginstruction = vi.fn();
+
+        new Parser(
+            {
+                onprocessinginstruction,
+            },
+            { lowerCaseTags: false },
+        ).end("<!DOCTYPEhtml>");
+
+        expect(onprocessinginstruction).toHaveBeenCalledWith(
+            "!DOCTYPE",
+            "!DOCTYPEhtml",
+        );
+    });
+
     it("should update the position when a single tag is spread across multiple chunks", () => {
         let called = false;
         const p = new Parser({
diff --git a/src/Parser.ts b/src/Parser.ts
index 0b33680d..1aa0f026 100644
--- a/src/Parser.ts
+++ b/src/Parser.ts
@@ -12,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"]);
@@ -21,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],
@@ -66,6 +68,8 @@ const openImpliesClose = new Map<string, Set<string>>([
     ["tfoot", tableSectionTags],
 ]);
 
+const DOCUMENT_TYPE = "doctype";
+
 const voidElements = new Set([
     "area",
     "base",
@@ -97,11 +101,57 @@ 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.
  */
@@ -216,8 +266,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;
@@ -248,7 +297,7 @@ export class Parser implements Callbacks {
             this.options,
             this,
         );
-        this.foreignContext = [!this.htmlMode];
+        this.foreignContext = [ForeignContext.None];
         this.cbs.onparserinit?.(this);
     }
 
@@ -277,6 +326,11 @@ export class Parser implements Callbacks {
         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.
@@ -286,6 +340,46 @@ export class Parser implements Callbacks {
         return this.htmlMode && voidElements.has(name);
     }
 
+    /**
+     * 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);
+
+        if (!(this.lowerCaseTagNames && this.htmlMode)) {
+            return name;
+        }
+
+        if (!this.isInForeignContext()) {
+            return name === "image" ? "img" : name;
+        }
+
+        if (this.foreignContext[0] === ForeignContext.Svg) {
+            return svgTagNameAdjustments.get(name) ?? name;
+        }
+
+        /*
+         * Closing tags for SVG elements inside HTML integration points
+         * (e.g. </foreignObject>) still need case adjustment.
+         */
+        if (this.foreignContext.length > 1) {
+            const adjusted = svgTagNameAdjustments.get(name);
+            if (adjusted !== undefined && adjusted === this.stack[0]) {
+                return adjusted;
+            }
+        }
+
+        return name;
+    }
+
     /**
      * @param start Start index for the current parser event.
      * @param endIndex End index for the current parser event.
@@ -293,20 +387,19 @@ export class Parser implements Callbacks {
      */
     onopentagname(start: number, endIndex: number): void {
         this.endIndex = endIndex;
-
-        let name = this.getSlice(start, endIndex);
-
-        if (this.lowerCaseTagNames) {
-            name = name.toLowerCase();
-        }
-
-        this.emitOpenTag(name);
+        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.
+        if (this.htmlMode && name === "form" && this.stack.includes("form")) {
+            this.tagname = "";
+            return;
+        }
+
         const impliesClose = this.htmlMode && openImpliesClose.get(name);
 
         if (impliesClose) {
@@ -322,10 +415,12 @@ export class Parser implements Callbacks {
             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);
                 }
             }
         }
@@ -366,12 +461,7 @@ export class Parser implements Callbacks {
      */
     onclosetag(start: number, endIndex: number): void {
         this.endIndex = endIndex;
-
-        let name = this.getSlice(start, endIndex);
-
-        if (this.lowerCaseTagNames) {
-            name = name.toLowerCase();
-        }
+        const name = this.readTagName(start, endIndex);
 
         if (
             this.htmlMode &&
@@ -413,7 +503,7 @@ export class Parser implements Callbacks {
      */
     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
@@ -514,7 +604,15 @@ export class Parser implements Callbacks {
         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}`);
         }
 
@@ -570,6 +668,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?.();
@@ -606,7 +706,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;
@@ -623,6 +723,10 @@ export class Parser implements Callbacks {
     }
 
     private getSlice(start: number, end: number) {
+        if (start === end) {
+            return "";
+        }
+
         while (start - this.bufferOffset >= this.buffers[0].length) {
             this.shiftBuffer();
         }
diff --git a/src/Tokenizer.spec.ts b/src/Tokenizer.spec.ts
index 6a1792e1..c60b8c5d 100644
--- a/src/Tokenizer.spec.ts
+++ b/src/Tokenizer.spec.ts
@@ -10,9 +10,12 @@ function tokenize(
     const tokenizer = new Tokenizer(
         options,
         new Proxy(
-            {},
+            { isInForeignContext: () => false },
             {
-                get(_, property) {
+                get(target, property) {
+                    if (property === "isInForeignContext") {
+                        return target.isInForeignContext;
+                    }
                     return (...values: unknown[]) =>
                         log.push([property, ...values]);
                 },
@@ -31,7 +34,7 @@ function tokenize(
 }
 
 describe("Tokenizer", () => {
-    describe("should support self-closing special tags", () => {
+    describe("should ignore self-closing slash in text-only HTML tags", () => {
         it("for self-closing script tag", () => {
             expect(tokenize("<script /><div></div>")).toMatchSnapshot();
         });
@@ -47,6 +50,18 @@ describe("Tokenizer", () => {
         it("for self-closing xmp tag", () => {
             expect(tokenize("<xmp /><div></div>")).toMatchSnapshot();
         });
+        it("for self-closing plaintext tag", () => {
+            expect(tokenize("<plaintext /><div></div>")).toMatchSnapshot();
+        });
+        it("for self-closing iframe tag", () => {
+            expect(tokenize("<iframe /><div></div>")).toMatchSnapshot();
+        });
+        it("for self-closing noembed tag", () => {
+            expect(tokenize("<noembed /><div></div>")).toMatchSnapshot();
+        });
+        it("for self-closing noframes tag", () => {
+            expect(tokenize("<noframes /><div></div>")).toMatchSnapshot();
+        });
     });
 
     describe("should support standard special tags", () => {
@@ -89,6 +104,24 @@ describe("Tokenizer", () => {
         });
     });
 
+    describe("should treat html inside raw-text tags as text", () => {
+        it("for div inside iframe tag", () => {
+            expect(
+                tokenize("<iframe>&amp;<div></div></iframe>"),
+            ).toMatchSnapshot();
+        });
+        it("for div inside noembed tag", () => {
+            expect(
+                tokenize("<noembed>&amp;<div></div></noembed>"),
+            ).toMatchSnapshot();
+        });
+        it("for div inside noframes tag", () => {
+            expect(
+                tokenize("<noframes>&amp;<div></div></noframes>"),
+            ).toMatchSnapshot();
+        });
+    });
+
     describe("should close special tags on end tags ending with />", () => {
         it("for script tag", () => {
             expect(tokenize("<script>safe</script/><img>")).toMatchSnapshot();
@@ -128,6 +161,13 @@ describe("Tokenizer", () => {
         it("for self-closing special tag", () => {
             expect(tokenize("<style />&apos;<br/>")).toMatchSnapshot();
         });
+        it("for recognized self-closing special tag", () => {
+            expect(
+                tokenize("<style />&apos;<br/>", {
+                    recognizeSelfClosing: true,
+                }),
+            ).toMatchSnapshot();
+        });
     });
 
     describe("should handle entities", () => {
@@ -158,6 +198,37 @@ describe("Tokenizer", () => {
         ).toMatchSnapshot();
     });
 
+    it("should handle abruptly closed comments", () => {
+        expect(tokenize("<!--->text")).toMatchSnapshot();
+    });
+
+    it.each(["<!>", "<!->"])("should treat %s as a bogus comment", (input) => {
+        expect(tokenize(input)).toMatchSnapshot();
+    });
+
+    it.each([
+        "<!--",
+        "<!---",
+        "<!----",
+        "<!--a-",
+        "<!--a--",
+        "<!--a--!",
+    ])("should trim unfinished HTML comment closes at EOF for %s", (input) => {
+        expect(tokenize(input)).toMatchSnapshot();
+    });
+
+    it("should treat <? and <! as bogus comments in HTML", () => {
+        expect(tokenize("<?foo><!foo>")).toMatchSnapshot();
+    });
+
+    it("should ignore empty closing tags", () => {
+        expect(tokenize("</>")).toMatchSnapshot();
+    });
+
+    it("should treat <!DOCTYPEhtml> as a declaration", () => {
+        expect(tokenize("<!DOCTYPEhtml>")).toMatchSnapshot();
+    });
+
     it("should not treat <!-->  as a complete comment in xmlMode", () => {
         expect(
             tokenize(
@@ -202,9 +273,12 @@ describe("Tokenizer", () => {
         const tokenizer = new Tokenizer(
             {},
             new Proxy(
-                {},
+                { isInForeignContext: () => false },
                 {
-                    get(_, property) {
+                    get(target, property) {
+                        if (property === "isInForeignContext") {
+                            return target.isInForeignContext;
+                        }
                         return (...values: unknown[]) => {
                             if (property === "ontext") {
                                 tokenizer.pause();
diff --git a/src/Tokenizer.ts b/src/Tokenizer.ts
index 83028a03..76d68f92 100644
--- a/src/Tokenizer.ts
+++ b/src/Tokenizer.ts
@@ -64,14 +64,14 @@ const enum State {
     // Comments & CDATA
     BeforeComment,
     CDATASequence,
+    DeclarationSequence,
     InSpecialComment,
     InCommentLike,
 
     // Special tags
-    BeforeSpecialS, // Decide if we deal with `<script` or `<style`
-    BeforeSpecialT, // Decide if we deal with `<title` or `<textarea`
     SpecialStartSequence,
     InSpecialTag,
+    InPlainText,
 
     InEntity,
 }
@@ -126,6 +126,7 @@ export interface Callbacks {
     onselfclosingtag(endIndex: number): void;
     ontext(start: number, endIndex: number): void;
     ontextentity(codepoint: number, endIndex: number): void;
+    isInForeignContext?(): boolean;
 }
 
 /**
@@ -139,6 +140,17 @@ const Sequences = {
     Cdata: new Uint8Array([0x43, 0x44, 0x41, 0x54, 0x41, 0x5b]), // CDATA[
     CdataEnd: new Uint8Array([0x5d, 0x5d, 0x3e]), // ]]>
     CommentEnd: new Uint8Array([0x2d, 0x2d, 0x21, 0x3e]), // `--!>`
+    Doctype: new Uint8Array([0x64, 0x6f, 0x63, 0x74, 0x79, 0x70, 0x65]), // `doctype`
+    IframeEnd: new Uint8Array([0x3c, 0x2f, 0x69, 0x66, 0x72, 0x61, 0x6d, 0x65]), // `</iframe`
+    NoembedEnd: new Uint8Array([
+        0x3c, 0x2f, 0x6e, 0x6f, 0x65, 0x6d, 0x62, 0x65, 0x64,
+    ]), // `</noembed`
+    NoframesEnd: new Uint8Array([
+        0x3c, 0x2f, 0x6e, 0x6f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73,
+    ]), // `</noframes`
+    Plaintext: new Uint8Array([
+        0x3c, 0x2f, 0x70, 0x6c, 0x61, 0x69, 0x6e, 0x74, 0x65, 0x78, 0x74,
+    ]), // `</plaintext`
     ScriptEnd: new Uint8Array([0x3c, 0x2f, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74]), // `</script`
     StyleEnd: new Uint8Array([0x3c, 0x2f, 0x73, 0x74, 0x79, 0x6c, 0x65]), // `</style`
     TitleEnd: new Uint8Array([0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65]), // `</title`
@@ -148,6 +160,21 @@ const Sequences = {
     XmpEnd: new Uint8Array([0x3c, 0x2f, 0x78, 0x6d, 0x70]), // `</xmp`
 };
 
+/**
+ * Maps the first lowercase character of an HTML tag name to the sequence
+ * used for special-tag detection.  All sequences share a common layout
+ * where index 2 is the first tag-name character, so matching always
+ * continues from offset 3.
+ */
+const specialStartSequences = new Map<number, Uint8Array>([
+    [Sequences.IframeEnd[2], Sequences.IframeEnd],
+    [Sequences.NoembedEnd[2], Sequences.NoembedEnd],
+    [Sequences.Plaintext[2], Sequences.Plaintext],
+    [Sequences.ScriptEnd[2], Sequences.ScriptEnd],
+    [Sequences.TitleEnd[2], Sequences.TitleEnd],
+    [Sequences.XmpEnd[2], Sequences.XmpEnd],
+]);
+
 /**
  * Tokenizer implementation used by `Parser`.
  */
@@ -173,17 +200,24 @@ export default class Tokenizer {
 
     private readonly xmlMode: boolean;
     private readonly decodeEntities: boolean;
+    private readonly recognizeSelfClosing: boolean;
     private readonly entityDecoder: EntityDecoder;
 
     constructor(
         {
             xmlMode = false,
             decodeEntities = true,
-        }: { xmlMode?: boolean; decodeEntities?: boolean },
+            recognizeSelfClosing = false,
+        }: {
+            xmlMode?: boolean;
+            decodeEntities?: boolean;
+            recognizeSelfClosing?: boolean;
+        },
         private readonly cbs: Callbacks,
     ) {
         this.xmlMode = xmlMode;
         this.decodeEntities = decodeEntities;
+        this.recognizeSelfClosing = recognizeSelfClosing;
         this.entityDecoder = new EntityDecoder(
             xmlMode ? xmlDecodeTree : htmlDecodeTree,
             (cp, consumed) => this.emitCodePoint(cp, consumed),
@@ -241,68 +275,80 @@ export default class Tokenizer {
 
     private currentSequence: Uint8Array = Sequences.Empty;
     private sequenceIndex = 0;
-    private stateSpecialStartSequence(c: number): void {
-        const isEnd = this.sequenceIndex === this.currentSequence.length;
-        const isMatch = isEnd
-            ? // If we are at the end of the sequence, make sure the tag name has ended
-              isEndOfTagSection(c)
-            : // Otherwise, do a case-insensitive comparison
-              (c | 0x20) === this.currentSequence[this.sequenceIndex];
-
-        if (!isMatch) {
-            this.isSpecial = false;
-        } else if (!isEnd) {
-            this.sequenceIndex++;
-            return;
-        }
 
-        this.sequenceIndex = 0;
-        this.state = State.InTagName;
-        this.stateInTagName(c);
+    private enterTagBody(): void {
+        if (this.currentSequence === Sequences.Plaintext) {
+            this.currentSequence = Sequences.Empty;
+            this.state = State.InPlainText;
+        } else if (this.isSpecial) {
+            this.state = State.InSpecialTag;
+            this.sequenceIndex = 0;
+        } else {
+            this.state = State.Text;
+        }
     }
 
     /**
-     * Look for an end tag. For <title> tags, also decode entities.
+     * Match the opening tag name against an HTML text-only tag sequence.
+     *
+     * Some tags share an initial prefix (`script`/`style`, `title`/`textarea`,
+     * `noembed`/`noframes`), so we may switch to an alternate sequence at the
+     * first distinguishing byte.  On a successful full match we fall back to
+     * the normal tag-name state; a later `>` will enter raw-text, RCDATA, or
+     * plaintext mode based on `currentSequence` / `isSpecial`.
      * @param c Current character code point.
      */
-    private stateInSpecialTag(c: number): void {
-        if (this.sequenceIndex === this.currentSequence.length) {
-            if (isEndOfTagSection(c)) {
-                const endOfText = this.index - this.currentSequence.length;
-
-                if (this.sectionStart < endOfText) {
-                    // Spoof the index so that reported locations match up.
-                    const actualIndex = this.index;
-                    this.index = endOfText;
-                    this.cbs.ontext(this.sectionStart, endOfText);
-                    this.index = actualIndex;
-                }
+    private stateSpecialStartSequence(c: number): void {
+        const lower = c | 0x20;
 
-                this.isSpecial = false;
-                this.sectionStart = endOfText + 2; // Skip over the `</`
-                this.stateInClosingTagName(c);
-                return; // We are done; skip the rest of the function.
+        // Still matching — check for an alternate sequence at branch points.
+        if (this.sequenceIndex < this.currentSequence.length) {
+            if (lower === this.currentSequence[this.sequenceIndex]) {
+                this.sequenceIndex++;
+                return;
             }
 
-            this.sequenceIndex = 0;
-        }
+            if (this.sequenceIndex === 3) {
+                if (
+                    this.currentSequence === Sequences.ScriptEnd &&
+                    lower === Sequences.StyleEnd[3]
+                ) {
+                    this.currentSequence = Sequences.StyleEnd;
+                    this.sequenceIndex = 4;
+                    return;
+                }
 
-        if ((c | 0x20) === this.currentSequence[this.sequenceIndex]) {
-            this.sequenceIndex += 1;
-        } else if (this.sequenceIndex === 0) {
-            if (this.currentSequence === Sequences.TitleEnd) {
-                // We have to parse entities in <title> tags.
-                if (this.decodeEntities && c === CharCodes.Amp) {
-                    this.startEntity();
+                if (
+                    this.currentSequence === Sequences.TitleEnd &&
+                    lower === Sequences.TextareaEnd[3]
+                ) {
+                    this.currentSequence = Sequences.TextareaEnd;
+                    this.sequenceIndex = 4;
+                    return;
                 }
-            } else if (this.fastForwardTo(CharCodes.Lt)) {
-                // Outside of <title> tags, we can fast-forward.
-                this.sequenceIndex = 1;
+            } else if (
+                this.sequenceIndex === 4 &&
+                this.currentSequence === Sequences.NoembedEnd &&
+                lower === Sequences.NoframesEnd[4]
+            ) {
+                this.currentSequence = Sequences.NoframesEnd;
+                this.sequenceIndex = 5;
+                return;
             }
-        } else {
-            // If we see a `<`, set the sequence index to 1; useful for eg. `<</script>`.
-            this.sequenceIndex = Number(c === CharCodes.Lt);
+        } else if (isEndOfTagSection(c)) {
+            // Full match on a valid tag boundary — keep the sequence.
+            this.sequenceIndex = 0;
+            this.state = State.InTagName;
+            this.stateInTagName(c);
+            return;
         }
+
+        // No match — abandon special-tag detection.
+        this.isSpecial = false;
+        this.currentSequence = Sequences.Empty;
+        this.sequenceIndex = 0;
+        this.state = State.InTagName;
+        this.stateInTagName(c);
     }
 
     private stateCDATASequence(c: number): void {
@@ -315,8 +361,13 @@ export default class Tokenizer {
             }
         } else {
             this.sequenceIndex = 0;
-            this.state = State.InDeclaration;
-            this.stateInDeclaration(c); // Reconsume the character
+            if (this.xmlMode) {
+                this.state = State.InDeclaration;
+                this.stateInDeclaration(c); // Reconsume the character
+            } else {
+                this.state = State.InSpecialComment;
+                this.stateInSpecialComment(c); // Reconsume the character
+            }
         }
     }
 
@@ -344,6 +395,17 @@ export default class Tokenizer {
         return false;
     }
 
+    /**
+     * Emit a comment token and return to the text state.
+     * @param offset Number of characters in the end sequence that have already been matched.
+     */
+    private emitComment(offset: number): void {
+        this.cbs.oncomment(this.sectionStart, this.index, offset);
+        this.sequenceIndex = 0;
+        this.sectionStart = this.index + 1;
+        this.state = State.Text;
+    }
+
     /**
      * Comments and CDATA end with `-->` and `]]>`.
      *
@@ -355,16 +417,21 @@ export default class Tokenizer {
      */
     private stateInCommentLike(c: number): void {
         if (
+            !this.xmlMode &&
+            this.currentSequence === Sequences.CommentEnd &&
+            this.sequenceIndex <= 1 &&
+            this.index === this.sectionStart + this.sequenceIndex &&
+            c === CharCodes.Gt
+        ) {
+            // `<!-->` and `<!--->` are valid empty HTML comments.
+            this.emitComment(this.sequenceIndex);
+        } else if (
             this.currentSequence === Sequences.CommentEnd &&
             this.sequenceIndex === 2 &&
             c === CharCodes.Gt
         ) {
             // `!` is optional here, so the same sequence also accepts `-->`.
-            this.cbs.oncomment(this.sectionStart, this.index, 2);
-
-            this.sequenceIndex = 0;
-            this.sectionStart = this.index + 1;
-            this.state = State.Text;
+            this.emitComment(2);
         } else if (
             this.currentSequence === Sequences.CommentEnd &&
             this.sequenceIndex === this.currentSequence.length - 1 &&
@@ -405,11 +472,54 @@ export default class Tokenizer {
         return this.xmlMode ? !isEndOfTagSection(c) : isASCIIAlpha(c);
     }
 
-    private startSpecial(sequence: Uint8Array, offset: number) {
-        this.isSpecial = true;
-        this.currentSequence = sequence;
-        this.sequenceIndex = offset;
-        this.state = State.SpecialStartSequence;
+    /**
+     * Scan raw-text / RCDATA content for the matching end tag.
+     *
+     * For RCDATA tags (`<title>`, `<textarea>`) entities are decoded inline.
+     * For raw-text tags (`<script>`, `<style>`, etc.) we fast-forward to `<`.
+     * @param c Current character code point.
+     */
+    private stateInSpecialTag(c: number): void {
+        if (this.sequenceIndex === this.currentSequence.length) {
+            if (isEndOfTagSection(c)) {
+                const endOfText = this.index - this.currentSequence.length;
+
+                if (this.sectionStart < endOfText) {
+                    // Spoof the index so that reported locations match up.
+                    const actualIndex = this.index;
+                    this.index = endOfText;
+                    this.cbs.ontext(this.sectionStart, endOfText);
+                    this.index = actualIndex;
+                }
+
+                this.isSpecial = false;
+                this.sectionStart = endOfText + 2; // Skip over the `</`
+                this.stateInClosingTagName(c);
+                return; // We are done; skip the rest of the function.
+            }
+
+            this.sequenceIndex = 0;
+        }
+
+        if ((c | 0x20) === this.currentSequence[this.sequenceIndex]) {
+            this.sequenceIndex += 1;
+        } else if (this.sequenceIndex === 0) {
+            if (
+                this.currentSequence === Sequences.TitleEnd ||
+                this.currentSequence === Sequences.TextareaEnd
+            ) {
+                // RCDATA tags have to parse entities while still looking for their end tag.
+                if (this.decodeEntities && c === CharCodes.Amp) {
+                    this.startEntity();
+                }
+            } else if (this.fastForwardTo(CharCodes.Lt)) {
+                // Outside of <title> tags, we can fast-forward.
+                this.sequenceIndex = 1;
+            }
+        } else {
+            // If we see a `<`, set the sequence index to 1; useful for eg. `<</script>`.
+            this.sequenceIndex = Number(c === CharCodes.Lt);
+        }
     }
 
     private stateBeforeTagName(c: number): void {
@@ -417,23 +527,29 @@ export default class Tokenizer {
             this.state = State.BeforeDeclaration;
             this.sectionStart = this.index + 1;
         } else if (c === CharCodes.Questionmark) {
-            this.state = State.InProcessingInstruction;
-            this.sequenceIndex = 0;
-            this.sectionStart = this.index + 1;
+            if (this.xmlMode) {
+                this.state = State.InProcessingInstruction;
+                this.sequenceIndex = 0;
+                this.sectionStart = this.index + 1;
+            } else {
+                this.state = State.InSpecialComment;
+                this.sectionStart = this.index;
+            }
         } else if (this.isTagStartChar(c)) {
-            const lower = c | 0x20;
             this.sectionStart = this.index;
-            if (this.xmlMode) {
+
+            const special =
+                this.xmlMode || this.cbs.isInForeignContext?.()
+                    ? undefined
+                    : specialStartSequences.get(c | 0x20);
+
+            if (special === undefined) {
                 this.state = State.InTagName;
-            } else if (lower === Sequences.ScriptEnd[2]) {
-                this.state = State.BeforeSpecialS;
-            } else if (
-                lower === Sequences.TitleEnd[2] ||
-                lower === Sequences.XmpEnd[2]
-            ) {
-                this.state = State.BeforeSpecialT;
             } else {
-                this.state = State.InTagName;
+                this.isSpecial = true;
+                this.currentSequence = special;
+                this.sequenceIndex = 3;
+                this.state = State.SpecialStartSequence;
             }
         } else if (c === CharCodes.Slash) {
             this.state = State.BeforeClosingTagName;
@@ -452,9 +568,17 @@ export default class Tokenizer {
     }
     private stateBeforeClosingTagName(c: number): void {
         if (isWhitespace(c)) {
-            // Ignore
+            if (this.xmlMode) {
+                // Ignore
+            } else {
+                this.state = State.InSpecialComment;
+                this.sectionStart = this.index;
+            }
         } else if (c === CharCodes.Gt) {
             this.state = State.Text;
+            if (!this.xmlMode) {
+                this.sectionStart = this.index + 1;
+            }
         } else {
             this.state = this.isTagStartChar(c)
                 ? State.InClosingTagName
@@ -480,12 +604,7 @@ export default class Tokenizer {
     private stateBeforeAttributeName(c: number): void {
         if (c === CharCodes.Gt) {
             this.cbs.onopentagend(this.index);
-            if (this.isSpecial) {
-                this.state = State.InSpecialTag;
-                this.sequenceIndex = 0;
-            } else {
-                this.state = State.Text;
-            }
+            this.enterTagBody();
             this.sectionStart = this.index + 1;
         } else if (c === CharCodes.Slash) {
             this.state = State.InSelfClosingTag;
@@ -494,12 +613,28 @@ export default class Tokenizer {
             this.sectionStart = this.index;
         }
     }
+    /**
+     * Handle `/` before `>` in an opening tag.
+     *
+     * In HTML mode, text-only tags ignore the self-closing flag and still enter
+     * their raw-text/RCDATA/plaintext state unless self-closing tags are being
+     * recognized. In XML mode, or for ordinary tags, the tokenizer returns to
+     * regular text parsing after emitting the self-closing callback.
+     * @param c Current character code point.
+     */
     private stateInSelfClosingTag(c: number): void {
         if (c === CharCodes.Gt) {
             this.cbs.onselfclosingtag(this.index);
-            this.state = State.Text;
             this.sectionStart = this.index + 1;
+
+            if (!(this.xmlMode || this.recognizeSelfClosing)) {
+                this.enterTagBody();
+                return;
+            }
+
+            this.state = State.Text;
             this.isSpecial = false; // Reset special state, in case of self-closing special tags
+            this.currentSequence = Sequences.Empty;
         } else if (!isWhitespace(c)) {
             this.state = State.BeforeAttributeName;
             this.stateBeforeAttributeName(c);
@@ -575,15 +710,57 @@ export default class Tokenizer {
             this.startEntity();
         }
     }
+    /**
+     * Distinguish between CDATA, declarations, HTML comments, and HTML bogus
+     * comments after `<!`.
+     *
+     * In HTML mode, only real comments and doctypes stay on declaration paths;
+     * everything else becomes a bogus comment terminated by the next `>`.
+     * @param c Current character code point.
+     */
     private stateBeforeDeclaration(c: number): void {
         if (c === CharCodes.OpeningSquareBracket) {
             this.state = State.CDATASequence;
             this.sequenceIndex = 0;
-        } else {
+        } else if (this.xmlMode) {
             this.state =
                 c === CharCodes.Dash
                     ? State.BeforeComment
                     : State.InDeclaration;
+        } else if ((c | 0x20) === Sequences.Doctype[0]) {
+            this.state = State.DeclarationSequence;
+            this.currentSequence = Sequences.Doctype;
+            this.sequenceIndex = 1;
+        } else if (c === CharCodes.Gt) {
+            this.cbs.oncomment(this.sectionStart, this.index, 0);
+            this.state = State.Text;
+            this.sectionStart = this.index + 1;
+        } else if (c === CharCodes.Dash) {
+            this.state = State.BeforeComment;
+        } else {
+            this.state = State.InSpecialComment;
+        }
+    }
+    /**
+     * Continue matching `doctype` after `<!d`.
+     *
+     * A full `doctype` match stays on the declaration path; any other name falls
+     * back to an HTML bogus comment, which matches browser behavior for
+     * non-doctype `<!...>` constructs.
+     * @param c Current character code point.
+     */
+    private stateDeclarationSequence(c: number): void {
+        if (this.sequenceIndex === this.currentSequence.length) {
+            this.state = State.InDeclaration;
+            this.stateInDeclaration(c);
+        } else if ((c | 0x20) === this.currentSequence[this.sequenceIndex]) {
+            this.sequenceIndex += 1;
+        } else if (c === CharCodes.Gt) {
+            this.cbs.oncomment(this.sectionStart, this.index, 0);
+            this.state = State.Text;
+            this.sectionStart = this.index + 1;
+        } else {
+            this.state = State.InSpecialComment;
         }
     }
     private stateInDeclaration(c: number): void {
@@ -593,43 +770,43 @@ export default class Tokenizer {
             this.sectionStart = this.index + 1;
         }
     }
+    /**
+     * XML processing instructions (`<?...?>`).
+     *
+     * In HTML mode `<?` is routed to `InSpecialComment` instead, so this
+     * state is only reachable in XML mode.
+     * @param c Current character code point.
+     */
     private stateInProcessingInstruction(c: number): void {
-        if (this.xmlMode) {
-            if (c === CharCodes.Questionmark) {
-                // Remember that we just consumed `?`, so the next `>` closes the PI.
-                this.sequenceIndex = 1;
-            } else if (c === CharCodes.Gt && this.sequenceIndex === 1) {
-                this.cbs.onprocessinginstruction(
-                    this.sectionStart,
-                    this.index - 1,
-                );
-                this.sequenceIndex = 0;
-                this.state = State.Text;
-                this.sectionStart = this.index + 1;
-            } else {
-                // Keep scanning for the next `?`, which can start a closing `?>`.
-                this.sequenceIndex = Number(
-                    this.fastForwardTo(CharCodes.Questionmark),
-                );
-            }
-        } else if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
-            this.cbs.onprocessinginstruction(this.sectionStart, this.index);
+        if (c === CharCodes.Questionmark) {
+            // Remember that we just consumed `?`, so the next `>` closes the PI.
+            this.sequenceIndex = 1;
+        } else if (c === CharCodes.Gt && this.sequenceIndex === 1) {
+            this.cbs.onprocessinginstruction(this.sectionStart, this.index - 1);
+            this.sequenceIndex = 0;
             this.state = State.Text;
             this.sectionStart = this.index + 1;
+        } else {
+            // Keep scanning for the next `?`, which can start a closing `?>`.
+            this.sequenceIndex = Number(
+                this.fastForwardTo(CharCodes.Questionmark),
+            );
         }
     }
     private stateBeforeComment(c: number): void {
         if (c === CharCodes.Dash) {
             this.state = State.InCommentLike;
             this.currentSequence = Sequences.CommentEnd;
-            /*
-             * In HTML, `<!-->` is a valid empty comment. In XML, comments
-             * must be closed by `-->`, so we require the full sequence.
-             */
-            this.sequenceIndex = this.xmlMode ? 0 : 2;
+            this.sequenceIndex = 0;
             this.sectionStart = this.index + 1;
-        } else {
+        } else if (this.xmlMode) {
             this.state = State.InDeclaration;
+        } else if (c === CharCodes.Gt) {
+            this.cbs.oncomment(this.sectionStart, this.index, 0);
+            this.state = State.Text;
+            this.sectionStart = this.index + 1;
+        } else {
+            this.state = State.InSpecialComment;
         }
     }
     private stateInSpecialComment(c: number): void {
@@ -639,42 +816,6 @@ export default class Tokenizer {
             this.sectionStart = this.index + 1;
         }
     }
-    private stateBeforeSpecialS(c: number): void {
-        const lower = c | 0x20;
-        if (lower === Sequences.ScriptEnd[3]) {
-            this.startSpecial(Sequences.ScriptEnd, 4);
-        } else if (lower === Sequences.StyleEnd[3]) {
-            this.startSpecial(Sequences.StyleEnd, 4);
-        } else {
-            this.state = State.InTagName;
-            this.stateInTagName(c); // Consume the token again
-        }
-    }
-
-    private stateBeforeSpecialT(c: number): void {
-        const lower = c | 0x20;
-        switch (lower) {
-            case Sequences.TitleEnd[3]: {
-                this.startSpecial(Sequences.TitleEnd, 4);
-
-                break;
-            }
-            case Sequences.TextareaEnd[3]: {
-                this.startSpecial(Sequences.TextareaEnd, 4);
-
-                break;
-            }
-            case Sequences.XmpEnd[3]: {
-                this.startSpecial(Sequences.XmpEnd, 4);
-
-                break;
-            }
-            default: {
-                this.state = State.InTagName;
-                this.stateInTagName(c); // Consume the token again
-            }
-        }
-    }
 
     private startEntity() {
         this.baseState = this.state;
@@ -724,6 +865,7 @@ export default class Tokenizer {
         if (this.running && this.sectionStart !== this.index) {
             if (
                 this.state === State.Text ||
+                this.state === State.InPlainText ||
                 (this.state === State.InSpecialTag && this.sequenceIndex === 0)
             ) {
                 this.cbs.ontext(this.sectionStart, this.index);
@@ -756,6 +898,9 @@ export default class Tokenizer {
                     this.stateText(c);
                     break;
                 }
+                case State.InPlainText: {
+                    break;
+                }
                 case State.SpecialStartSequence: {
                     this.stateSpecialStartSequence(c);
                     break;
@@ -768,6 +913,10 @@ export default class Tokenizer {
                     this.stateCDATASequence(c);
                     break;
                 }
+                case State.DeclarationSequence: {
+                    this.stateDeclarationSequence(c);
+                    break;
+                }
                 case State.InAttributeValueDq: {
                     this.stateInAttributeValueDoubleQuotes(c);
                     break;
@@ -820,14 +969,6 @@ export default class Tokenizer {
                     this.stateAfterClosingTagName(c);
                     break;
                 }
-                case State.BeforeSpecialS: {
-                    this.stateBeforeSpecialS(c);
-                    break;
-                }
-                case State.BeforeSpecialT: {
-                    this.stateBeforeSpecialT(c);
-                    break;
-                }
                 case State.InAttributeValueNq: {
                     this.stateInAttributeValueNoQuotes(c);
                     break;
@@ -873,38 +1014,107 @@ export default class Tokenizer {
         this.cbs.onend();
     }
 
+    private handleTrailingCommentLikeData(endIndex: number): boolean {
+        if (this.state !== State.InCommentLike) {
+            return false;
+        }
+
+        if (this.currentSequence === Sequences.CdataEnd) {
+            if (this.xmlMode) {
+                if (this.sectionStart < endIndex) {
+                    this.cbs.oncdata(this.sectionStart, endIndex, 0);
+                }
+            } else {
+                /* In HTML mode, unclosed CDATA is a bogus comment. */
+                const cdataStart =
+                    this.sectionStart - Sequences.Cdata.length - 1;
+                this.cbs.oncomment(cdataStart, endIndex, 0);
+            }
+        } else {
+            const offset = this.xmlMode
+                ? 0
+                : Math.min(this.sequenceIndex, Sequences.CommentEnd.length - 1);
+            this.cbs.oncomment(this.sectionStart, endIndex, offset);
+        }
+
+        return true;
+    }
+
+    private handleTrailingMarkupDeclaration(endIndex: number): boolean {
+        if (this.xmlMode) {
+            switch (this.state) {
+                case State.InSpecialComment:
+                case State.BeforeComment:
+                case State.CDATASequence:
+                case State.DeclarationSequence:
+                case State.InDeclaration: {
+                    this.cbs.ontext(this.sectionStart, endIndex);
+                    return true;
+                }
+                default: {
+                    return false;
+                }
+            }
+        }
+
+        switch (this.state) {
+            case State.BeforeDeclaration:
+            case State.InSpecialComment:
+            case State.BeforeComment:
+            case State.CDATASequence: {
+                this.cbs.oncomment(this.sectionStart, endIndex, 0);
+                return true;
+            }
+            case State.DeclarationSequence: {
+                if (this.sequenceIndex !== Sequences.Doctype.length) {
+                    this.cbs.oncomment(this.sectionStart, endIndex, 0);
+                }
+                return true;
+            }
+            case State.InDeclaration: {
+                return true;
+            }
+            default: {
+                return false;
+            }
+        }
+    }
+
     /** Handle any trailing data. */
     private handleTrailingData() {
         const endIndex = this.buffer.length + this.offset;
 
+        if (
+            this.handleTrailingCommentLikeData(endIndex) ||
+            this.handleTrailingMarkupDeclaration(endIndex)
+        ) {
+            return;
+        }
+
         // If there is no remaining data, we are done.
         if (this.sectionStart >= endIndex) {
             return;
         }
 
-        if (this.state === State.InCommentLike) {
-            if (this.currentSequence === Sequences.CdataEnd) {
-                this.cbs.oncdata(this.sectionStart, endIndex, 0);
-            } else {
-                this.cbs.oncomment(this.sectionStart, endIndex, 0);
+        switch (this.state) {
+            case State.InTagName:
+            case State.BeforeAttributeName:
+            case State.BeforeAttributeValue:
+            case State.AfterAttributeName:
+            case State.InAttributeName:
+            case State.InAttributeValueSq:
+            case State.InAttributeValueDq:
+            case State.InAttributeValueNq:
+            case State.InClosingTagName: {
+                /*
+                 * If we are currently in an opening or closing tag, us not calling the
+                 * respective callback signals that the tag should be ignored.
+                 */
+                break;
+            }
+            default: {
+                this.cbs.ontext(this.sectionStart, endIndex);
             }
-        } else if (
-            this.state === State.InTagName ||
-            this.state === State.BeforeAttributeName ||
-            this.state === State.BeforeAttributeValue ||
-            this.state === State.AfterAttributeName ||
-            this.state === State.InAttributeName ||
-            this.state === State.InAttributeValueSq ||
-            this.state === State.InAttributeValueDq ||
-            this.state === State.InAttributeValueNq ||
-            this.state === State.InClosingTagName
-        ) {
-            /*
-             * If we are currently in an opening or closing tag, us not calling the
-             * respective callback signals that the tag should be ignored.
-             */
-        } else {
-            this.cbs.ontext(this.sectionStart, endIndex);
         }
     }
 
diff --git a/src/__snapshots__/Parser.events.spec.ts.snap b/src/__snapshots__/Parser.events.spec.ts.snap
index ca7af1db..b4ce2e06 100644
--- a/src/__snapshots__/Parser.events.spec.ts.snap
+++ b/src/__snapshots__/Parser.events.spec.ts.snap
@@ -40,6 +40,33 @@ exports[`Events > </title> in <script> (#745) 1`] = `
 ]
 `;
 
+exports[`Events > Abruptly closed comment 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "",
+    ],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "text",
+    ],
+    "endIndex": 9,
+    "startIndex": 6,
+  },
+]
+`;
+
 exports[`Events > Attribute in XML (see #1350) 1`] = `
 [
   {
@@ -95,6 +122,52 @@ exports[`Events > Attribute in XML (see #1350) 1`] = `
 ]
 `;
 
+exports[`Events > Bogus comment after </ and whitespace 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "div",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "div",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "comment",
+    "data": [
+      " div",
+    ],
+    "endIndex": 11,
+    "startIndex": 5,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 11,
+    "startIndex": 5,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "div",
+      true,
+    ],
+    "endIndex": 12,
+    "startIndex": 12,
+  },
+]
+`;
+
 exports[`Events > CDATA (inside special) 1`] = `
 [
   {
@@ -199,14 +272,19 @@ exports[`Events > CDATA 1`] = `
 exports[`Events > CDATA edge-cases 1`] = `
 [
   {
-    "$event": "processinginstruction",
+    "$event": "comment",
     "data": [
-      "![cdata",
-      "![CDATA",
+      "[CDATA",
     ],
     "endIndex": 8,
     "startIndex": 0,
   },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 8,
+    "startIndex": 0,
+  },
   {
     "$event": "cdatastart",
     "data": [],
@@ -228,21 +306,15 @@ exports[`Events > CDATA edge-cases 1`] = `
     "startIndex": 9,
   },
   {
-    "$event": "cdatastart",
-    "data": [],
-    "endIndex": 40,
-    "startIndex": 28,
-  },
-  {
-    "$event": "text",
+    "$event": "comment",
     "data": [
-      "foo",
+      "[CDATA[foo",
     ],
     "endIndex": 40,
     "startIndex": 28,
   },
   {
-    "$event": "cdataend",
+    "$event": "commentend",
     "data": [],
     "endIndex": 40,
     "startIndex": 28,
@@ -297,14 +369,19 @@ exports[`Events > CDATA more edge-cases 1`] = `
 exports[`Events > Comment edge-cases 1`] = `
 [
   {
-    "$event": "processinginstruction",
+    "$event": "comment",
     "data": [
-      "!-foo",
-      "!-foo",
+      "-foo",
     ],
     "endIndex": 6,
     "startIndex": 0,
   },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 6,
+    "startIndex": 0,
+  },
   {
     "$event": "comment",
     "data": [
@@ -355,14 +432,175 @@ exports[`Events > Comment false ending 1`] = `
 ]
 `;
 
+exports[`Events > Doctype without whitespace 1`] = `
+[
+  {
+    "$event": "processinginstruction",
+    "data": [
+      "!doctype",
+      "!DOCTYPEhtml",
+    ],
+    "endIndex": 13,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > EOF bogus comments 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "-",
+    ],
+    "endIndex": 3,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 3,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > EOF complete doctype 1`] = `[]`;
+
+exports[`Events > EOF empty bogus comment 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "",
+    ],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > EOF incomplete doctype 1`] = `[]`;
+
+exports[`Events > EOF partial doctype 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "DOC",
+    ],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > EOF processing instruction 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "?",
+    ],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > Empty EOF comment 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > Empty closing tag 1`] = `[]`;
+
+exports[`Events > Empty closing tag, xmlMode=true 1`] = `
+[
+  {
+    "$event": "text",
+    "data": [
+      "</>",
+    ],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+]
+`;
+
 exports[`Events > Empty tag name 1`] = `
 [
   {
     "$event": "text",
     "data": [
-      "< ></ >",
+      "< >",
+    ],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+  {
+    "$event": "comment",
+    "data": [
+      " ",
     ],
     "endIndex": 6,
+    "startIndex": 3,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 6,
+    "startIndex": 3,
+  },
+]
+`;
+
+exports[`Events > Empty unclosed CDATA at EOF 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "[CDATA[",
+    ],
+    "endIndex": 9,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 9,
     "startIndex": 0,
   },
 ]
@@ -458,36 +696,181 @@ exports[`Events > Entity after < 1`] = `
 ]
 `;
 
-exports[`Events > Implicit close tags 1`] = `
+exports[`Events > Foreign CDATA in MathML 1`] = `
 [
   {
     "$event": "opentagname",
     "data": [
-      "ol",
+      "math",
     ],
-    "endIndex": 3,
+    "endIndex": 5,
     "startIndex": 0,
   },
   {
     "$event": "opentag",
     "data": [
-      "ol",
+      "math",
       {},
       false,
     ],
-    "endIndex": 3,
+    "endIndex": 5,
     "startIndex": 0,
   },
   {
-    "$event": "opentagname",
+    "$event": "text",
     "data": [
-      "li",
+      "a<b",
     ],
-    "endIndex": 7,
-    "startIndex": 4,
+    "endIndex": 20,
+    "startIndex": 6,
   },
   {
-    "$event": "attribute",
+    "$event": "closetag",
+    "data": [
+      "math",
+      false,
+    ],
+    "endIndex": 27,
+    "startIndex": 21,
+  },
+]
+`;
+
+exports[`Events > Foreign CDATA in SVG 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "a<b",
+    ],
+    "endIndex": 19,
+    "startIndex": 5,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      false,
+    ],
+    "endIndex": 25,
+    "startIndex": 20,
+  },
+]
+`;
+
+exports[`Events > HTML bogus comments 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "?foo",
+    ],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "comment",
+    "data": [
+      "foo",
+    ],
+    "endIndex": 11,
+    "startIndex": 6,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 11,
+    "startIndex": 6,
+  },
+]
+`;
+
+exports[`Events > HTML image alias 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "img",
+    ],
+    "endIndex": 6,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "img",
+      {},
+      false,
+    ],
+    "endIndex": 6,
+    "startIndex": 0,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "img",
+      true,
+    ],
+    "endIndex": 6,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > Implicit close tags 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "ol",
+    ],
+    "endIndex": 3,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "ol",
+      {},
+      false,
+    ],
+    "endIndex": 3,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "li",
+    ],
+    "endIndex": 7,
+    "startIndex": 4,
+  },
+  {
+    "$event": "attribute",
     "data": [
       "class",
       "test",
@@ -1632,6 +2015,299 @@ exports[`Events > Not quite closed 1`] = `
 ]
 `;
 
+exports[`Events > Partial CDATA at EOF 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "[C",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > Partial CDATA match with > 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "[CD",
+    ],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+]
+`;
+
+exports[`Events > SVG image is not aliased 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "image",
+    ],
+    "endIndex": 11,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "image",
+      {},
+      false,
+    ],
+    "endIndex": 11,
+    "startIndex": 5,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "image",
+      false,
+    ],
+    "endIndex": 19,
+    "startIndex": 12,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      false,
+    ],
+    "endIndex": 25,
+    "startIndex": 20,
+  },
+]
+`;
+
+exports[`Events > SVG tag case adjustment 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "foreignObject",
+    ],
+    "endIndex": 19,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "foreignObject",
+      {},
+      false,
+    ],
+    "endIndex": 19,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "b",
+    ],
+    "endIndex": 22,
+    "startIndex": 20,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "b",
+      {},
+      false,
+    ],
+    "endIndex": 22,
+    "startIndex": 20,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "x",
+    ],
+    "endIndex": 23,
+    "startIndex": 23,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "b",
+      false,
+    ],
+    "endIndex": 27,
+    "startIndex": 24,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "foreignObject",
+      true,
+    ],
+    "endIndex": 49,
+    "startIndex": 44,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      false,
+    ],
+    "endIndex": 49,
+    "startIndex": 44,
+  },
+]
+`;
+
+exports[`Events > SVG title is not HTML special 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "title",
+    ],
+    "endIndex": 11,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "title",
+      {},
+      false,
+    ],
+    "endIndex": 11,
+    "startIndex": 5,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "&",
+    ],
+    "endIndex": 16,
+    "startIndex": 12,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "b",
+    ],
+    "endIndex": 19,
+    "startIndex": 17,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "b",
+      {},
+      false,
+    ],
+    "endIndex": 19,
+    "startIndex": 17,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "x",
+    ],
+    "endIndex": 20,
+    "startIndex": 20,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "b",
+      false,
+    ],
+    "endIndex": 24,
+    "startIndex": 21,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "title",
+      false,
+    ],
+    "endIndex": 32,
+    "startIndex": 25,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      false,
+    ],
+    "endIndex": 38,
+    "startIndex": 33,
+  },
+]
+`;
+
 exports[`Events > Scripts creating other scripts 1`] = `
 [
   {
@@ -1795,32 +2471,84 @@ exports[`Events > Self-closing indices (#941) 1`] = `
     "startIndex": 9,
   },
   {
-    "$event": "opentag",
+    "$event": "opentag",
+    "data": [
+      "b",
+      {},
+      false,
+    ],
+    "endIndex": 12,
+    "startIndex": 9,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "b",
+      true,
+    ],
+    "endIndex": 12,
+    "startIndex": 9,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "xml",
+      false,
+    ],
+    "endIndex": 18,
+    "startIndex": 13,
+  },
+]
+`;
+
+exports[`Events > Short HTML bogus comments 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "",
+    ],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 2,
+    "startIndex": 0,
+  },
+  {
+    "$event": "comment",
     "data": [
-      "b",
-      {},
-      false,
+      "-",
     ],
-    "endIndex": 12,
-    "startIndex": 9,
+    "endIndex": 6,
+    "startIndex": 3,
   },
   {
-    "$event": "closetag",
-    "data": [
-      "b",
-      true,
-    ],
-    "endIndex": 12,
-    "startIndex": 9,
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 6,
+    "startIndex": 3,
   },
+]
+`;
+
+exports[`Events > Short bang comment 1`] = `
+[
   {
-    "$event": "closetag",
+    "$event": "comment",
     "data": [
-      "xml",
-      false,
+      "!>",
     ],
-    "endIndex": 18,
-    "startIndex": 13,
+    "endIndex": 6,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 6,
+    "startIndex": 0,
   },
 ]
 `;
@@ -2736,6 +3464,25 @@ exports[`Events > Trailing numeric entity 1`] = `
 ]
 `;
 
+exports[`Events > Unclosed CDATA at EOF 1`] = `
+[
+  {
+    "$event": "comment",
+    "data": [
+      "[CDATA[foo",
+    ],
+    "endIndex": 12,
+    "startIndex": 0,
+  },
+  {
+    "$event": "commentend",
+    "data": [],
+    "endIndex": 12,
+    "startIndex": 0,
+  },
+]
+`;
+
 exports[`Events > XML tags 1`] = `
 [
   {
@@ -3410,6 +4157,140 @@ exports[`Events > end slash: non-void element ending with />, xmlMode=true 1`] =
 ]
 `;
 
+exports[`Events > end slash: plaintext tag ending with />, recognizeSelfClosing=true 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "plaintext",
+    ],
+    "endIndex": 10,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "plaintext",
+      {},
+      false,
+    ],
+    "endIndex": 11,
+    "startIndex": 0,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "plaintext",
+      true,
+    ],
+    "endIndex": 11,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "b",
+    ],
+    "endIndex": 14,
+    "startIndex": 12,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "b",
+      {},
+      false,
+    ],
+    "endIndex": 14,
+    "startIndex": 12,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "x",
+    ],
+    "endIndex": 15,
+    "startIndex": 15,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "b",
+      false,
+    ],
+    "endIndex": 19,
+    "startIndex": 16,
+  },
+]
+`;
+
+exports[`Events > end slash: special tag ending with />, recognizeSelfClosing=true 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "script",
+    ],
+    "endIndex": 7,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "script",
+      {},
+      false,
+    ],
+    "endIndex": 8,
+    "startIndex": 0,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "script",
+      true,
+    ],
+    "endIndex": 8,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "b",
+    ],
+    "endIndex": 11,
+    "startIndex": 9,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "b",
+      {},
+      false,
+    ],
+    "endIndex": 11,
+    "startIndex": 9,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "x",
+    ],
+    "endIndex": 12,
+    "startIndex": 12,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "b",
+      false,
+    ],
+    "endIndex": 16,
+    "startIndex": 13,
+  },
+]
+`;
+
 exports[`Events > end slash: void element ending with /> 1`] = `
 [
   {
@@ -3707,6 +4588,46 @@ exports[`Events > entity in attribute 1`] = `
 ]
 `;
 
+exports[`Events > entity in textarea 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "textarea",
+    ],
+    "endIndex": 9,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "textarea",
+      {},
+      false,
+    ],
+    "endIndex": 9,
+    "startIndex": 0,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "&",
+    ],
+    "endIndex": 14,
+    "startIndex": 10,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "textarea",
+      false,
+    ],
+    "endIndex": 25,
+    "startIndex": 15,
+  },
+]
+`;
+
 exports[`Events > entity in title (#592) 1`] = `
 [
   {
@@ -3924,6 +4845,46 @@ exports[`Events > open-implies-close case of (non-br) void close tag in non-XML
 ]
 `;
 
+exports[`Events > plaintext 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "plaintext",
+    ],
+    "endIndex": 10,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "plaintext",
+      {},
+      false,
+    ],
+    "endIndex": 10,
+    "startIndex": 0,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "<b>hi</b>",
+    ],
+    "endIndex": 19,
+    "startIndex": 11,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "plaintext",
+      true,
+    ],
+    "endIndex": 20,
+    "startIndex": 20,
+  },
+]
+`;
+
 exports[`Events > simple 1`] = `
 [
   {
diff --git a/src/__snapshots__/Tokenizer.spec.ts.snap b/src/__snapshots__/Tokenizer.spec.ts.snap
index 8ad0e859..70f7e69c 100644
--- a/src/__snapshots__/Tokenizer.spec.ts.snap
+++ b/src/__snapshots__/Tokenizer.spec.ts.snap
@@ -325,6 +325,25 @@ exports[`Tokenizer > should correctly mark attributes > for single quotes attrib
 ]
 `;
 
+exports[`Tokenizer > should handle abruptly closed comments 1`] = `
+[
+  [
+    "oncomment",
+    4,
+    5,
+    1,
+  ],
+  [
+    "ontext",
+    6,
+    10,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
 exports[`Tokenizer > should handle entities > for XML entities 1`] = `
 [
   [
@@ -475,40 +494,51 @@ exports[`Tokenizer > should handle entities > for trailing legacy entity 1`] = `
 ]
 `;
 
-exports[`Tokenizer > should not break after special tag followed by an entity > for normal special tag 1`] = `
+exports[`Tokenizer > should ignore empty closing tags 1`] = `
+[
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing iframe tag 1`] = `
 [
   [
     "onopentagname",
     1,
-    6,
+    7,
   ],
   [
-    "onopentagend",
-    6,
+    "onselfclosingtag",
+    9,
   ],
   [
     "ontext",
-    7,
     10,
+    21,
   ],
   [
-    "onclosetag",
-    12,
-    17,
-  ],
-  [
-    "ontextentity",
-    39,
-    24,
+    "onend",
   ],
+]
+`;
+
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing noembed tag 1`] = `
+[
   [
     "onopentagname",
-    25,
-    27,
+    1,
+    8,
   ],
   [
     "onselfclosingtag",
-    28,
+    10,
+  ],
+  [
+    "ontext",
+    11,
+    22,
   ],
   [
     "onend",
@@ -516,30 +546,43 @@ exports[`Tokenizer > should not break after special tag followed by an entity >
 ]
 `;
 
-exports[`Tokenizer > should not break after special tag followed by an entity > for self-closing special tag 1`] = `
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing noframes tag 1`] = `
 [
   [
     "onopentagname",
     1,
-    6,
+    9,
   ],
   [
     "onselfclosingtag",
-    8,
+    11,
   ],
   [
-    "ontextentity",
-    39,
-    15,
+    "ontext",
+    12,
+    23,
+  ],
+  [
+    "onend",
   ],
+]
+`;
+
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing plaintext tag 1`] = `
+[
   [
     "onopentagname",
-    16,
-    18,
+    1,
+    10,
   ],
   [
     "onselfclosingtag",
-    19,
+    12,
+  ],
+  [
+    "ontext",
+    13,
+    24,
   ],
   [
     "onend",
@@ -547,17 +590,21 @@ exports[`Tokenizer > should not break after special tag followed by an entity >
 ]
 `;
 
-exports[`Tokenizer > should not lose data when pausing 1`] = `
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing script tag 1`] = `
 [
   [
-    "ontextentity",
-    38,
-    5,
+    "onopentagname",
+    1,
+    7,
+  ],
+  [
+    "onselfclosingtag",
+    9,
   ],
   [
     "ontext",
-    5,
-    12,
+    10,
+    21,
   ],
   [
     "onend",
@@ -565,65 +612,65 @@ exports[`Tokenizer > should not lose data when pausing 1`] = `
 ]
 `;
 
-exports[`Tokenizer > should not treat <!-->  as a complete comment in xmlMode 1`] = `
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing style tag 1`] = `
 [
   [
     "onopentagname",
     1,
-    5,
+    6,
   ],
   [
-    "onopentagend",
-    5,
+    "onselfclosingtag",
+    8,
+  ],
+  [
+    "ontext",
+    9,
+    20,
+  ],
+  [
+    "onend",
   ],
+]
+`;
+
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing textarea tag 1`] = `
+[
   [
     "onopentagname",
-    7,
-    11,
+    1,
+    9,
   ],
   [
-    "onopentagend",
+    "onselfclosingtag",
     11,
   ],
   [
     "ontext",
     12,
-    17,
-  ],
-  [
-    "onclosetag",
-    19,
     23,
   ],
   [
-    "oncomment",
-    28,
-    58,
-    2,
+    "onend",
   ],
+]
+`;
+
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing title tag 1`] = `
+[
   [
     "onopentagname",
-    60,
-    64,
+    1,
+    6,
   ],
   [
-    "onopentagend",
-    64,
+    "onselfclosingtag",
+    8,
   ],
   [
     "ontext",
-    65,
-    68,
-  ],
-  [
-    "onclosetag",
-    70,
-    74,
-  ],
-  [
-    "onclosetag",
-    77,
-    81,
+    9,
+    20,
   ],
   [
     "onend",
@@ -631,30 +678,21 @@ exports[`Tokenizer > should not treat <!-->  as a complete comment in xmlMode 1`
 ]
 `;
 
-exports[`Tokenizer > should support self-closing special tags > for self-closing script tag 1`] = `
+exports[`Tokenizer > should ignore self-closing slash in text-only HTML tags > for self-closing xmp tag 1`] = `
 [
   [
     "onopentagname",
     1,
-    7,
+    4,
   ],
   [
     "onselfclosingtag",
-    9,
-  ],
-  [
-    "onopentagname",
-    11,
-    14,
-  ],
-  [
-    "onopentagend",
-    14,
+    6,
   ],
   [
-    "onclosetag",
-    17,
-    20,
+    "ontext",
+    7,
+    18,
   ],
   [
     "onend",
@@ -662,7 +700,7 @@ exports[`Tokenizer > should support self-closing special tags > for self-closing
 ]
 `;
 
-exports[`Tokenizer > should support self-closing special tags > for self-closing style tag 1`] = `
+exports[`Tokenizer > should not break after special tag followed by an entity > for normal special tag 1`] = `
 [
   [
     "onopentagname",
@@ -670,22 +708,32 @@ exports[`Tokenizer > should support self-closing special tags > for self-closing
     6,
   ],
   [
-    "onselfclosingtag",
-    8,
+    "onopentagend",
+    6,
   ],
   [
-    "onopentagname",
+    "ontext",
+    7,
     10,
-    13,
   ],
   [
-    "onopentagend",
-    13,
+    "onclosetag",
+    12,
+    17,
   ],
   [
-    "onclosetag",
-    16,
-    19,
+    "ontextentity",
+    39,
+    24,
+  ],
+  [
+    "onopentagname",
+    25,
+    27,
+  ],
+  [
+    "onselfclosingtag",
+    28,
   ],
   [
     "onend",
@@ -693,30 +741,30 @@ exports[`Tokenizer > should support self-closing special tags > for self-closing
 ]
 `;
 
-exports[`Tokenizer > should support self-closing special tags > for self-closing textarea tag 1`] = `
+exports[`Tokenizer > should not break after special tag followed by an entity > for recognized self-closing special tag 1`] = `
 [
   [
     "onopentagname",
     1,
-    9,
+    6,
   ],
   [
     "onselfclosingtag",
-    11,
+    8,
   ],
   [
-    "onopentagname",
-    13,
-    16,
+    "ontextentity",
+    39,
+    15,
   ],
   [
-    "onopentagend",
+    "onopentagname",
     16,
+    18,
   ],
   [
-    "onclosetag",
+    "onselfclosingtag",
     19,
-    22,
   ],
   [
     "onend",
@@ -724,7 +772,7 @@ exports[`Tokenizer > should support self-closing special tags > for self-closing
 ]
 `;
 
-exports[`Tokenizer > should support self-closing special tags > for self-closing title tag 1`] = `
+exports[`Tokenizer > should not break after special tag followed by an entity > for self-closing special tag 1`] = `
 [
   [
     "onopentagname",
@@ -736,18 +784,27 @@ exports[`Tokenizer > should support self-closing special tags > for self-closing
     8,
   ],
   [
-    "onopentagname",
-    10,
-    13,
+    "ontext",
+    9,
+    20,
   ],
   [
-    "onopentagend",
-    13,
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should not lose data when pausing 1`] = `
+[
+  [
+    "ontextentity",
+    38,
+    5,
   ],
   [
-    "onclosetag",
-    16,
-    19,
+    "ontext",
+    5,
+    12,
   ],
   [
     "onend",
@@ -755,20 +812,20 @@ exports[`Tokenizer > should support self-closing special tags > for self-closing
 ]
 `;
 
-exports[`Tokenizer > should support self-closing special tags > for self-closing xmp tag 1`] = `
+exports[`Tokenizer > should not treat <!-->  as a complete comment in xmlMode 1`] = `
 [
   [
     "onopentagname",
     1,
-    4,
+    5,
   ],
   [
-    "onselfclosingtag",
-    6,
+    "onopentagend",
+    5,
   ],
   [
     "onopentagname",
-    8,
+    7,
     11,
   ],
   [
@@ -776,10 +833,45 @@ exports[`Tokenizer > should support self-closing special tags > for self-closing
     11,
   ],
   [
-    "onclosetag",
-    14,
+    "ontext",
+    12,
     17,
   ],
+  [
+    "onclosetag",
+    19,
+    23,
+  ],
+  [
+    "oncomment",
+    28,
+    58,
+    2,
+  ],
+  [
+    "onopentagname",
+    60,
+    64,
+  ],
+  [
+    "onopentagend",
+    64,
+  ],
+  [
+    "ontext",
+    65,
+    68,
+  ],
+  [
+    "onclosetag",
+    70,
+    74,
+  ],
+  [
+    "onclosetag",
+    77,
+    81,
+  ],
   [
     "onend",
   ],
@@ -979,6 +1071,148 @@ exports[`Tokenizer > should terminate XML processing instructions on ?> 1`] = `
 ]
 `;
 
+exports[`Tokenizer > should treat <!> as a bogus comment 1`] = `
+[
+  [
+    "oncomment",
+    2,
+    2,
+    0,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should treat <!-> as a bogus comment 1`] = `
+[
+  [
+    "oncomment",
+    2,
+    3,
+    0,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should treat <!DOCTYPEhtml> as a declaration 1`] = `
+[
+  [
+    "ondeclaration",
+    2,
+    13,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should treat <? and <! as bogus comments in HTML 1`] = `
+[
+  [
+    "oncomment",
+    1,
+    5,
+    0,
+  ],
+  [
+    "oncomment",
+    8,
+    11,
+    0,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should treat html inside raw-text tags as text > for div inside iframe tag 1`] = `
+[
+  [
+    "onopentagname",
+    1,
+    7,
+  ],
+  [
+    "onopentagend",
+    7,
+  ],
+  [
+    "ontext",
+    8,
+    24,
+  ],
+  [
+    "onclosetag",
+    26,
+    32,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should treat html inside raw-text tags as text > for div inside noembed tag 1`] = `
+[
+  [
+    "onopentagname",
+    1,
+    8,
+  ],
+  [
+    "onopentagend",
+    8,
+  ],
+  [
+    "ontext",
+    9,
+    25,
+  ],
+  [
+    "onclosetag",
+    27,
+    34,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should treat html inside raw-text tags as text > for div inside noframes tag 1`] = `
+[
+  [
+    "onopentagname",
+    1,
+    9,
+  ],
+  [
+    "onopentagend",
+    9,
+  ],
+  [
+    "ontext",
+    10,
+    26,
+  ],
+  [
+    "onclosetag",
+    28,
+    36,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
 exports[`Tokenizer > should treat html inside special tags as text > for div inside script tag 1`] = `
 [
   [
@@ -1113,3 +1347,87 @@ exports[`Tokenizer > should treat html inside special tags as text > for div ins
   ],
 ]
 `;
+
+exports[`Tokenizer > should trim unfinished HTML comment closes at EOF for <!-- 1`] = `
+[
+  [
+    "oncomment",
+    4,
+    4,
+    0,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should trim unfinished HTML comment closes at EOF for <!--- 1`] = `
+[
+  [
+    "oncomment",
+    4,
+    5,
+    1,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should trim unfinished HTML comment closes at EOF for <!---- 1`] = `
+[
+  [
+    "oncomment",
+    4,
+    6,
+    2,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should trim unfinished HTML comment closes at EOF for <!--a- 1`] = `
+[
+  [
+    "oncomment",
+    4,
+    6,
+    1,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should trim unfinished HTML comment closes at EOF for <!--a-- 1`] = `
+[
+  [
+    "oncomment",
+    4,
+    7,
+    2,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
+
+exports[`Tokenizer > should trim unfinished HTML comment closes at EOF for <!--a--! 1`] = `
+[
+  [
+    "oncomment",
+    4,
+    8,
+    3,
+  ],
+  [
+    "onend",
+  ],
+]
+`;
diff --git a/src/__snapshots__/index.spec.ts.snap b/src/__snapshots__/index.spec.ts.snap
index 556bedcb..f79f028f 100644
--- a/src/__snapshots__/index.spec.ts.snap
+++ b/src/__snapshots__/index.spec.ts.snap
@@ -24,22 +24,7 @@ Document {
     >
       <b>
         <c>
-          ProcessingInstruction {
-            "data": "?foo",
-            "endIndex": null,
-            "name": "?foo",
-            "next": Yay!,
-            "parent": <c>
-              [Circular]
-              Yay!
-            </c>,
-            "prev": null,
-            "startIndex": null,
-            "type": "directive",
-            "x-name": undefined,
-            "x-publicId": undefined,
-            "x-systemId": undefined,
-          }
+          <!--?foo-->
           Yay!
         </c>
       </b>
@@ -53,3 +38,19 @@ Document {
   "type": "root",
 }
 `;
+
+exports[`Index > parseDocument in foreign content 1`] = `
+Document {
+  "children": [
+    <svg>
+      a&lt;b
+    </svg>,
+  ],
+  "endIndex": null,
+  "next": null,
+  "parent": null,
+  "prev": null,
+  "startIndex": null,
+  "type": "root",
+}
+`;
diff --git a/src/index.spec.ts b/src/index.spec.ts
index c3e56a9d..80e4ccc3 100644
--- a/src/index.spec.ts
+++ b/src/index.spec.ts
@@ -26,6 +26,11 @@ describe("Index", () => {
         expect(dom).toMatchSnapshot();
     });
 
+    it("parseDocument in foreign content", () => {
+        const dom = parseDocument("<svg><![CDATA[a<b]]></svg>");
+        expect(dom).toMatchSnapshot();
+    });
+
     it("createDocumentStream", () => {
         let documentStream!: Parser;
 

From 69c1b353584ba9c1a899cfa7b5b0c68d61a3decd Mon Sep 17 00:00:00 2001
From: Felix <188768+fb55@users.noreply.github.com>
Date: Fri, 20 Mar 2026 22:26:49 +0000
Subject: [PATCH 2/6] fix foreign content bugs

---
 src/Parser.events.spec.ts                    |  13 +
 src/Parser.ts                                |  30 ++-
 src/__snapshots__/Parser.events.spec.ts.snap | 269 ++++++++++++++++++-
 3 files changed, 295 insertions(+), 17 deletions(-)

diff --git a/src/Parser.events.spec.ts b/src/Parser.events.spec.ts
index 3679d7fa..15dc734e 100644
--- a/src/Parser.events.spec.ts
+++ b/src/Parser.events.spec.ts
@@ -198,6 +198,19 @@ describe("Events", () => {
     it("SVG tag case adjustment", () =>
         runTest("<svg><foreignObject><b>x</b></foreignObject></svg>"));
 
+    it("SVG integration point closing with unclosed child", () =>
+        runTest(
+            "<svg><foreignObject><div>x</foreignObject></svg>after",
+        ));
+
+    it("Content after SVG integration point", () =>
+        runTest(
+            "<svg><foreignObject><b>x</b></foreignObject><rect/></svg>",
+        ));
+
+    it("Stray </svg> does not break foreign context", () =>
+        runTest("</svg><script><b>not a tag</b></script>"));
+
     it("HTML image alias", () => runTest("<image></image>"));
 
     it("SVG image is not aliased", () => runTest("<svg><image></image></svg>"));
diff --git a/src/Parser.ts b/src/Parser.ts
index 1aa0f026..c596f957 100644
--- a/src/Parser.ts
+++ b/src/Parser.ts
@@ -358,25 +358,26 @@ export class Parser implements Callbacks {
             return name;
         }
 
-        if (!this.isInForeignContext()) {
-            return name === "image" ? "img" : name;
-        }
-
         if (this.foreignContext[0] === ForeignContext.Svg) {
             return svgTagNameAdjustments.get(name) ?? name;
         }
 
         /*
          * Closing tags for SVG elements inside HTML integration points
-         * (e.g. </foreignObject>) still need case adjustment.
+         * (e.g. </foreignObject> while inside its own content) still need
+         * case adjustment so the name matches what was pushed to the stack.
          */
         if (this.foreignContext.length > 1) {
             const adjusted = svgTagNameAdjustments.get(name);
-            if (adjusted !== undefined && adjusted === this.stack[0]) {
+            if (adjusted !== undefined && this.stack.includes(adjusted)) {
                 return adjusted;
             }
         }
 
+        if (!this.isInForeignContext()) {
+            return name === "image" ? "img" : name;
+        }
+
         return name;
     }
 
@@ -463,17 +464,18 @@ export class Parser implements Callbacks {
         this.endIndex = endIndex;
         const name = this.readTagName(start, endIndex);
 
-        if (
-            this.htmlMode &&
-            (foreignContextElements.has(name) ||
-                htmlIntegrationElements.has(name))
-        ) {
-            this.foreignContext.shift();
-        }
-
         if (!this.isVoidElement(name)) {
             const pos = this.stack.indexOf(name);
             if (pos !== -1) {
+                // Only shift foreignContext when the element is actually on
+                // the stack — a stray </svg> must not underflow the stack.
+                if (
+                    this.htmlMode &&
+                    (foreignContextElements.has(name) ||
+                        htmlIntegrationElements.has(name))
+                ) {
+                    this.foreignContext.shift();
+                }
                 for (let index = 0; index <= pos; index++) {
                     const element = this.stack.shift();
                     if (element === undefined) {
diff --git a/src/__snapshots__/Parser.events.spec.ts.snap b/src/__snapshots__/Parser.events.spec.ts.snap
index b4ce2e06..85b1a39c 100644
--- a/src/__snapshots__/Parser.events.spec.ts.snap
+++ b/src/__snapshots__/Parser.events.spec.ts.snap
@@ -432,6 +432,127 @@ exports[`Events > Comment false ending 1`] = `
 ]
 `;
 
+exports[`Events > Content after SVG integration point 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "foreignObject",
+    ],
+    "endIndex": 19,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "foreignObject",
+      {},
+      false,
+    ],
+    "endIndex": 19,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "b",
+    ],
+    "endIndex": 22,
+    "startIndex": 20,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "b",
+      {},
+      false,
+    ],
+    "endIndex": 22,
+    "startIndex": 20,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "x",
+    ],
+    "endIndex": 23,
+    "startIndex": 23,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "b",
+      false,
+    ],
+    "endIndex": 27,
+    "startIndex": 24,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "foreignObject",
+      false,
+    ],
+    "endIndex": 43,
+    "startIndex": 28,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "rect",
+    ],
+    "endIndex": 49,
+    "startIndex": 44,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "rect",
+      {},
+      false,
+    ],
+    "endIndex": 50,
+    "startIndex": 44,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "rect",
+      true,
+    ],
+    "endIndex": 50,
+    "startIndex": 44,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      false,
+    ],
+    "endIndex": 56,
+    "startIndex": 51,
+  },
+]
+`;
+
 exports[`Events > Doctype without whitespace 1`] = `
 [
   {
@@ -2112,6 +2233,108 @@ exports[`Events > SVG image is not aliased 1`] = `
 ]
 `;
 
+exports[`Events > SVG integration point closing with unclosed child 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "foreignObject",
+    ],
+    "endIndex": 19,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "foreignObject",
+      {},
+      false,
+    ],
+    "endIndex": 19,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "div",
+    ],
+    "endIndex": 24,
+    "startIndex": 20,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "div",
+      {},
+      false,
+    ],
+    "endIndex": 24,
+    "startIndex": 20,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "x",
+    ],
+    "endIndex": 25,
+    "startIndex": 25,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "div",
+      true,
+    ],
+    "endIndex": 41,
+    "startIndex": 26,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "foreignObject",
+      false,
+    ],
+    "endIndex": 41,
+    "startIndex": 26,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      false,
+    ],
+    "endIndex": 47,
+    "startIndex": 42,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "after",
+    ],
+    "endIndex": 52,
+    "startIndex": 48,
+  },
+]
+`;
+
 exports[`Events > SVG tag case adjustment 1`] = `
 [
   {
@@ -2189,10 +2412,10 @@ exports[`Events > SVG tag case adjustment 1`] = `
     "$event": "closetag",
     "data": [
       "foreignObject",
-      true,
+      false,
     ],
-    "endIndex": 49,
-    "startIndex": 44,
+    "endIndex": 43,
+    "startIndex": 28,
   },
   {
     "$event": "closetag",
@@ -3359,6 +3582,46 @@ exports[`Events > Start & end indices from domhandler 1`] = `
 ]
 `;
 
+exports[`Events > Stray </svg> does not break foreign context 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "script",
+    ],
+    "endIndex": 13,
+    "startIndex": 6,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "script",
+      {},
+      false,
+    ],
+    "endIndex": 13,
+    "startIndex": 6,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "<b>not a tag</b>",
+    ],
+    "endIndex": 29,
+    "startIndex": 14,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "script",
+      false,
+    ],
+    "endIndex": 38,
+    "startIndex": 30,
+  },
+]
+`;
+
 exports[`Events > Template script tags 1`] = `
 [
   {

From 55695db45f4d875a189ec01f1f9793b797ce57fa Mon Sep 17 00:00:00 2001
From: Felix <188768+fb55@users.noreply.github.com>
Date: Fri, 20 Mar 2026 22:38:55 +0000
Subject: [PATCH 3/6] simplify

---
 src/Parser.events.spec.ts                    |  16 +-
 src/Parser.ts                                |  40 ++--
 src/Tokenizer.ts                             |   2 +
 src/__snapshots__/Parser.events.spec.ts.snap | 196 +++++++++++++++++++
 4 files changed, 230 insertions(+), 24 deletions(-)

diff --git a/src/Parser.events.spec.ts b/src/Parser.events.spec.ts
index 15dc734e..40c4c85e 100644
--- a/src/Parser.events.spec.ts
+++ b/src/Parser.events.spec.ts
@@ -199,18 +199,22 @@ describe("Events", () => {
         runTest("<svg><foreignObject><b>x</b></foreignObject></svg>"));
 
     it("SVG integration point closing with unclosed child", () =>
-        runTest(
-            "<svg><foreignObject><div>x</foreignObject></svg>after",
-        ));
+        runTest("<svg><foreignObject><div>x</foreignObject></svg>after"));
 
     it("Content after SVG integration point", () =>
-        runTest(
-            "<svg><foreignObject><b>x</b></foreignObject><rect/></svg>",
-        ));
+        runTest("<svg><foreignObject><b>x</b></foreignObject><rect/></svg>"));
 
     it("Stray </svg> does not break foreign context", () =>
         runTest("</svg><script><b>not a tag</b></script>"));
 
+    it("Implicit close of nested foreign elements", () =>
+        runTest("<svg><math><mi>text</svg><script><b>x</b></script>"));
+
+    it("Self-closing foreign element with recognizeSelfClosing", () =>
+        runTest("<svg/><script><b>x</b></script>", {
+            recognizeSelfClosing: true,
+        }));
+
     it("HTML image alias", () => runTest("<image></image>"));
 
     it("SVG image is not aliased", () => runTest("<svg><image></image></svg>"));
diff --git a/src/Parser.ts b/src/Parser.ts
index c596f957..d3644a6f 100644
--- a/src/Parser.ts
+++ b/src/Parser.ts
@@ -467,22 +467,10 @@ export class Parser implements Callbacks {
         if (!this.isVoidElement(name)) {
             const pos = this.stack.indexOf(name);
             if (pos !== -1) {
-                // Only shift foreignContext when the element is actually on
-                // the stack — a stray </svg> must not underflow the stack.
-                if (
-                    this.htmlMode &&
-                    (foreignContextElements.has(name) ||
-                        htmlIntegrationElements.has(name))
-                ) {
-                    this.foreignContext.shift();
-                }
-                for (let index = 0; index <= pos; index++) {
-                    const element = this.stack.shift();
-                    if (element === undefined) {
-                        break;
-                    }
-                    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");
@@ -516,15 +504,31 @@ 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);
         }
     }
 
diff --git a/src/Tokenizer.ts b/src/Tokenizer.ts
index 76d68f92..2f7d655c 100644
--- a/src/Tokenizer.ts
+++ b/src/Tokenizer.ts
@@ -899,6 +899,8 @@ export default class Tokenizer {
                     break;
                 }
                 case State.InPlainText: {
+                    // Skip to end of buffer; cleanup() emits the text.
+                    this.index = this.buffer.length + this.offset - 1;
                     break;
                 }
                 case State.SpecialStartSequence: {
diff --git a/src/__snapshots__/Parser.events.spec.ts.snap b/src/__snapshots__/Parser.events.spec.ts.snap
index 85b1a39c..686fcafc 100644
--- a/src/__snapshots__/Parser.events.spec.ts.snap
+++ b/src/__snapshots__/Parser.events.spec.ts.snap
@@ -962,6 +962,135 @@ exports[`Events > HTML image alias 1`] = `
 ]
 `;
 
+exports[`Events > Implicit close of nested foreign elements 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "math",
+    ],
+    "endIndex": 10,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "math",
+      {},
+      false,
+    ],
+    "endIndex": 10,
+    "startIndex": 5,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "mi",
+    ],
+    "endIndex": 14,
+    "startIndex": 11,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "mi",
+      {},
+      false,
+    ],
+    "endIndex": 14,
+    "startIndex": 11,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "text",
+    ],
+    "endIndex": 18,
+    "startIndex": 15,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "mi",
+      true,
+    ],
+    "endIndex": 24,
+    "startIndex": 19,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "math",
+      true,
+    ],
+    "endIndex": 24,
+    "startIndex": 19,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      false,
+    ],
+    "endIndex": 24,
+    "startIndex": 19,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "script",
+    ],
+    "endIndex": 32,
+    "startIndex": 25,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "script",
+      {},
+      false,
+    ],
+    "endIndex": 32,
+    "startIndex": 25,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "<b>x</b>",
+    ],
+    "endIndex": 40,
+    "startIndex": 33,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "script",
+      false,
+    ],
+    "endIndex": 49,
+    "startIndex": 41,
+  },
+]
+`;
+
 exports[`Events > Implicit close tags 1`] = `
 [
   {
@@ -2638,6 +2767,73 @@ exports[`Events > Scripts ending with < 1`] = `
 ]
 `;
 
+exports[`Events > Self-closing foreign element with recognizeSelfClosing 1`] = `
+[
+  {
+    "$event": "opentagname",
+    "data": [
+      "svg",
+    ],
+    "endIndex": 4,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "svg",
+      {},
+      false,
+    ],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "svg",
+      true,
+    ],
+    "endIndex": 5,
+    "startIndex": 0,
+  },
+  {
+    "$event": "opentagname",
+    "data": [
+      "script",
+    ],
+    "endIndex": 13,
+    "startIndex": 6,
+  },
+  {
+    "$event": "opentag",
+    "data": [
+      "script",
+      {},
+      false,
+    ],
+    "endIndex": 13,
+    "startIndex": 6,
+  },
+  {
+    "$event": "text",
+    "data": [
+      "<b>x</b>",
+    ],
+    "endIndex": 21,
+    "startIndex": 14,
+  },
+  {
+    "$event": "closetag",
+    "data": [
+      "script",
+      false,
+    ],
+    "endIndex": 30,
+    "startIndex": 22,
+  },
+]
+`;
+
 exports[`Events > Self-closing indices (#941) 1`] = `
 [
   {

From 25f2363e7eab8447d6587e3d7581e21419156c08 Mon Sep 17 00:00:00 2001
From: Felix <188768+fb55@users.noreply.github.com>
Date: Fri, 20 Mar 2026 22:56:14 +0000
Subject: [PATCH 4/6] fix

---
 src/Parser.ts    | 7 ++-----
 src/Tokenizer.ts | 6 +++---
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/Parser.ts b/src/Parser.ts
index d3644a6f..18baf752 100644
--- a/src/Parser.ts
+++ b/src/Parser.ts
@@ -405,11 +405,7 @@ export class Parser implements Callbacks {
 
         if (impliesClose) {
             while (this.stack.length > 0 && impliesClose.has(this.stack[0])) {
-                const element = this.stack.shift();
-                if (element === undefined) {
-                    break;
-                }
-                this.cbs.onclosetag?.(element, true);
+                this.popElement(true);
             }
         }
         if (!this.isVoidElement(name)) {
@@ -705,6 +701,7 @@ export class Parser implements Callbacks {
         this.tokenizer.reset();
         this.tagname = "";
         this.attribname = "";
+        this.attribvalue = "";
         this.attribs = null;
         this.stack.length = 0;
         this.startIndex = 0;
diff --git a/src/Tokenizer.ts b/src/Tokenizer.ts
index 2f7d655c..b66f9a77 100644
--- a/src/Tokenizer.ts
+++ b/src/Tokenizer.ts
@@ -207,7 +207,7 @@ export default class Tokenizer {
         {
             xmlMode = false,
             decodeEntities = true,
-            recognizeSelfClosing = false,
+            recognizeSelfClosing = xmlMode,
         }: {
             xmlMode?: boolean;
             decodeEntities?: boolean;
@@ -513,7 +513,7 @@ export default class Tokenizer {
                     this.startEntity();
                 }
             } else if (this.fastForwardTo(CharCodes.Lt)) {
-                // Outside of <title> tags, we can fast-forward.
+                // Outside of RCDATA tags, we can fast-forward.
                 this.sequenceIndex = 1;
             }
         } else {
@@ -627,7 +627,7 @@ export default class Tokenizer {
             this.cbs.onselfclosingtag(this.index);
             this.sectionStart = this.index + 1;
 
-            if (!(this.xmlMode || this.recognizeSelfClosing)) {
+            if (!this.recognizeSelfClosing) {
                 this.enterTagBody();
                 return;
             }

From d9fa35fbdafc0b962e3a9a49120229f1adea8e74 Mon Sep 17 00:00:00 2001
From: Felix <188768+fb55@users.noreply.github.com>
Date: Fri, 20 Mar 2026 23:04:01 +0000
Subject: [PATCH 5/6] improve comments

---
 src/Parser.ts    | 19 ++++++++++++++++---
 src/Tokenizer.ts |  7 ++++++-
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/Parser.ts b/src/Parser.ts
index 18baf752..d26dc9cc 100644
--- a/src/Parser.ts
+++ b/src/Parser.ts
@@ -94,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",
@@ -364,8 +370,10 @@ export class Parser implements Callbacks {
 
         /*
          * Closing tags for SVG elements inside HTML integration points
-         * (e.g. </foreignObject> while inside its own content) still need
-         * case adjustment so the name matches what was pushed to the stack.
+         * (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);
@@ -395,7 +403,12 @@ export class Parser implements Callbacks {
         this.openTagStart = this.startIndex;
         this.tagname = name;
 
-        // The spec ignores a second <form> when one is already open.
+        /*
+         * 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;
diff --git a/src/Tokenizer.ts b/src/Tokenizer.ts
index b66f9a77..be64a327 100644
--- a/src/Tokenizer.ts
+++ b/src/Tokenizer.ts
@@ -420,10 +420,15 @@ export default class Tokenizer {
             !this.xmlMode &&
             this.currentSequence === Sequences.CommentEnd &&
             this.sequenceIndex <= 1 &&
+            /*
+             * We're still at the very start of the comment: the only
+             * characters consumed since `<!--` are the dashes that
+             * advanced sequenceIndex (0 for `<!-->`, 1 for `<!--->`).
+             */
             this.index === this.sectionStart + this.sequenceIndex &&
             c === CharCodes.Gt
         ) {
-            // `<!-->` and `<!--->` are valid empty HTML comments.
+            // Abruptly closed empty HTML comment.
             this.emitComment(this.sequenceIndex);
         } else if (
             this.currentSequence === Sequences.CommentEnd &&

From ada72e50c552461d45474ab770d13e2e909f2a52 Mon Sep 17 00:00:00 2001
From: Felix <188768+fb55@users.noreply.github.com>
Date: Fri, 20 Mar 2026 23:06:13 +0000
Subject: [PATCH 6/6] Update Parser.ts

---
 src/Parser.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Parser.ts b/src/Parser.ts
index d26dc9cc..800ca0e7 100644
--- a/src/Parser.ts
+++ b/src/Parser.ts
@@ -96,7 +96,7 @@ 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.
  */