From 0f98267a8519ee6563dceae5ee31db3d60d2844f Mon Sep 17 00:00:00 2001 From: Alexandre Mutel Date: Sat, 13 Jun 2026 08:47:21 +0200 Subject: [PATCH] Fix pipe table cells with unmatched subscript (#932) --- src/Markdig.Tests/TestPipeTable.cs | 29 ++ .../Extensions/Tables/PipeTableExtension.cs | 7 +- .../Extensions/Tables/PipeTableParser.cs | 302 +++++++++++++++--- 3 files changed, 287 insertions(+), 51 deletions(-) diff --git a/src/Markdig.Tests/TestPipeTable.cs b/src/Markdig.Tests/TestPipeTable.cs index 6486329e..c282740e 100644 --- a/src/Markdig.Tests/TestPipeTable.cs +++ b/src/Markdig.Tests/TestPipeTable.cs @@ -162,6 +162,35 @@ public sealed class TestPipeTable Assert.That(html, Does.Contain("Code block")); } + [Test] + public void BoldTableCellWithUnmatchedSubscriptDelimiterDoesNotAddCells() + { + const string markdown = + """ + | Component | Per query | Per 1,000 queries | + |-----------|-----------|-------------------| + | Embedding | ~$0.00001 | ~$0.01 | + | LLM | ~$0.0015 | ~$1.50 | + | **Total** | **~$0.0015** | **~$1.50** | + """; + + var pipeline = new MarkdownPipelineBuilder() + .UseAdvancedExtensions() + .Build(); + + var document = Markdown.Parse(markdown, pipeline); + var table = document.Descendants().OfType().Single(); + var rows = table.OfType().ToArray(); + + Assert.That(rows, Has.Length.EqualTo(4)); + Assert.That(rows, Has.All.Count.EqualTo(3)); + + var html = Markdown.ToHtml(markdown, pipeline); + + Assert.That(html, Does.Contain("")); + Assert.That(html, Does.Contain("")); + } + [Test] public void CodeInlineWithIndentedContentPreservesWhitespace() { diff --git a/src/Markdig/Extensions/Tables/PipeTableExtension.cs b/src/Markdig/Extensions/Tables/PipeTableExtension.cs index bea6dffc..de70da20 100644 --- a/src/Markdig/Extensions/Tables/PipeTableExtension.cs +++ b/src/Markdig/Extensions/Tables/PipeTableExtension.cs @@ -41,7 +41,12 @@ public class PipeTableExtension : IMarkdownExtension var lineBreakParser = pipeline.InlineParsers.FindExact(); if (!pipeline.InlineParsers.Contains()) { - pipeline.InlineParsers.InsertAfter(new PipeTableParser(lineBreakParser!, Options)); + // Pipe table post-processing must split the paragraph into isolated table cells before emphasis + // post-processing can pair delimiters across the paragraph. Otherwise an unmatched emphasis-extra + // delimiter inside a cell, e.g. the subscript `~` in `**~$1.50**`, can leave pipe delimiters nested + // in an emphasis delimiter tree and make the table parser see phantom cells. PipeTableParser re-runs + // inline post-processors inside each extracted cell after the table structure has been fixed. + pipeline.InlineParsers.InsertBefore(new PipeTableParser(lineBreakParser!, Options)); } } diff --git a/src/Markdig/Extensions/Tables/PipeTableParser.cs b/src/Markdig/Extensions/Tables/PipeTableParser.cs index c3bbb95d..9eafcc1a 100644 --- a/src/Markdig/Extensions/Tables/PipeTableParser.cs +++ b/src/Markdig/Extensions/Tables/PipeTableParser.cs @@ -240,9 +240,17 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor var cells = tableState.Cells; cells.Clear(); - // Pipes may end up nested inside unmatched emphasis delimiters, e.g.: - // *a | b*| - // Promote them to root level so we have a flat sibling structure. + // Pipe tables are post-processed before emphasis is resolved so that table boundaries win over + // emphasis/subscript spans. At this point unmatched emphasis-extra delimiters may still be open + // containers; for example `**~$0.0015**` leaves an unresolved `~` delimiter inside the delimiter + // structure for the bold cell. + // If a pipe or line break was emitted while such a container was open, it is not a root-level + // sibling and cannot be used reliably as a cell/row boundary. Normalize these delimiters first; + // cell contents are post-processed for emphasis again after each cell has been isolated. + if (HasNestedDelimiters(delimiters, container)) + { + PromoteNestedLineBreaksToRootLevel(container); + } PromoteNestedPipesToRootLevel(delimiters, container); // The inline tree is now flat: all pipes and line breaks are siblings at root level. @@ -288,8 +296,11 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor firstRow ??= row; - // Skip leading pipe at start of row (e.g., `| a | b` or `| a | b |`) - if (pipeSeparator != null && (delimiter.PreviousSibling is null || delimiter.PreviousSibling is LineBreakInline)) + // Skip leading pipe at start of row (e.g., `| a | b` or `| a | b |`). Delimiter promotion + // can leave empty wrapper inlines before the pipe; ignore them so a leading pipe is not + // mistaken for an empty first cell. + var previousSignificantSibling = SkipPreviousEmptyInlines(delimiter.PreviousSibling); + if (pipeSeparator != null && (previousSignificantSibling is null || previousSignificantSibling is LineBreakInline)) { delimiter.Remove(); if (table.Span.IsEmpty) @@ -325,13 +336,10 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor cellContentIt = cellContentIt.PreviousSibling; } - // If the current delimiter is a pipe `|` OR - // the beginOfCell/endOfCell are not null and - // either they are: - // - different - // - they contain a single element, but it is not a line break (\n) or an empty/whitespace Literal. - // Then we can add a cell to the current row - if (!isLine || (beginOfCell != null && endOfCell != null && ( beginOfCell != endOfCell || !(beginOfCell is LineBreakInline || (beginOfCell is LiteralInline beingOfCellLiteral && beingOfCellLiteral.Content.IsEmptyOrWhitespace()))))) + // A pipe delimiter always starts a new cell. A line break only closes a cell when there is real + // content between it and the previous boundary. Delimiter promotion may leave only whitespace or + // empty plain containers in that range; treating those as empty avoids phantom cells at row ends. + if (!isLine || (beginOfCell != null && endOfCell != null && !IsEmptyInlineRange(beginOfCell, endOfCell))) { // We trim whitespace at the beginning and ending of the cell TrimStart(beginOfCell); @@ -346,8 +354,8 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor { var nextSibling = cellIt.NextSibling; - // Skip empty literals (can result from trimming) - if (cellIt is LiteralInline { Content.IsEmpty: true }) + // Skip empty inlines (can result from trimming or delimiter promotion) + if (IsEmptyInline(cellIt)) { cellIt.Remove(); cellIt = nextSibling; @@ -355,17 +363,14 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor } cellIt.Remove(); - if (cellContainer.Span.IsEmpty) - { - cellContainer.Line = cellIt.Line; - cellContainer.Column = cellIt.Column; - cellContainer.Span = cellIt.Span; - } - cellContainer.AppendChild(cellIt); - cellContainer.Span.End = cellIt.Span.End; + AppendCellInline(cellContainer, cellIt); cellIt = nextSibling; } + TrimStart(cellContainer.FirstChild); + TrimEnd(cellContainer.LastChild); + RemoveEmptyBoundaryInlines(cellContainer); + if (!isLine) { // Remove the pipe delimiter AFTER copying cell content @@ -437,9 +442,10 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor table.ColumnDefinitions.AddRange(aligns); } - // Perform all post-processors on cell content - // With InsertAfter, emphasis runs before pipe table, so we need to re-run from index 0 - // to ensure emphasis delimiters in cells are properly matched + // Perform all post-processors on cell content. The first pass deliberately ran pipe tables before + // emphasis so an unresolved emphasis/subscript delimiter could not claim pipes from neighboring + // cells. Now each cell has its own inline root, so re-running from index 0 lets emphasis, links, and + // other post-processors resolve normally, but only within that cell. foreach (var cell in cells) { var paragraph = (ParagraphBlock) cell[0]; @@ -657,6 +663,77 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor return inline; } + private static Inline? SkipPreviousEmptyInlines(Inline? inline) + { + // Promotion can split an unresolved delimiter container into an empty plain ContainerInline followed + // by the promoted pipe. Such containers are structural leftovers, not table content. + while (inline is not null && IsEmptyOrWhitespaceInline(inline)) + { + inline = inline.PreviousSibling; + } + + return inline; + } + + private static bool IsEmptyInlineRange(Inline begin, Inline end) + { + var inline = begin; + while (inline is not null) + { + if (!IsEmptyOrWhitespaceInline(inline)) + { + return false; + } + + if (inline == end) + { + return true; + } + + inline = inline.NextSibling; + } + + return true; + } + + private static bool IsEmptyInline(Inline inline) + { + return IsEmptyInline(inline, whitespaceIsEmpty: false); + } + + private static bool IsEmptyOrWhitespaceInline(Inline inline) + { + return IsEmptyInline(inline, whitespaceIsEmpty: true); + } + + private static bool IsEmptyInline(Inline inline, bool whitespaceIsEmpty) + { + if (inline is LiteralInline literal) + { + return whitespaceIsEmpty ? literal.Content.IsEmptyOrWhitespace() : literal.Content.IsEmpty; + } + + // Only a plain ContainerInline is considered synthetic/transparent here. Derived containers such as + // EmphasisInline or PipeTableDelimiterInline carry markdown semantics and must remain visible. + if (inline.GetType() == typeof(ContainerInline)) + { + var child = ((ContainerInline)inline).FirstChild; + while (child is not null) + { + if (!IsEmptyInline(child, whitespaceIsEmpty)) + { + return false; + } + + child = child.NextSibling; + } + + return true; + } + + return false; + } + private static bool IsLine(Inline inline) { return inline is LineBreakInline; @@ -728,12 +805,130 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor return false; } + private static void AppendCellInline(ContainerInline cellContainer, Inline inline) + { + // SplitContainerAtDelimiter introduces plain wrappers for content that used to live after a promoted + // boundary inside an unresolved delimiter. Flatten those wrappers while moving content into the cell; + // keeping them would make trimming/emptiness checks see artificial cell content. Semantic containers + // are preserved because the type check below only matches exactly ContainerInline. + if (inline.GetType() == typeof(ContainerInline)) + { + var container = (ContainerInline)inline; + var child = container.FirstChild; + while (child is not null) + { + var next = child.NextSibling; + child.Remove(); + AppendCellInline(cellContainer, child); + child = next; + } + + return; + } + + if (IsEmptyInline(inline)) + { + return; + } + + if (cellContainer.Span.IsEmpty) + { + cellContainer.Line = inline.Line; + cellContainer.Column = inline.Column; + cellContainer.Span = inline.Span; + } + + cellContainer.AppendChild(inline); + cellContainer.Span.End = inline.Span.End; + } + + private static void RemoveEmptyBoundaryInlines(ContainerInline container) + { + // After flattening, trimming can expose empty synthetic wrappers at the cell boundaries. Drop them so + // the cell span and later inline post-processing are based on real cell content. + while (container.FirstChild is not null && IsEmptyOrWhitespaceInline(container.FirstChild)) + { + container.FirstChild.Remove(); + } + + while (container.LastChild is not null && IsEmptyOrWhitespaceInline(container.LastChild)) + { + container.LastChild.Remove(); + } + + container.UpdateSpanFromChildren(preserveSelfSpan: false); + } + + private static bool HasNestedDelimiters(List delimiters, ContainerInline root) + { + for (int i = 0; i < delimiters.Count; i++) + { + if (delimiters[i].Parent != root) + { + return true; + } + } + + return false; + } + /// - /// Promotes nested pipe delimiters and line breaks to root level. + /// Promotes nested line breaks to root level. /// /// - /// Handles cases like `*a | b*|` where the pipe ends up inside an unmatched emphasis container. - /// After promotion, all delimiters become siblings at root level for consistent cell boundary detection. + /// Once any tracked table delimiter is nested, row boundaries may be nested in the same unresolved inline + /// container. Promoting pipes without promoting those line breaks would let cell extraction walk across + /// physical rows and produce incorrect cells. + /// + private static void PromoteNestedLineBreaksToRootLevel(ContainerInline root) + { + List? nestedLineBreaks = null; + var stack = new Stack(); + var child = root.LastChild; + while (child is not null) + { + stack.Push(child); + child = child.PreviousSibling; + } + + while (stack.Count > 0) + { + var inline = stack.Pop(); + if (inline is LineBreakInline && inline.Parent != root) + { + nestedLineBreaks ??= []; + nestedLineBreaks.Add(inline); + } + + if (inline is ContainerInline container) + { + child = container.LastChild; + while (child is not null) + { + stack.Push(child); + child = child.PreviousSibling; + } + } + } + + if (nestedLineBreaks is null) + { + return; + } + + foreach (var lineBreak in nestedLineBreaks) + { + PromoteNestedDelimiterToRootLevel(lineBreak, root); + } + } + + /// + /// Promotes nested pipe delimiters and tracked line breaks to root level. + /// + /// + /// Handles cases like `*a | b*|` and `**~$0.01** |` where a table boundary was emitted while an emphasis + /// delimiter container was still open. After promotion, all tracked table delimiters become root-level + /// siblings, so the table parser can count columns without depending on unresolved inline structure. /// private static void PromoteNestedPipesToRootLevel(List delimiters, ContainerInline root) { @@ -747,25 +942,31 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor if (!isPipe && !isLineBreak) continue; - // Skip if already at root level - if (delimiter.Parent == root) - continue; - - // Find the top-level ancestor (direct child of root) - var ancestor = delimiter.Parent; - while (ancestor?.Parent != null && ancestor.Parent != root) - { - ancestor = ancestor.Parent; - } - - if (ancestor is null || ancestor.Parent != root) - continue; - - // Split: promote delimiter to be sibling of ancestor - SplitContainerAtDelimiter(delimiter, ancestor); + PromoteNestedDelimiterToRootLevel(delimiter, root); } } + private static void PromoteNestedDelimiterToRootLevel(Inline delimiter, ContainerInline root) + { + // Skip if already at root level + if (delimiter.Parent == root) + return; + + // Find the top-level ancestor (direct child of root). The delimiter will be inserted after this + // ancestor, splitting the open inline container at the exact table boundary. + var ancestor = delimiter.Parent; + while (ancestor?.Parent != null && ancestor.Parent != root) + { + ancestor = ancestor.Parent; + } + + if (ancestor is null || ancestor.Parent != root) + return; + + // Split: promote delimiter to be sibling of ancestor + SplitContainerAtDelimiter(delimiter, ancestor); + } + /// /// Splits a container at the delimiter, promoting the delimiter to root level. /// @@ -774,6 +975,8 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor /// EmphasisDelimiter { "a", Pipe, "b" } /// After splitting: /// EmphasisDelimiter { "a" }, Pipe, Container { "b" } + /// The tail container is intentionally plain. It keeps post-pipe content attached to the root until cell + /// extraction moves it into a TableCell, without preserving an unresolved delimiter span across the pipe. /// private static void SplitContainerAtDelimiter(Inline delimiter, Inline ancestor) { @@ -803,8 +1006,7 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor // If there's content after, wrap in new container and insert after delimiter if (contentAfter.Count > 0) { - // Create new container matching the original parent type - var newContainer = CreateMatchingContainer(parent); + var newContainer = CreateSplitContainer(parent); foreach (var inline in contentAfter) { newContainer.AppendChild(inline); @@ -814,12 +1016,12 @@ public class PipeTableParser : InlineParser, IPostInlineProcessor } /// - /// Creates a container to wrap content split from the source container. + /// Creates a plain container to wrap content split from the source container. /// - private static ContainerInline CreateMatchingContainer(ContainerInline source) + private static ContainerInline CreateSplitContainer(ContainerInline source) { - // Emphasis processing runs before pipe table processing, so emphasis delimiters - // are already resolved. A plain ContainerInline suffices. + // The split tail is post-processed after the table cells are isolated. + // Use a plain container so unresolved delimiters cannot keep spanning cell boundaries. return new ContainerInline { Span = source.Span,
~$0.0015~$1.50