notionary 0.2.21__py3-none-any.whl → 0.2.23__py3-none-any.whl

notionary/page/reader/handler/line_renderer.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Optional
+
 from notionary.page.reader.handler import BlockHandler, BlockRenderingContext
 
 
@@ -8,9 +12,9 @@ class LineRenderer(BlockHandler):
         # Always can handle - this is the fallback handler
         return True
 
-    def _process(self, context: BlockRenderingContext) -> None:
-        # Convert the block itself
-        block_markdown = context.block_registry.notion_to_markdown(context.block)
+    async def _process(self, context: BlockRenderingContext) -> None:
+        # Convert the block itself using direct element iteration
+        block_markdown = await self._convert_block_to_markdown(context)
 
         # If block has no direct markdown, either return empty or process children
         if not block_markdown:
@@ -58,3 +62,12 @@ class LineRenderer(BlockHandler):
             else block_markdown
         )
         context.was_processed = True
+
+    async def _convert_block_to_markdown(
+        self, context: BlockRenderingContext
+    ) -> Optional[str]:
+        """Convert a Notion block to markdown using registered elements."""
+        for element in context.block_registry.get_elements():
+            if element.match_notion(context.block):
+                return await element.notion_to_markdown(context.block)
+        return None

notionary/page/reader/handler/numbered_list_renderer.py

@@ -0,0 +1,85 @@
+from notionary.blocks.models import Block, BlockType
+from notionary.blocks.registry.block_registry import BlockRegistry
+from notionary.page.reader.handler.base_block_renderer import BlockHandler
+from notionary.page.reader.handler.block_rendering_context import BlockRenderingContext
+
+
+class NumberedListRenderer(BlockHandler):
+    """Handles numbered list items with sequential numbering."""
+
+    def _can_handle(self, context: BlockRenderingContext) -> bool:
+        """Check if this is a numbered list item."""
+        return (
+            context.block.type == BlockType.NUMBERED_LIST_ITEM
+            and context.block.numbered_list_item is not None
+        )
+
+    async def _process(self, context: BlockRenderingContext) -> None:
+        """Process numbered list item with sequential numbering."""
+        if context.all_blocks is None or context.current_block_index is None:
+            await self._process_single_item(context, 1)
+            return
+
+        items, blocks_to_skip = self._collect_numbered_list_items(context)
+
+        markdown_parts = []
+        for i, item_context in enumerate(items, 1):
+            item_markdown = await self._process_single_item(item_context, i)
+            if item_markdown:
+                markdown_parts.append(item_markdown)
+
+        # Set result and mark how many blocks to skip
+        if markdown_parts:
+            context.markdown_result = "\n".join(markdown_parts)
+            context.was_processed = True
+            context.blocks_consumed = blocks_to_skip
+
+    def _collect_numbered_list_items(
+        self, context: BlockRenderingContext
+    ) -> tuple[list[BlockRenderingContext], int]:
+        """Collect all consecutive numbered list items starting from current position."""
+        items = []
+        current_index = context.current_block_index
+        all_blocks = context.all_blocks
+
+        # Start with current block
+        items.append(context)
+        blocks_processed = 1
+
+        # Look ahead for more numbered list items
+        for i in range(current_index + 1, len(all_blocks)):
+            block = all_blocks[i]
+
+            # Check if it's a numbered list item
+            if (
+                block.type == BlockType.NUMBERED_LIST_ITEM
+                and block.numbered_list_item is not None
+            ):
+
+                # Create context for this item
+                item_context = BlockRenderingContext(
+                    block=block,
+                    indent_level=context.indent_level,
+                    block_registry=context.block_registry,
+                    convert_children_callback=context.convert_children_callback,
+                )
+                items.append(item_context)
+                blocks_processed += 1
+            else:
+                # Not a numbered list item - stop collecting
+                break
+
+        return items, blocks_processed
+
+    async def _process_single_item(
+        self, context: BlockRenderingContext, number: int
+    ) -> str:
+        """Process a single numbered list item with the given number."""
+        from notionary.blocks.rich_text.text_inline_formatter import TextInlineFormatter
+
+        rich_text = context.block.numbered_list_item.rich_text
+        content = await TextInlineFormatter.extract_text_with_formatting(rich_text)
+
+        # Apply indentation
+        indent = "  " * context.indent_level
+        return f"{indent}{number}. {content}"

notionary/page/reader/page_content_retriever.py

@@ -5,6 +5,7 @@ from notionary.page.reader.handler import (
     ColumnListRenderer,
     ColumnRenderer,
     LineRenderer,
+    NumberedListRenderer,
     ToggleableHeadingRenderer,
     ToggleRenderer,
 )
@@ -27,7 +28,7 @@ class PageContentRetriever(LoggingMixin):
         Retrieve page content and convert it to Markdown.
         Uses the chain of responsibility pattern for scalable block processing.
         """
-        return self._convert_blocks_to_markdown(blocks, indent_level=0)
+        return await self._convert_blocks_to_markdown(blocks, indent_level=0)
 
     def _setup_handler_chain(self) -> None:
         """Setup the chain of handlers in priority order."""
@@ -35,16 +36,19 @@ class PageContentRetriever(LoggingMixin):
         toggleable_heading_handler = ToggleableHeadingRenderer()
         column_list_handler = ColumnListRenderer()
         column_handler = ColumnRenderer()
+        numbered_list_handler = NumberedListRenderer()
         regular_handler = LineRenderer()
 
         # Chain handlers - most specific first
         toggle_handler.set_next(toggleable_heading_handler).set_next(
             column_list_handler
-        ).set_next(column_handler).set_next(regular_handler)
+        ).set_next(column_handler).set_next(numbered_list_handler).set_next(
+            regular_handler
+        )
 
         self._handler_chain = toggle_handler
 
-    def _convert_blocks_to_markdown(
+    async def _convert_blocks_to_markdown(
         self, blocks: list[Block], indent_level: int = 0
     ) -> str:
         """Convert blocks to Markdown using the handler chain."""
@@ -52,18 +56,26 @@ class PageContentRetriever(LoggingMixin):
             return ""
 
         markdown_parts = []
+        i = 0
 
-        for block in blocks:
+        while i < len(blocks):
+            block = blocks[i]
             context = BlockRenderingContext(
                 block=block,
                 indent_level=indent_level,
                 block_registry=self._block_registry,
+                all_blocks=blocks,
+                current_block_index=i,
+                convert_children_callback=self._convert_blocks_to_markdown,
             )
 
-            self._handler_chain.handle(context)
+            await self._handler_chain.handle(context)
 
             if context.was_processed and context.markdown_result:
                 markdown_parts.append(context.markdown_result)
 
+            # Skip additional blocks if they were consumed by batch processing
+            i += max(1, context.blocks_consumed)
+
         separator = "\n\n" if indent_level == 0 else "\n"
         return separator.join(markdown_parts)

notionary/page/writer/handler/__init__.py

@@ -1,6 +1,7 @@
 from .code_handler import CodeHandler
 from .column_handler import ColumnHandler
 from .column_list_handler import ColumnListHandler
+from .equation_handler import EquationHandler
 from .line_handler import LineHandler
 from .line_processing_context import LineProcessingContext, ParentBlockContext
 from .regular_line_handler import RegularLineHandler
@@ -19,4 +20,5 @@ __all__ = [
     "TableHandler",
     "RegularLineHandler",
     "CodeHandler",
+    "EquationHandler",
 ]

notionary/page/writer/handler/code_handler.py

@@ -1,7 +1,6 @@
 import re
 
 from notionary.blocks.code.code_element import CodeElement
-from notionary.blocks.rich_text.rich_text_models import RichTextObject
 from notionary.page.writer.handler.line_handler import (
     LineHandler,
     LineProcessingContext,
@@ -27,9 +26,9 @@ class CodeHandler(LineHandler):
             return False
         return self._is_code_start(context)
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         if self._is_code_start(context):
-            self._process_complete_code_block(context)
+            await self._process_complete_code_block(context)
             self._mark_processed(context)
 
     def _is_code_start(self, context: LineProcessingContext) -> bool:
@@ -40,33 +39,19 @@ class CodeHandler(LineHandler):
         """Check if we're currently inside any parent context (toggle, heading, etc.)."""
         return len(context.parent_stack) > 0
 
-    def _process_complete_code_block(self, context: LineProcessingContext) -> None:
-        """Process the entire code block in one go."""
-        # Extract language and caption from opening fence
-        language, caption = self._extract_fence_info(context.line)
-
-        # Create base code block
-        result = CodeElement.markdown_to_notion(f"```{language}")
-        if not result:
-            return
-
-        block = result[0] if isinstance(result, list) else result
-
+    async def _process_complete_code_block(
+        self, context: LineProcessingContext
+    ) -> None:
+        """Process the entire code block in one go using CodeElement."""
         code_lines, lines_to_consume = self._collect_code_lines(context)
 
-        self._set_block_content(block, code_lines)
+        block = CodeElement.create_from_markdown_block(
+            opening_line=context.line, code_lines=code_lines
+        )
 
-        self._set_block_caption(block, caption)
-
-        context.lines_consumed = lines_to_consume
-        context.result_blocks.append(block)
-
-    def _extract_fence_info(self, line: str) -> tuple[str, str]:
-        """Extract the language and optional caption from a code fence."""
-        match = self._code_start_pattern.match(line.strip())
-        lang = match.group(1) if match and match.group(1) else ""
-        cap = match.group(2) if match and match.group(2) else ""
-        return lang, cap
+        if block:
+            context.lines_consumed = lines_to_consume
+            context.result_blocks.append(block)
 
     def _collect_code_lines(
         self, context: LineProcessingContext
@@ -85,16 +70,3 @@ class CodeHandler(LineHandler):
         """Mark context as processed and continue."""
         context.was_processed = True
         context.should_continue = True
-
-    def _set_block_content(self, block, code_lines: list[str]) -> None:
-        """Set the code rich_text content on the block."""
-        if not code_lines:
-            return
-        content = "\n".join(code_lines)
-        block.code.rich_text = [RichTextObject.for_code_block(content)]
-
-    def _set_block_caption(self, block, caption: str) -> None:
-        """Append caption to the code block if provided."""
-        if not caption:
-            return
-        block.code.caption.append(RichTextObject.for_code_block(caption))

notionary/page/writer/handler/column_handler.py

@@ -26,14 +26,14 @@ class ColumnHandler(LineHandler):
     def _can_handle(self, context: LineProcessingContext) -> bool:
         return self._is_column_start(context) or self._is_column_end(context)
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         if self._is_column_start(context):
-            self._start_column(context)
+            await self._start_column(context)
             self._mark_processed(context)
             return
 
         if self._is_column_end(context):
-            self._finalize_column(context)
+            await self._finalize_column(context)
             self._mark_processed(context)
 
     def _is_column_start(self, context: LineProcessingContext) -> bool:
@@ -52,15 +52,15 @@ class ColumnHandler(LineHandler):
         current_parent = context.parent_stack[-1]
         return issubclass(current_parent.element_type, ColumnElement)
 
-    def _start_column(self, context: LineProcessingContext) -> None:
+    async def _start_column(self, context: LineProcessingContext) -> None:
         """Start a new column."""
         # Create Column block directly - much more efficient!
         column_element = ColumnElement()
-        result = column_element.markdown_to_notion(context.line)
+        result = await column_element.markdown_to_notion(context.line)
         if not result:
             return
 
-        block = result if not isinstance(result, list) else result[0]
+        block = result
 
         # Push to parent stack
         parent_context = ParentBlockContext(
@@ -70,10 +70,10 @@ class ColumnHandler(LineHandler):
         )
         context.parent_stack.append(parent_context)
 
-    def _finalize_column(self, context: LineProcessingContext) -> None:
+    async def _finalize_column(self, context: LineProcessingContext) -> None:
         """Finalize a single column and add it to the column list or result."""
         column_context = context.parent_stack.pop()
-        self._assign_column_children_if_any(column_context, context)
+        await self._assign_column_children_if_any(column_context, context)
 
         if context.parent_stack:
             parent = context.parent_stack[-1]
@@ -87,7 +87,7 @@ class ColumnHandler(LineHandler):
         # Fallback: no parent or parent is not ColumnList
         context.result_blocks.append(column_context.block)
 
-    def _assign_column_children_if_any(
+    async def _assign_column_children_if_any(
         self, column_context: ParentBlockContext, context: LineProcessingContext
     ) -> None:
         """Collect and assign any children blocks inside this column."""
@@ -96,7 +96,7 @@ class ColumnHandler(LineHandler):
         # Process text lines
         if column_context.child_lines:
             children_text = "\n".join(column_context.child_lines)
-            text_blocks = self._convert_children_text(
+            text_blocks = await self._convert_children_text(
                 children_text, context.block_registry
             )
             all_children.extend(text_blocks)
@@ -123,7 +123,7 @@ class ColumnHandler(LineHandler):
         parent.block.column_list.children.append(column_context.block)
         return True
 
-    def _convert_children_text(self, text: str, block_registry) -> list:
+    async def _convert_children_text(self, text: str, block_registry) -> list:
         """Convert children text to blocks."""
         from notionary.page.writer.markdown_to_notion_converter import (
             MarkdownToNotionConverter,
@@ -133,7 +133,7 @@ class ColumnHandler(LineHandler):
             return []
 
         child_converter = MarkdownToNotionConverter(block_registry)
-        return child_converter._process_lines(text)
+        return await child_converter.process_lines(text)
 
     def _mark_processed(self, context: LineProcessingContext) -> None:
         """Mark context as processed and signal to continue."""

notionary/page/writer/handler/column_list_handler.py

@@ -7,9 +7,9 @@ from notionary.page.writer.handler.line_handler import (
     LineHandler,
     LineProcessingContext,
 )
-
 from notionary.page.writer.handler.line_processing_context import ParentBlockContext
 
+
 class ColumnListHandler(LineHandler):
     """Handles column list elements - both start and end.
     Syntax:
@@ -31,15 +31,15 @@ class ColumnListHandler(LineHandler):
     def _can_handle(self, context: LineProcessingContext) -> bool:
         return self._is_column_list_start(context) or self._is_column_list_end(context)
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         if self._is_column_list_start(context):
-            self._start_column_list(context)
+            await self._start_column_list(context)
             context.was_processed = True
             context.should_continue = True
             return
 
         if self._is_column_list_end(context):
-            self._finalize_column_list(context)
+            await self._finalize_column_list(context)
             context.was_processed = True
             context.should_continue = True
 
@@ -59,7 +59,7 @@ class ColumnListHandler(LineHandler):
         current_parent = context.parent_stack[-1]
         return issubclass(current_parent.element_type, ColumnListElement)
 
-    def _start_column_list(self, context: LineProcessingContext) -> None:
+    async def _start_column_list(self, context: LineProcessingContext) -> None:
         """Start a new column list."""
         # Create ColumnList block using the element from registry
         column_list_element = None
@@ -72,11 +72,11 @@ class ColumnListHandler(LineHandler):
             return
 
         # Create the block
-        result = column_list_element.markdown_to_notion(context.line)
+        result = await column_list_element.markdown_to_notion(context.line)
         if not result:
             return
 
-        block = result if not isinstance(result, list) else result[0]
+        block = result
 
         # Push to parent stack
         parent_context = ParentBlockContext(
@@ -86,10 +86,10 @@ class ColumnListHandler(LineHandler):
         )
         context.parent_stack.append(parent_context)
 
-    def _finalize_column_list(self, context: LineProcessingContext) -> None:
+    async def _finalize_column_list(self, context: LineProcessingContext) -> None:
         """Finalize a column list and add it to result_blocks."""
         column_list_context = context.parent_stack.pop()
-        self._assign_column_list_children_if_any(column_list_context, context)
+        await self._assign_column_list_children_if_any(column_list_context, context)
 
         # Check if we have a parent context to add this column_list to
         if context.parent_stack:
@@ -101,7 +101,7 @@ class ColumnListHandler(LineHandler):
             # No parent, add to top level
             context.result_blocks.append(column_list_context.block)
 
-    def _assign_column_list_children_if_any(
+    async def _assign_column_list_children_if_any(
         self, column_list_context: ParentBlockContext, context: LineProcessingContext
     ) -> None:
         """Collect and assign any column children blocks inside this column list."""
@@ -110,7 +110,7 @@ class ColumnListHandler(LineHandler):
         # Process text lines
         if column_list_context.child_lines:
             children_text = "\n".join(column_list_context.child_lines)
-            children_blocks = self._convert_children_text(
+            children_blocks = await self._convert_children_text(
                 children_text, context.block_registry
             )
             all_children.extend(children_blocks)
@@ -126,7 +126,7 @@ class ColumnListHandler(LineHandler):
         ]
         column_list_context.block.column_list.children = column_children
 
-    def _convert_children_text(self, text: str, block_registry) -> list:
+    async def _convert_children_text(self, text: str, block_registry) -> list:
         """Convert children text to blocks."""
         from notionary.page.writer.markdown_to_notion_converter import (
             MarkdownToNotionConverter,
@@ -136,4 +136,4 @@ class ColumnListHandler(LineHandler):
             return []
 
         child_converter = MarkdownToNotionConverter(block_registry)
-        return child_converter._process_lines(text)
+        return await child_converter.process_lines(text)

notionary/page/writer/handler/equation_handler.py

@@ -0,0 +1,74 @@
+import re
+
+from notionary.blocks.equation.equation_element import EquationElement
+from notionary.page.writer.handler.line_handler import (
+    LineHandler,
+    LineProcessingContext,
+)
+
+
+class EquationHandler(LineHandler):
+    """Handles equation block specific logic with batching.
+
+    Markdown syntax:
+    $$
+    \sum_{i=1}^n i = \frac{n(n+1)}{2} \\
+    \sum_{i=1}^n i^2 = \frac{n(n+1)(2n+1)}{6} \\
+    \sum_{i=1}^n i^3 = \left(\frac{n(n+1)}{2}\right)^2
+    $$
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._equation_start_pattern = re.compile(r"^\$\$\s*$")
+        self._equation_end_pattern = re.compile(r"^\$\$\s*$")
+
+    def _can_handle(self, context: LineProcessingContext) -> bool:
+        if self._is_inside_parent_context(context):
+            return False
+        return self._is_equation_start(context)
+
+    async def _process(self, context: LineProcessingContext) -> None:
+        if self._is_equation_start(context):
+            await self._process_complete_equation_block(context)
+            self._mark_processed(context)
+
+    def _is_equation_start(self, context: LineProcessingContext) -> bool:
+        """Check if this line starts an equation block."""
+        return self._equation_start_pattern.match(context.line.strip()) is not None
+
+    def _is_inside_parent_context(self, context: LineProcessingContext) -> bool:
+        """Check if we're currently inside any parent context (toggle, heading, etc.)."""
+        return len(context.parent_stack) > 0
+
+    async def _process_complete_equation_block(
+        self, context: LineProcessingContext
+    ) -> None:
+        """Process the entire equation block in one go using EquationElement."""
+        equation_lines, lines_to_consume = self._collect_equation_lines(context)
+
+        block = EquationElement.create_from_markdown_block(
+            opening_line=context.line, equation_lines=equation_lines
+        )
+
+        if block:
+            context.lines_consumed = lines_to_consume
+            context.result_blocks.append(block)
+
+    def _collect_equation_lines(
+        self, context: LineProcessingContext
+    ) -> tuple[list[str], int]:
+        """Collect lines until closing $$ fence and return (lines, count_to_consume)."""
+        lines = []
+        for idx, ln in enumerate(context.get_remaining_lines()):
+            if self._equation_end_pattern.match(ln.strip()):
+                return lines, idx + 1
+            lines.append(ln)
+        # No closing fence: consume all remaining
+        rem = context.get_remaining_lines()
+        return rem, len(rem)
+
+    def _mark_processed(self, context: LineProcessingContext) -> None:
+        """Mark context as processed and continue."""
+        context.was_processed = True
+        context.should_continue = True

notionary/page/writer/handler/line_handler.py

@@ -17,12 +17,12 @@ class LineHandler(ABC):
         self._next_handler = handler
         return handler
 
-    def handle(self, context: LineProcessingContext) -> None:
+    async def handle(self, context: LineProcessingContext) -> None:
         """Handle the line or pass to next handler."""
         if self._can_handle(context):
-            self._process(context)
+            await self._process(context)
         elif self._next_handler:
-            self._next_handler.handle(context)
+            await self._next_handler.handle(context)
 
     @abstractmethod
     def _can_handle(self, context: LineProcessingContext) -> bool:
@@ -30,6 +30,6 @@ class LineHandler(ABC):
         pass
 
     @abstractmethod
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         """Process the line and update context."""
         pass

notionary/page/writer/handler/regular_line_handler.py

@@ -1,6 +1,5 @@
 from notionary.blocks.column.column_element import ColumnElement
 from notionary.blocks.column.column_list_element import ColumnListElement
-from notionary.blocks.models import BlockCreateRequest, BlockCreateResult
 from notionary.page.writer.handler import LineHandler, LineProcessingContext
 
 
@@ -10,16 +9,16 @@ class RegularLineHandler(LineHandler):
     def _can_handle(self, context: LineProcessingContext) -> bool:
         return context.line.strip()
 
-    def _process(self, context: LineProcessingContext) -> None:
+    async def _process(self, context: LineProcessingContext) -> None:
         if self._is_in_column_context(context):
             self._add_to_column_context(context)
             context.was_processed = True
             context.should_continue = True
             return
 
-        block_created = self._process_single_line_content(context)
+        block_created = await self._process_single_line_content(context)
         if not block_created:
-            self._process_as_paragraph(context)
+            await self._process_as_paragraph(context)
 
         context.was_processed = True
 
@@ -37,56 +36,51 @@ class RegularLineHandler(LineHandler):
         """Add line as child to the current Column context."""
         context.parent_stack[-1].add_child_line(context.line)
 
-    def _process_single_line_content(self, context: LineProcessingContext) -> bool:
+    async def _process_single_line_content(
+        self, context: LineProcessingContext
+    ) -> bool:
         """Process a regular line for simple elements (lists, etc.)."""
+        specialized_elements = self._get_specialized_elements()
+
         for element in context.block_registry.get_elements():
-            # Skip all elements that have specialized handlers
-            from notionary.blocks.code import CodeElement
-            from notionary.blocks.paragraph import ParagraphElement
-            from notionary.blocks.table import TableElement
-            from notionary.blocks.toggle import ToggleElement
-            from notionary.blocks.toggleable_heading import ToggleableHeadingElement
-
-            specialized_elements = (
-                ColumnListElement,
-                ColumnElement,
-                ToggleElement,
-                ToggleableHeadingElement,
-                TableElement,
-                CodeElement,
-                ParagraphElement,  # Skip paragraph to ensure equations are processed first
-            )
 
             if issubclass(element, specialized_elements):
                 continue
 
-            result = element.markdown_to_notion(context.line)
+            result = await element.markdown_to_notion(context.line)
             if not result:
                 continue
 
-            blocks = self._normalize_to_list(result)
-            for block in blocks:
-                context.result_blocks.append(block)
+            context.result_blocks.append(result)
 
             return True
 
         return False
 
-    def _process_as_paragraph(self, context: LineProcessingContext) -> None:
+    async def _process_as_paragraph(self, context: LineProcessingContext) -> None:
         """Process a line as a paragraph."""
         from notionary.blocks.paragraph.paragraph_element import ParagraphElement
 
         paragraph_element = ParagraphElement()
-        result = paragraph_element.markdown_to_notion(context.line)
+        result = await paragraph_element.markdown_to_notion(context.line)
 
         if result:
-            blocks = self._normalize_to_list(result)
-            for block in blocks:
-                context.result_blocks.append(block)
-
-    @staticmethod
-    def _normalize_to_list(result: BlockCreateResult) -> list[BlockCreateRequest]:
-        """Normalize the result to a list."""
-        if result is None:
-            return []
-        return result if isinstance(result, list) else [result]
+            context.result_blocks.append(result)
+
+    def _get_specialized_elements(self):
+        """Get tuple of elements that have specialized handlers."""
+        from notionary.blocks.code import CodeElement
+        from notionary.blocks.paragraph import ParagraphElement
+        from notionary.blocks.table import TableElement
+        from notionary.blocks.toggle import ToggleElement
+        from notionary.blocks.toggleable_heading import ToggleableHeadingElement
+
+        return (
+            ColumnListElement,
+            ColumnElement,
+            ToggleElement,
+            ToggleableHeadingElement,
+            TableElement,
+            CodeElement,
+            ParagraphElement,
+        )