fix: use display width of concealed ranges

## Details

When computing widths for concealed text in highlights we were correctly
using the display width of the associated node's text. However, when
accounting for conceal `extmark`s added by this plugin we simply used
the difference between start & end column, which is the size in bytes.

This meant that if something concealed by this plugin contained glyphs
which are displayed shorter than the number of bytes (common in many
languages) we would incorrectly calculate offsets.

Fixing this is a little involved since we need access to the actual text
that is being concealed, however when adding the mark all we have is the
range. We can get around this since we do have access to the text and
start / end columns when we are computing the widths. So we no longer
store the width information directly, instead we store the concealed
ranges along with some additional metadata, find the overlap of these
ranges with the text, then calculate the width of the text associated
with any overlaps.

To make this all work we needed to be much better about how ranges were
stored and added. We do a coalesce operation (similar to view ranges)
each time a new one is added at the row level, when we combine a range
with another we include the combined conceal characters and the number
of individual blocks that made the combination. This information is
needed to correctly handle different conceal level behaviors.

The `interval` module `overlaps` method has been replaced with an
`overlap` method which returns the region associated with an overlap
rather than just a `boolean`. This was needed for the new functionality,
existing usage was replaced since checking if `overlap` is non-nil does
the same thing.

Minor quality of life improvement for unit testing, the `expected` marks
are now sorted using the same logic as the `actual` marks before being
compared. This means the order information is added does not matter for
correctness allowing us to share common marks as needed. For instance
for many of the `table` related tests the offsets and such are different
but the pipe related marks all occur at the same absolute locations, so
we can create a method to compute those and include them where needed.

Author: MeanderingProgrammer

doc/render-markdown.txt

@@ -1,4 +1,4 @@
-*render-markdown.txt*      For NVIM v0.11.4     Last change: 2025 September 10
+*render-markdown.txt*      For NVIM v0.11.4     Last change: 2025 September 11
 
 ==============================================================================
 Table of Contents                          *render-markdown-table-of-contents*

lua/render-markdown/health.lua

@@ -5,7 +5,7 @@ local state = require('render-markdown.state')
 local M = {}
 
 ---@private
-M.version = '8.8.3'
+M.version = '8.8.4'
 
 function M.check()
     M.start('versions')

lua/render-markdown/lib/extmark.lua

@@ -34,7 +34,7 @@ function Extmark:overlaps(range)
     if not range then
         return false
     end
-    return interval.overlaps(self.range, range)
+    return interval.overlap(self.range, range) ~= nil
 end
 
 ---@param ns integer

lua/render-markdown/lib/interval.lua

@@ -1,10 +1,21 @@
 ---@class render.md.Range
----@field [1] integer
----@field [2] integer
+---@field [1] integer start
+---@field [2] integer end
 
 ---@class render.md.Interval
 local M = {}
 
+---@param range render.md.Range
+---@param exclusive? boolean
+---@return boolean
+function M.valid(range, exclusive)
+    if exclusive then
+        return range[1] < range[2]
+    else
+        return range[1] <= range[2]
+    end
+end
+
 ---noncommutative
 ---@param a render.md.Range
 ---@param b render.md.Range
@@ -17,25 +28,20 @@ end
 ---@param a render.md.Range
 ---@param b render.md.Range
 ---@param exclusive? boolean
----@return boolean
-function M.overlaps(a, b, exclusive)
-    if exclusive then
-        return b[1] < a[2] and b[2] > a[1]
-    else
-        return b[1] <= a[2] and b[2] >= a[1]
-    end
+---@return render.md.Range?
+function M.overlap(a, b, exclusive)
+    ---@type render.md.Range
+    local result = {
+        math.max(a[1], b[1]),
+        math.min(a[2], b[2]),
+    }
+    return M.valid(result, exclusive) and result or nil
 end
 
 ---@param ranges render.md.Range[]
 ---@return render.md.Range[]
 function M.coalesce(ranges)
-    table.sort(ranges, function(a, b)
-        if a[1] ~= b[1] then
-            return a[1] < b[1]
-        else
-            return a[2] < b[2]
-        end
-    end)
+    M.sort(ranges)
     local result = {} ---@type render.md.Range[]
     result[#result + 1] = ranges[1]
     for i = 2, #ranges do
@@ -49,4 +55,15 @@ function M.coalesce(ranges)
     return result
 end
 
+---@param ranges render.md.Range[]
+function M.sort(ranges)
+    table.sort(ranges, function(a, b)
+        if a[1] ~= b[1] then
+            return a[1] < b[1]
+        else
+            return a[2] < b[2]
+        end
+    end)
+end
+
 return M

lua/render-markdown/lib/marks.lua

@@ -123,19 +123,15 @@ end
 ---@private
 ---@param mark render.md.Mark
 function Marks:run_update(mark)
-    local row, start_col = mark.start_row, mark.start_col
-    if mark.opts.conceal then
-        local end_col = assert(mark.opts.end_col, 'conceal requires end_col')
-        self.context.conceal:add(row, {
-            col = { start_col, end_col },
-            width = end_col - start_col,
-            character = mark.opts.conceal,
-        })
+    local row, start_col, opts = mark.start_row, mark.start_col, mark.opts
+    if opts.conceal then
+        local end_col = assert(opts.end_col, 'conceal requires end_col')
+        self.context.conceal:add(row, { start_col, end_col, opts.conceal, 1 })
     end
-    if mark.opts.virt_text_pos == 'inline' then
+    if opts.virt_text_pos == 'inline' then
         self.context.offset:add(row, {
             col = start_col,
-            width = str.line_width(mark.opts.virt_text),
+            width = str.line_width(opts.virt_text),
         })
     end
 end

lua/render-markdown/render/markdown/table.lua

@@ -333,7 +333,7 @@ function Render:shift(col, side, amount)
             virt_text_pos = 'inline',
         })
     elseif amount < 0 then
-        amount = amount - self.context.conceal:width('')
+        amount = amount - self.context.conceal:width('', 1)
         self.marks:add(self.config, true, col.row, column + amount, {
             priority = 0,
             end_col = column,

lua/render-markdown/request/conceal.lua

@@ -5,12 +5,11 @@ local str = require('render-markdown.lib.str')
 
 ---@class render.md.request.conceal.Line
 ---@field hidden boolean
----@field sections render.md.request.conceal.Section[]
+---@field ranges render.md.request.conceal.Range[]
 
----@class render.md.request.conceal.Section
----@field col render.md.Range
----@field width integer
----@field character? string
+---@class render.md.request.conceal.Range: render.md.Range
+---@field [3] string replacement
+---@field [4] integer blocks
 
 ---@class render.md.request.Conceal
 ---@field private buf integer
@@ -41,46 +40,55 @@ function Conceal:enabled()
 end
 
 ---@param row integer
----@param entry boolean|render.md.request.conceal.Section
+---@param entry boolean|render.md.request.conceal.Range
 function Conceal:add(row, entry)
     if not self:enabled() then
         return
     end
     if not self.lines[row] then
-        self.lines[row] = { hidden = false, sections = {} }
+        self.lines[row] = { hidden = false, ranges = {} }
     end
     local line = self.lines[row]
     if type(entry) == 'boolean' then
         line.hidden = entry
     else
-        if entry.width > 0 and not Conceal.contains(line, entry) then
-            line.sections[#line.sections + 1] = entry
+        if interval.valid(entry, true) then
+            line.ranges[#line.ranges + 1] = entry
+            line.ranges = Conceal.coalesce(line.ranges)
         end
     end
 end
 
 ---@private
----@param line render.md.request.conceal.Line
----@param entry render.md.request.conceal.Section
----@return boolean
-function Conceal.contains(line, entry)
-    for _, section in ipairs(line.sections) do
-        if interval.contains(section.col, entry.col) then
-            return true
+---@param ranges render.md.request.conceal.Range[]
+---@return render.md.request.conceal.Range[]
+function Conceal.coalesce(ranges)
+    interval.sort(ranges)
+    local result = {} ---@type render.md.request.conceal.Range[]
+    result[#result + 1] = ranges[1]
+    for i = 2, #ranges do
+        local range, last = ranges[i], result[#result]
+        if range[1] <= last[2] then
+            last[2] = math.max(last[2], range[2])
+            last[3] = last[3] .. range[3]
+            last[4] = last[4] + range[4]
+        else
+            result[#result + 1] = range
         end
     end
-    return false
+    return result
 end
 
----@param character? string
+---@param s string
+---@param blocks integer
 ---@return integer
-function Conceal:width(character)
+function Conceal:width(s, blocks)
     if self.level == 1 then
         -- each block is replaced with one character
-        return 1
+        return blocks
     elseif self.level == 2 then
-        -- replacement character width is used
-        return str.width(character)
+        -- replacement characters width is used
+        return str.width(s)
     else
         -- text is completely hidden
         return 0
@@ -98,10 +106,15 @@ end
 ---@return integer
 function Conceal:get(body)
     local result = 0
-    local col = { body.start_col, body.end_col } ---@type render.md.Range
-    for _, section in ipairs(self:line(body).sections) do
-        if interval.overlaps(section.col, col, true) then
-            local width = section.width - self:width(section.character)
+    local target = { body.start_col, body.end_col } ---@type render.md.Range
+    for _, range in ipairs(self:line(body).ranges) do
+        local overlap = interval.overlap(range, target, true)
+        if overlap then
+            local text = body.text:sub(
+                overlap[1] - target[1] + 1,
+                overlap[2] - target[1]
+            )
+            local width = str.width(text) - self:width(range[3], range[4])
             result = result + width
         end
     end
@@ -118,7 +131,7 @@ function Conceal:line(body)
     end
     local line = self.lines[body.start_row]
     if not line then
-        line = { hidden = false, sections = {} }
+        line = { hidden = false, ranges = {} }
     end
     return line
 end
@@ -162,12 +175,7 @@ function Conceal:tree(language, root)
         end
         if data.conceal then
             local row, start_col, _, end_col = Conceal.range(id, node, data)
-            local text = vim.treesitter.get_node_text(node, self.buf)
-            self:add(row, {
-                col = { start_col, end_col },
-                width = str.width(text),
-                character = data.conceal,
-            })
+            self:add(row, { start_col, end_col, data.conceal, 1 })
         end
     end)
 end

lua/render-markdown/request/view.lua

@@ -48,7 +48,7 @@ end
 function View:overlaps(node)
     local start_row, _, end_row = node:range()
     for _, range in ipairs(self.ranges) do
-        if interval.overlaps(range, { start_row, end_row }) then
+        if interval.overlap(range, { start_row, end_row }) then
             return true
         end
     end