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

notionary/page/content/markdown/builder.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import Self
 
-from notionary.blocks.enums import CodeLanguage
+from notionary.blocks.enums import CodingLanguage
 from notionary.page.content.markdown.nodes import (
     AudioMarkdownNode,
     BookmarkMarkdownNode,
@@ -28,27 +28,24 @@ from notionary.page.content.markdown.nodes import (
     TableMarkdownNode,
     TableOfContentsMarkdownNode,
     TodoMarkdownNode,
-    ToggleableHeadingMarkdownNode,
     ToggleMarkdownNode,
     VideoMarkdownNode,
 )
+from notionary.page.content.markdown.nodes.container import flatten_children
 
 
 class MarkdownBuilder:
     def __init__(self) -> None:
         self.children: list[MarkdownNode] = []
 
-    def h1(self, text: str) -> Self:
-        self.children.append(HeadingMarkdownNode(text=text, level=1))
-        return self
+    def h1(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self._add_heading(text, 1, builder_func)
 
-    def h2(self, text: str) -> Self:
-        self.children.append(HeadingMarkdownNode(text=text, level=2))
-        return self
+    def h2(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self._add_heading(text, 2, builder_func)
 
-    def h3(self, text: str) -> Self:
-        self.children.append(HeadingMarkdownNode(text=text, level=3))
-        return self
+    def h3(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self._add_heading(text, 3, builder_func)
 
     def paragraph(self, text: str) -> Self:
         self.children.append(ParagraphMarkdownNode(text=text))
@@ -58,8 +55,9 @@ class MarkdownBuilder:
         self.children.append(SpaceMarkdownNode())
         return self
 
-    def quote(self, text: str) -> Self:
-        self.children.append(QuoteMarkdownNode(text=text))
+    def quote(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(QuoteMarkdownNode(text=text, children=children))
         return self
 
     def divider(self) -> Self:
@@ -70,24 +68,48 @@ class MarkdownBuilder:
         self.children.append(NumberedListMarkdownNode(texts=items))
         return self
 
+    def numbered_list_item(
+        self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None
+    ) -> Self:
+        children = self._build_children(builder_func)
+        wrapped = flatten_children(children)
+        child_nodes = [wrapped] if wrapped else None
+        self.children.append(NumberedListMarkdownNode(texts=[text], children=child_nodes))
+        return self
+
     def bulleted_list(self, items: list[str]) -> Self:
         self.children.append(BulletedListMarkdownNode(texts=items))
         return self
 
-    def todo(self, text: str, checked: bool = False) -> Self:
-        self.children.append(TodoMarkdownNode(text=text, checked=checked))
+    def bulleted_list_item(
+        self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None
+    ) -> Self:
+        children = self._build_children(builder_func)
+        wrapped = flatten_children(children)
+        child_nodes = [wrapped] if wrapped else None
+        self.children.append(BulletedListMarkdownNode(texts=[text], children=child_nodes))
         return self
 
-    def checked_todo(self, text: str) -> Self:
-        return self.todo(text, checked=True)
+    def todo(
+        self,
+        text: str,
+        checked: bool = False,
+        builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None,
+    ) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(TodoMarkdownNode(text=text, checked=checked, children=children))
+        return self
 
-    def unchecked_todo(self, text: str) -> Self:
-        return self.todo(text, checked=False)
+    def checked_todo(self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None) -> Self:
+        return self.todo(text, checked=True, builder_func=builder_func)
 
-    def todo_list(self, items: list[str], completed: list[bool] | None = None) -> Self:
-        if completed is None:
-            completed = [False] * len(items)
+    def unchecked_todo(
+        self, text: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None
+    ) -> Self:
+        return self.todo(text, checked=False, builder_func=builder_func)
 
+    def todo_list(self, items: list[str], completed: list[bool] | None = None) -> Self:
+        completed = completed or [False] * len(items)
         for i, item in enumerate(items):
             is_done = completed[i] if i < len(completed) else False
             self.children.append(TodoMarkdownNode(text=item, checked=is_done))
@@ -103,75 +125,13 @@ class MarkdownBuilder:
         emoji: str | None = None,
         builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None = None,
     ) -> Self:
-        """
-        Add a callout block with children built using the builder API.
-
-        Args:
-            text: The callout text content
-            emoji: Optional emoji for the callout icon
-            builder_func: Optional function that receives a MarkdownBuilder and returns it configured
-
-        Example:
-            builder.callout_with_children("Important note", "⚠️", lambda c:
-                c.paragraph("Additional details here")
-                .bulleted_list(["Point 1", "Point 2"])
-            )
-        """
-        if builder_func is None:
-            self.children.append(CalloutMarkdownNode(text=text, emoji=emoji))
-            return self
-
-        callout_builder = MarkdownBuilder()
-        builder_func(callout_builder)
-        self.children.append(CalloutMarkdownNode(text=text, emoji=emoji, children=callout_builder.children))
+        children = self._build_children(builder_func)
+        self.children.append(CalloutMarkdownNode(text=text, emoji=emoji, children=children))
         return self
 
     def toggle(self, title: str, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder]) -> Self:
-        """
-        Add a toggle block with content built using the builder API.
-
-        Args:
-            title: The toggle title/header text
-            builder_func: Function that receives a MarkdownBuilder and returns it configured
-
-        Example:
-            builder.toggle("Advanced Settings", lambda t:
-                t.h3("Configuration")
-                .paragraph("Settings description")
-                .table(["Setting", "Value"], [["Debug", "True"]])
-                .callout("Important note", "⚠️")
-            )
-        """
-        toggle_builder = MarkdownBuilder()
-        builder_func(toggle_builder)
-        self.children.append(ToggleMarkdownNode(title=title, children=toggle_builder.children))
-        return self
-
-    def toggleable_heading(
-        self,
-        text: str,
-        level: int,
-        builder_func: Callable[[MarkdownBuilder], MarkdownBuilder],
-    ) -> Self:
-        """
-        Add a toggleable heading with content built using the builder API.
-
-        Args:
-            text: The heading text content
-            level: Heading level (1-3)
-            builder_func: Function that receives a MarkdownBuilder and returns it configured
-
-        Example:
-            builder.toggleable_heading("Advanced Section", 2, lambda t:
-                t.paragraph("Introduction to this section")
-                .numbered_list(["Step 1", "Step 2", "Step 3"])
-                .code("example_code()", "python")
-                .table(["Feature", "Status"], [["API", "Ready"]])
-            )
-        """
-        toggle_builder = MarkdownBuilder()
-        builder_func(toggle_builder)
-        self.children.append(ToggleableHeadingMarkdownNode(text=text, level=level, children=toggle_builder.children))
+        children = self._build_children(builder_func)
+        self.children.append(ToggleMarkdownNode(title=title, children=children))
         return self
 
     def image(self, url: str, caption: str | None = None) -> Self:
@@ -202,22 +162,18 @@ class MarkdownBuilder:
         self.children.append(EmbedMarkdownNode(url=url, caption=caption))
         return self
 
-    def code(self, code: str, language: CodeLanguage | None = None, caption: str | None = None) -> Self:
+    def code(self, code: str, language: CodingLanguage | None = None, caption: str | None = None) -> Self:
         self.children.append(CodeMarkdownNode(code=code, language=language, caption=caption))
         return self
 
     def mermaid(self, diagram: str, caption: str | None = None) -> Self:
-        self.children.append(CodeMarkdownNode(code=diagram, language=CodeLanguage.MERMAID.value, caption=caption))
+        self.children.append(CodeMarkdownNode(code=diagram, language=CodingLanguage.MERMAID.value, caption=caption))
         return self
 
     def table(self, headers: list[str], rows: list[list[str]]) -> Self:
         self.children.append(TableMarkdownNode(headers=headers, rows=rows))
         return self
 
-    def add_custom(self, node: MarkdownNode) -> Self:
-        self.children.append(node)
-        return self
-
     def breadcrumb(self) -> Self:
         self.children.append(BreadcrumbMarkdownNode())
         return self
@@ -235,70 +191,36 @@ class MarkdownBuilder:
         *builder_funcs: Callable[[MarkdownBuilder], MarkdownBuilder],
         width_ratios: list[float] | None = None,
     ) -> Self:
-        """
-        Add multiple columns in a layout.
-
-        Args:
-            *builder_funcs: Multiple functions, each building one column
-            width_ratios: Optional list of width ratios (0.0 to 1.0).
-                        If None, columns have equal width.
-                        Length must match number of builder_funcs.
-
-        Examples:
-            # Equal width (original API unchanged):
-            builder.columns(
-                lambda col: col.h2("Left").paragraph("Left content"),
-                lambda col: col.h2("Right").paragraph("Right content")
-            )
-
-            # Custom ratios:
-            builder.columns(
-                lambda col: col.h2("Main").paragraph("70% width"),
-                lambda col: col.h2("Sidebar").paragraph("30% width"),
-                width_ratios=[0.7, 0.3]
-            )
-
-            # Three columns with custom ratios:
-            builder.columns(
-                lambda col: col.h3("Nav").paragraph("Navigation"),
-                lambda col: col.h2("Main").paragraph("Main content"),
-                lambda col: col.h3("Ads").paragraph("Advertisement"),
-                width_ratios=[0.2, 0.6, 0.2]
-            )
-        """
-        self._validate_columns_args(builder_funcs, width_ratios)
-
-        # Create all columns
-        columns = []
-        for i, builder_func in enumerate(builder_funcs):
-            width_ratio = width_ratios[i] if width_ratios else None
-
-            col_builder = MarkdownBuilder()
-            builder_func(col_builder)
+        columns = self._build_columns(builder_funcs, width_ratios)
+        self.children.append(ColumnListMarkdownNode(columns=columns))
+        return self
 
-            column_node = ColumnMarkdownNode(children=col_builder.children, width_ratio=width_ratio)
-            columns.append(column_node)
+    def build(self) -> str:
+        return "\n\n".join(child.to_markdown() for child in self.children if child is not None)
 
-        self.children.append(ColumnListMarkdownNode(columns=columns))
+    def _add_heading(
+        self, text: str, level: int, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None
+    ) -> Self:
+        children = self._build_children(builder_func)
+        self.children.append(HeadingMarkdownNode(text=text, level=level, children=children))
         return self
 
-    def _validate_columns_args(
+    def _build_children(self, builder_func: Callable[[MarkdownBuilder], MarkdownBuilder] | None) -> list[MarkdownNode]:
+        if builder_func is None:
+            return []
+
+        builder = MarkdownBuilder()
+        builder_func(builder)
+        return builder.children
+
+    def _build_columns(
         self,
         builder_funcs: tuple[Callable[[MarkdownBuilder], MarkdownBuilder], ...],
         width_ratios: list[float] | None,
-    ) -> None:
-        if len(builder_funcs) < 2:
-            raise ValueError("Column layout requires at least 2 columns")
-
-        if width_ratios is not None:
-            if len(width_ratios) != len(builder_funcs):
-                raise ValueError(
-                    f"width_ratios length ({len(width_ratios)}) must match number of columns ({len(builder_funcs)})"
-                )
-
-            ratio_sum = sum(width_ratios)
-            if not (0.9 <= ratio_sum <= 1.1):  # Allow small floating point errors
-                raise ValueError(f"width_ratios should sum to 1.0, got {ratio_sum}")
-
-    def build(self) -> str:
-        return "\n\n".join(child.to_markdown() for child in self.children if child is not None)
+    ) -> list[ColumnMarkdownNode]:
+        columns = []
+        for i, builder_func in enumerate(builder_funcs):
+            width_ratio = width_ratios[i] if width_ratios else None
+            children = self._build_children(builder_func)
+            columns.append(ColumnMarkdownNode(children=children, width_ratio=width_ratio))
+        return columns

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

@@ -21,7 +21,6 @@ from .table import TableMarkdownNode
 from .table_of_contents import TableOfContentsMarkdownNode
 from .todo import TodoMarkdownNode
 from .toggle import ToggleMarkdownNode
-from .toggleable_heading import ToggleableHeadingMarkdownNode
 from .video import VideoMarkdownNode
 
 __all__ = [
@@ -49,6 +48,5 @@ __all__ = [
     "TableOfContentsMarkdownNode",
     "TodoMarkdownNode",
     "ToggleMarkdownNode",
-    "ToggleableHeadingMarkdownNode",
     "VideoMarkdownNode",
 ]

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

@@ -2,7 +2,7 @@ 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
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class AudioMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):

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

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class MarkdownNode(ABC):

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

@@ -2,7 +2,7 @@ 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
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class BookmarkMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):

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

@@ -1,7 +1,7 @@
 from typing import override
 
 from notionary.page.content.markdown.nodes.base import MarkdownNode
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class BreadcrumbMarkdownNode(MarkdownNode):

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

@@ -1,18 +1,41 @@
 from typing import override
 
 from notionary.page.content.markdown.nodes.base import MarkdownNode
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
 
 
-class BulletedListMarkdownNode(MarkdownNode):
-    def __init__(self, texts: list[str], syntax_registry: SyntaxRegistry | None = None) -> None:
+class BulletedListMarkdownNode(ContainerNode):
+    def __init__(
+        self,
+        texts: list[str],
+        children: list[MarkdownNode | None] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ) -> None:
         super().__init__(syntax_registry=syntax_registry)
         self.texts = texts
+        self.children = children or []
 
     @override
     def to_markdown(self) -> str:
-        bulleted_list_syntax = self._syntax_registry.get_bulleted_list_syntax()
-        result = []
-        for text in self.texts:
-            result.append(f"{bulleted_list_syntax.start_delimiter} {text}")
-        return "\n".join(result)
+        list_items = [self._render_list_item(index, text) for index, text in enumerate(self.texts)]
+        return "\n".join(list_items)
+
+    def _render_list_item(self, index: int, text: str) -> str:
+        delimiter = self._get_list_delimiter()
+        item_line = f"{delimiter}{text}"
+
+        child = self._get_child_for_item(index)
+        if child:
+            child_content = self.render_child(child)
+            return f"{item_line}\n{child_content}"
+
+        return item_line
+
+    def _get_list_delimiter(self) -> str:
+        return self._syntax_registry.get_bulleted_list_syntax().start_delimiter
+
+    def _get_child_for_item(self, index: int) -> MarkdownNode | None:
+        if not self.children or index >= len(self.children):
+            return None
+        return self.children[index]

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

@@ -1,10 +1,11 @@
 from typing import override
 
 from notionary.page.content.markdown.nodes.base import MarkdownNode
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
 
 
-class CalloutMarkdownNode(MarkdownNode):
+class CalloutMarkdownNode(ContainerNode):
     def __init__(
         self,
         text: str,
@@ -19,14 +20,15 @@ class CalloutMarkdownNode(MarkdownNode):
 
     @override
     def to_markdown(self) -> str:
-        callout_syntax = self._syntax_registry.get_callout_syntax()
-        start_tag = f"{callout_syntax.start_delimiter} {self.emoji}" if self.emoji else callout_syntax.start_delimiter
+        callout_content = self._format_callout_content()
+        start_delimiter = self._syntax_registry.get_callout_syntax().start_delimiter
+        result = f"{start_delimiter}({callout_content})"
 
-        if not self.children:
-            return f"{start_tag}\n{self.text}\n{callout_syntax.end_delimiter}"
+        result += self.render_children()
 
-        # Convert children to markdown
-        content_parts = [self.text] + [child.to_markdown() for child in self.children]
-        content_text = "\n\n".join(content_parts)
+        return result
 
-        return f"{start_tag}\n{content_text}\n{callout_syntax.end_delimiter}"
+    def _format_callout_content(self) -> str:
+        if self.emoji:
+            return f'{self.text} "{self.emoji}"'
+        return self.text

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

@@ -1,18 +1,16 @@
 from typing import override
 
-from notionary.blocks.enums import CodeLanguage
+from notionary.blocks.enums import CodingLanguage
 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
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class CodeMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):
-    """Code node for creating Notion-style code blocks."""
-
     def __init__(
         self,
         code: str,
-        language: CodeLanguage | None = None,
+        language: CodingLanguage | None = None,
         caption: str | None = None,
         syntax_registry: SyntaxRegistry | None = None,
     ) -> None:

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

@@ -1,10 +1,11 @@
 from typing import override
 
 from notionary.page.content.markdown.nodes.base import MarkdownNode
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.markdown.nodes.container import ContainerNode
+from notionary.page.content.syntax import SyntaxRegistry
 
 
-class ColumnMarkdownNode(MarkdownNode):
+class ColumnMarkdownNode(ContainerNode):
     def __init__(
         self,
         children: list[MarkdownNode] | None = None,
@@ -17,35 +18,52 @@ class ColumnMarkdownNode(MarkdownNode):
 
     @override
     def to_markdown(self) -> str:
-        column_syntax = self._syntax_registry.get_column_syntax()
-        start_tag = (
-            f"{column_syntax.start_delimiter} {self.width_ratio}"
-            if self.width_ratio is not None
-            else column_syntax.start_delimiter
-        )
+        start_tag = self._format_column_start_tag()
+        result = start_tag + self.render_children()
+        return result
 
-        if not self.children:
-            return f"{start_tag}\n{column_syntax.end_delimiter}"
+    def _format_column_start_tag(self) -> str:
+        delimiter = self._syntax_registry.get_column_syntax().start_delimiter
 
-        # Convert children to markdown
-        content_parts = [child.to_markdown() for child in self.children]
-        content_text = "\n\n".join(content_parts)
-
-        return f"{start_tag}\n{content_text}\n{column_syntax.end_delimiter}"
+        if self.width_ratio is not None:
+            return f"{delimiter} {self.width_ratio}"
+        return delimiter
 
 
 class ColumnListMarkdownNode(MarkdownNode):
-    def __init__(self, columns: list[ColumnMarkdownNode] | None = None, syntax_registry: SyntaxRegistry | None = None):
+    def __init__(
+        self,
+        columns: list[ColumnMarkdownNode] | None = None,
+        syntax_registry: SyntaxRegistry | None = None,
+    ):
         super().__init__(syntax_registry=syntax_registry)
         self.columns = columns or []
 
     @override
     def to_markdown(self) -> str:
-        column_list_syntax = self._syntax_registry.get_column_list_syntax()
+        start_delimiter = self._get_column_list_delimiter()
+
         if not self.columns:
-            return f"{column_list_syntax.start_delimiter}\n{column_list_syntax.end_delimiter}"
+            return start_delimiter
+
+        result = start_delimiter + self._render_columns()
+        return result
+
+    def _get_column_list_delimiter(self) -> str:
+        return self._syntax_registry.get_column_list_syntax().start_delimiter
+
+    def _render_columns(self) -> str:
+        rendered_columns = []
+
+        for column in self.columns:
+            column_markdown = column.to_markdown()
+            if column_markdown:
+                indented = self._indent_column(column_markdown)
+                rendered_columns.append(indented)
 
-        column_parts = [column.to_markdown() for column in self.columns]
-        columns_content = "\n\n".join(column_parts)
+        return "\n" + "\n".join(rendered_columns) if rendered_columns else ""
 
-        return f"{column_list_syntax.start_delimiter}\n{columns_content}\n{column_list_syntax.end_delimiter}"
+    @staticmethod
+    def _indent_column(text: str, indent: str = "    ") -> str:
+        lines = text.split("\n")
+        return "\n".join(f"{indent}{line}" if line.strip() else line for line in lines)

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

@@ -0,0 +1,64 @@
+from notionary.page.content.markdown.nodes.base import MarkdownNode
+from notionary.page.content.syntax import SyntaxRegistry
+from notionary.page.content.syntax.grammar import MarkdownGrammar
+
+
+def flatten_children(children: list[MarkdownNode]) -> MarkdownNode | None:
+    """Convert a list of child nodes to a single node for container compatibility."""
+    if not children:
+        return None
+    if len(children) == 1:
+        return children[0]
+    return _MultiChildWrapper(children)
+
+
+class _MultiChildWrapper(MarkdownNode):
+    def __init__(self, children: list[MarkdownNode]) -> None:
+        super().__init__()
+        self.children = children
+
+    def to_markdown(self) -> str:
+        return "\n".join(child.to_markdown() for child in self.children if child)
+
+
+class ContainerNode(MarkdownNode):
+    children: list[MarkdownNode]
+
+    def __init__(self, syntax_registry: SyntaxRegistry | None = None) -> None:
+        super().__init__(syntax_registry=syntax_registry)
+        grammar = self._get_grammar(syntax_registry)
+        self._spaces_per_nesting_level = grammar.spaces_per_nesting_level
+
+    def render_children(self, indent_level: int = 1) -> str:
+        if not self.children:
+            return ""
+
+        indent = self._calculate_indent(indent_level)
+        rendered = [self._indent_child(child, indent) for child in self.children]
+        rendered = [text for text in rendered if text]
+
+        return f"\n{'\n'.join(rendered)}" if rendered else ""
+
+    def render_child(self, child: MarkdownNode, indent_level: int = 1) -> str:
+        child_markdown = child.to_markdown()
+        if not child_markdown:
+            return ""
+
+        indent = self._calculate_indent(indent_level)
+        return self._indent_text(child_markdown, indent)
+
+    def _calculate_indent(self, level: int) -> str:
+        return " " * (self._spaces_per_nesting_level * level)
+
+    def _indent_child(self, child: MarkdownNode, indent: str) -> str:
+        child_markdown = child.to_markdown()
+        return self._indent_text(child_markdown, indent) if child_markdown else ""
+
+    @staticmethod
+    def _indent_text(text: str, indent: str) -> str:
+        lines = text.split("\n")
+        return "\n".join(f"{indent}{line}" if line.strip() else line for line in lines)
+
+    @staticmethod
+    def _get_grammar(syntax_registry: SyntaxRegistry | None) -> MarkdownGrammar:
+        return syntax_registry._markdown_grammar if syntax_registry else MarkdownGrammar()

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

@@ -1,7 +1,7 @@
 from typing import override
 
 from notionary.page.content.markdown.nodes.base import MarkdownNode
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class DividerMarkdownNode(MarkdownNode):

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

@@ -2,7 +2,7 @@ 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
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class EmbedMarkdownNode(MarkdownNode, CaptionMarkdownNodeMixin):

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

@@ -1,7 +1,7 @@
 from typing import override
 
 from notionary.page.content.markdown.nodes.base import MarkdownNode
-from notionary.page.content.syntax.service import SyntaxRegistry
+from notionary.page.content.syntax import SyntaxRegistry
 
 
 class EquationMarkdownNode(MarkdownNode):