);

}

function convertTelegramRichSegmentNewlines(

segment: string,

prevStructural: boolean,

nextStructural: boolean,

): string {

if (!segment.includes("\n")) {

return segment;

}

// Keep newline runs that hug a structural tag: Telegram already starts a new

// line there, so a stray <br> would add a blank line or land as an invalid

// child inside a container (table/figure/details/list).

return segment.replace(/\n+/g, (run: string, offset: number) => {

const hugsPrev = offset === 0 && prevStructural;

const hugsNext = offset + run.length === segment.length && nextStructural;

return hugsPrev || hugsNext ? run : "<br>".repeat(run.length);

});

}

// Tags whose inner whitespace Telegram renders verbatim, so their newlines stay

// literal: code/pre keep source formatting and math holds raw LaTeX.

const TELEGRAM_RICH_LITERAL_WHITESPACE_TAGS = new Set(["code", "pre", "tg-math", "tg-math-block"]);

// Structural tags whose surrounding/inner newlines are layout whitespace, not

// prose: the rich block set plus the table/figure/details container children

// that TELEGRAM_RICH_BLOCK_HTML_TAGS omits (it is tuned for chunk block

// counting). A <br> wedged between these would be an invalid container child or

// a stray blank line, so their boundary newlines stay literal.

const TELEGRAM_RICH_LINE_BREAK_STRUCTURAL_TAGS: ReadonlySet<string> = new Set([

...TELEGRAM_RICH_BLOCK_HTML_TAGS,

"caption",

"col",

"colgroup",

"figcaption",

"summary",

"tbody",

"td",

"tfoot",

"th",

"thead",

]);

function isTelegramRichLineBreakStructuralTag(rawTag: string, tagName: string): boolean {

return (

TELEGRAM_RICH_LINE_BREAK_STRUCTURAL_TAGS.has(tagName) ||

(tagName === "a" && /\sname="[^"]+"/i.test(rawTag))

);

}

// Bot API 10.1 rich messages parse structured HTML, so literal newlines are

// insignificant whitespace — unlike the legacy HTML parse mode that renders them

// as line breaks. Materialize inline newlines as <br> so multi-line prose and

// bullet runs keep their breaks, while leaving newlines literal inside

// code/pre/math and where they only separate block-level tags.

export function materializeTelegramRichHtmlLineBreaks(html: string): string {

if (!html.includes("\n")) {

return html;

}

let result = "";

let lastIndex = 0;

let literalDepth = 0;

let prevStructural = false;

HTML_TAG_PATTERN.lastIndex = 0;

let match: RegExpExecArray | null;

while ((match = HTML_TAG_PATTERN.exec(html)) !== null) {

const tagStart = match.index;

const tagEnd = HTML_TAG_PATTERN.lastIndex;

const rawTag = match[0];

const isClosing = match[1] === "</";

const tagName = normalizeLowercaseStringOrEmpty(match[2]);

// <br> already emits a break, so treat it like a structural boundary: a

// hugging newline stays literal instead of doubling into a blank line.

const tagIsStructural =

tagName === "br" || isTelegramRichLineBreakStructuralTag(rawTag, tagName);

const segment = html.slice(lastIndex, tagStart);

result +=

literalDepth > 0

? segment

: convertTelegramRichSegmentNewlines(segment, prevStructural, tagIsStructural);

// Self-closing literal tags (e.g. a stray <pre/>) must not open a region that

// never closes and swallows every later line break.

if (TELEGRAM_RICH_LITERAL_WHITESPACE_TAGS.has(tagName) && !rawTag.trimEnd().endsWith("/>")) {

literalDepth = isClosing ? Math.max(0, literalDepth - 1) : literalDepth + 1;

}

result += rawTag;

lastIndex = tagEnd;

prevStructural = tagIsStructural;

}

const tail = html.slice(lastIndex);

result +=

literalDepth > 0 ? tail : convertTelegramRichSegmentNewlines(tail, prevStructural, false);

return result;

}

export function markdownToTelegramRichHtml(

markdown: string,

options: { tableMode?: MarkdownTableMode; skipEntityDetection?: boolean } = {},