fix: parseincompletemarkdown emphasis character block issue (#94)

* Handle trailing markdown

* Fix nested italics

* Create old-facts-beg.md

Author: haydenbleasel

.changeset/old-facts-beg.md

@@ -0,0 +1,5 @@
+---
+"streamdown": patch
+---
+
+fix: parseIncompleteMarkdown Emphasis Character Block Issue

packages/streamdown/__tests__/parse-incomplete-markdown.test.ts

@@ -781,10 +781,10 @@ describe("parseIncompleteMarkdown", () => {
   describe("edge cases", () => {
     it("should handle text ending with formatting characters", () => {
       expect(parseIncompleteMarkdown("Text ending with *")).toBe(
-        "Text ending with **"
+        "Text ending with *"
       );
       expect(parseIncompleteMarkdown("Text ending with **")).toBe(
-        "Text ending with ****"
+        "Text ending with **"
       );
     });
 
@@ -793,16 +793,45 @@ describe("parseIncompleteMarkdown", () => {
       expect(parseIncompleteMarkdown("``")).toBe("``");
     });
 
+    it("should handle standalone emphasis characters (issue #90)", () => {
+      // Standalone markers should not be auto-closed
+      expect(parseIncompleteMarkdown("**")).toBe("**");
+      expect(parseIncompleteMarkdown("__")).toBe("__");
+      expect(parseIncompleteMarkdown("***")).toBe("***");
+      expect(parseIncompleteMarkdown("*")).toBe("*");
+      expect(parseIncompleteMarkdown("_")).toBe("_");
+      expect(parseIncompleteMarkdown("~~")).toBe("~~");
+      expect(parseIncompleteMarkdown("`")).toBe("`");
+      
+      // Multiple standalone markers on the same line
+      expect(parseIncompleteMarkdown("** __")).toBe("** __");
+      expect(parseIncompleteMarkdown("\n** __\n")).toBe("\n** __\n");
+      expect(parseIncompleteMarkdown("* _ ~~ `")).toBe("* _ ~~ `");
+      
+      // Standalone markers with only whitespace
+      expect(parseIncompleteMarkdown("** ")).toBe("** ");
+      expect(parseIncompleteMarkdown(" **")).toBe(" **");
+      expect(parseIncompleteMarkdown("  **  ")).toBe("  **  ");
+      
+      // But markers with actual content should still be closed
+      expect(parseIncompleteMarkdown("**text")).toBe("**text**");
+      expect(parseIncompleteMarkdown("__text")).toBe("__text__");
+      expect(parseIncompleteMarkdown("*text")).toBe("*text*");
+      expect(parseIncompleteMarkdown("_text")).toBe("_text_");
+      expect(parseIncompleteMarkdown("~~text")).toBe("~~text~~");
+      expect(parseIncompleteMarkdown("`text")).toBe("`text`");
+    });
+
     it("should handle very long text", () => {
       const longText = `${"a".repeat(10_000)} **bold`;
       const expected = `${"a".repeat(10_000)} **bold**`;
       expect(parseIncompleteMarkdown(longText)).toBe(expected);
     });
 
     it("should handle text with only formatting characters", () => {
-      expect(parseIncompleteMarkdown("*")).toBe("**");
-      expect(parseIncompleteMarkdown("**")).toBe("****");
-      expect(parseIncompleteMarkdown("`")).toBe("``");
+      expect(parseIncompleteMarkdown("*")).toBe("*");
+      expect(parseIncompleteMarkdown("**")).toBe("**");
+      expect(parseIncompleteMarkdown("`")).toBe("`");
     });
 
     it("should handle escaped characters", () => {
@@ -811,11 +840,11 @@ describe("parseIncompleteMarkdown", () => {
     });
 
     it("should handle markdown at very end of string", () => {
-      expect(parseIncompleteMarkdown("text**")).toBe("text****");
-      expect(parseIncompleteMarkdown("text*")).toBe("text**");
-      expect(parseIncompleteMarkdown("text`")).toBe("text``");
+      expect(parseIncompleteMarkdown("text**")).toBe("text**");
+      expect(parseIncompleteMarkdown("text*")).toBe("text*");
+      expect(parseIncompleteMarkdown("text`")).toBe("text`");
       expect(parseIncompleteMarkdown("text$")).toBe("text$"); // Single dollar not completed
-      expect(parseIncompleteMarkdown("text~~")).toBe("text~~~~");
+      expect(parseIncompleteMarkdown("text~~")).toBe("text~~");
     });
 
     it("should handle whitespace before incomplete markdown", () => {

packages/streamdown/lib/parse-incomplete-markdown.ts

@@ -46,6 +46,14 @@ const handleIncompleteBold = (text: string): string => {
   const boldMatch = text.match(boldPattern);
 
   if (boldMatch) {
+    // Don't close if there's no meaningful content after the opening markers
+    // boldMatch[2] contains the content after **
+    // Check if content is only whitespace or other emphasis markers
+    const contentAfterMarker = boldMatch[2];
+    if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+      return text;
+    }
+    
     const asteriskPairs = (text.match(/\*\*/g) || []).length;
     if (asteriskPairs % 2 === 1) {
       return `${text}**`;
@@ -60,6 +68,14 @@ const handleIncompleteDoubleUnderscoreItalic = (text: string): string => {
   const italicMatch = text.match(italicPattern);
 
   if (italicMatch) {
+    // Don't close if there's no meaningful content after the opening markers
+    // italicMatch[2] contains the content after __
+    // Check if content is only whitespace or other emphasis markers
+    const contentAfterMarker = italicMatch[2];
+    if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+      return text;
+    }
+    
     const underscorePairs = (text.match(/__/g) || []).length;
     if (underscorePairs % 2 === 1) {
       return `${text}__`;
@@ -119,6 +135,28 @@ const handleIncompleteSingleAsteriskItalic = (text: string): string => {
   const singleAsteriskMatch = text.match(singleAsteriskPattern);
 
   if (singleAsteriskMatch) {
+    // Find the first single asterisk position (not part of **)
+    let firstSingleAsteriskIndex = -1;
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === '*' && text[i-1] !== '*' && text[i+1] !== '*') {
+        firstSingleAsteriskIndex = i;
+        break;
+      }
+    }
+    
+    if (firstSingleAsteriskIndex === -1) {
+      return text;
+    }
+    
+    // Get content after the first single asterisk
+    const contentAfterFirstAsterisk = text.substring(firstSingleAsteriskIndex + 1);
+    
+    // Check if there's meaningful content after the asterisk
+    // Don't close if content is only whitespace or emphasis markers
+    if (!contentAfterFirstAsterisk || /^[\s_~*`]*$/.test(contentAfterFirstAsterisk)) {
+      return text;
+    }
+    
     const singleAsterisks = countSingleAsterisks(text);
     if (singleAsterisks % 2 === 1) {
       return `${text}*`;
@@ -189,6 +227,28 @@ const handleIncompleteSingleUnderscoreItalic = (text: string): string => {
   const singleUnderscoreMatch = text.match(singleUnderscorePattern);
 
   if (singleUnderscoreMatch) {
+    // Find the first single underscore position (not part of __)
+    let firstSingleUnderscoreIndex = -1;
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === '_' && text[i-1] !== '_' && text[i+1] !== '_' && !isWithinMathBlock(text, i)) {
+        firstSingleUnderscoreIndex = i;
+        break;
+      }
+    }
+    
+    if (firstSingleUnderscoreIndex === -1) {
+      return text;
+    }
+    
+    // Get content after the first single underscore
+    const contentAfterFirstUnderscore = text.substring(firstSingleUnderscoreIndex + 1);
+    
+    // Check if there's meaningful content after the underscore
+    // Don't close if content is only whitespace or emphasis markers
+    if (!contentAfterFirstUnderscore || /^[\s_~*`]*$/.test(contentAfterFirstUnderscore)) {
+      return text;
+    }
+    
     const singleUnderscores = countSingleUnderscores(text);
     if (singleUnderscores % 2 === 1) {
       return `${text}_`;
@@ -260,6 +320,14 @@ const handleIncompleteInlineCode = (text: string): string => {
   const inlineCodeMatch = text.match(inlineCodePattern);
 
   if (inlineCodeMatch && !insideIncompleteCodeBlock) {
+    // Don't close if there's no meaningful content after the opening marker
+    // inlineCodeMatch[2] contains the content after `
+    // Check if content is only whitespace or other emphasis markers
+    const contentAfterMarker = inlineCodeMatch[2];
+    if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+      return text;
+    }
+    
     const singleBacktickCount = countSingleBackticks(text);
     if (singleBacktickCount % 2 === 1) {
       return `${text}\``;
@@ -274,6 +342,14 @@ const handleIncompleteStrikethrough = (text: string): string => {
   const strikethroughMatch = text.match(strikethroughPattern);
 
   if (strikethroughMatch) {
+    // Don't close if there's no meaningful content after the opening markers
+    // strikethroughMatch[2] contains the content after ~~
+    // Check if content is only whitespace or other emphasis markers
+    const contentAfterMarker = strikethroughMatch[2];
+    if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+      return text;
+    }
+    
     const tildePairs = (text.match(/~~/g) || []).length;
     if (tildePairs % 2 === 1) {
       return `${text}~~`;
@@ -359,6 +435,14 @@ const handleIncompleteBoldItalic = (text: string): string => {
   const boldItalicMatch = text.match(boldItalicPattern);
 
   if (boldItalicMatch) {
+    // Don't close if there's no meaningful content after the opening markers
+    // boldItalicMatch[2] contains the content after ***
+    // Check if content is only whitespace or other emphasis markers
+    const contentAfterMarker = boldItalicMatch[2];
+    if (!contentAfterMarker || /^[\s_~*`]*$/.test(contentAfterMarker)) {
+      return text;
+    }
+    
     const tripleAsteriskCount = countTripleAsterisks(text);
     if (tripleAsteriskCount % 2 === 1) {
       return `${text}***`;