",
+]
+
+_FOCUS_LINES = [
+ "# רמה 1",
+ "## רמה 2",
+ "### רמה 3",
+ "#### רמה 4",
+ "##### רמה 5",
+ "###### רמה 6",
+ "####### שבע סולמיות",
+ "#בלי רווח",
+ "## סולמית סוגרת ##",
+ "###",
+ f"## {_RLM}כותרת עם RLM",
+ "## כותרת עם `בקטיקים`",
+ "## **מודגש**",
+ "## [קישור](https://example.com)",
+ "## כותרת עם \\# escape",
+ "טקסט שעשוי להיות setext",
+ "---",
+ "===",
+ "```",
+ "```python",
+ "~~~",
+ ":::",
+ "\tכותרת בטאב",
+ " # כותרת מוזחת",
+ "> # כותרת בציטוט",
+ "- # כותרת בפריט",
+ "
",
+ "",
+]
+
+_NEXT_LINES = [
+ "",
+ "===",
+ "---",
+ "טקסט אחרי",
+ "# כותרת אחרי",
+ "```",
+ " קוד מוזח",
+ "\tקוד בטאב",
+ "|---|---|",
+ ":::",
+ "
",
+ "
",
+ "> ציטוט אחרי",
+]
+
+_ENDINGS = ["\n", ""]
+
+
+def _context_shapes():
+ for previous, focus, following, ending in itertools.product(
+ _PREVIOUS_LINES, _FOCUS_LINES, _NEXT_LINES, _ENDINGS
+ ):
+ yield f"{previous}\n{focus}\n{following}{ending}"
+
+
+@pytest.mark.parametrize("bucket", range(6))
+def test_the_context_matrix_agrees_with_cmark(bucket):
+ """המכפלה הקרטזית: שורה קודמת × שורת מוקד × שורה עוקבת × צורת סיום.
+
+ מחולקת לשישה דליים כדי שאף טסט לא יתקרב לתקרת הזמן של ``pytest``.
+ """
+ shapes = [s for i, s in enumerate(_context_shapes()) if i % 6 == bucket]
+ assert len(shapes) > 500, "הטבלה התכווצה — זו רגרסיה בכיסוי"
+ _compare(shapes)
+
+
+# ════════════════════════════════════════════════════════════════════
+# קינון גדרות — השורש של הבאג האמיתי שנמצא בקורפוס
+# ════════════════════════════════════════════════════════════════════
+
+def _fence_nesting_shapes():
+ """חיצונית × פנימית × הזחות × תו, ואחרי כל אחת כותרות.
+
+ **הצורה שמכילה את הבאג:** גדר פנימית עם שם שפה ובאותו אורך
+ כחיצונית. היא אינה יכולה לסגור — לסוגרת אסור שיהיה טקסט אחריה —
+ ולכן ה-``\\`\\`\\``` הבא סוגר דווקא את ה**חיצונית**, ומשם הזוגיות
+ הפוכה עד סוף הקובץ. זו בדיוק המחלקה שלא הייתה בטבלה של הסבב
+ הראשון.
+ """
+ for outer_len, inner_len, inner_indent, closing_indent, char in itertools.product(
+ (3, 4, 5), (3, 4, 5), (0, 2, 3, 4), (0, 3), ("`", "~")
+ ):
+ outer, inner = char * outer_len, char * inner_len
+ pad, close_pad = " " * inner_indent, " " * closing_indent
+ for inner_info in ("", "python"):
+ yield (
+ f"{outer}\n"
+ f"{pad}{inner}{inner_info}\n"
+ f"code\n"
+ f"{close_pad}{inner}\n"
+ f"{outer}\n"
+ f"\n## אחרי\n"
+ f"\n### עמוק יותר\n"
+ )
+
+
+@pytest.mark.parametrize("bucket", range(2))
+def test_fence_nesting_agrees_with_cmark(bucket):
+ shapes = [s for i, s in enumerate(_fence_nesting_shapes()) if i % 2 == bucket]
+ assert len(shapes) > 100, "טבלת הקינון התכווצה"
+ _compare(shapes)
+
+
+def test_a_fence_with_a_language_name_cannot_close_its_own_block():
+ """המקרה הבודד שהיה באג אמיתי בקובץ בריפו, מקובע בנפרד.
+
+ בלי הצורה הזאת בטבלה, שמונה שורות שנראות בדיוק כמו כותרות סעיף
+ נבלעות בתוך בלוק קוד — ופארסר שמציג אותן היה מראה סעיפים
+ ש-GitHub מסתיר.
+ """
+ text = "```\n```python\ncode\n```\n\n## נבלעת?\n"
+ assert _ours(text) == _oracle_sections(text)
+
+
+# ════════════════════════════════════════════════════════════════════
+# בלוקי HTML — צמודים ומופרדים
+# ════════════════════════════════════════════════════════════════════
+
+def _html_shapes():
+ """שש תגיות, צמודות ומופרדות, עם ובלי מאפיינים, והכותרת בשלושה מקומות.
+
+ ``span`` ו-``unknown-tag`` כאן בכוונה: הן אינן ברשימת התגיות של
+ CommonMark, ולכן הן נופלות למחלקת בלוק ה-HTML מסוג 7 — שהיא זו
+ שדורשת שורה ריקה לפניה. ההבדל בין "צמוד" ל"מופרד" הוא בדיוק מה
+ שמפעיל או מכבה את המחלקה הזאת.
+ """
+ tags = ("div", "details", "table", "p", "span", "unknown-tag")
+ for tag, attributes, blank_before, blank_inside, position, blank_before_close in (
+ itertools.product(
+ tags, ("", ' class="x"'), (True, False), (True, False),
+ ("inside", "after", "both"), (True, False),
+ )
+ ):
+ opening = f"<{tag}{attributes}>"
+ gap_before = "\n" if blank_before else ""
+ gap_inside = "\n" if blank_inside else ""
+ gap_close = "\n" if blank_before_close else ""
+ body = "## בתוך הבלוק\n" if position in ("inside", "both") else "טקסט\n"
+ tail = "\n## אחרי הבלוק\n" if position in ("after", "both") else ""
+ yield (
+ f"# לפני\n{gap_before}"
+ f"{opening}\n{gap_inside}"
+ f"{body}{gap_close}"
+ f"\n"
+ f"{tail}"
+ )
+
+
+_HTML_EDGE_CASES = [
+ "
\n## בלי סגירה\n",
+ "\n\n## אחרי הערה\n",
+ "\n## צמוד להערה\n",
+ "\n\n## אחרי processing instruction\n",
+ "
\n\n## בלוק שנסגר בשורה ריקה\n",
+]
+
+
+def test_html_blocks_agree_with_cmark():
+ _compare(list(_html_shapes()) + _HTML_EDGE_CASES)
+
+
+# ════════════════════════════════════════════════════════════════════
+# טבלאות — המחלקה שהמטריצה למעלה אינה מייצרת
+# ════════════════════════════════════════════════════════════════════
+#
+# **למה משפחה נפרדת ולא עוד שורה באוצר המילים.** טבלה היא **שתי שורות
+# צמודות** — שורת תאים ומיד אחריה שורת מפריד — והמטריצה למעלה בונה כל
+# צורה משורה קודמת, שורת מוקד ושורה עוקבת, ולכן היא לעולם אינה מציבה
+# את השתיים זו אחרי זו. זה בדיוק החור שדרכו עברה רגרסיה אמיתית: בלי
+# ``enable("table")`` הטבלה היא פסקה, ו-``---`` שאחריה הופך אותה לכותרת
+# setext.
+
+
+def _table_shapes():
+ """טבלה × מה שבא אחריה × האם יש שורת גוף, ואחריה כותרת."""
+ followers = ("---", "===", "", "## כותרת אחרי", "text", "|---|---|", "-")
+ for follower, with_body, blank_before in itertools.product(
+ followers, (True, False), (True, False)
+ ):
+ body = "| 1 | 2 |\n" if with_body else ""
+ gap = "\n" if blank_before else ""
+ tail = f"{follower}\n" if follower else ""
+ yield f"## לפני\n\n| a | b |\n|---|---|\n{body}{gap}{tail}\n## הסעיף הבא\n"
+
+
+def test_tables_agree_with_cmark():
+ shapes = list(_table_shapes())
+ assert len(shapes) > 20, "טבלת הטבלאות התכווצה"
+ _compare(shapes)
+
+
+# ════════════════════════════════════════════════════════════════════
+# מכלים — cmark רואה את הכותרת, המפה שלנו לא
+# ════════════════════════════════════════════════════════════════════
+
+_CONTAINER_SHAPES = [
+ "## לפני\n\n> ## בתוך ציטוט\n\n## אחרי\n",
+ "## לפני\n\n- ## בתוך פריט\n\n## אחרי\n",
+ "## לפני\n\n> > ## ציטוט בתוך ציטוט\n\n## אחרי\n",
+ "## לפני\n\n1. ## בתוך פריט ממוספר\n\n## אחרי\n",
+ "## לפני\n\n- - ## פריט בתוך פריט\n\n## אחרי\n",
+ "> ## ציטוט בלבד\n",
+]
+
+
+@pytest.mark.parametrize("text", _CONTAINER_SHAPES)
+def test_a_heading_inside_a_container_is_seen_by_cmark_and_excluded_by_us(text):
+ """הסינון הוא חלק מההשוואה, לא חריגה ממנה.
+
+ האורקל **כן** מזהה את הכותרת — היא כותרת, ו-GitHub מרנדר אותה —
+ ולכן הטסט דורש את שני הדברים יחד: שהיא קיימת אצלו כשהיא בתוך מכל,
+ ושהיא אינה במפה שלנו.
+ """
+ all_headings = _oracle_all_headings(text)
+ assert any(inside for _lvl, _line, inside in all_headings), "הצורה אינה מכילה מכל"
+ assert _ours(text) == _oracle_sections(text)
+
+
+# ════════════════════════════════════════════════════════════════════
+# הפער הידוע היחיד — תגית HTML מסוג 7 צמודה לשורת פריט רשימה
+# ════════════════════════════════════════════════════════════════════
+
+#: תגיות שאינן ברשימת ה-block של CommonMark ולכן נופלות ל**סוג 7**: תג
+#: פתיחה שלם (לא ``pre``/``script``/``style``/``textarea``) או תג סגירה
+#: שלם, לבדו בשורה. ```` הוא סוג 7 כי הוא **סגירה**: הכלל של סוג 1
+#: תופס רק פתיחה.
+_TYPE7_TAGS = ("
", "
", "", '
')
+_LIST_MARKERS = ("- ", "1. ")
+
+
+def _type7_after_list_shapes():
+ """(טקסט, האם שני הפארסרים מסכימים) — תגית מסוג 7 אחרי שורת פריט.
+
+ **זו המחלקה היחידה שידועה בה אי-הסכמה**, והיא נמדדה: כשהתגית
+ **צמודה** לשורת הפריט, ``markdown-it`` (הפורט ל-Python **וגם**
+ המקור ב-JS, 14.3.2 — נמדד, הפורט נאמן) רואה בה המשך עצל של פסקת
+ הפריט, ולכן ``## אחרי`` שאחריה הוא כותרת; cmark-gfm סוגר את הרשימה,
+ פותח בלוק HTML, והבלוק בולע את ``## אחרי`` עד שורה ריקה. **מימוש
+ הייחוס של המפרט** (``commonmark.py`` 0.9.2, פורט של commonmark.js)
+ מסכים עם cmark — כלומר זו סטייה של ``markdown-it`` ולא שלנו, ולא של
+ GitHub.
+
+ עם **שורה ריקה** בין הפריט לתגית שני הצדדים מסכימים, וזה מה שהופך
+ את החצי הזה למקרה בקרה: הוא עובר ב-``_compare`` כמו כל משפחה אחרת.
+
+ **ולמה זה לא מתוקן אצלנו.** התיקון המתבקש — להפוך את דגל
+ ה-terminate של סוג 7 ב-``rules_block/html_block.py`` — נמדד ונדחה:
+ הוא גורם ל-``
`` להפריע לפסקה גם **בלי** רשימה, ושם שני הצדדים
+ מסכימים היום. כלומר הוא מחליף אי-הסכמה אחת באחרת. התיקון הנכון
+ הוא בדיקה מודעת-מכל כמו של cmark, והוא שייך ל-``markdown-it-py``
+ ולא לכלל שנכתוב ביד. **מתועד upstream** — טקסט האישו המלא, עם שלושת המימושים והצורה המינימלית,
+ בגוף PR #3418; הוא נפתח מסשן שיש לו גישה ל-``executablebooks/markdown-it-py``
+ ומספרו יוכנס כאן.
+ אפס מופעים ב-521 הקבצים האמיתיים שנמדדו (93 + 428).
+ """
+ for tag, marker, adjacent in itertools.product(_TYPE7_TAGS, _LIST_MARKERS, (True, False)):
+ gap = "" if adjacent else "\n"
+ yield f"## לפני\n\n{marker}פריט\n{gap}{tag}\n## אחרי\n", not adjacent
+
+
+def test_the_type7_family_agrees_when_a_blank_line_separates_it():
+ """חצי הבקרה של המשפחה עובר דרך אותה ``_compare`` כמו כולם."""
+ agreeing = [text for text, agrees in _type7_after_list_shapes() if agrees]
+ assert len(agreeing) == len(_TYPE7_TAGS) * len(_LIST_MARKERS)
+ _compare(agreeing)
+
+
+@pytest.mark.parametrize(
+ "text", [text for text, agrees in _type7_after_list_shapes() if not agrees]
+)
+def test_a_type7_tag_glued_to_a_list_item_still_disagrees_as_measured(text):
+ """**הטסט הזה מקבע פער מדוד, ולא התנהגות רצויה.**
+
+ אצלנו שני סעיפים — ``## לפני`` ו-``## אחרי`` — ואצל cmark-gfm אחד,
+ כי ``## אחרי`` נבלע לתוך בלוק ה-HTML. הצורה המדויקת נטענת כאן
+ בשני הצדדים, כדי שהפער לא יוכל להיסחף לכיוון שלישי בשקט.
+
+ .. warning::
+
+ **נפילה של הטסט הזה היא תוצאה מכוונת**, ופירושה ש-``markdown-it``
+ תיקנה את ההתנהגות (או ש-cmark שינתה את שלה). אז הצורה הזאת
+ עוברת לחצי המסכים של המשפחה, והמשפט על "המחלקה הידועה היחידה"
+ ב-``services/md_parser.py`` נמחק יחד איתה. אל "תתקן" את הטסט
+ הזה כאילו היה באג.
+ """
+ ours, theirs = _ours(text), _oracle_sections(text)
+ assert theirs == [(2, 1)], ("cmark-gfm שינה את התנהגותו", text, theirs)
+ assert [lvl for lvl, _ in ours] == [2, 2] and ours[0] == (2, 1), (
+ "markdown-it שינה את התנהגותו — ראו את האזהרה", text, ours,
+ )
+
+
+def test_the_excluded_class_is_exactly_the_glued_shapes_and_nothing_more():
+ """ההחרגה נאמרת בקול: מה שלא נכנס ל-``_compare`` — ולמה.
+
+ כמו ``compared > 100`` ב-``_compare_titles``: החרגה שקטה יכולה
+ להתרחב בלי שאיש ישים לב. כאן נטען שהקבוצה המוחרגת היא **בדיוק**
+ הצורות הצמודות, לא ריקה ולא רחבה מזה — ושכל אחת מהן באמת חלוקה,
+ כלומר ההחרגה מוצדקת מופע-מופע ולא כהנחה.
+ """
+ excluded = [text for text, agrees in _type7_after_list_shapes() if not agrees]
+ assert len(excluded) == len(_TYPE7_TAGS) * len(_LIST_MARKERS)
+ assert all("\n\n" not in text.split("פריט\n", 1)[1].split("\n## אחרי")[0] for text in excluded), (
+ "צורה מופרדת נכנסה לקבוצה המוחרגת"
+ )
+ for text in excluded:
+ assert _ours(text) != _oracle_sections(text), ("מוחרגת אבל מסכימה — ההחרגה רחבה מדי", text)
+
+
+# ════════════════════════════════════════════════════════════════════
+# המספר שבפרוזה נגזר מכאן, ולא מוקלד פעמיים
+# ════════════════════════════════════════════════════════════════════
+
+def test_the_generated_shape_count_matches_the_prose():
+ """כמה צורות באמת מושוות, ומה הדוקסטרינג מצהיר.
+
+ **זה כבר נסחף.** ``services/md_parser.py`` אמר 11,400,
+ ``requirements/base.txt`` אמר 11,507, והמחוללים ייצרו מספר שלישי —
+ כי משפחת הטבלאות נוספה בלי שאיש עדכן את המשפטים. מספר שמוקלד ביד
+ מתיישן בשקט; מספר שנגזר מהקוד מפיל את החבילה.
+
+ הספירה כאן חייבת לכלול **כל** משפחה שמגיעה ל-``_compare``. משפחה
+ חדשה שתישכח כאן תוריד את הסכום ותפיל — וזו התוצאה הרצויה.
+ """
+ import re
+ from pathlib import Path
+
+ type7 = list(_type7_after_list_shapes())
+ total = (
+ len(list(_context_shapes()))
+ + len(list(_fence_nesting_shapes()))
+ + len(list(_html_shapes()))
+ + len(_HTML_EDGE_CASES)
+ + len(list(_table_shapes()))
+ + len(_CONTAINER_SHAPES)
+ + sum(1 for _text, agrees in type7 if agrees)
+ )
+ excluded = sum(1 for _text, agrees in type7 if not agrees)
+ assert total > 10_000, f"מחולל נשמט מהספירה — {total} צורות בלבד"
+ assert excluded > 0, "המחלקה המוחרגת ריקה — הפרוזה על 'מחלקה ידועה אחת' כבר אינה נכונה"
+
+ source = (Path(__file__).resolve().parents[1] / "services" / "md_parser.py").read_text(
+ encoding="utf-8"
+ )
+ quoted = re.search(r"על \*\*([\d,]+) צורות מחוללות\*\*", source)
+ assert quoted, "המשפט על מספר הצורות אינו במקומו ב-``md_parser`` docstring"
+ assert quoted.group(1) == f"{total:,}", (
+ f"הדוקסטרינג אומר {quoted.group(1)} והמחוללים מייצרים {total:,}. "
+ "עדכן את שני המקומות שמצטטים אותו — ``services/md_parser.py`` "
+ "ו-``requirements/base.txt``."
+ )
+ # **וגם המספר של המחלקה המוחרגת נגזר, לא מוקלד.** אותה סחיפה בדיוק
+ # מחכה לו: תגית שתתווסף ל-``_TYPE7_TAGS`` בלי עדכון המשפט.
+ quoted_excluded = re.search(r"מחלקה אחת ידועה ומקובעת של \*\*(\d+) צורות\*\*", source)
+ assert quoted_excluded, "המשפט על המחלקה המוחרגת אינו במקומו ב-``md_parser`` docstring"
+ assert quoted_excluded.group(1) == str(excluded)
+
+ base = (Path(__file__).resolve().parents[1] / "requirements" / "base.txt").read_text(
+ encoding="utf-8"
+ )
+ assert f"{total:,} הצורות" in base, (
+ f"``requirements/base.txt`` אינו אומר {total:,} — אותו מספר, שני מקומות."
+ )
+
+
+# ════════════════════════════════════════════════════════════════════
+# טקסט הכותרת — התוספת של SUGG-010, על תת-קבוצה ובמפורש
+# ════════════════════════════════════════════════════════════════════
+
+
+@pytest.mark.parametrize("bucket", range(6))
+def test_the_heading_text_agrees_with_cmark_where_it_can_be_compared(bucket):
+ """אותה מטריצה בדיוק, והפעם על **הטקסט** ולא על המיקום.
+
+ מושווה רק מה שאין בו סימון פנימי — ההנמקה המלאה ב-
+ ``_compare_titles``. הדלי זהה לזה של מבחן המיקום, מאותה סיבה:
+ ``pytest.ini`` קובע ``timeout = 60``.
+ """
+ shapes = [s for i, s in enumerate(_context_shapes()) if i % 6 == bucket]
+ compared = _compare_titles(shapes)
+ # **"אפס אי-הסכמות" על אפס השוואות אינו הצלחה.** בלי השורה הזאת,
+ # שינוי ב-``_has_inline_markup`` שיחריג בטעות את כל הכותרות היה
+ # משאיר את הטסט ירוק בזמן שהוא כבר לא בודק דבר.
+ assert compared > 100, f"רק {compared} כותרות הושוו — הסינון בלע את הטבלה"
+
+
+#: הצורות שהמבחן למעלה מדלג עליהן, וכאן נאמר **למה**: לכל אחת, מה
+#: אנחנו מחזירים מול מה ש-cmark מחזיר אחרי הרינדור.
+_RENDERED_AWAY = [
+ ("## כותרת עם `בקטיקים`", "כותרת עם `בקטיקים`", "כותרת עם בקטיקים"),
+ ("## **מודגש**", "**מודגש**", "מודגש"),
+ ("## [קישור](https://example.com)", "[קישור](https://example.com)", "קישור"),
+ ("## כותרת עם \\# escape", "כותרת עם \\# escape", "כותרת עם # escape"),
+]
+
+
+@pytest.mark.parametrize("source, ours, cmark", _RENDERED_AWAY)
+def test_a_heading_with_inline_markup_is_excluded_on_purpose(source, ours, cmark):
+ """ההחרגה נאמרת בקול, כדי שלא תיראה כמו חור בכיסוי.
+
+ לכל צורה כאן שלוש טענות: הכותרת שלנו היא המקור הגולמי, של cmark
+ היא הטקסט אחרי הרינדור, **והשתיים באמת נבדלות**. זו הסיבה שהן
+ מוחרגות — ולא הנחה על מה שאולי יקרה.
+
+ .. note::
+
+ **הטסט הזה אינו יכול ליפול על הקוד שלפני הסבב הזה, וזה מכוון.**
+ הוא אינו שומר על תיקון אלא מקבע החלטה שלא השתנתה: שהכותרת אצלנו
+ היא המקור הגולמי. מי ש"יתקן" את ``_title_of`` להסיר גם סימון —
+ כלומר להחזיר טקסט מרונדר — יפיל אותו. ואת הכיוון ההפוך, צמצום
+ של ``_has_inline_markup`` שיפסיק להחריג אחת מהצורות, מפיל מבחן
+ הטקסט שלמעלה.
+ """
+ text = f"{source}\n"
+ assert _has_inline_markup(ours), "הצורה הזאת אמורה להיות מוחרגת"
+ assert [s.title for s in parse_document(text).sections] == [ours]
+ assert [title for _, _, title in _oracle_titles(text)] == [cmark]
+ assert ours != cmark, "אילו השתיים היו זהות, לא היה טעם להחריג"