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

notionary/page/content/markdown/nodes/embed.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class EmbedMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        embed_syntax = self._syntax_registry.get_embed_syntax()
+        base_markdown = f"{embed_syntax.start_delimiter}{self.url}{embed_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/equation.py

@@ -0,0 +1,19 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class EquationMarkdownNode(MarkdownNode):
+    def __init__(self, expression: str, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.expression = expression
+
+    @override
+    def to_markdown(self) -> str:
+        expr = self.expression.strip()
+        equation_syntax = self._syntax_registry.get_equation_syntax()
+        if not expr:
+            return f"{equation_syntax.start_delimiter}{equation_syntax.end_delimiter}"
+
+        return f"{equation_syntax.start_delimiter}{expr}{equation_syntax.end_delimiter}"

notionary/page/content/markdown/nodes/file.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class FileMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        file_syntax = self._syntax_registry.get_file_syntax()
+        base_markdown = f"{file_syntax.start_delimiter}{self.url}{file_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/heading.py

@@ -0,0 +1,16 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class HeadingMarkdownNode(MarkdownNode):
+    def __init__(self, text: str, level: int = 1, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+        self.level = max(1, min(3, level))
+
+    @override
+    def to_markdown(self) -> str:
+        heading_syntax = self._syntax_registry.get_heading_syntax()
+        return f"{heading_syntax.start_delimiter * self.level} {self.text}"

notionary/page/content/markdown/nodes/image.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ImageMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        image_syntax = self._syntax_registry.get_image_syntax()
+        base_markdown = f"{image_syntax.start_delimiter}{self.url}{image_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/mixins/caption.py

@@ -0,0 +1,12 @@
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class CaptionMarkdownNodeMixin:
+    _syntax_registry: SyntaxRegistry
+
+    def _append_caption_to_markdown(self, base_markdown: str, caption: str | None) -> str:
+        if not caption:
+            return base_markdown
+
+        caption_syntax = self._syntax_registry.get_caption_syntax()
+        return f"{base_markdown}\n{caption_syntax.start_delimiter} {caption}"

notionary/page/content/markdown/nodes/numbered_list.py

@@ -0,0 +1,15 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class NumberedListMarkdownNode(MarkdownNode):
+    def __init__(self, texts: list[str], syntax_registry: SyntaxRegistry | None = None):
+        super().__init__(syntax_registry=syntax_registry)
+        self.texts = texts
+
+    @override
+    def to_markdown(self) -> str:
+        numbered_list_syntax = self._syntax_registry.get_numbered_list_syntax()
+        return "\n".join(f"{i + 1}{numbered_list_syntax.end_delimiter} {text}" for i, text in enumerate(self.texts))

notionary/page/content/markdown/nodes/paragraph.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ParagraphMarkdownNode(MarkdownNode):
+    def __init__(self, text: str, syntax_registry: SyntaxRegistry | None = None):
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+
+    @override
+    def to_markdown(self) -> str:
+        return self.text

notionary/page/content/markdown/nodes/pdf.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class PdfMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        pdf_syntax = self._syntax_registry.get_pdf_syntax()
+        base_markdown = f"{pdf_syntax.start_delimiter}{self.url}{pdf_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/markdown/nodes/quote.py

@@ -0,0 +1,15 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class QuoteMarkdownNode(MarkdownNode):
+    def __init__(self, text: str, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+
+    @override
+    def to_markdown(self) -> str:
+        quote_syntax = self._syntax_registry.get_quote_syntax()
+        return f"{quote_syntax.start_delimiter} {self.text}"

notionary/page/content/markdown/nodes/space.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class SpaceMarkdownNode(MarkdownNode):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+
+    @override
+    def to_markdown(self) -> str:
+        space_syntax = self._syntax_registry.get_space_syntax()
+        return space_syntax.start_delimiter

notionary/page/content/markdown/nodes/table.py

@@ -0,0 +1,45 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class TableMarkdownNode(MarkdownNode):
+    def __init__(
+        self, headers: list[str], rows: list[list[str]], syntax_registry: SyntaxRegistry | None = None
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self._validate_input(headers, rows)
+        self.headers = headers
+        self.rows = rows
+
+    def _validate_input(self, headers: list[str], rows: list[list[str]]) -> None:
+        if not headers:
+            raise ValueError("headers must not be empty")
+        if not all(isinstance(row, list) for row in rows):
+            raise ValueError("rows must be a list of lists")
+
+    @override
+    def to_markdown(self) -> str:
+        header = self._build_header_row()
+        separator = self._build_separator_row()
+        data_rows = self._build_data_rows()
+        return "\n".join([header, separator, *data_rows])
+
+    def _build_header_row(self) -> str:
+        return self._format_row(self.headers)
+
+    def _format_row(self, cells: list[str]) -> str:
+        table_syntax = self._syntax_registry.get_table_syntax()
+        delimiter = table_syntax.start_delimiter
+        joined_cells = f" {delimiter} ".join(cells)
+        return f"{delimiter} {joined_cells} {delimiter}"
+
+    def _build_separator_row(self) -> str:
+        table_syntax = self._syntax_registry.get_table_syntax()
+        col_count = len(self.headers)
+        separators = [table_syntax.end_delimiter] * col_count
+        return self._format_row(separators)
+
+    def _build_data_rows(self) -> list[str]:
+        return [self._format_row(row) for row in self.rows]

notionary/page/content/markdown/nodes/table_of_contents.py

@@ -0,0 +1,14 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class TableOfContentsMarkdownNode(MarkdownNode):
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+
+    @override
+    def to_markdown(self) -> str:
+        toc_syntax = self._syntax_registry.get_table_of_contents_syntax()
+        return toc_syntax.start_delimiter

notionary/page/content/markdown/nodes/todo.py

@@ -0,0 +1,22 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class TodoMarkdownNode(MarkdownNode):
+    def __init__(
+        self, text: str, checked: bool = False, marker: str = "-", syntax_registry: SyntaxRegistry | None = None
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+        self.checked = checked
+        self.marker = marker
+
+    @override
+    def to_markdown(self) -> str:
+        # Validate marker to ensure it's valid
+        valid_marker = self.marker if self.marker in {"-", "*", "+"} else "-"
+        todo_syntax = self._syntax_registry.get_todo_syntax()
+        checkbox_state = todo_syntax.end_delimiter if self.checked else todo_syntax.start_delimiter
+        return f"{valid_marker} {checkbox_state} {self.text}"

notionary/page/content/markdown/nodes/toggle.py

@@ -0,0 +1,28 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ToggleMarkdownNode(MarkdownNode):
+    def __init__(
+        self, title: str, children: list[MarkdownNode] | None = None, syntax_registry: SyntaxRegistry | None = None
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.title = title
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        toggle_syntax = self._syntax_registry.get_toggle_syntax()
+        result = f"{toggle_syntax.start_delimiter} {self.title}"
+
+        if not self.children:
+            result += f"\n{toggle_syntax.end_delimiter}"
+            return result
+
+        # Convert children to markdown
+        content_parts = [child.to_markdown() for child in self.children]
+        content_text = "\n\n".join(content_parts)
+
+        return result + "\n" + content_text + f"\n{toggle_syntax.end_delimiter}"

notionary/page/content/markdown/nodes/toggleable_heading.py

@@ -0,0 +1,35 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ToggleableHeadingMarkdownNode(MarkdownNode):
+    def __init__(
+        self,
+        text: str,
+        level: int,
+        children: list[MarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
+        super().__init__(syntax_registry=syntax_registry)
+        self.text = text
+        self.level = max(1, min(3, level))
+        self.children = children or []
+
+    @override
+    def to_markdown(self) -> str:
+        toggle_syntax = self._syntax_registry.get_toggle_syntax()
+        heading_syntax = self._syntax_registry.get_heading_syntax()
+        prefix = toggle_syntax.start_delimiter + (heading_syntax.start_delimiter * self.level)
+        result = f"{prefix} {self.text}"
+
+        if not self.children:
+            result += f"\n{toggle_syntax.end_delimiter}"
+            return result
+
+        # Convert children to markdown
+        content_parts = [child.to_markdown() for child in self.children]
+        content_text = "\n\n".join(content_parts)
+
+        return result + "\n" + content_text + f"\n{toggle_syntax.end_delimiter}"

notionary/page/content/markdown/nodes/video.py

@@ -0,0 +1,23 @@
+from typing import override
+
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.markdown.nodes.mixins.caption import CaptionMarkdownNodeMixin
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class VideoMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
+    def __init__(
+        self,
+        url: str,
+        caption: str | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        self.url = url
+        self.caption = caption
+
+    @override
+    def to_markdown(self) -> str:
+        video_syntax = self._syntax_registry.get_video_syntax()
+        base_markdown = f"{video_syntax.start_delimiter}{self.url}{video_syntax.end_delimiter}"
+        return self._append_caption_to_markdown(base_markdown, self.caption)

notionary/page/content/parser/context.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+
+from notionary.blocks.schemas import BlockCreatePayload
+
+
+@dataclass
+class ParentBlockContext:
+    block: BlockCreatePayload
+    child_lines: list[str]
+    child_blocks: list[BlockCreatePayload] = field(default_factory=list)
+
+    def add_child_line(self, content: str) -> None:
+        self.child_lines.append(content)
+
+    def add_child_block(self, block: BlockCreatePayload) -> None:
+        self.child_blocks.append(block)
+
+
+ParseChildrenCallback = Callable[[list[str]], Awaitable[list[BlockCreatePayload]]]
+
+
+@dataclass
+class BlockParsingContext:
+    line: str
+    result_blocks: list[BlockCreatePayload]
+    parent_stack: list[ParentBlockContext]
+
+    parse_children_callback: ParseChildrenCallback | None = None
+
+    all_lines: list[str] | None = None
+    current_line_index: int | None = None
+    lines_consumed: int = 0
+
+    async def parse_nested_content(self, nested_lines: list[str]) -> list[BlockCreatePayload]:
+        if not self.parse_children_callback or not nested_lines:
+            return []
+
+        return await self.parse_children_callback(nested_lines)
+
+    def get_remaining_lines(self) -> list[str]:
+        if self.all_lines is None or self.current_line_index is None:
+            return []
+        return self.all_lines[self.current_line_index + 1 :]
+
+    def is_inside_parent_context(self) -> bool:
+        return len(self.parent_stack) > 0

notionary/page/content/parser/factory.py

@@ -0,0 +1,219 @@
+from notionary.blocks.rich_text.markdown_rich_text_converter import (
+    MarkdownRichTextConverter,
+)
+from notionary.page.content.parser.parsers import (
+    AudioParser,
+    BookmarkParser,
+    BreadcrumbParser,
+    BulletedListParser,
+    CalloutParser,
+    CaptionParser,
+    CodeParser,
+    ColumnListParser,
+    ColumnParser,
+    DividerParser,
+    EmbedParser,
+    EquationParser,
+    FileParser,
+    HeadingParser,
+    ImageParser,
+    LineParser,
+    NumberedListParser,
+    ParagraphParser,
+    PdfParser,
+    QuoteParser,
+    SpaceParser,
+    TableOfContentsParser,
+    TableParser,
+    TodoParser,
+    ToggleableHeadingParser,
+    ToggleParser,
+    VideoParser,
+)
+from notionary.page.content.syntax.service import SyntaxRegistry
+
+
+class ConverterChainFactory:
+    def __init__(
+        self,
+        rich_text_converter: MarkdownRichTextConverter | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
+        self._rich_text_converter = rich_text_converter or MarkdownRichTextConverter()
+        self._syntax_registry = syntax_registry or SyntaxRegistry()
+
+    def create(self) -> LineParser:
+        # multi-line (structural) blocks
+        code_parser = self._create_code_parser()
+        equation_parser = self._create_equation_parser()
+        table_parser = self._create_table_parser()
+        column_parser = self._create_column_parser()
+        column_list_parser = self._create_column_list_parser()
+        toggleable_heading_parser = self._create_toggleable_heading_parser()
+        toggle_parser = self._create_toggle_parser()
+
+        # Single-line blocks
+        divider_parser = self._create_divider_parser()
+        breadcrumb_parser = self._create_breadcrumb_parser()
+        table_of_contents_parser = self._create_table_of_contents_parser()
+        space_parser = self._create_space_parser()
+        heading_parser = self._create_heading_parser()
+        quote_parser = self._create_quote_parser()
+        callout_parser = self._create_callout_parser()
+        todo_parser = self._create_todo_parser()
+        bulleted_list_parser = self._create_bulleted_list_parser()
+        numbered_list_parser = self._create_numbered_list_parser()
+
+        # Media blocks
+        bookmark_parser = self._create_bookmark_parser()
+        embed_parser = self._create_embed_parser()
+        image_parser = self._create_image_parser()
+        video_parser = self._create_video_parser()
+        audio_parser = self._create_audio_parser()
+        file_parser = self._create_file_parser()
+        pdf_parser = self._create_pdf_parser()
+
+        # Caption and Fallback
+        caption_parser = self._create_caption_parser()
+        paragraph_parser = self._create_paragraph_parser()
+
+        (
+            code_parser.set_next(equation_parser)
+            .set_next(table_parser)
+            .set_next(column_parser)
+            .set_next(column_list_parser)
+            .set_next(toggleable_heading_parser)
+            .set_next(toggle_parser)
+            .set_next(divider_parser)
+            .set_next(breadcrumb_parser)
+            .set_next(table_of_contents_parser)
+            .set_next(space_parser)
+            .set_next(heading_parser)
+            .set_next(quote_parser)
+            .set_next(callout_parser)
+            .set_next(todo_parser)
+            .set_next(bulleted_list_parser)
+            .set_next(numbered_list_parser)
+            .set_next(bookmark_parser)
+            .set_next(embed_parser)
+            .set_next(image_parser)
+            .set_next(video_parser)
+            .set_next(audio_parser)
+            .set_next(file_parser)
+            .set_next(pdf_parser)
+            .set_next(caption_parser)
+            .set_next(paragraph_parser)
+        )
+
+        return code_parser
+
+    def _create_code_parser(self) -> CodeParser:
+        return CodeParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_equation_parser(self) -> EquationParser:
+        return EquationParser(syntax_registry=self._syntax_registry)
+
+    def _create_table_parser(self) -> TableParser:
+        return TableParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_column_parser(self) -> ColumnParser:
+        return ColumnParser(syntax_registry=self._syntax_registry)
+
+    def _create_column_list_parser(self) -> ColumnListParser:
+        return ColumnListParser(syntax_registry=self._syntax_registry)
+
+    def _create_toggleable_heading_parser(self) -> ToggleableHeadingParser:
+        return ToggleableHeadingParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_toggle_parser(self) -> ToggleParser:
+        return ToggleParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_divider_parser(self) -> DividerParser:
+        return DividerParser(syntax_registry=self._syntax_registry)
+
+    def _create_breadcrumb_parser(self) -> BreadcrumbParser:
+        return BreadcrumbParser(syntax_registry=self._syntax_registry)
+
+    def _create_table_of_contents_parser(self) -> TableOfContentsParser:
+        return TableOfContentsParser(syntax_registry=self._syntax_registry)
+
+    def _create_space_parser(self) -> SpaceParser:
+        return SpaceParser(syntax_registry=self._syntax_registry)
+
+    def _create_heading_parser(self) -> HeadingParser:
+        return HeadingParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_quote_parser(self) -> QuoteParser:
+        return QuoteParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_callout_parser(self) -> CalloutParser:
+        return CalloutParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_todo_parser(self) -> TodoParser:
+        return TodoParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_bulleted_list_parser(self) -> BulletedListParser:
+        return BulletedListParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_numbered_list_parser(self) -> NumberedListParser:
+        return NumberedListParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_bookmark_parser(self) -> BookmarkParser:
+        return BookmarkParser(syntax_registry=self._syntax_registry)
+
+    def _create_embed_parser(self) -> EmbedParser:
+        return EmbedParser(syntax_registry=self._syntax_registry)
+
+    def _create_image_parser(self) -> ImageParser:
+        return ImageParser(syntax_registry=self._syntax_registry)
+
+    def _create_video_parser(self) -> VideoParser:
+        return VideoParser(syntax_registry=self._syntax_registry)
+
+    def _create_audio_parser(self) -> AudioParser:
+        return AudioParser(syntax_registry=self._syntax_registry)
+
+    def _create_file_parser(self) -> FileParser:
+        return FileParser(syntax_registry=self._syntax_registry)
+
+    def _create_pdf_parser(self) -> PdfParser:
+        return PdfParser(syntax_registry=self._syntax_registry)
+
+    def _create_caption_parser(self) -> CaptionParser:
+        return CaptionParser(
+            syntax_registry=self._syntax_registry,
+            rich_text_converter=self._rich_text_converter,
+        )
+
+    def _create_paragraph_parser(self) -> ParagraphParser:
+        return ParagraphParser(rich_text_converter=self._rich_text_converter)