slack-markdown-parser 2.4.2__tar.gz → 2.4.4__tar.gz

{slack_markdown_parser-2.4.2 → slack_markdown_parser-2.4.4}/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on Keep a Changelog, and the project follows Semantic Versio
 
 ## [Unreleased]
 
+## [2.4.4] - 2026-06-10
+
+### Fixed
+
+- Stopped a link wrapped entirely in emphasis (`**[text](url)**`, and the `*`/`_`/`__`/`~~`/`***` variants) from rendering as dead, literal text in `rich_text` contexts such as list items and table cells. The emphasis token pattern matched the whole `**[text](url)**` span before the link pattern got a chance, so `_create_rich_text_inline_elements` emitted the inner `[text](url)` as a styled plain-text run and the link was never clickable. When a styled (non-code) token's inner content is itself a complete markdown link, it now becomes a `link` element carrying that style (e.g. a bold link), matching the already-working emphasis-inside-the-brackets form (`[**text**](url)`).
+- Stopped Slack mention tokens from rendering as literal text inside promoted list items. Since 2.4.0 a simple list is emitted as a `rich_text` block, but the inline builder only tokenized links, code, and emphasis — so a `<#C123>` / `<@U123>` / `<!subteam^S123>` / `<!here>` token in a list item fell through as a plain `text` run. In a `rich_text` block a mention has to be a structured element (`channel`, `user`, `usergroup`, `broadcast`), so Slack showed the raw `<#C123>` rather than a pill. (Prose was unaffected: it stays in a `markdown` block, where Slack resolves the token itself.) These tokens are now converted to the matching rich_text elements, an optional `|label` display suffix is dropped (Slack renders the element from the id), and the plain-text fallback re-emits the canonical `<#C123>` token so a downgraded mrkdwn fallback still links and notifies. The same applies inside table cells: `extract_plain_text_from_table_cell` now delegates inline runs to the shared rich_text downgrade path instead of a separate near-copy, so a mention in a cell also survives into the fallback text rather than vanishing.
+
+## [2.4.3] - 2026-05-29
+
+### Fixed
+
+- Stopped bare-URL autolinking from greedily swallowing trailing text. `normalize_bare_urls_for_slack_markdown` matched `https?://[^\s<]+`, so a scheme URL glued directly to following CJK text (e.g. `(https://example.com)**。に句点を直結。`) — common in Japanese, which puts no space after a URL — captured the closing paren, the `**` markers, the CJK punctuation, and the rest of the sentence into one `<…>` autolink, over-extending the link and exposing the literal `**`. The matched URL is now trimmed GFM-style: it stops at a doubled emphasis run (`**`/`~~`), at code/angle/pipe markers (`` ` ``, `<`, `>`, `|`), and at CJK punctuation (`、`/`。`/`」` …), and trailing punctuation (GFM's autolink set `! ? . , : * _ ~`, and an unbalanced `)`) is dropped while balanced parentheses are kept. `;` and quotes are kept (URL-legal), and a lone `*` (URL wildcards/queries) and CJK letters (IRIs / Unicode IDN hosts) are preserved.
+
 ## [2.4.2] - 2026-05-29
 
 ### Fixed

{slack_markdown_parser-2.4.2/slack_markdown_parser.egg-info → slack_markdown_parser-2.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.4.2
+Version: 2.4.4
 Summary: Convert LLM Markdown into Slack Block Kit messages
 Author: darkgaldragon
 License-Expression: MIT

{slack_markdown_parser-2.4.2 → slack_markdown_parser-2.4.4}/docs/spec-ja.md

@@ -72,7 +72,7 @@ Slack は 2026-03-06 に `markdown` ブロックの公式ドキュメントを
 ### このパーサーが補正・安定化するもの
 
 - `_..._` / `__...__` を Slack 互換の `*...*` / `**...**` に正規化する
-- bare URL を Slack で安定しやすい `<https://...>` 形式にそろえる
+- bare URL を Slack で安定しやすい `<https://...>` 形式にそろえる。まず URL を実際の範囲にトリミングする(GFM 風): 二重の強調記号(`**`/`~~`)・コード/山かっこ/パイプ記号(`` ` ``・`<`・`>`・`|`)・CJK / 全角の句読点(`、` `。` `」` `）` `！` …)で停止し、末尾の句読点(GFM の autolink 集合 `! ? . , : * _ ~` と不均衡な `)`)を除外する(`;` と引用符は URL で正当なため保持)。単独の `*`(URL のワイルドカード/クエリ)と CJK の**文字**(反復記号 `々` を含む。IRI / Unicode IDN ホスト。例 `https://ja.wikipedia.org/wiki/人々`)は保持する。これにより、日本語のように URL の直後へ空白なしで CJK 本文が続く場合でも、URL が行末まで(閉じの `**` ごと)貪欲に飲み込んでリンク化する事故を防ぐ。
 - 崩れた Markdown テーブルを補って `table` ブロックへ変換する
 - 意味が明確な単独 Markdown 構文を Slack ネイティブのブロックへ変換する
   - 単独行の画像構文 `![alt](https://...)` → `image`

{slack_markdown_parser-2.4.2 → slack_markdown_parser-2.4.4}/docs/spec.md

@@ -72,7 +72,7 @@ Slack still controls when those newer features appear and how they look, so trea
 ### Things this parser corrects or stabilizes
 
 - `_..._` and `__...__` are normalized into Slack-friendly `*...*` and `**...**`
-- Bare URLs are wrapped into Slack-friendly `<https://...>` form before `markdown` block delivery
+- Bare URLs are wrapped into Slack-friendly `<https://...>` form before `markdown` block delivery. The URL is trimmed to its real extent first (GFM-style): it stops at a doubled emphasis run (`**`/`~~`), at code/angle/pipe markers (`` ` ``, `<`, `>`, `|`), and at CJK / full-width punctuation (`、` `。` `」` `）` `！` …); trailing punctuation (GFM's autolink set `! ? . , : * _ ~`, and an unbalanced `)`) is excluded — `;` and quotes are kept because they are URL-legal. A lone `*` (URL wildcards/queries) and CJK *letters* — including iteration marks like `々` (IRIs / Unicode IDN hosts such as `https://ja.wikipedia.org/wiki/人々`) — are preserved. This keeps a scheme URL glued directly to following CJK text — common in Japanese, where no space separates them — from greedily swallowing the rest of the line (including a closing `**`) into the autolink.
 - Malformed Markdown tables are repaired before `table` block generation
 - Unambiguous standalone Markdown constructs are promoted into native Slack blocks:
   - standalone image syntax `![alt](https://...)` to `image`
@@ -81,6 +81,7 @@ Slack still controls when those newer features appear and how they look, so trea
   - simple one-level quotes to `rich_text_quote`
   - simple bullet and ordered lists to `rich_text_list`
     - Lists are promoted only when the list starts at the beginning of the text region or after a blank line, each non-blank line in the run is a list item, the list does not use ambiguous 1-3-space nested indentation, the item text does not rely on Markdown backslash escapes, and the run is not followed by an indented continuation paragraph.
+    - Slack mention tokens inside a promoted list item are converted to their structured `rich_text` elements — `<@U…>`/`<@W…>` to `user`, `<#C…>`/`<#G…>` to `channel`, `<!subteam^S…>` to `usergroup`, and `<!here>`/`<!channel>`/`<!everyone>` to `broadcast` — since a `rich_text` block does not resolve a raw token. An optional `|label` display suffix is dropped (Slack renders the element from the id).
 - Table-like rows inside fenced code blocks are kept out of table parsing
 - Internal blank lines can optionally be rewritten into placeholder lines so Slack keeps visible paragraph separation
 - Unsupported Slack angle-bracket tokens such as `<foo>` or raw HTML-like tags are neutralized

{slack_markdown_parser-2.4.2 → slack_markdown_parser-2.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slack-markdown-parser"
-version = "2.4.2"
+version = "2.4.4"
 description = "Convert LLM Markdown into Slack Block Kit messages"
 readme = "README.md"
 requires-python = ">=3.10"

{slack_markdown_parser-2.4.2 → slack_markdown_parser-2.4.4}/slack_markdown_parser/__init__.py

@@ -1,6 +1,6 @@
 """slack-markdown-parser public package API."""
 
-__version__ = "2.4.2"
+__version__ = "2.4.4"
 __license__ = "MIT"
 
 from .converter import (

{slack_markdown_parser-2.4.2 → slack_markdown_parser-2.4.4}/slack_markdown_parser/converter.py

@@ -84,6 +84,12 @@ LOOSE_TABLE_SEPARATOR_PATTERN = re.compile(
 TABLE_TOKEN_PATTERN = re.compile(
     r"\[(?P<markdown_label>[^\]\n]+)\]\((?P<markdown_url>https?://[^\s)]+)\)"
     r"|<(?P<angle_url>https?://[^>\s|]+)(?:\|(?P<angle_label>[^>\n]+))?>"
+    # Slack mention tokens: user (<@U…>/<@W…>), channel (<#C…>/<#G…>), user
+    # group (<!subteam^S…>), and broadcast (<!here>/<!channel>/<!everyone>).
+    # An optional ``|label`` is the human-readable display the author saw; the
+    # rich_text element is rendered by Slack from the id, so the label is dropped.
+    r"|<(?P<mention>@[UW][A-Z0-9]+|#[CG][A-Z0-9]+|!subteam\^[A-Z0-9]+"
+    r"|!(?:here|channel|everyone))(?:\|[^>\n]+)?>"
     r"|(?P<token>"
     r"(?P<code>(?P<code_delimiter>`+)(?P<code_text>[^\n]+?)(?P=code_delimiter))"
     r"|~~[^~]+~~"
@@ -143,6 +149,72 @@ def _is_han_or_kana_char(char: str) -> bool:
     )
 
 
+# Code/angle/pipe markers that never appear inside a bare URL in this library's
+# prose context. (A single ``*`` and CJK letters are intentionally NOT here: a
+# URL may legally contain a wildcard/query ``*`` and an IRI/IDN may contain CJK
+# letters, so those must be preserved.)
+_URL_STOP_CHARS = frozenset("`<>|")
+# Trailing punctuation stripped from the end of a bare URL. This is exactly
+# GFM's autolink-extension set (``! ? . , : * _ ~``); a closing paren is handled
+# separately, with balancing. ``;`` and quotes are intentionally NOT included —
+# ``;`` is URL-legal in matrix/path parameters and quotes are sub-delimiters, so
+# trimming them could change the link target rather than just shedding prose.
+_URL_TRAILING_PUNCTUATION = frozenset("!?.,:*_~")
+# CJK and full/half-width punctuation/brackets that terminate prose, so a bare
+# URL is cut here. This is an explicit set rather than the whole U+3000–U+303F
+# block on purpose: letter-like CJK iteration marks (々 U+3005, 〻 U+303B),
+# ditto/closure marks (〆 U+3006) and the ideographic number zero (〇 U+3007)
+# are *excluded* so IRIs such as ``https://ja.wikipedia.org/wiki/人々`` survive.
+_URL_CJK_BOUNDARY_CHARS = frozenset(
+    "、。〃〈〉《》「」『』【】〔〕〖〗〘〙〚〛〜〝〞・…"  # CJK punctuation & brackets
+    "！？，．：；（）［］｛｝＜＞｜"  # full-width punctuation & brackets
+    "｡｢｣､"  # half-width CJK punctuation & brackets
+)
+
+
+def _is_url_boundary_char(char: str) -> bool:
+    """Return True when ``char`` is a hard boundary where a bare URL must stop.
+
+    Only unambiguous prose/markup boundaries qualify: code/angle/pipe markers
+    and CJK/full-width *punctuation* (``、``/``。``/``」``/``）`` …). CJK
+    *letters* (including iteration marks like ``々``) are not a boundary, so
+    IRIs such as ``https://ja.wikipedia.org/wiki/人々`` survive.
+    """
+    return char in _URL_STOP_CHARS or char in _URL_CJK_BOUNDARY_CHARS
+
+
+def _trim_bare_url(url: str) -> str:
+    """Trim a greedily matched bare URL down to its real extent.
+
+    In CJK writing a URL is usually glued directly to the following text with no
+    whitespace, so the greedy ``[^\\s<]+`` match would otherwise swallow the
+    trailing ``)``/``**``/``。`` and the rest of the sentence. This stops the URL
+    at the first hard boundary or doubled emphasis run (``**``/``~~``) — single
+    ``*`` and CJK letters are preserved — then drops GFM-style trailing
+    punctuation and unbalanced closing parens, so ``https://example.com)**。``
+    becomes ``https://example.com``.
+    """
+    for index, char in enumerate(url):
+        nxt = url[index + 1] if index + 1 < len(url) else ""
+        if _is_url_boundary_char(char) or (char in "*~" and nxt == char):
+            url = url[:index]
+            break
+
+    while url:
+        last = url[-1]
+        if last == ")":
+            if url.count(")") <= url.count("("):
+                break
+            url = url[:-1]
+            continue
+        if last in _URL_TRAILING_PUNCTUATION:
+            url = url[:-1]
+            continue
+        break
+
+    return url
+
+
 def _nested_code_space_strategy(
     source: str,
     start: int,
@@ -596,9 +668,15 @@ def normalize_bare_urls_for_slack_markdown(text: str) -> str:
 
             url_match = BARE_URL_PATTERN.match(chunk, cursor)
             if url_match:
-                parts.append(f"<{url_match.group(0)}>")
-                cursor = url_match.end()
-                continue
+                url = _trim_bare_url(url_match.group(0))
+                scheme = re.match(r"https?://", url, re.IGNORECASE)
+                # Only autolink when something host-like survives the trim;
+                # a bare ``https://`` followed straight by CJK would otherwise
+                # produce an empty ``<https://>`` autolink.
+                if scheme and len(url) > scheme.end():
+                    parts.append(f"<{url}>")
+                    cursor += len(url)
+                    continue
 
             parts.append(char)
             cursor += 1
@@ -1245,6 +1323,40 @@ def looks_like_markdown_table(text: str) -> bool:
     return table_like_lines >= 2
 
 
+def _slack_mention_element(mention: str) -> dict[str, Any]:
+    """Map a Slack mention token body to its rich_text element.
+
+    ``mention`` is the token interior without the angle brackets or ``|label``
+    (e.g. ``@U123``, ``#C123``, ``!subteam^S123``, ``!here``). Slack renders
+    these from the id alone, so no display text is carried.
+    """
+    sigil, body = mention[0], mention[1:]
+    if sigil == "@":
+        return {"type": "user", "user_id": body}
+    if sigil == "#":
+        return {"type": "channel", "channel_id": body}
+    if body.startswith("subteam^"):
+        return {"type": "usergroup", "usergroup_id": body[len("subteam^") :]}
+    return {"type": "broadcast", "range": body}
+
+
+def _slack_mention_element_to_token(element: dict[str, Any]) -> str:
+    """Inverse of :func:`_slack_mention_element` for plain-text fallbacks.
+
+    Emitting the canonical ``<#C…>`` / ``<@U…>`` token (rather than an empty
+    string) keeps the mention live when a rich_text block is downgraded to a
+    mrkdwn fallback, so it still links and notifies.
+    """
+    element_type = element.get("type")
+    if element_type == "user":
+        return f"<@{element.get('user_id', '')}>"
+    if element_type == "channel":
+        return f"<#{element.get('channel_id', '')}>"
+    if element_type == "usergroup":
+        return f"<!subteam^{element.get('usergroup_id', '')}>"
+    return f"<!{element.get('range', '')}>"
+
+
 def _create_rich_text_inline_elements(
     text: str, *, empty_text: str = ""
 ) -> list[dict[str, Any]]:
@@ -1268,6 +1380,7 @@ def _create_rich_text_inline_elements(
         markdown_url = match.group("markdown_url")
         angle_url = match.group("angle_url")
         angle_label = match.group("angle_label")
+        mention = match.group("mention")
         token = match.group("token") or ""
 
         if markdown_label and markdown_url:
@@ -1278,6 +1391,8 @@ def _create_rich_text_inline_elements(
                 "url": angle_url,
                 "text": angle_label or angle_url,
             }
+        elif mention:
+            element = _slack_mention_element(mention)
         else:
             style: dict[str, bool] = {}
             content = token
@@ -1296,9 +1411,26 @@ def _create_rich_text_inline_elements(
                 content = content[1:-1]
                 style["italic"] = True
 
-            element = {"type": "text", "text": content}
-            if style:
-                element["style"] = style
+            # A link wrapped entirely in emphasis (``**[text](url)**``) is matched
+            # by the emphasis branch above, not the link branch, so its inner
+            # content is a bare ``[text](url)``. Emit a styled ``link`` element
+            # rather than a literal text run, otherwise the link is dead in Slack.
+            inner_link = (
+                TABLE_TOKEN_PATTERN.fullmatch(content)
+                if style and not style.get("code")
+                else None
+            )
+            if inner_link is not None and inner_link.group("markdown_url"):
+                element = {
+                    "type": "link",
+                    "url": inner_link.group("markdown_url"),
+                    "text": inner_link.group("markdown_label"),
+                    "style": style,
+                }
+            else:
+                element = {"type": "text", "text": content}
+                if style:
+                    element["style"] = style
         elements.append(element)
         last_index = match.end()
 
@@ -1338,12 +1470,11 @@ def extract_plain_text_from_table_cell(cell: dict[str, Any]) -> str:
             if not isinstance(element, dict):
                 continue
             if element.get("type") == "rich_text_section":
-                for child in element.get("elements", []):
-                    if isinstance(child, dict):
-                        if child.get("type") == "link":
-                            texts.append(str(child.get("text") or child.get("url", "")))
-                        else:
-                            texts.append(child.get("text", ""))
+                texts.append(
+                    _rich_text_inline_elements_to_plain_text(
+                        element.get("elements", [])
+                    )
+                )
             elif "text" in element:
                 texts.append(str(element.get("text", "")))
         return "".join(texts)
@@ -1410,6 +1541,8 @@ def _rich_text_inline_elements_to_plain_text(elements: list[dict[str, Any]]) ->
         element_type = element.get("type")
         if element_type == "link":
             texts.append(str(element.get("text") or element.get("url", "")))
+        elif element_type in {"user", "channel", "usergroup", "broadcast"}:
+            texts.append(_slack_mention_element_to_token(element))
         else:
             texts.append(str(element.get("text", "")))
     return "".join(texts)
@@ -1945,44 +2078,73 @@ def convert_markdown_to_slack_payloads(
     return payloads
 
 
-def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
-    """Build plain text representation from Slack blocks."""
+def _markdown_block_to_plain_text(block: dict[str, Any]) -> str:
+    """Downgrade a ``markdown`` block, preferring the build-time annotation."""
+    text = getattr(block, "_plain_text", None) or ""
+    if text:
+        return str(text)
+    raw_text = block.get("text", "")
+    if not raw_text:
+        return ""
+    return _normalize_markdown_block_plain_text(
+        _strip_synthetic_blank_line_placeholders(
+            _strip_synthetic_spaces_from_plain_text(
+                strip_zero_width_spaces(raw_text),
+                getattr(block, "_synthetic_space_indices", None),
+            ),
+            getattr(block, "_synthetic_blank_line_indices", None),
+        )
+    )
+
+
+def _blocks_to_downgrade_parts(
+    blocks: list[dict[str, Any]], *, fallback: bool
+) -> list[str]:
+    """Shared block walker behind :func:`blocks_to_plain_text` and
+    :func:`build_fallback_text_from_blocks`.
+
+    The two public functions intentionally differ in a few policies, kept
+    explicit on the ``fallback`` flag: fallback keeps table cells verbatim
+    (empty cells preserve column alignment) and emits a whole table as one
+    part, while the plain-text view strips zero-width spaces, drops empty
+    cells, emits one part per row, and surfaces ``text`` from unknown blocks.
+    """
     parts: list[str] = []
 
     for block in blocks or []:
-        block_type = block.get("type") if isinstance(block, dict) else None
+        if not isinstance(block, dict):
+            continue
+        block_type = block.get("type")
 
         if block_type == "markdown":
-            text = getattr(block, "_plain_text", None) or ""
-            if not text:
-                raw_text = block.get("text", "")
-                if raw_text:
-                    text = _normalize_markdown_block_plain_text(
-                        _strip_synthetic_blank_line_placeholders(
-                            _strip_synthetic_spaces_from_plain_text(
-                                strip_zero_width_spaces(raw_text),
-                                getattr(block, "_synthetic_space_indices", None),
-                            ),
-                            getattr(block, "_synthetic_blank_line_indices", None),
-                        )
-                    )
-            if text:
+            text = _markdown_block_to_plain_text(block)
+            if text.strip() if fallback else text:
                 parts.append(text)
         elif block_type == "table":
-            rows = block.get("rows") or []
-            for row in rows:
-                cell_texts: list[str] = []
+            row_texts: list[str] = []
+            for row in block.get("rows") or []:
                 if not isinstance(row, list):
                     continue
-                for cell in row:
-                    cell_text = extract_plain_text_from_table_cell(cell)
-                    if cell_text:
-                        cell_texts.append(strip_zero_width_spaces(cell_text))
+                if fallback:
+                    cell_texts = [
+                        extract_plain_text_from_table_cell(cell) for cell in row
+                    ]
+                else:
+                    cell_texts = []
+                    for cell in row:
+                        cell_text = extract_plain_text_from_table_cell(cell)
+                        if cell_text:
+                            cell_texts.append(strip_zero_width_spaces(cell_text))
                 if cell_texts:
-                    parts.append(" | ".join(cell_texts))
+                    row_texts.append(" | ".join(cell_texts))
+            if fallback:
+                if row_texts:
+                    parts.append("\n".join(row_texts))
+            else:
+                parts.extend(row_texts)
         elif block_type == "rich_text":
             text = _rich_text_block_to_plain_text(block)
-            if text:
+            if text.strip() if fallback else text:
                 parts.append(text)
         elif block_type == "header":
             text = block.get("text", {})
@@ -1998,66 +2160,24 @@ def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
                 parts.append(image_text)
         elif block_type == "divider":
             parts.append(getattr(block, "_plain_text", None) or "---")
-        elif isinstance(block, dict):
+        elif not fallback:
             text = block.get("text", "")
             if text:
                 parts.append(str(text))
 
+    return parts
+
+
+def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
+    """Build plain text representation from Slack blocks."""
+    parts = _blocks_to_downgrade_parts(blocks, fallback=False)
     return "\n".join([p for p in parts if p]).strip()
 
 
 def build_fallback_text_from_blocks(blocks: list[dict[str, Any]]) -> str:
     """Build Slack fallback text from block structure."""
-    plain_parts: list[str] = []
-
-    for block in blocks or []:
-        if not isinstance(block, dict):
-            continue
-
-        if block.get("type") == "markdown":
-            text = getattr(block, "_plain_text", None) or ""
-            if not text:
-                text = _normalize_markdown_block_plain_text(
-                    _strip_synthetic_blank_line_placeholders(
-                        _strip_synthetic_spaces_from_plain_text(
-                            strip_zero_width_spaces(block.get("text", "")),
-                            getattr(block, "_synthetic_space_indices", None),
-                        ),
-                        getattr(block, "_synthetic_blank_line_indices", None),
-                    ),
-                )
-            if text.strip():
-                plain_parts.append(text)
-        elif block.get("type") == "table":
-            table_lines: list[str] = []
-            for row in block.get("rows", []):
-                if not isinstance(row, list):
-                    continue
-                cells = [extract_plain_text_from_table_cell(cell) for cell in row]
-                if cells:
-                    table_lines.append(" | ".join(cells))
-            if table_lines:
-                plain_parts.append("\n".join(table_lines))
-        elif block.get("type") == "rich_text":
-            text = _rich_text_block_to_plain_text(block)
-            if text.strip():
-                plain_parts.append(text)
-        elif block.get("type") == "header":
-            text = block.get("text", {})
-            if isinstance(text, dict) and text.get("text"):
-                plain_parts.append(str(text.get("text", "")))
-        elif block.get("type") == "image":
-            alt_text = str(block.get("alt_text", "")).strip()
-            image_url = str(block.get("image_url", "")).strip()
-            image_text = alt_text or image_url
-            if alt_text and image_url:
-                image_text = f"{alt_text} ({image_url})"
-            if image_text:
-                plain_parts.append(image_text)
-        elif block.get("type") == "divider":
-            plain_parts.append(getattr(block, "_plain_text", None) or "---")
-
-    return "\n\n".join([part for part in plain_parts if part.strip()])
+    parts = _blocks_to_downgrade_parts(blocks, fallback=True)
+    return "\n\n".join([part for part in parts if part.strip()])
 
 
 # Backward-compatible helper retained for existing imports.

{slack_markdown_parser-2.4.2 → slack_markdown_parser-2.4.4/slack_markdown_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.4.2
+Version: 2.4.4
 Summary: Convert LLM Markdown into Slack Block Kit messages
 Author: darkgaldragon
 License-Expression: MIT