notionary 0.2.26__py3-none-any.whl → 0.2.28__py3-none-any.whl

notionary/page/content/renderer/renderers/video.py

@@ -0,0 +1,31 @@
+from typing import override
+
+from notionary.blocks.schemas import Block, BlockType
+from notionary.page.content.renderer.renderers.captioned_block import CaptionedBlockRenderer
+
+
+class VideoRenderer(CaptionedBlockRenderer):
+    @override
+    def _can_handle(self, block: Block) -> bool:
+        return block.type == BlockType.VIDEO
+
+    @override
+    async def _render_main_content(self, block: Block) -> str:
+        url = self._extract_video_url(block)
+
+        if not url:
+            return ""
+
+        syntax = self._syntax_registry.get_video_syntax()
+        return f"{syntax.start_delimiter}{url}{syntax.end_delimiter}"
+
+    def _extract_video_url(self, block: Block) -> str:
+        if not block.video:
+            return ""
+
+        if block.video.external:
+            return block.video.external.url or ""
+        elif block.video.file:
+            return block.video.file.url or ""
+
+        return ""

notionary/page/content/renderer/service.py

@@ -0,0 +1,50 @@
+from notionary.blocks.schemas import Block
+from notionary.page.content.renderer.context import MarkdownRenderingContext
+from notionary.page.content.renderer.post_processing.service import MarkdownRenderingPostProcessor
+from notionary.page.content.renderer.renderers import BlockRenderer
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class NotionToMarkdownConverter(LoggingMixin):
+    def __init__(
+        self,
+        renderer_chain: BlockRenderer,
+        post_processor: MarkdownRenderingPostProcessor,
+    ) -> None:
+        self._renderer_chain = renderer_chain
+        self._post_processor = post_processor
+
+    async def convert(self, blocks: list[Block], indent_level: int = 0) -> str:
+        if not blocks:
+            return ""
+
+        rendered_block_parts = []
+        current_block_index = 0
+
+        while current_block_index < len(blocks):
+            context = self._create_rendering_context(blocks, current_block_index, indent_level)
+            await self._renderer_chain.handle(context)
+
+            if context.markdown_result:
+                rendered_block_parts.append(context.markdown_result)
+
+            current_block_index += 1
+
+        result = self._join_rendered_blocks(rendered_block_parts, indent_level)
+        result = self._post_processor.process(result)
+
+        return result
+
+    def _create_rendering_context(
+        self, blocks: list[Block], block_index: int, indent_level: int
+    ) -> MarkdownRenderingContext:
+        block = blocks[block_index]
+        return MarkdownRenderingContext(
+            block=block,
+            indent_level=indent_level,
+            convert_children_callback=self.convert,
+        )
+
+    def _join_rendered_blocks(self, rendered_parts: list[str], indent_level: int) -> str:
+        separator = "\n\n" if indent_level == 0 else "\n"
+        return separator.join(rendered_parts)

notionary/page/content/service.py

@@ -0,0 +1,65 @@
+import asyncio
+from collections.abc import Callable
+
+from notionary.blocks.client import NotionBlockHttpClient
+from notionary.blocks.schemas import Block
+from notionary.page.content.markdown.builder import MarkdownBuilder
+from notionary.page.content.parser.service import MarkdownToNotionConverter
+from notionary.page.content.renderer.service import NotionToMarkdownConverter
+from notionary.utils.async_retry import async_retry
+from notionary.utils.mixins.logging import LoggingMixin
+
+
+class PageContentService(LoggingMixin):
+    def __init__(
+        self,
+        page_id: str,
+        block_client: NotionBlockHttpClient,
+        markdown_converter: MarkdownToNotionConverter,
+        notion_to_markdown_converter: NotionToMarkdownConverter,
+    ) -> None:
+        self._page_id = page_id
+        self._block_client = block_client
+        self._markdown_converter = markdown_converter
+        self._notion_to_markdown_converter = notion_to_markdown_converter
+
+    async def get_as_markdown(self) -> str:
+        blocks = await self._block_client.get_block_tree(parent_block_id=self._page_id)
+        return await self._notion_to_markdown_converter.convert(blocks=blocks)
+
+    async def clear(self) -> None:
+        children_response = await self._block_client.get_block_children(block_id=self._page_id)
+
+        if not children_response or not children_response.results:
+            self.logger.debug("No blocks to delete for page: %s", self._page_id)
+            return
+
+        await asyncio.gather(*[self._delete_single_block(block) for block in children_response.results])
+
+    @async_retry(max_retries=10, initial_delay=0.2, backoff_factor=1.5)
+    async def _delete_single_block(self, block: Block) -> None:
+        self.logger.debug("Deleting block: %s", block.id)
+        await self._block_client.delete_block(block.id)
+
+    async def append_markdown(self, content: str | Callable[[MarkdownBuilder], MarkdownBuilder]) -> None:
+        markdown = self._extract_markdown(content)
+        if not markdown:
+            self.logger.debug("No markdown content to append for page: %s", self._page_id)
+            return
+
+        blocks = await self._markdown_converter.convert(markdown)
+        await self._append_blocks(blocks)
+
+    def _extract_markdown(self, content: str | Callable[[MarkdownBuilder], MarkdownBuilder]) -> str:
+        if isinstance(content, str):
+            return content
+
+        if callable(content):
+            builder = MarkdownBuilder()
+            content(builder)
+            return builder.build()
+
+        raise ValueError("content must be either a string or a callable that takes a MarkdownBuilder")
+
+    async def _append_blocks(self, blocks: list[Block]) -> None:
+        await self._block_client.append_block_children(block_id=self._page_id, children=blocks)

notionary/page/content/syntax/models.py

@@ -0,0 +1,68 @@
+import re
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class SyntaxRegistryKey(StrEnum):
+    AUDIO = "audio"
+    BOOKMARK = "bookmark"
+    IMAGE = "image"
+    VIDEO = "video"
+    FILE = "file"
+    PDF = "pdf"
+
+    # List blocks
+    BULLETED_LIST = "bulleted_list"
+    NUMBERED_LIST = "numbered_list"
+    TO_DO = "todo"
+    TO_DO_DONE = "todo_done"
+
+    TOGGLE = "toggle"
+    TOGGLEABLE_HEADING = "toggleable_heading"
+    CALLOUT = "callout"
+    QUOTE = "quote"
+    CODE = "code"
+
+    COLUMN_LIST = "column_list"
+    COLUMN = "column"
+
+    # Heading blocks
+    HEADING_1 = "heading_1"
+    HEADING_2 = "heading_2"
+    HEADING_3 = "heading_3"
+    HEADING = "heading"  # Shared pattern for regular headings
+
+    DIVIDER = "divider"
+    BREADCRUMB = "breadcrumb"
+    TABLE_OF_CONTENTS = "table_of_contents"
+    EQUATION = "equation"
+    EMBED = "embed"
+    TABLE = "table"
+    TABLE_ROW = "table_row"
+
+    CAPTION = "caption"
+    SPACE = "space"
+
+
+# some elemente need closing delimiters, others not
+# either use union type or validate config in service
+@dataclass(frozen=True)
+class SyntaxDefinition:
+    """
+    Defines the syntax pattern for a block type.
+
+    Attributes:
+        start_delimiter: The opening delimiter (e.g., "```", "+++", ">")
+        end_delimiter: The optional closing delimiter (empty string if none)
+        regex_pattern: The compiled regex pattern to match this syntax
+        end_regex_pattern: Optional compiled regex pattern for end delimiter
+        is_multiline_block: Whether this block can contain child blocks
+        is_inline: Whether this is an inline syntax (like [audio](url))
+    """
+
+    start_delimiter: str
+    end_delimiter: str
+    regex_pattern: re.Pattern
+    end_regex_pattern: re.Pattern | None = None
+    is_multiline_block: bool = False
+    is_inline: bool = False

notionary/page/content/syntax/service.py

@@ -0,0 +1,453 @@
+import re
+
+from notionary.page.content.syntax.models import SyntaxDefinition, SyntaxRegistryKey
+
+
+class SyntaxRegistry:
+    MULTI_LINE_BLOCK_DELIMITER = ":::"
+    TOGGLE_DELIMITER = "+++"
+    TABLE_DELIMITER = "|"
+
+    def __init__(self) -> None:
+        self._definitions: dict[SyntaxRegistryKey, SyntaxDefinition] = {}
+        self._register_defaults()
+
+    def get_audio_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.AUDIO]
+
+    def get_bookmark_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.BOOKMARK]
+
+    def get_breadcrumb_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.BREADCRUMB]
+
+    def get_bulleted_list_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.BULLETED_LIST]
+
+    def get_callout_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.CALLOUT]
+
+    def get_code_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.CODE]
+
+    def get_column_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.COLUMN]
+
+    def get_column_list_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.COLUMN_LIST]
+
+    def get_divider_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.DIVIDER]
+
+    def get_embed_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.EMBED]
+
+    def get_equation_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.EQUATION]
+
+    def get_file_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.FILE]
+
+    def get_image_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.IMAGE]
+
+    def get_numbered_list_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.NUMBERED_LIST]
+
+    def get_pdf_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.PDF]
+
+    def get_quote_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.QUOTE]
+
+    def get_table_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TABLE]
+
+    def get_table_row_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TABLE_ROW]
+
+    def get_table_of_contents_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TABLE_OF_CONTENTS]
+
+    def get_todo_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TO_DO]
+
+    def get_todo_done_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TO_DO_DONE]
+
+    def get_toggle_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TOGGLE]
+
+    def get_toggleable_heading_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING]
+
+    def get_video_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.VIDEO]
+
+    def get_caption_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.CAPTION]
+
+    def get_space_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.SPACE]
+
+    def get_heading_syntax(self) -> SyntaxDefinition:
+        return self._definitions[SyntaxRegistryKey.HEADING]
+
+    def _register_defaults(self) -> None:
+        self._register_audio_syntax()
+        self._register_bookmark_syntax()
+        self._register_image_syntax()
+        self._register_video_syntax()
+        self._register_file_syntax()
+        self._register_pdf_syntax()
+
+        # List blocks
+        self._register_bulleted_list_syntax()
+        self._register_numbered_list_syntax()
+        self._register_todo_syntax()
+        self._register_todo_done_syntax()
+
+        # Container blocks
+        self._register_toggle_syntax()
+        self._register_toggleable_heading_syntax()
+        self._register_callout_syntax()
+        self._register_quote_syntax()
+        self._register_code_syntax()
+
+        # Column layout blocks
+        self._register_column_list_syntax()
+        self._register_column_syntax()
+
+        self._register_heading_1_syntax()
+        self._register_heading_2_syntax()
+        self._register_heading_3_syntax()
+        self._register_heading_syntax()  # Shared pattern for regular headings
+
+        self._register_divider_syntax()
+        self._register_breadcrumb_syntax()
+        self._register_table_of_contents_syntax()
+        self._register_equation_syntax()
+        self._register_embed_syntax()
+        self._register_table_syntax()
+        self._register_table_row_syntax()
+
+        # Post-processing and utility blocks
+        self._register_caption_syntax()
+        self._register_space_syntax()
+
+    def _register_audio_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[audio](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[audio\]\(([^)]+)\)"),
+            is_multiline_block=False,
+            is_inline=True,
+        )
+        self._definitions[SyntaxRegistryKey.AUDIO] = definition
+
+    def _register_bookmark_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[bookmark](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[bookmark\]\((https?://[^\s\"]+)\)"),
+            is_multiline_block=False,
+            is_inline=True,
+        )
+        self._definitions[SyntaxRegistryKey.BOOKMARK] = definition
+
+    def _register_breadcrumb_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[breadcrumb]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[breadcrumb\]\s*$", re.IGNORECASE),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.BREADCRUMB] = definition
+
+    def _register_bulleted_list_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="- ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^(\s*)-\s+(?!\[[ xX]\])(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.BULLETED_LIST] = definition
+
+    def _register_callout_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter=f"{self.MULTI_LINE_BLOCK_DELIMITER} callout",
+            end_delimiter=self.MULTI_LINE_BLOCK_DELIMITER,
+            regex_pattern=re.compile(
+                rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*callout(?:\s+(\S+))?\s*$", re.IGNORECASE
+            ),
+            end_regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*$"),
+            is_multiline_block=True,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.CALLOUT] = definition
+
+    def _register_code_syntax(self) -> None:
+        code_delimiter = "```"
+        definition = SyntaxDefinition(
+            start_delimiter=code_delimiter,
+            end_delimiter=code_delimiter,
+            regex_pattern=re.compile("^" + re.escape(code_delimiter) + r"(\w*)\s*$"),
+            end_regex_pattern=re.compile("^" + re.escape(code_delimiter) + r"\s*$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.CODE] = definition
+
+    def _register_column_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter=f"{self.MULTI_LINE_BLOCK_DELIMITER} column",
+            end_delimiter=self.MULTI_LINE_BLOCK_DELIMITER,
+            regex_pattern=re.compile(
+                rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*column(?:\s+(0?\.\d+|1(?:\.0?)?))??\s*$",
+                re.IGNORECASE | re.MULTILINE,
+            ),
+            end_regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*$", re.MULTILINE),
+            is_multiline_block=True,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.COLUMN] = definition
+
+    def _register_column_list_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter=f"{self.MULTI_LINE_BLOCK_DELIMITER} columns",
+            end_delimiter=self.MULTI_LINE_BLOCK_DELIMITER,
+            regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*columns?\s*$", re.IGNORECASE),
+            end_regex_pattern=re.compile(rf"^{re.escape(self.MULTI_LINE_BLOCK_DELIMITER)}\s*$"),
+            is_multiline_block=True,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.COLUMN_LIST] = definition
+
+    def _register_divider_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="---",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\s*-{3,}\s*$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.DIVIDER] = definition
+
+    def _register_embed_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[embed](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[embed\]\((https?://[^\s)]+)\)"),
+            is_multiline_block=False,
+            is_inline=True,
+        )
+        self._definitions[SyntaxRegistryKey.EMBED] = definition
+
+    def _register_equation_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="$$",
+            end_delimiter="$$",
+            regex_pattern=re.compile(r"^\$\$\s*$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.EQUATION] = definition
+
+    def _register_file_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[file](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[file\]\(([^)]+)\)"),
+            is_multiline_block=False,
+            is_inline=True,
+        )
+        self._definitions[SyntaxRegistryKey.FILE] = definition
+
+    def _register_heading_1_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="# ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^#\s+(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.HEADING_1] = definition
+
+    def _register_heading_2_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="## ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^#{2}\s+(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.HEADING_2] = definition
+
+    def _register_heading_3_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="### ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^#{3}\s+(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.HEADING_3] = definition
+
+    def _register_image_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[image](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"(?<!!)\[image\]\(([^)]+)\)"),
+            is_multiline_block=False,
+            is_inline=True,
+        )
+        self._definitions[SyntaxRegistryKey.IMAGE] = definition
+
+    def _register_numbered_list_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="1. ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^(\s*)(\d+)\.\s+(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.NUMBERED_LIST] = definition
+
+    def _register_pdf_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[pdf](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[pdf\]\(([^)]+)\)"),
+            is_multiline_block=False,
+            is_inline=True,
+        )
+        self._definitions[SyntaxRegistryKey.PDF] = definition
+
+    def _register_quote_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="> ",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^>(?!>)\s*(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.QUOTE] = definition
+
+    def _register_table_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter=self.TABLE_DELIMITER,
+            end_delimiter="",
+            regex_pattern=re.compile(
+                rf"^\s*{re.escape(self.TABLE_DELIMITER)}(.+){re.escape(self.TABLE_DELIMITER)}\s*$"
+            ),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.TABLE] = definition
+
+    def _register_table_row_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter=self.TABLE_DELIMITER,
+            end_delimiter="",
+            regex_pattern=re.compile(
+                rf"^\s*{re.escape(self.TABLE_DELIMITER)}([\s\-:|]+){re.escape(self.TABLE_DELIMITER)}\s*$"
+            ),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.TABLE_ROW] = definition
+
+    def _register_table_of_contents_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[toc]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[toc\]$", re.IGNORECASE),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.TABLE_OF_CONTENTS] = definition
+
+    def _register_todo_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="- [ ]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\s*-\s+\[ \]\s+(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.TO_DO] = definition
+
+    def _register_todo_done_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="- [x]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\s*-\s+\[x\]\s+(.+)$", re.IGNORECASE),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.TO_DO_DONE] = definition
+
+    def _register_toggle_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter=self.TOGGLE_DELIMITER,
+            end_delimiter=self.TOGGLE_DELIMITER,
+            regex_pattern=re.compile(rf"^{re.escape(self.TOGGLE_DELIMITER)}\s+(.+)$"),
+            end_regex_pattern=re.compile(rf"^{re.escape(self.TOGGLE_DELIMITER)}\s*$"),
+            is_multiline_block=True,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.TOGGLE] = definition
+
+    def _register_toggleable_heading_syntax(self) -> None:
+        escaped_delimiter = re.escape(self.TOGGLE_DELIMITER)
+        definition = SyntaxDefinition(
+            start_delimiter=f"{self.TOGGLE_DELIMITER} #",
+            end_delimiter=self.TOGGLE_DELIMITER,
+            regex_pattern=re.compile(rf"^{escaped_delimiter}\s*(?P<level>#{{1,3}})(?!#)\s*(.+)$", re.IGNORECASE),
+            end_regex_pattern=re.compile(rf"^{escaped_delimiter}\s*$"),
+            is_multiline_block=True,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.TOGGLEABLE_HEADING] = definition
+
+    def _register_video_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[video](",
+            end_delimiter=")",
+            regex_pattern=re.compile(r"\[video\]\(([^)]+)\)"),
+            is_multiline_block=False,
+            is_inline=True,
+        )
+        self._definitions[SyntaxRegistryKey.VIDEO] = definition
+
+    def _register_caption_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[caption]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[caption\]\s+(\S.*)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.CAPTION] = definition
+
+    def _register_space_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="[space]",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^\[space\]\s*$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.SPACE] = definition
+
+    def _register_heading_syntax(self) -> None:
+        definition = SyntaxDefinition(
+            start_delimiter="#",
+            end_delimiter="",
+            regex_pattern=re.compile(r"^(#{1,3})[ \t]+(.+)$"),
+            is_multiline_block=False,
+            is_inline=False,
+        )
+        self._definitions[SyntaxRegistryKey.HEADING] = definition