slack-markdown-parser 2.4.1__tar.gz → 2.4.3__tar.gz

{slack_markdown_parser-2.4.1 → slack_markdown_parser-2.4.3}/CHANGELOG.md

@@ -6,6 +6,19 @@ The format is based on Keep a Changelog, and the project follows Semantic Versio
 
 ## [Unreleased]
 
+## [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
+
+- 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

{slack_markdown_parser-2.4.1/slack_markdown_parser.egg-info → slack_markdown_parser-2.4.3}/PKG-INFO

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

{slack_markdown_parser-2.4.1 → slack_markdown_parser-2.4.3}/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`
@@ -178,6 +178,7 @@ LLM は外枠パイプの省略、区切り行の欠落、列数の不一致な
 - チャンクの先頭・末尾（行頭・行末・テキスト端、またはフェンスドコードブロックの境界）は安全とみなし、ゼロ幅スペースを付けません。
 - 外側の片方が前後の非境界テキストに密着している場合、その側だけにゼロ幅スペースを付けます。安全（境界）側はそのままにします。
 - 強調マーカー（`**`・`*`・`~~`）の内側が句読点に密着している場合（例 `**注意:**` や `**70.9%→83.0%**`）、マーカーの内側にゼロ幅スペースを挿入します。これによりマーカーの内側隣接文字が非句読点になり、後続が何であっても Slack の CommonMark right-/left-flanking 判定が成立します。Slack が flanking 近傍として認めない CJK テキストや CJK 句読点（`、` / `。`）の直前でも有効です。インラインコードは flanking 規則の対象外なので、このルールから除外します。
+- 強調デリミタは CommonMark の最小 flanking 条件を満たす場合のみ認識します。すなわち、開きランの直後が空白でなく、閉じランの直前が空白でないこと。両側が空白の単独マーカー（例 `閉じ ** が` の literal な `**`）や、その他の対になっていないマーカーはそのまま残します。これにより、1 個の余分なマーカーが近くの正しい装飾のペアリングをずらして、ゼロ幅スペースを誤った位置に挿入することを防ぎます。
 
 例外:
 

{slack_markdown_parser-2.4.1 → slack_markdown_parser-2.4.3}/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`
@@ -177,6 +177,7 @@ 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:
 

{slack_markdown_parser-2.4.1 → slack_markdown_parser-2.4.3}/pyproject.toml

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

{slack_markdown_parser-2.4.1 → slack_markdown_parser-2.4.3}/slack_markdown_parser/__init__.py

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

{slack_markdown_parser-2.4.1 → slack_markdown_parser-2.4.3}/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(
@@ -129,6 +143,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,
@@ -582,9 +662,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

{slack_markdown_parser-2.4.1 → slack_markdown_parser-2.4.3/slack_markdown_parser.egg-info}/PKG-INFO

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