import type { JSONContent, MarkdownRendererHelpers } from '@tiptap/core'
import {
type TableCellAlign as TableCellAlignType,
normalizeTableCellAlignFromAttributes,
TableCellAlign,
} from '../../utils/parseAlign.js'
export const DEFAULT_CELL_LINE_SEPARATOR = '\u001F'
/**
* Walk a single table-row line and escape any `|` characters that appear
* inside backtick code spans so marked's cell splitter ignores them.
* Backslash escape sequences outside code spans are passed through untouched.
* If a backtick run has no matching closer on the same line it is emitted
* as-is — no over-escaping for malformed input.
*/
export function escapeTableCellPipes(line: string): string {
let result = ''
let i = 0
while (i < line.length) {
if (line[i] === '\\' && i + 1 < line.length) {
result += line[i] + line[i + 1]
i += 2
continue
}
if (line[i] !== '`') {
result += line[i++]
continue
}
let runLen = 0
while (i + runLen < line.length && line[i + runLen] === '`') runLen += 1
let j = i + runLen
let found = false
while (j < line.length) {
if (line[j] !== '`') {
j += 1
continue
}
let closeLen = 0
while (j + closeLen < line.length && line[j + closeLen] === '`') closeLen += 1
if (closeLen === runLen) {
const spanContent = line.slice(i + runLen, j)
// Matches an already-escaped pipe (`\|`, kept as-is) or a bare pipe
// (escaped). Deliberately avoids a negative lookbehind assertion:
// WebKit before Safari 16.4 cannot parse lookbehind, and a regex
// literal fails the whole chunk at parse time, not at call time.
result +=
line.slice(i, i + runLen) +
spanContent.replace(/\\\||\|/g, match => (match === '|' ? '\\|' : match)) +
line.slice(j, j + runLen)
i = j + runLen
found = true
break
}
j += closeLen
}
if (!found) {
result += line.slice(i, i + runLen)
i += runLen
}
}
return result
}
/**
* Escape pipe characters inside backtick code spans on table-row lines.
* marked's `splitCells` only recognises backslash-escaped pipes (`\|`) and
* splits on every other `|`, so \`a || b\` in a table cell would be treated
* as multiple column delimiters. Escaping them here lets `splitCells` skip
* them; it already converts `\|` → `|` after splitting, so the cell content
* is restored correctly.
*/
export function preprocessTablePipes(src: string): string {
return src
.split('\n')
.map(line => {
if (!line.includes('|') || !line.includes('`')) return line
return escapeTableCellPipes(line)
})
.join('\n')
}
function collapseWhitespace(s: string) {
return (s || '').replaceAll(DEFAULT_CELL_LINE_SEPARATOR, ' ').replace(/\s+/g, ' ').trim()
}
function replaceCellLineSeparator(value: string, cellLineSeparator?: string) {
if (!cellLineSeparator) {
return value
}
return value.split(cellLineSeparator).join('\n')
}
function escapePipesInCellText(text: string) {
// Keep already escaped pipes as they are
return text.replace(/\\.|\|/g, match => (match === '|' ? '\\|' : match))
}
export function renderTableToMarkdown(
node: JSONContent,
h: MarkdownRendererHelpers,
options: { cellLineSeparator?: string } = {},
) {
if (!node || !node.content || node.content.length === 0) {
return ''
}
// Build rows: each cell is { text, isHeader, align }
const rows: { text: string; isHeader: boolean; align: TableCellAlignType | null }[][] = []
node.content.forEach(rowNode => {
const cells: { text: string; isHeader: boolean; align: TableCellAlignType | null }[] = []
if (rowNode.content) {
rowNode.content.forEach(cellNode => {
let raw = ''
if (cellNode.content && Array.isArray(cellNode.content) && cellNode.content.length > 1) {
const parts = cellNode.content.map(child =>
replaceCellLineSeparator(
h.renderChildren(child as unknown as JSONContent),
options.cellLineSeparator,
),
)
raw = parts.join('\n')
} else {
raw = replaceCellLineSeparator(
cellNode.content ? h.renderChildren(cellNode.content as unknown as JSONContent[]) : '',
options.cellLineSeparator,
)
}
// Cells have to stay on a single line, so line breaks become
tags.
// The parser already turns
back into hard breaks, so this round trips.
const singleLine = collapseWhitespace(raw.replace(/[ \t]*\r?\n[ \t]*/g, '
'))
const text = escapePipesInCellText(singleLine)
const isHeader = cellNode.type === 'tableHeader'
const align = normalizeTableCellAlignFromAttributes(cellNode.attrs)
cells.push({ text, isHeader, align })
})
}
rows.push(cells)
})
const columnCount = rows.reduce((max, r) => Math.max(max, r.length), 0)
if (columnCount === 0) {
return ''
}
// Compute max width for each column
const colWidths = Array.from({ length: columnCount }).fill(0)
rows.forEach(r => {
for (let i = 0; i < columnCount; i += 1) {
const cell = r[i]?.text || ''
const len = cell.length
if (len > colWidths[i]) {
colWidths[i] = len
}
if (colWidths[i] < 3) {
colWidths[i] = 3
}
}
})
const pad = (s: string, width: number) => s + ' '.repeat(Math.max(0, width - s.length))
const headerRow = rows[0]
const hasHeader = headerRow.some(c => c.isHeader)
const colAlignments: Array = Array.from({
length: columnCount,
}).fill(null)
rows.forEach(r => {
for (let i = 0; i < columnCount; i += 1) {
if (!colAlignments[i] && r[i]?.align) {
colAlignments[i] = r[i].align
}
}
})
let out = '\n'
// Render header: if the document has a header row (tableHeader cells) use it,
// otherwise emit an empty header row so most Markdown parsers will recognize
// the table (this makes roundtripping to Markdown -> JSON more reliable).
const headerTexts = Array.from({ length: columnCount }).map((_, i) =>
hasHeader ? (headerRow[i] && headerRow[i].text) || '' : '',
)
out += `| ${headerTexts.map((t, i) => pad(t, colWidths[i])).join(' | ')} |\n`
// Separator (use at least 3 dashes per column and include alignment markers)
out += `| ${colWidths
.map((w, index) => {
const dashCount = Math.max(3, w)
const alignment = colAlignments[index]
if (alignment === TableCellAlign.Left) {
return `:${'-'.repeat(dashCount)}`
}
if (alignment === TableCellAlign.Right) {
return `${'-'.repeat(dashCount)}:`
}
if (alignment === TableCellAlign.Center) {
return `:${'-'.repeat(dashCount)}:`
}
return '-'.repeat(dashCount)
})
.join(' | ')} |\n`
// Body rows: if we had a header, skip the first row; otherwise render all rows
const body = hasHeader ? rows.slice(1) : rows
body.forEach(r => {
out += `| ${Array.from({ length: columnCount })
.fill(0)
.map((_, i) => pad((r[i] && r[i].text) || '', colWidths[i]))
.join(' | ')} |\n`
})
return out
}
export default renderTableToMarkdown