notionary 0.1.24__tar.gz → 0.1.26__tar.gz

{notionary-0.1.24 → notionary-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.24
+Version: 0.1.26
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends

{notionary-0.1.24 → notionary-0.1.26}/notionary/elements/audio_element.py

@@ -1,7 +1,10 @@
 import re
 from typing import Dict, Any, Optional, List
 from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.prompts.element_prompt_content import ElementPromptContent
+from notionary.elements.prompts.element_prompt_content import (
+    ElementPromptBuilder,
+    ElementPromptContent,
+)
 
 
 class AudioElement(NotionBlockElement):
@@ -16,40 +19,34 @@ class AudioElement(NotionBlockElement):
     Supports various audio URLs including direct audio file links from CDNs and other sources.
     """
 
-    # Regex pattern for audio syntax
-    PATTERN = re.compile(
-        r"^\$\[(.*?)\]"  # $[Caption] part
-        + r'\((https?://[^\s"]+)'  # (URL part
-        + r"\)$"  # closing parenthesis
-    )
+    PATTERN = re.compile(r"^\$\[(.*?)\]" + r'\((https?://[^\s"]+)' + r"\)$")
 
-    # Audio file extensions
     AUDIO_EXTENSIONS = [".mp3", ".wav", ".ogg", ".m4a", ".flac", ".aac"]
 
-    @staticmethod
-    def match_markdown(text: str) -> bool:
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
         """Check if text is a markdown audio embed."""
         text = text.strip()
-        return text.startswith("$[") and bool(AudioElement.PATTERN.match(text))
+        return text.startswith("$[") and bool(cls.PATTERN.match(text))
 
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
         """Check if block is a Notion audio."""
         return block.get("type") == "audio"
 
-    @staticmethod
-    def is_audio_url(url: str) -> bool:
+    @classmethod
+    def is_audio_url(cls, url: str) -> bool:
         """Check if URL points to an audio file."""
         return (
-            any(url.lower().endswith(ext) for ext in AudioElement.AUDIO_EXTENSIONS)
+            any(url.lower().endswith(ext) for ext in cls.AUDIO_EXTENSIONS)
             or "audio" in url.lower()
             or "storage.googleapis.com/audio_summaries" in url.lower()
         )
 
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
         """Convert markdown audio embed to Notion audio block."""
-        audio_match = AudioElement.PATTERN.match(text.strip())
+        audio_match = cls.PATTERN.match(text.strip())
         if not audio_match:
             return None
 
@@ -60,7 +57,7 @@ class AudioElement(NotionBlockElement):
             return None
 
         # Make sure this is an audio URL
-        if not AudioElement.is_audio_url(url):
+        if not cls.is_audio_url(url):
             # If not obviously an audio URL, we'll still accept it as the user might know better
             pass
 
@@ -78,8 +75,8 @@ class AudioElement(NotionBlockElement):
 
         return audio_block
 
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion audio block to markdown audio embed."""
         if block.get("type") != "audio":
             return None
@@ -101,17 +98,17 @@ class AudioElement(NotionBlockElement):
         caption = ""
         caption_rich_text = audio_data.get("caption", [])
         if caption_rich_text:
-            caption = AudioElement._extract_text_content(caption_rich_text)
+            caption = cls._extract_text_content(caption_rich_text)
 
         return f"$[{caption}]({url})"
 
-    @staticmethod
-    def is_multiline() -> bool:
+    @classmethod
+    def is_multiline(cls) -> bool:
         """Audio embeds are single-line elements."""
         return False
 
-    @staticmethod
-    def _extract_text_content(rich_text: List[Dict[str, Any]]) -> str:
+    @classmethod
+    def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
         """Extract plain text content from Notion rich_text elements."""
         result = ""
         for text_obj in rich_text:
@@ -124,16 +121,22 @@ class AudioElement(NotionBlockElement):
     @classmethod
     def get_llm_prompt_content(cls) -> ElementPromptContent:
         """Returns information for LLM prompts about this element."""
-        return {
-            "description": "Embeds audio content from external sources like CDNs or direct audio URLs.",
-            "syntax": "$[Caption](https://example.com/audio.mp3)",
-            "examples": [
-                "$[Podcast Episode](https://storage.googleapis.com/audio_summaries/ep_ai_summary_127d02ec-ca12-4312-a5ed-cb14b185480c.mp3)",
-                "$[Voice recording](https://example.com/audio/recording.mp3)",
-                "$[](https://storage.googleapis.com/audio_summaries/example.mp3)",
-            ],
-            "when_to_use": (
+        return (
+            ElementPromptBuilder()
+            .with_description(
+                "Embeds audio content from external sources like CDNs or direct audio URLs."
+            )
+            .with_syntax("$[Caption](https://example.com/audio.mp3)")
+            .with_examples(
+                [
+                    "$[Podcast Episode](https://storage.googleapis.com/audio_summaries/ep_ai_summary_127d02ec-ca12-4312-a5ed-cb14b185480c.mp3)",
+                    "$[Voice recording](https://example.com/audio/recording.mp3)",
+                    "$[](https://storage.googleapis.com/audio_summaries/example.mp3)",
+                ]
+            )
+            .with_usage_guidelines(
                 "Use audio embeds when you want to include audio content directly in your document. "
                 "Audio embeds are useful for podcasts, music, voice recordings, or any content that benefits from audio explanation."
-            ),
-        }
+            )
+            .build()
+        )

{notionary-0.1.24 → notionary-0.1.26}/notionary/elements/bookmark_element.py

@@ -2,7 +2,10 @@ import re
 from typing import Dict, Any, Optional, List, Tuple
 
 from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.prompts.element_prompt_content import ElementPromptContent
+from notionary.elements.prompts.element_prompt_content import (
+    ElementPromptBuilder,
+    ElementPromptContent,
+)
 
 
 class BookmarkElement(NotionBlockElement):
@@ -29,20 +32,20 @@ class BookmarkElement(NotionBlockElement):
         + r"\)$"  # closing parenthesis
     )
 
-    @staticmethod
-    def match_markdown(text: str) -> bool:
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
         """Check if text is a markdown bookmark."""
         return text.strip().startswith("[bookmark]") and bool(
             BookmarkElement.PATTERN.match(text.strip())
         )
 
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
         """Check if block is a Notion bookmark."""
         return block.get("type") in ["bookmark", "external-bookmark"]
 
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
         """Convert markdown bookmark to Notion bookmark block."""
         bookmark_match = BookmarkElement.PATTERN.match(text.strip())
         if not bookmark_match:
@@ -120,8 +123,8 @@ class BookmarkElement(NotionBlockElement):
 
         return {"type": "bookmark", "bookmark": bookmark_data}
 
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion bookmark block to markdown bookmark."""
         block_type = block.get("type", "")
 
@@ -158,13 +161,13 @@ class BookmarkElement(NotionBlockElement):
 
         return f"[bookmark]({url})"
 
-    @staticmethod
-    def is_multiline() -> bool:
+    @classmethod
+    def is_multiline(cls) -> bool:
         """Bookmarks are single-line elements."""
         return False
 
-    @staticmethod
-    def _extract_text_content(rich_text: List[Dict[str, Any]]) -> str:
+    @classmethod
+    def _extract_text_content(cls, rich_text: List[Dict[str, Any]]) -> str:
         """Extract plain text content from Notion rich_text elements."""
         result = ""
         for text_obj in rich_text:
@@ -174,8 +177,8 @@ class BookmarkElement(NotionBlockElement):
                 result += text_obj.get("plain_text", "")
         return result
 
-    @staticmethod
-    def _parse_caption(caption: List[Dict[str, Any]]) -> Tuple[str, str]:
+    @classmethod
+    def _parse_caption(cls, caption: List[Dict[str, Any]]) -> Tuple[str, str]:
         """
         Parse Notion caption into title and description components.
         Returns a tuple of (title, description).
@@ -196,17 +199,23 @@ class BookmarkElement(NotionBlockElement):
         """
         Returns structured LLM prompt metadata for the bookmark element.
         """
-        return {
-            "description": "Creates a bookmark that links to an external website.",
-            "when_to_use": (
+        return (
+            ElementPromptBuilder()
+            .with_description("Creates a bookmark that links to an external website.")
+            .with_usage_guidelines(
                 "Use bookmarks when you want to reference external content while keeping the page clean and organized. "
                 "Bookmarks display a preview card for the linked content."
-            ),
-            "syntax": '[bookmark](https://example.com "Optional Title" "Optional Description")',
-            "examples": [
-                "[bookmark](https://example.com)",
-                '[bookmark](https://example.com "Example Title")',
-                '[bookmark](https://example.com "Example Title" "Example description of the site")',
-                '[bookmark](https://github.com "GitHub" "Where the world builds software")',
-            ],
-        }
+            )
+            .with_syntax(
+                '[bookmark](https://example.com "Optional Title" "Optional Description")'
+            )
+            .with_examples(
+                [
+                    "[bookmark](https://example.com)",
+                    '[bookmark](https://example.com "Example Title")',
+                    '[bookmark](https://example.com "Example Title" "Example description of the site")',
+                    '[bookmark](https://github.com "GitHub" "Where the world builds software")',
+                ]
+            )
+            .build()
+        )

{notionary-0.1.24 → notionary-0.1.26}/notionary/elements/bulleted_list_element.py

@@ -1,17 +1,18 @@
 import re
 from typing import Dict, Any, Optional
-from typing_extensions import override
 from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.prompts.element_prompt_content import ElementPromptContent
+from notionary.elements.prompts.element_prompt_content import (
+    ElementPromptBuilder,
+    ElementPromptContent,
+)
 from notionary.elements.text_inline_formatter import TextInlineFormatter
 
 
 class BulletedListElement(NotionBlockElement):
     """Class for converting between Markdown bullet lists and Notion bulleted list items."""
 
-    @override
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
         """Convert markdown bulleted list item to Notion block."""
         pattern = re.compile(
             r"^(\s*)[*\-+]\s+(?!\[[ x]\])(.+)$"
@@ -30,8 +31,8 @@ class BulletedListElement(NotionBlockElement):
             "bulleted_list_item": {"rich_text": rich_text, "color": "default"},
         }
 
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion bulleted list item block to markdown."""
         if block.get("type") != "bulleted_list_item":
             return None
@@ -41,14 +42,14 @@ class BulletedListElement(NotionBlockElement):
 
         return f"- {content}"
 
-    @staticmethod
-    def match_markdown(text: str) -> bool:
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
         """Check if this element can handle the given markdown text."""
         pattern = re.compile(r"^(\s*)[*\-+]\s+(?!\[[ x]\])(.+)$")
         return bool(pattern.match(text))
 
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
         """Check if this element can handle the given Notion block."""
         return block.get("type") == "bulleted_list_item"
 
@@ -57,13 +58,19 @@ class BulletedListElement(NotionBlockElement):
         """
         Returns structured LLM prompt metadata for the bulleted list element.
         """
-        return {
-            "description": "Creates bulleted list items for unordered lists.",
-            "when_to_use": "Use for lists where order doesn't matter, such as features, options, or items without hierarchy.",
-            "syntax": "- Item text",
-            "examples": [
-                "- First item\n- Second item\n- Third item",
-                "* Apple\n* Banana\n* Cherry",
-                "+ Task A\n+ Task B",
-            ],
-        }
+        return (
+            ElementPromptBuilder()
+            .with_description("Creates bulleted list items for unordered lists.")
+            .with_usage_guidelines(
+                "Use for lists where order doesn't matter, such as features, options, or items without hierarchy."
+            )
+            .with_syntax("- Item text")
+            .with_examples(
+                [
+                    "- First item\n- Second item\n- Third item",
+                    "* Apple\n* Banana\n* Cherry",
+                    "+ Task A\n+ Task B",
+                ]
+            )
+            .build()
+        )

{notionary-0.1.24 → notionary-0.1.26}/notionary/elements/callout_element.py

@@ -1,8 +1,10 @@
 import re
 from typing import Dict, Any, Optional
-from typing_extensions import override
 
-from notionary.elements.prompts.element_prompt_content import ElementPromptContent
+from notionary.elements.prompts.element_prompt_content import (
+    ElementPromptBuilder,
+    ElementPromptContent,
+)
 from notionary.elements.text_inline_formatter import TextInlineFormatter
 from notionary.elements.notion_block_element import NotionBlockElement
 
@@ -28,23 +30,20 @@ class CalloutElement(NotionBlockElement):
     DEFAULT_EMOJI = "💡"
     DEFAULT_COLOR = "gray_background"
 
-    @override
-    @staticmethod
-    def match_markdown(text: str) -> bool:
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
         """Check if text is a markdown callout."""
         return text.strip().startswith("!>") and bool(
             CalloutElement.PATTERN.match(text)
         )
 
-    @override
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
         """Check if block is a Notion callout."""
         return block.get("type") == "callout"
 
-    @override
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
         """Convert markdown callout to Notion callout block."""
         callout_match = CalloutElement.PATTERN.match(text)
         if not callout_match:
@@ -65,9 +64,8 @@ class CalloutElement(NotionBlockElement):
             },
         }
 
-    @override
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion callout block to markdown callout."""
         if block.get("type") != "callout":
             return None
@@ -90,28 +88,38 @@ class CalloutElement(NotionBlockElement):
 
         return f"!> {emoji_str}{text}"
 
-    @override
-    @staticmethod
-    def is_multiline() -> bool:
+    @classmethod
+    def is_multiline(cls) -> bool:
         return False
 
     @classmethod
     def get_llm_prompt_content(cls) -> ElementPromptContent:
         """
-        Returns a dictionary with all information needed for LLM prompts about this element.
+        Returns structured LLM prompt metadata for the callout element.
         Includes description, usage guidance, syntax options, and examples.
         """
-        return {
-            "description": "Creates a callout block to highlight important information with an icon.",
-            "when_to_use": (
+        return (
+            ElementPromptBuilder()
+            .with_description(
+                "Creates a callout block to highlight important information with an icon."
+            )
+            .with_usage_guidelines(
                 "Use callouts when you want to draw attention to important information, "
-                "tips, warnings, or notes that stand out from the main content."
-            ),
-            "syntax": "!> [emoji] Text",
-            "examples": [
-                "!> This is a default callout with the light bulb emoji",
-                "!> [🔔] This is a callout with a bell emoji",
-                "!> [⚠️] Warning: This is an important note to pay attention to",
-                "!> [💡] Tip: Add emoji that matches your content's purpose",
-            ],
-        }
+                "tips, warnings, or notes that stand out from the main content. "
+                "The emoji MUST be enclosed in square brackets to properly display."
+            )
+            .with_syntax("!> [emoji] Text")
+            .with_examples(
+                [
+                    "!> [💡] This is a default callout with the light bulb emoji",
+                    "!> [🔔] This is a callout with a bell emoji",
+                    "!> [⚠️] Warning: This is an important note to pay attention to",
+                    "!> [💡] Tip: Add emoji that matches your content's purpose",
+                ]
+            )
+            .with_avoidance_guidelines(
+                "NEVER omit the square brackets around the emoji. The format MUST be !> [emoji] and not !> emoji. "
+                "Without the square brackets, Notion will not properly render the callout with the specified emoji."
+            )
+            .build()
+        )

{notionary-0.1.24 → notionary-0.1.26}/notionary/elements/code_block_element.py

@@ -1,7 +1,10 @@
 import re
 from typing import Dict, Any, Optional, List, Tuple
 from notionary.elements.notion_block_element import NotionBlockElement
-from notionary.elements.prompts.element_prompt_content import ElementPromptContent
+from notionary.elements.prompts.element_prompt_content import (
+    ElementPromptBuilder,
+    ElementPromptContent,
+)
 
 
 class CodeBlockElement(NotionBlockElement):
@@ -20,18 +23,18 @@ class CodeBlockElement(NotionBlockElement):
 
     PATTERN = re.compile(r"```(\w*)\n([\s\S]+?)```", re.MULTILINE)
 
-    @staticmethod
-    def match_markdown(text: str) -> bool:
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
         """Check if text contains a markdown code block."""
         return bool(CodeBlockElement.PATTERN.search(text))
 
-    @staticmethod
-    def match_notion(block: Dict[str, Any]) -> bool:
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
         """Check if block is a Notion code block."""
         return block.get("type") == "code"
 
-    @staticmethod
-    def markdown_to_notion(text: str) -> Optional[Dict[str, Any]]:
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
         """Convert markdown code block to Notion code block."""
         match = CodeBlockElement.PATTERN.search(text)
         if not match:
@@ -65,8 +68,8 @@ class CodeBlockElement(NotionBlockElement):
             },
         }
 
-    @staticmethod
-    def notion_to_markdown(block: Dict[str, Any]) -> Optional[str]:
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
         """Convert Notion code block to markdown code block."""
         if block.get("type") != "code":
             return None
@@ -84,8 +87,8 @@ class CodeBlockElement(NotionBlockElement):
         # Format as a markdown code block
         return f"```{language}\n{content}\n```"
 
-    @staticmethod
-    def find_matches(text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
+    @classmethod
+    def find_matches(cls, text: str) -> List[Tuple[int, int, Dict[str, Any]]]:
         """
         Find all code block matches in the text and return their positions.
 
@@ -130,8 +133,8 @@ class CodeBlockElement(NotionBlockElement):
 
         return matches
 
-    @staticmethod
-    def is_multiline() -> bool:
+    @classmethod
+    def is_multiline(cls) -> bool:
         return True
 
     @classmethod
@@ -139,21 +142,30 @@ class CodeBlockElement(NotionBlockElement):
         """
         Returns structured LLM prompt metadata for the code block element.
         """
-        return {
-            "description": (
+        return (
+            ElementPromptBuilder()
+            .with_description(
                 "Use fenced code blocks to format content as code. Supports language annotations like "
                 "'python', 'json', or 'mermaid'. Useful for displaying code, configurations, command-line "
                 "examples, or diagram syntax. Also suitable for explaining or visualizing systems with diagram languages."
-            ),
-            "when_to_use": (
+            )
+            .with_usage_guidelines(
                 "Use code blocks when you want to present technical content like code snippets, terminal commands, "
                 "JSON structures, or system diagrams. Especially helpful when structure and formatting are essential."
-            ),
-            "syntax": "```language\ncode content\n```",
-            "examples": [
-                "```python\nprint('Hello, world!')\n```",
-                '```json\n{"name": "Alice", "age": 30}\n```',
-                "```mermaid\nflowchart TD\n  A --> B\n```",
-            ],
-            "avoid": "NEVER EVER wrap markdown content with ```markdown. Markdown should be written directly without code block formatting. NEVER use ```markdown under any circumstances."
-        }
+            )
+            .with_syntax("```language\ncode content\n```")
+            .with_examples(
+                [
+                    "```python\nprint('Hello, world!')\n```",
+                    '```json\n{"name": "Alice", "age": 30}\n```',
+                    "```mermaid\nflowchart TD\n  A --> B\n```",
+                ]
+            )
+            .with_avoidance_guidelines(
+                "NEVER EVER wrap markdown content with ```markdown. Markdown should be written directly without code block formatting. "
+                "NEVER use ```markdown under any circumstances. "
+                "For Mermaid diagrams, use ONLY the default styling without colors, backgrounds, or custom styling attributes. "
+                "Keep Mermaid diagrams simple and minimal without any styling or color modifications."
+            )
+            .build()
+        )

notionary-0.1.26/notionary/elements/divider_element.py

@@ -0,0 +1,67 @@
+import re
+from typing import Dict, Any, Optional
+
+from notionary.elements.notion_block_element import NotionBlockElement
+from notionary.elements.prompts.element_prompt_content import (
+    ElementPromptBuilder,
+    ElementPromptContent,
+)
+
+
+class DividerElement(NotionBlockElement):
+    """
+    Handles conversion between Markdown horizontal dividers and Notion divider blocks.
+
+    Markdown divider syntax:
+    - Three or more hyphens (---) on a line by themselves
+    """
+
+    PATTERN = re.compile(r"^\s*-{3,}\s*$")
+
+    @classmethod
+    def match_markdown(cls, text: str) -> bool:
+        """Check if text is a markdown divider."""
+        return bool(DividerElement.PATTERN.match(text))
+
+    @classmethod
+    def match_notion(cls, block: Dict[str, Any]) -> bool:
+        """Check if block is a Notion divider."""
+        return block.get("type") == "divider"
+
+    @classmethod
+    def markdown_to_notion(cls, text: str) -> Optional[Dict[str, Any]]:
+        """Convert markdown divider to Notion divider block."""
+        if not DividerElement.match_markdown(text):
+            return None
+
+        return {"type": "divider", "divider": {}}
+
+    @classmethod
+    def notion_to_markdown(cls, block: Dict[str, Any]) -> Optional[str]:
+        """Convert Notion divider block to markdown divider."""
+        if block.get("type") != "divider":
+            return None
+
+        return "---"
+
+    @classmethod
+    def is_multiline(cls) -> bool:
+        return False
+
+    @classmethod
+    def get_llm_prompt_content(cls) -> ElementPromptContent:
+        """Returns structured LLM prompt metadata for the divider element."""
+        return (
+            ElementPromptBuilder()
+            .with_description(
+                "Creates a horizontal divider line to visually separate sections of content."
+            )
+            .with_usage_guidelines(
+                "Use to create clear visual breaks between different sections without requiring headings."
+            )
+            .with_syntax("---")
+            .with_examples(
+                ["## Section 1\nContent\n\n---\n\n## Section 2\nMore content"]
+            )
+            .build()
+        )