slack-markdown-parser 2.3.0__tar.gz → 2.3.2__tar.gz

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on Keep a Changelog, and the project follows Semantic Versio
 
 ## [Unreleased]
 
+## [2.3.2] - 2026-04-17
+
+### Fixed
+
+- Stopped `preserve_visual_blank_lines` from keeping ordered-list context open after list items, including continued items, nested lists, and ordered-list paragraph interruption edge cases.
+- Avoided false-positive list-context detection for indented non-list lines and thematic breaks, so visible blank-line preservation no longer regresses on inputs like `    1. not-a-list` or `- - -`.
+
+## [2.3.1] - 2026-04-10
+
+### Fixed
+
+- Stopped `preserve_visual_blank_lines` from inserting visual-only blank-line placeholders inside fenced code blocks.
+- Kept fallback plain text stable when visual blank-line placeholders are enabled alongside parser-added spacing markers around emphasis or inline code.
+
 ## [2.3.0] - 2026-04-10
 
 ### Changed

{slack_markdown_parser-2.3.0/slack_markdown_parser.egg-info → slack_markdown_parser-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.3.0
+Version: 2.3.2
 Summary: Convert LLM Markdown into Slack Block Kit markdown/table messages
 Author: darkgaldragon
 License-Expression: MIT
@@ -26,7 +26,6 @@ Requires-Dist: pip-audit>=2.7.0; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
-Requires-Dist: twine>=5.1.0; extra == "dev"
 Dynamic: license-file
 
 # slack-markdown-parser
@@ -210,8 +209,9 @@ Markdown segments with lines that contain only a non-breaking space. Those
 placeholder lines are removed again when generating preview plain text, so Slack
 notifications and logs stay close to the original Markdown source.
 The current implementation deliberately skips blank runs that sit immediately
-before setext-heading underlines or reference-link definitions, because those
-boundaries can change Markdown meaning in newer Slack Markdown rendering.
+after list-item content, before setext-heading underlines, or before
+reference-link definitions, because those boundaries can change Markdown meaning in newer
+Slack Markdown rendering or keep list formatting open in some clients.
 
 ### Utility functions
 

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/README-ja.md

@@ -161,7 +161,7 @@ QA | ~~保留~~ | Team C
 
 `preserve_visual_blank_lines=True` は、非テーブル領域の内部空行を「改行を見えやすくするための補助行」に置き換えるオプションです。
 この補助行はプレビュー文字列を作るときに取り除かれるので、通知文やログは元の Markdown に近い形を保てます。
-また、setext 見出しの下線直前や参照リンク定義直前には補助行を入れず、Markdown の意味が変わらないようにしています。
+また、リスト項目の内容直後、setext 見出しの下線直前、参照リンク定義直前には補助行を入れず、Markdown の意味が変わったり一部クライアントでリスト解釈が継続したりしないようにしています。
 
 ### ユーティリティ関数（公開関数）
 

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/README.md

@@ -179,8 +179,9 @@ Markdown segments with lines that contain only a non-breaking space. Those
 placeholder lines are removed again when generating preview plain text, so Slack
 notifications and logs stay close to the original Markdown source.
 The current implementation deliberately skips blank runs that sit immediately
-before setext-heading underlines or reference-link definitions, because those
-boundaries can change Markdown meaning in newer Slack Markdown rendering.
+after list-item content, before setext-heading underlines, or before
+reference-link definitions, because those boundaries can change Markdown meaning in newer
+Slack Markdown rendering or keep list formatting open in some clients.
 
 ### Utility functions
 

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/docs/spec-ja.md

@@ -205,6 +205,7 @@ LLM は外枠パイプの省略、区切り行の欠落、列数の不一致な
 - 見える行に挟まれた内部空行だけを書き換える
 - 先頭・末尾の空行のまとまりはそのまま残す
 - table 領域には適用しない
+- リスト項目の内容直後の空行はそのまま残す
 - setext 見出しの下線直前の空行はそのまま残す
 - 参照リンク定義直前の空行はそのまま残す
 - プレビュー文字列と `blocks_to_plain_text` では補助用のマーカーを除去し、元の空行構造に戻す

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/docs/spec.md

@@ -207,6 +207,7 @@ This workaround is intentionally narrow:
 - Only blank lines between visible lines are rewritten
 - Leading and trailing blank runs are left untouched
 - Table segments are not modified by this option
+- Blank runs immediately after list-item content are left untouched
 - Blank runs immediately before setext-heading underlines are left untouched
 - Blank runs immediately before reference-link definitions are left untouched
 - Preview text and `blocks_to_plain_text` remove those placeholder markers again, preserving the original blank lines in plain-text output

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slack-markdown-parser"
-version = "2.3.0"
+version = "2.3.2"
 description = "Convert LLM Markdown into Slack Block Kit markdown/table messages"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,7 +33,6 @@ dev = [
   "pytest>=8.0.0",
   "pytest-cov>=5.0.0",
   "ruff>=0.6.0",
-  "twine>=5.1.0",
 ]
 
 [project.urls]
@@ -57,4 +56,7 @@ target-version = "py310"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B"]
-ignore = ["E501", "UP006", "UP035", "UP045"]
+ignore = ["E501"]  # line length is enforced by black
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/slack_markdown_parser/__init__.py

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

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/slack_markdown_parser/converter.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import html
 import re
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 ZWSP = "\u200b"
 NBSP = "\u00a0"
@@ -42,6 +42,12 @@ PROTECTED_UNDERSCORE_SPAN_PATTERN = re.compile(
 )
 REFERENCE_DEFINITION_PATTERN = re.compile(r"^[ \t]{0,3}\[[^\]\n]+\]:")
 SETEXT_HEADING_UNDERLINE_PATTERN = re.compile(r"^[ \t]{0,3}(?:=+|-+)\s*$")
+THEMATIC_BREAK_PATTERN = re.compile(
+    r"^[ \t]{0,3}(?P<char>[-_*])(?:[ \t]*\1){2,}[ \t]*$"
+)
+LIST_ITEM_PATTERN = re.compile(
+    r"^(?P<indent>[ \t]*)(?P<marker>\d+[.)]|[-+*])(?P<spacing>[ \t]+|$)"
+)
 DOUBLE_UNDERSCORE_EMPHASIS_PATTERN = re.compile(
     r"(?<![\\0-9A-Za-z_])__(?=\S)(.+?\S)__(?![0-9A-Za-z_])"
 )
@@ -118,7 +124,7 @@ def _nested_code_space_strategy(
     source: str,
     start: int,
     end: int,
-    boundary_chars: Optional[set[str]] = None,
+    boundary_chars: set[str] | None = None,
 ) -> str | None:
     boundary_chars = boundary_chars or {*VISIBLE_BOUNDARY_CHARS, ZWSP}
     neighbors = []
@@ -153,8 +159,20 @@ def _normalize_markdown_block_plain_text(text: str) -> str:
     return re.sub(r"<(https?://[^>\s|]+)>", r"\1", text)
 
 
+def _build_markdown_block_plain_text(
+    text: str, synthetic_space_indices: list[int] | None = None
+) -> str:
+    """Build fallback/plain text for a markdown block before visual-only rewrites."""
+    return _normalize_markdown_block_plain_text(
+        _strip_synthetic_spaces_from_plain_text(
+            strip_zero_width_spaces(text),
+            synthetic_space_indices,
+        )
+    )
+
+
 def _strip_synthetic_spaces_from_plain_text(
-    text: str, synthetic_space_indices: Optional[List[int]] = None
+    text: str, synthetic_space_indices: list[int] | None = None
 ) -> str:
     if not text or not synthetic_space_indices:
         return text
@@ -165,13 +183,148 @@ def _strip_synthetic_spaces_from_plain_text(
     )
 
 
-def _inject_visual_blank_line_placeholders(text: str) -> tuple[str, List[int]]:
+def _indent_width(text: str) -> int:
+    width = 0
+    for char in text:
+        if char == " ":
+            width += 1
+        elif char == "\t":
+            # Treat tabs conservatively for list-continuation heuristics.
+            width += 4
+        else:
+            break
+    return width
+
+
+def _list_item_content_indent(match: re.Match[str]) -> int:
+    spacing = match.group("spacing") or ""
+    spacing_width = _indent_width(spacing) if spacing else 1
+    return (
+        _indent_width(match.group("indent") or "")
+        + len(match.group("marker") or "")
+        + spacing_width
+    )
+
+
+def _is_ordered_list_marker(marker: str) -> bool:
+    return bool(marker) and marker[0].isdigit()
+
+
+def _is_thematic_break_line(line: str) -> bool:
+    return bool(THEMATIC_BREAK_PATTERN.match(line))
+
+
+def _ordered_list_marker_starts_at_one(marker: str) -> bool:
+    if not _is_ordered_list_marker(marker):
+        return False
+    return marker[:-1] == "1"
+
+
+def _starts_root_list_item(lines: list[str], marker_index: int) -> bool:
+    line = lines[marker_index]
+    if _is_thematic_break_line(line):
+        return False
+    match = LIST_ITEM_PATTERN.match(line)
+    if not match or _indent_width(match.group("indent") or "") > 3:
+        return False
+
+    marker = match.group("marker") or ""
+    if marker_index == 0 or not lines[marker_index - 1].strip(" \t\r"):
+        return True
+
+    if not _is_ordered_list_marker(marker):
+        return True
+
+    return _ordered_list_marker_starts_at_one(marker)
+
+
+def _line_belongs_to_list_context(
+    lines: list[str], *, marker_index: int, target_index: int
+) -> bool:
+    marker_match = LIST_ITEM_PATTERN.match(lines[marker_index])
+    if not marker_match:
+        return False
+
+    list_indent_stack = [
+        (
+            _indent_width(marker_match.group("indent") or ""),
+            _list_item_content_indent(marker_match),
+        )
+    ]
+
+    for idx in range(marker_index + 1, target_index + 1):
+        line = lines[idx]
+        if not line.strip(" \t\r"):
+            return False
+
+        line_indent = _indent_width(line)
+        nested_match = LIST_ITEM_PATTERN.match(line)
+        if nested_match and not _is_thematic_break_line(line):
+            marker_indent = _indent_width(nested_match.group("indent") or "")
+            while list_indent_stack and marker_indent < list_indent_stack[-1][0]:
+                list_indent_stack.pop()
+
+            if not list_indent_stack:
+                return False
+
+            if marker_indent == list_indent_stack[-1][0]:
+                list_indent_stack[-1] = (
+                    marker_indent,
+                    _list_item_content_indent(nested_match),
+                )
+                continue
+
+            if marker_indent >= list_indent_stack[-1][1]:
+                list_indent_stack.append(
+                    (
+                        marker_indent,
+                        _list_item_content_indent(nested_match),
+                    )
+                )
+                continue
+
+            return False
+
+        while len(list_indent_stack) > 1 and line_indent < list_indent_stack[-1][0]:
+            list_indent_stack.pop()
+
+        if line_indent >= list_indent_stack[-1][1]:
+            continue
+
+        return False
+
+    return True
+
+
+def _blank_run_follows_list_context(lines: list[str], blank_start: int) -> bool:
+    previous_visible_index = blank_start - 1
+    if previous_visible_index < 0 or not lines[previous_visible_index].strip(" \t\r"):
+        return False
+
+    block_start = previous_visible_index
+    while block_start > 0 and lines[block_start - 1].strip(" \t\r"):
+        block_start -= 1
+
+    for marker_index in range(previous_visible_index, block_start - 1, -1):
+        if not _starts_root_list_item(lines, marker_index):
+            continue
+        if _line_belongs_to_list_context(
+            lines, marker_index=marker_index, target_index=previous_visible_index
+        ):
+            return True
+
+    return False
+
+
+def _inject_visual_blank_line_placeholders_in_chunk(
+    text: str,
+) -> tuple[str, list[int]]:
     """Replace internal blank lines with NBSP-only lines for Slack rendering."""
     if not text or "\n" not in text:
         return text, []
 
     lines = text.split("\n")
-    rewritten: List[tuple[str, bool]] = []
+    rewritten: list[tuple[str, bool]] = []
     i = 0
 
     while i < len(lines):
@@ -188,6 +341,9 @@ def _inject_visual_blank_line_placeholders(text: str) -> tuple[str, List[int]]:
             lines[blank_start - 1].strip(" \t\r")
         )
         has_visible_line_after = i < len(lines) and bool(lines[i].strip(" \t\r"))
+        blank_run_follows_list_context = has_visible_line_before and (
+            _blank_run_follows_list_context(lines, blank_start)
+        )
         next_visible_starts_reference_definition = has_visible_line_after and bool(
             REFERENCE_DEFINITION_PATTERN.match(lines[i])
         )
@@ -203,6 +359,7 @@ def _inject_visual_blank_line_placeholders(text: str) -> tuple[str, List[int]]:
         if (
             has_visible_line_before
             and has_visible_line_after
+            and not blank_run_follows_list_context
             and not next_visible_starts_reference_definition
             and not next_visible_starts_setext_heading
         ):
@@ -210,8 +367,8 @@ def _inject_visual_blank_line_placeholders(text: str) -> tuple[str, List[int]]:
         else:
             rewritten.extend((line, False) for line in lines[blank_start:i])
 
-    rebuilt_parts: List[str] = []
-    synthetic_indices: List[int] = []
+    rebuilt_parts: list[str] = []
+    synthetic_indices: list[int] = []
     offset = 0
 
     for idx, (line, is_synthetic) in enumerate(rewritten):
@@ -226,8 +383,33 @@ def _inject_visual_blank_line_placeholders(text: str) -> tuple[str, List[int]]:
     return "".join(rebuilt_parts), synthetic_indices
 
 
+def _inject_visual_blank_line_placeholders(text: str) -> tuple[str, list[int]]:
+    """Replace internal blank lines outside fenced code blocks."""
+    if not text or "\n" not in text:
+        return text, []
+
+    rebuilt_parts: list[str] = []
+    synthetic_indices: list[int] = []
+    offset = 0
+
+    for is_fenced, chunk in _split_fenced_code_chunks(text):
+        if is_fenced:
+            rebuilt_parts.append(chunk)
+            offset += len(chunk)
+            continue
+
+        rewritten_chunk, chunk_indices = (
+            _inject_visual_blank_line_placeholders_in_chunk(chunk)
+        )
+        rebuilt_parts.append(rewritten_chunk)
+        synthetic_indices.extend(offset + idx for idx in chunk_indices)
+        offset += len(rewritten_chunk)
+
+    return "".join(rebuilt_parts), synthetic_indices
+
+
 def _strip_synthetic_blank_line_placeholders(
-    text: str, synthetic_blank_line_indices: Optional[List[int]] = None
+    text: str, synthetic_blank_line_indices: list[int] | None = None
 ) -> str:
     if not text or not synthetic_blank_line_indices:
         return text
@@ -238,12 +420,12 @@ def _strip_synthetic_blank_line_placeholders(
     )
 
 
-def _remove_synthetic_space_markers(text: str) -> tuple[str, List[int]]:
+def _remove_synthetic_space_markers(text: str) -> tuple[str, list[int]]:
     if not text or SYNTH_SPACE_MARKER not in text:
         return text, []
 
-    cleaned: List[str] = []
-    synthetic_indices: List[int] = []
+    cleaned: list[str] = []
+    synthetic_indices: list[int] = []
     mark_next_space = False
 
     for char in text:
@@ -327,7 +509,7 @@ def normalize_bare_urls_for_slack_markdown(text: str) -> str:
         return text
 
     def wrap_chunk(chunk: str) -> str:
-        parts: List[str] = []
+        parts: list[str] = []
         cursor = 0
         length = len(chunk)
 
@@ -391,7 +573,7 @@ def sanitize_slack_text(text: str) -> str:
     return SLACK_ANGLE_TOKEN_PATTERN.sub(replace_invalid_token, cleaned)
 
 
-def _match_fence_open(line: str) -> Optional[tuple[str, int]]:
+def _match_fence_open(line: str) -> tuple[str, int] | None:
     match = FENCE_OPEN_PATTERN.match(line)
     if not match:
         return None
@@ -408,13 +590,13 @@ def _is_fence_close(line: str, fence: tuple[str, int]) -> bool:
     )
 
 
-def _split_fenced_code_chunks(text: str) -> List[tuple[bool, str]]:
-    chunks: List[tuple[bool, str]] = []
+def _split_fenced_code_chunks(text: str) -> list[tuple[bool, str]]:
+    chunks: list[tuple[bool, str]] = []
     if not text:
         return chunks
 
-    current: List[str] = []
-    active_fence: Optional[tuple[str, int]] = None
+    current: list[str] = []
+    active_fence: tuple[str, int] | None = None
 
     for line in text.splitlines(keepends=True):
         opening_fence = _match_fence_open(line) if active_fence is None else None
@@ -440,7 +622,7 @@ def _split_fenced_code_chunks(text: str) -> List[tuple[bool, str]]:
 
 
 def _normalize_underscore_emphasis_chunk(text: str) -> str:
-    protected_spans: List[str] = []
+    protected_spans: list[str] = []
 
     def protect(match: re.Match[str]) -> str:
         token = f"\ufff0{len(protected_spans)}\ufff1"
@@ -478,7 +660,7 @@ def add_zero_width_spaces_to_markdown(text: str) -> str:
     return formatted
 
 
-def _format_markdown_with_spacing_metadata(text: str) -> tuple[str, List[int]]:
+def _format_markdown_with_spacing_metadata(text: str) -> tuple[str, list[int]]:
     """Return formatted markdown text plus synthetic visible-space positions."""
     if not text:
         return text, []
@@ -576,12 +758,12 @@ def _format_markdown_with_spacing_metadata(text: str) -> tuple[str, List[int]]:
         suffix = STRIP_RIGHT_ZWSP_MARKER if after_char == ZWSP else ""
         return f"{prefix}{adjusted_text}{suffix}"
 
-    def wrap_segment(segment: str) -> tuple[str, List[int]]:
+    def wrap_segment(segment: str) -> tuple[str, list[int]]:
         if not segment:
             return segment, []
 
         placeholder_map: dict[str, dict[str, str]] = {}
-        protected_parts: List[str] = []
+        protected_parts: list[str] = []
         last_end = 0
 
         for idx, match in enumerate(INLINE_CODE_SPAN_PATTERN.finditer(segment)):
@@ -651,8 +833,8 @@ def _format_markdown_with_spacing_metadata(text: str) -> tuple[str, List[int]]:
         return _remove_synthetic_space_markers(protected_segment)
 
     chunks = _split_fenced_code_chunks(text)
-    combined_parts: List[str] = []
-    combined_indices: List[int] = []
+    combined_parts: list[str] = []
+    combined_indices: list[int] = []
     offset = 0
     for is_fenced, chunk in chunks:
         if is_fenced:
@@ -671,7 +853,7 @@ def _format_markdown_with_spacing_metadata(text: str) -> tuple[str, List[int]]:
 add_zero_width_spaces = add_zero_width_spaces_to_markdown
 
 
-def _split_markdown_table_cells(line: str) -> List[str]:
+def _split_markdown_table_cells(line: str) -> list[str]:
     """Split markdown table cells while preserving pipes inside <...|...> links."""
     working = line.strip()
     if not working:
@@ -682,8 +864,8 @@ def _split_markdown_table_cells(line: str) -> List[str]:
     if working.endswith("|"):
         working = working[:-1]
 
-    cells: List[str] = []
-    current: List[str] = []
+    cells: list[str] = []
+    current: list[str] = []
     in_angle = False
     escaped = False
     cursor = 0
@@ -733,8 +915,8 @@ def _count_cell_words(cell_text: str) -> int:
 
 
 def _split_heading_prefix_and_first_cell(
-    heading_prefix: str, reference_cell: Optional[str]
-) -> Optional[tuple[str, str]]:
+    heading_prefix: str, reference_cell: str | None
+) -> tuple[str, str] | None:
     tokens = [token for token in heading_prefix.strip().split() if token]
     if len(tokens) < 2:
         return None
@@ -753,8 +935,8 @@ def _split_heading_prefix_and_first_cell(
 
 
 def _split_heading_and_table_row(
-    line: str, next_line: Optional[str] = None
-) -> Optional[tuple[str, str]]:
+    line: str, next_line: str | None = None
+) -> tuple[str, str] | None:
     """Split lines like '# Heading |a|b|' into heading and table row."""
     if "|" not in line:
         return None
@@ -812,7 +994,7 @@ def _split_heading_and_table_row(
     if not explicit_cells:
         return None
 
-    reference_cell: Optional[str] = None
+    reference_cell: str | None = None
     if (
         next_line
         and "|" in next_line
@@ -848,10 +1030,10 @@ def normalize_markdown_tables(markdown_text: str) -> str:
         return markdown_text
 
     lines = markdown_text.splitlines()
-    normalized: List[str] = []
-    buffer: List[str] = []
+    normalized: list[str] = []
+    buffer: list[str] = []
 
-    def is_table_block(candidates: List[str]) -> bool:
+    def is_table_block(candidates: list[str]) -> bool:
         if len(candidates) < 2:
             return False
         if any(
@@ -859,7 +1041,7 @@ def normalize_markdown_tables(markdown_text: str) -> str:
         ):
             return True
 
-        column_counts: List[int] = []
+        column_counts: list[int] = []
         for line in candidates:
             working = line.strip()
             if "|" not in working:
@@ -916,7 +1098,7 @@ def normalize_markdown_tables(markdown_text: str) -> str:
             normalized.extend(buffer)
         buffer = []
 
-    active_fence: Optional[tuple[str, int]] = None
+    active_fence: tuple[str, int] | None = None
 
     for idx, line in enumerate(lines):
         opening_fence = _match_fence_open(line) if active_fence is None else None
@@ -964,13 +1146,13 @@ def looks_like_markdown_table(text: str) -> bool:
     return table_like_lines >= 2
 
 
-def _create_table_cell(text: str) -> Dict[str, Any]:
+def _create_table_cell(text: str) -> dict[str, Any]:
     """Build Slack rich_text cell from markdown fragment."""
     clean_text = strip_zero_width_spaces(text or "")
     clean_text = clean_text.replace("\\|", "|")
     if not clean_text.strip():
         clean_text = "-"
-    elements: List[Dict[str, Any]] = []
+    elements: list[dict[str, Any]] = []
     last_index = 0
 
     for match in TABLE_TOKEN_PATTERN.finditer(clean_text):
@@ -979,7 +1161,7 @@ def _create_table_cell(text: str) -> Dict[str, Any]:
             if prefix:
                 elements.append({"type": "text", "text": prefix})
 
-        element: Dict[str, Any]
+        element: dict[str, Any]
         markdown_label = match.group("markdown_label")
         markdown_url = match.group("markdown_url")
         angle_url = match.group("angle_url")
@@ -995,7 +1177,7 @@ def _create_table_cell(text: str) -> Dict[str, Any]:
                 "text": angle_label or angle_url,
             }
         else:
-            style: Dict[str, bool] = {}
+            style: dict[str, bool] = {}
             content = token
 
             if content.startswith("`") and content.endswith("`"):
@@ -1031,13 +1213,13 @@ def _create_table_cell(text: str) -> Dict[str, Any]:
     }
 
 
-def extract_plain_text_from_table_cell(cell: Dict[str, Any]) -> str:
+def extract_plain_text_from_table_cell(cell: dict[str, Any]) -> str:
     """Extract plain text from a Slack table cell object."""
     if not isinstance(cell, dict):
         return ""
 
     if cell.get("type") == "rich_text":
-        texts: List[str] = []
+        texts: list[str] = []
         for element in cell.get("elements", []):
             if not isinstance(element, dict):
                 continue
@@ -1055,13 +1237,13 @@ def extract_plain_text_from_table_cell(cell: Dict[str, Any]) -> str:
     return str(cell.get("text", ""))
 
 
-def markdown_table_to_slack_table(table_markdown: str) -> Optional[Dict[str, Any]]:
+def markdown_table_to_slack_table(table_markdown: str) -> dict[str, Any] | None:
     """Convert markdown table text to Slack table block."""
     lines = [
         line.rstrip() for line in table_markdown.strip().splitlines() if line.strip()
     ]
-    rows: List[List[Dict[str, Any]]] = []
-    expected_columns: Optional[int] = None
+    rows: list[list[dict[str, Any]]] = []
+    expected_columns: int | None = None
 
     for line in lines:
         if TABLE_SEPARATOR_PATTERN.match(line):
@@ -1092,15 +1274,15 @@ def markdown_table_to_slack_table(table_markdown: str) -> Optional[Dict[str, Any
 markdown_table_to_table_block = markdown_table_to_slack_table
 
 
-def split_markdown_into_segments(markdown_text: str) -> List[Dict[str, str]]:
+def split_markdown_into_segments(markdown_text: str) -> list[dict[str, str]]:
     """Split markdown into alternating text/table segments."""
-    segments: List[Dict[str, str]] = []
+    segments: list[dict[str, str]] = []
     if not markdown_text:
         return segments
 
     lines = markdown_text.splitlines()
-    current: List[str] = []
-    current_is_table: Optional[bool] = None
+    current: list[str] = []
+    current_is_table: bool | None = None
 
     def flush() -> None:
         nonlocal current, current_is_table
@@ -1114,7 +1296,7 @@ def split_markdown_into_segments(markdown_text: str) -> List[Dict[str, str]]:
         current = []
         current_is_table = None
 
-    active_fence: Optional[tuple[str, int]] = None
+    active_fence: tuple[str, int] | None = None
 
     for line in lines:
         stripped = line.strip()
@@ -1147,7 +1329,7 @@ def split_markdown_into_segments(markdown_text: str) -> List[Dict[str, str]]:
 
 def convert_markdown_to_slack_blocks(
     markdown_text: str, *, preserve_visual_blank_lines: bool = False
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Convert markdown text into Slack markdown/table blocks."""
     if not markdown_text:
         return []
@@ -1157,7 +1339,7 @@ def convert_markdown_to_slack_blocks(
     markdown_text = normalize_underscore_emphasis(markdown_text)
     markdown_text = normalize_bare_urls_for_slack_markdown(markdown_text)
     markdown_text = normalize_markdown_tables(markdown_text)
-    blocks: List[Dict[str, Any]] = []
+    blocks: list[dict[str, Any]] = []
 
     for segment in split_markdown_into_segments(markdown_text):
         content = segment.get("content", "")
@@ -1171,13 +1353,15 @@ def convert_markdown_to_slack_blocks(
                 continue
 
         formatted, synthetic_indices = _format_markdown_with_spacing_metadata(content)
-        synthetic_blank_line_indices: List[int] = []
+        plain_text = _build_markdown_block_plain_text(formatted, synthetic_indices)
+        synthetic_blank_line_indices: list[int] = []
         if preserve_visual_blank_lines:
             formatted, synthetic_blank_line_indices = (
                 _inject_visual_blank_line_placeholders(formatted)
             )
         if formatted.strip():
             block = _AnnotatedSlackBlock({"type": "markdown", "text": formatted})
+            block._plain_text = plain_text
             block._synthetic_space_indices = synthetic_indices
             block._synthetic_blank_line_indices = synthetic_blank_line_indices
             blocks.append(block)
@@ -1189,10 +1373,10 @@ def convert_markdown_to_slack_blocks(
 convert_markdown_text_to_blocks = convert_markdown_to_slack_blocks
 
 
-def split_blocks_by_table(blocks: List[Dict[str, Any]]) -> List[List[Dict[str, Any]]]:
+def split_blocks_by_table(blocks: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:
     """Split blocks into multiple messages to satisfy one-table-per-message constraint."""
-    messages: List[List[Dict[str, Any]]] = []
-    current_message: List[Dict[str, Any]] = []
+    messages: list[list[dict[str, Any]]] = []
+    current_message: list[dict[str, Any]] = []
 
     for block in blocks or []:
         if isinstance(block, dict) and block.get("type") == "table":
@@ -1213,7 +1397,7 @@ def convert_markdown_to_slack_messages(
     markdown_text: str,
     *,
     preserve_visual_blank_lines: bool = False,
-) -> List[List[Dict[str, Any]]]:
+) -> list[list[dict[str, Any]]]:
     """Convert markdown text into a list of Slack message block groups."""
     blocks = convert_markdown_to_slack_blocks(
         markdown_text, preserve_visual_blank_lines=preserve_visual_blank_lines
@@ -1227,9 +1411,9 @@ def convert_markdown_to_slack_payloads(
     markdown_text: str,
     *,
     preserve_visual_blank_lines: bool = False,
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Convert markdown text into Slack-ready payload dicts with fallback text."""
-    payloads: List[Dict[str, Any]] = []
+    payloads: list[dict[str, Any]] = []
     for blocks in convert_markdown_to_slack_messages(
         markdown_text, preserve_visual_blank_lines=preserve_visual_blank_lines
     ):
@@ -1238,31 +1422,33 @@ def convert_markdown_to_slack_payloads(
     return payloads
 
 
-def blocks_to_plain_text(blocks: List[Dict[str, Any]]) -> str:
+def blocks_to_plain_text(blocks: list[dict[str, Any]]) -> str:
     """Build plain text representation from Slack blocks."""
-    parts: List[str] = []
+    parts: list[str] = []
 
     for block in blocks or []:
         block_type = block.get("type") if isinstance(block, dict) else None
 
         if block_type == "markdown":
-            text = block.get("text", "")
-            if text:
-                parts.append(
-                    _normalize_markdown_block_plain_text(
+            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(text),
+                                strip_zero_width_spaces(raw_text),
                                 getattr(block, "_synthetic_space_indices", None),
                             ),
                             getattr(block, "_synthetic_blank_line_indices", None),
-                        ),
+                        )
                     )
-                )
+            if text:
+                parts.append(text)
         elif block_type == "table":
             rows = block.get("rows") or []
             for row in rows:
-                cell_texts: List[str] = []
+                cell_texts: list[str] = []
                 if not isinstance(row, list):
                     continue
                 for cell in row:
@@ -1279,28 +1465,30 @@ def blocks_to_plain_text(blocks: List[Dict[str, Any]]) -> str:
     return "\n".join([p for p in parts if p]).strip()
 
 
-def build_fallback_text_from_blocks(blocks: List[Dict[str, Any]]) -> str:
+def build_fallback_text_from_blocks(blocks: list[dict[str, Any]]) -> str:
     """Build Slack fallback text from block structure."""
-    plain_parts: List[str] = []
+    plain_parts: list[str] = []
 
     for block in blocks or []:
         if not isinstance(block, dict):
             continue
 
         if block.get("type") == "markdown":
-            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),
+            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),
                     ),
-                    getattr(block, "_synthetic_blank_line_indices", None),
-                ),
-            )
+                )
             if text.strip():
                 plain_parts.append(text)
         elif block.get("type") == "table":
-            table_lines: List[str] = []
+            table_lines: list[str] = []
             for row in block.get("rows", []):
                 if not isinstance(row, list):
                     continue
@@ -1314,9 +1502,9 @@ def build_fallback_text_from_blocks(blocks: List[Dict[str, Any]]) -> str:
 
 
 # Backward-compatible helper retained for existing imports.
-def parse_markdown_table(table_text: str) -> List[List[str]]:
+def parse_markdown_table(table_text: str) -> list[list[str]]:
     """Parse markdown table into row/cell text matrix."""
-    rows: List[List[str]] = []
+    rows: list[list[str]] = []
     for line in [line for line in table_text.strip().splitlines() if line.strip()]:
         if TABLE_SEPARATOR_PATTERN.match(line.strip()):
             continue

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2/slack_markdown_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slack-markdown-parser
-Version: 2.3.0
+Version: 2.3.2
 Summary: Convert LLM Markdown into Slack Block Kit markdown/table messages
 Author: darkgaldragon
 License-Expression: MIT
@@ -26,7 +26,6 @@ Requires-Dist: pip-audit>=2.7.0; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
-Requires-Dist: twine>=5.1.0; extra == "dev"
 Dynamic: license-file
 
 # slack-markdown-parser
@@ -210,8 +209,9 @@ Markdown segments with lines that contain only a non-breaking space. Those
 placeholder lines are removed again when generating preview plain text, so Slack
 notifications and logs stay close to the original Markdown source.
 The current implementation deliberately skips blank runs that sit immediately
-before setext-heading underlines or reference-link definitions, because those
-boundaries can change Markdown meaning in newer Slack Markdown rendering.
+after list-item content, before setext-heading underlines, or before
+reference-link definitions, because those boundaries can change Markdown meaning in newer
+Slack Markdown rendering or keep list formatting open in some clients.
 
 ### Utility functions
 

{slack_markdown_parser-2.3.0 → slack_markdown_parser-2.3.2}/slack_markdown_parser.egg-info/requires.txt

@@ -6,4 +6,3 @@ pip-audit>=2.7.0
 pytest>=8.0.0
 pytest-cov>=5.0.0
 ruff>=0.6.0
-twine>=5.1.0