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

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

@@ -6,6 +6,20 @@ The format is based on Keep a Changelog, and the project follows Semantic Versio
 
 ## [Unreleased]
 
+## [2.4.2] - 2026-05-29
+
+### Fixed
+
+- Stopped an unbalanced emphasis delimiter from corrupting unrelated, well-formed spans in the same block. The bold/italic/strikethrough patterns are matched with `re.DOTALL`, so a single stray `**` (for example a whitespace-flanked literal `**` in `閉じ ** が`, or an unclosed marker) shifted marker pairing across the whole block and flipped the protective ZWSP of nearby punctuation-terminated bold to the broken *outer* position, re-exposing the literal markers on Slack. `EMPHASIS_PATTERNS` now enforces CommonMark's minimal flanking requirement — an opening run is not followed by whitespace and a closing run is not preceded by whitespace — so a non-flanking stray marker stays literal and no longer disturbs its neighbours.
+- Bounded the `**` and `~~` emphasis bodies to a single delimiter run so a dangling opener with no valid closer of its own (for example `**oops **` or `**: x **` before a later `**…%**`) can no longer scan past the literal stray and steal a following well-formed span's closing marker, which had misplaced that span's protective ZWSP. The single-`*` italic body is intentionally left unbounded because italics legitimately wrap `**bold**`.
+
+## [2.4.1] - 2026-05-29
+
+### Fixed
+
+- Stopped punctuation-terminated emphasis from leaking its literal markers (`**`, `*`, `~~`) in `markdown` blocks. A ZWSP placed just outside a closing marker broke Slack's CommonMark right-flanking check whenever the last inner character was punctuation (e.g. `- **項目:**` at a line end, or `**70.9%→83.0%**、` before CJK punctuation), exposing the raw markers. Chunk boundaries are now treated as safe so no stray ZWSP is appended at line/text ends, and when a marker sits against inner punctuation a ZWSP is inserted just inside it so the run flanks via rule 2a regardless of the following character — including before CJK text and CJK punctuation that Slack does not accept as a flanking neighbor.
+- Stopped preserving English-like punctuation-flanked emphasis raw when its tight neighbor is non-ASCII punctuation (e.g. `**APIYI (apiyi.com)**。` or `Score **70.9%→83.0%**、`). Slack only accepts ASCII punctuation/whitespace as a flanking neighbor, so these now receive the inner ZWSP protection instead of being emitted unchanged.
+
 ## [2.4.0] - 2026-05-14
 
 ### Added

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

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

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

@@ -166,16 +166,23 @@ LLM は外枠パイプの省略、区切り行の欠落、列数の不一致な
 
 ### 対象パターン
 
-以下の装飾記号について、前後のどちらか一方でも隣接文字がスペース・タブ・改行・既存のゼロ幅スペースでない場合、または行頭・行末に接している場合、通常は装飾トークン全体をゼロ幅スペース（`U+200B`）で囲みます。
+以下の装飾記号について、見た目を変えずに Slack の装飾境界を保つために必要な箇所だけにゼロ幅スペース（`U+200B`）を挿入します。
 
 - `` `code` `` — インラインコード
 - `**bold**` — 太字
 - `*italic*` — 斜体
 - `~~strike~~` — 取消線
 
+ルール:
+
+- チャンクの先頭・末尾（行頭・行末・テキスト端、またはフェンスドコードブロックの境界）は安全とみなし、ゼロ幅スペースを付けません。
+- 外側の片方が前後の非境界テキストに密着している場合、その側だけにゼロ幅スペースを付けます。安全（境界）側はそのままにします。
+- 強調マーカー（`**`・`*`・`~~`）の内側が句読点に密着している場合（例 `**注意:**` や `**70.9%→83.0%**`）、マーカーの内側にゼロ幅スペースを挿入します。これによりマーカーの内側隣接文字が非句読点になり、後続が何であっても Slack の CommonMark right-/left-flanking 判定が成立します。Slack が flanking 近傍として認めない CJK テキストや CJK 句読点（`、` / `。`）の直前でも有効です。インラインコードは flanking 規則の対象外なので、このルールから除外します。
+- 強調デリミタは CommonMark の最小 flanking 条件を満たす場合のみ認識します。すなわち、開きランの直後が空白でなく、閉じランの直前が空白でないこと。両側が空白の単独マーカー（例 `閉じ ** が` の literal な `**`）や、その他の対になっていないマーカーはそのまま残します。これにより、1 個の余分なマーカーが近くの正しい装飾のペアリングをずらして、ゼロ幅スペースを誤った位置に挿入することを防ぎます。
+
 例外:
 
-- 装飾の中身が英語系テキストで、密着している隣接文字が句読点だけの場合は、元のトークンをそのまま保つ。`**APIYI (apiyi.com)**:` のように Slack がそのまま表示できるケースで、不要なゼロ幅スペースを増やさないためです。
+- 装飾の中身が英語系テキストで、密着している隣接文字が **ASCII** 句読点だけの場合は、元のトークンをそのまま保ちます。`**APIYI (apiyi.com)**:` のように Slack がそのまま表示できるケースで、不要なゼロ幅スペースを増やさないためです。`、` や `。` のような非ASCII句読点が隣接する場合は保持せず、上記の内側ゼロ幅スペースで保護します。
 
 ### 除外範囲
 

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

@@ -165,16 +165,23 @@ In languages such as Japanese, Chinese, and Korean that do not usually put space
 
 ### Target patterns
 
-For each formatting token below, if either adjacent side is not a space, tab, newline, or existing zero-width space, or if the token touches the start or end of a line, the whole token is normally wrapped in a zero-width space (`U+200B`) so Slack recognizes it as a standalone formatting boundary:
+The library inserts zero-width spaces (`U+200B`) only where they are needed to keep Slack's formatting boundaries intact, without changing the visible layout, for each formatting token below:
 
 - `` `code` ``: inline code
 - `**bold**`: bold
 - `*italic*`: italic
 - `~~strike~~`: strikethrough
 
+Rules:
+
+- The start and end of a chunk (a line/text boundary, or the edge of a fenced code block) are treated as safe; no zero-width space is added there.
+- When an outer edge is tight against surrounding non-boundary text, only that edge is padded with a zero-width space. The safe (boundary) edge is left clean.
+- When an emphasis marker (`**`, `*`, `~~`) sits directly against punctuation on its inner side (for example `**注意:**` or `**70.9%→83.0%**`), a zero-width space is inserted just *inside* the marker. This makes the marker's inner neighbor a non-punctuation character, so Slack's CommonMark right-/left-flanking check succeeds regardless of what surrounds the token — including before CJK text and CJK punctuation (`、` / `。`), which Slack does not accept as a flanking neighbor. Inline code spans are exempt from this rule because they do not obey flanking rules.
+- Emphasis delimiters are recognized only when they satisfy CommonMark's minimal flanking rule: an opening run is not immediately followed by whitespace, and a closing run is not immediately preceded by whitespace. A stray, whitespace-flanked marker (for example the literal `**` in `閉じ ** が`), or an otherwise unbalanced marker, is left untouched. This prevents one dangling marker from shifting the pairing of nearby well-formed spans and misplacing their zero-width spaces.
+
 Exception:
 
-- If the token body is English-like text and the only tight neighbors are punctuation characters, the raw token is preserved. This avoids over-correcting spans such as `**APIYI (apiyi.com)**:` that Slack already renders correctly without extra zero-width spaces.
+- If the token body is English-like text and its only tight neighbors are **ASCII** punctuation characters, the raw token is preserved. This avoids over-correcting spans such as `**APIYI (apiyi.com)**:` that Slack already renders correctly without extra zero-width spaces. A non-ASCII punctuation neighbor such as `、` or `。` is not preserved — it is protected by the inner zero-width space described above.
 
 ### Excluded regions
 

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

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

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

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

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

@@ -32,10 +32,24 @@ STANDALONE_IMAGE_PATTERN = re.compile(
 )
 MARKDOWN_LINK_PATTERN = re.compile(r"\[[^\]\n]+\]\([^\)\n]+\)")
 INLINE_CODE_SPAN_PATTERN = re.compile(r"(?<!`)`[^`\n]+`(?!`)", flags=re.DOTALL)
+# Emphasis delimiters must satisfy CommonMark's minimal flanking requirement:
+# an opening run is not followed by whitespace and a closing run is not preceded
+# by whitespace. Enforcing this keeps a stray, whitespace-flanked delimiter
+# (e.g. the literal ``**`` in ``閉じ ** が``) from being paired at all.
+#
+# For ``**`` and ``~~`` the body additionally may not contain the same delimiter
+# run (``(?:(?!\*\*).)+?`` / ``(?:(?!~~).)+?``). Without this, a dangling opener
+# with no valid closer of its own (``**oops ** and **70.9%→83.0%**``) would scan
+# past the literal stray and steal a *later* well-formed span's closing marker,
+# shifting the pairing and corrupting that span's ZWSP placement. Bounding the
+# body to a single run makes the regex pair the same markers CommonMark does.
+# (The single-``*`` italic body is intentionally not bounded this way: italics
+# legitimately wrap ``**bold**`` and ``*`` is heavily overloaded, so it keeps the
+# whitespace guard only.)
 EMPHASIS_PATTERNS = (
-    re.compile(r"(?<!\*)\*\*(.+?)\*\*(?!\*)", flags=re.DOTALL),
-    re.compile(r"(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)", flags=re.DOTALL),
-    re.compile(r"~~(.+?)~~", flags=re.DOTALL),
+    re.compile(r"(?<!\*)\*\*(?!\s)((?:(?!\*\*).)+?)(?<!\s)\*\*(?!\*)", flags=re.DOTALL),
+    re.compile(r"(?<!\*)\*(?!\*)(?!\s)(.+?)(?<!\s)(?<!\*)\*(?!\*)", flags=re.DOTALL),
+    re.compile(r"~~(?!\s)((?:(?!~~).)+?)(?<!\s)~~", flags=re.DOTALL),
 )
 INLINE_CODE_PLACEHOLDER_PATTERN = re.compile(r"\ufff0code\d+\ufff1")
 PROTECTED_UNDERSCORE_SPAN_PATTERN = re.compile(
@@ -515,6 +529,13 @@ def _should_preserve_raw_punctuation_emphasis(
         return False
     if any(not _is_punctuation_like(char, boundary_chars) for char in tight_chars):
         return False
+    # Slack only accepts ASCII punctuation (and whitespace) as a flanking
+    # neighbor. A non-ASCII punctuation neighbor — e.g. the CJK comma/period
+    # ``、``/``。`` — does not satisfy the right-/left-flanking rule, so the
+    # token must not be preserved raw; it needs the inner-ZWSP protection in
+    # ``wrap_match`` instead.
+    if any(ord(char) > 127 for char in tight_chars):
+        return False
     if any(_is_han_or_kana_char(char) or _is_hangul_char(char) for char in token_text):
         return False
 
@@ -703,21 +724,65 @@ def _format_markdown_with_spacing_metadata(text: str) -> tuple[str, list[int]]:
 
     def wrap_match(match: re.Match[str], source: str) -> str:
         start, end = match.start(), match.end()
-        before_safe = start > 0 and source[start - 1] in boundary_chars
-        after_safe = end < len(source) and source[end] in boundary_chars
+        token = match.group(0)
+        # The start/end of the chunk are effective boundaries: there is no
+        # adjacent text to separate the marker from, so they are safe. Treating
+        # them as unsafe used to append a ZWSP right after a closing marker, and
+        # when the last content character was punctuation (e.g. ``**注意:**``)
+        # the trailing ZWSP made Slack fail the CommonMark right-flanking check
+        # and exposed the literal ``**``.
+        before_safe = start == 0 or source[start - 1] in boundary_chars
+        after_safe = end == len(source) or source[end] in boundary_chars
         if before_safe and after_safe:
-            return match.group(0)
+            return token
         if _should_preserve_raw_punctuation_emphasis(
-            source, start, end, match.group(0), boundary_chars
+            source, start, end, token, boundary_chars
         ):
-            return match.group(0)
-
-        # When either outer edge is tightly coupled to surrounding text or
-        # punctuation, wrap the whole token so Slack can treat the decoration
-        # as a standalone span.
-        prefix = ZWSP
-        suffix = ZWSP
-        return f"{prefix}{match.group(0)}{suffix}"
+            return token
+
+        # When an outer edge is tightly coupled to surrounding text, pad only
+        # that edge so Slack can treat the decoration as a standalone span.
+        # Padding a safe edge is unnecessary noise.
+        prefix = "" if before_safe else ZWSP
+        suffix = "" if after_safe else ZWSP
+
+        # Emphasis markers (``*``/``**``/``~~``) obey CommonMark delimiter-run
+        # flanking rules; inline code spans (``` `…` ```) do not. When an
+        # emphasis marker sits directly against punctuation on its inner side
+        # (``**注意:**``, ``**70%→83%**``) Slack treats the run as a delimiter
+        # only when the *outer* neighbour is whitespace or ASCII punctuation; a
+        # following CJK character or CJK punctuation (e.g. ``、``) — and even a
+        # ZWSP placed just outside the marker — leaves the literal ``**``
+        # exposed. Inserting a ZWSP just *inside* the marker makes its inner
+        # neighbour a non-punctuation character, so the run flanks via rule 2a
+        # regardless of what surrounds the token.
+        marker_char = token[0]
+        if marker_char != "`":
+            marker_len = len(token) - len(token.lstrip(marker_char))
+            open_marker = token[:marker_len]
+            inner = token[marker_len : len(token) - marker_len]
+            close_marker = token[len(token) - marker_len :]
+            inner_prefix = (
+                ZWSP if inner and _is_punctuation_like(inner[0], boundary_chars) else ""
+            )
+            inner_suffix = (
+                ZWSP
+                if inner and _is_punctuation_like(inner[-1], boundary_chars)
+                else ""
+            )
+            if inner_prefix or inner_suffix:
+                token = (
+                    f"{open_marker}{inner_prefix}{inner}{inner_suffix}{close_marker}"
+                )
+                # The inner ZWSP already lets the marker flank correctly, so an
+                # outer ZWSP on the same edge is redundant — and after a closing
+                # marker it is precisely what would re-break rendering.
+                if inner_prefix:
+                    prefix = ""
+                if inner_suffix:
+                    suffix = ""
+
+        return f"{prefix}{token}{suffix}"
 
     def wrap_nested_code_emphasis_match(
         match: re.Match[str],

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

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