prezo 2026.1.1__py3-none-any.whl → 2026.1.2__py3-none-any.whl

prezo/app.py

@@ -39,7 +39,7 @@ from .screens import (
 )
 from .terminal import ImageCapability, detect_image_capability
 from .themes import get_next_theme, get_theme
-from .widgets import ImageDisplay, StatusBar
+from .widgets import ImageDisplay, SlideContent, StatusBar
 
 WELCOME_MESSAGE = """\
 # Welcome to Prezo
@@ -389,7 +389,7 @@ class PrezoApp(App):
                             yield ImageDisplay(id="slide-image")
                         # Text container
                         with VerticalScroll(id="slide-container"):
-                            yield Markdown("", id="slide-content")
+                            yield SlideContent("", id="slide-content")
                 with Vertical(id="notes-panel"):
                     yield Static("Notes", id="notes-title")
                     yield Markdown("", id="notes-content")
@@ -519,7 +519,7 @@ class PrezoApp(App):
         recent_section = _format_recent_files(self.state.recent_files)
         if recent_section:
             welcome += recent_section
-        self.query_one("#slide-content", Markdown).update(welcome)
+        self.query_one("#slide-content", SlideContent).set_content(welcome)
         status = self.query_one("#status-bar", StatusBar)
         status.current = 0
         status.total = 1
@@ -591,7 +591,9 @@ class PrezoApp(App):
                 image_widget.clear()
 
         # Use cleaned content (bg images already removed by parser)
-        self.query_one("#slide-content", Markdown).update(slide.content.strip())
+        self.query_one("#slide-content", SlideContent).set_content(
+            slide.content.strip()
+        )
 
         container = self.query_one("#slide-container", VerticalScroll)
         container.scroll_home(animate=False)

prezo/export.py

@@ -16,7 +16,8 @@ from rich.panel import Panel
 from rich.style import Style
 from rich.text import Text
 
-from .parser import parse_presentation
+from .layout import has_layout_blocks, parse_layout, render_layout
+from .parser import clean_marp_directives, extract_notes, parse_presentation
 from .themes import get_theme
 
 # Export result types
@@ -48,7 +49,7 @@ SVG_FORMAT_NO_CHROME = """\
     }}
 
     .{unique_id}-matrix {{
-        font-family: Fira Code, monospace;
+        font-family: Fira Code, "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", monospace;
         font-size: {char_height}px;
         line-height: {line_height}px;
         font-variant-east-asian: full-width;
@@ -113,13 +114,17 @@ def render_slide_to_svg(
     # Base style for the entire slide (background color)
     base_style = Style(color=theme.text, bgcolor=theme.background)
 
-    # Render the markdown content
-    md = Markdown(content)
+    # Render the content (with layout support)
+    if has_layout_blocks(content):
+        blocks = parse_layout(content)
+        slide_content = render_layout(blocks)
+    else:
+        slide_content = Markdown(content)
 
     # Create a panel with the slide content (height - 2 for status bar and padding)
     panel_height = height - 2
     panel = Panel(
-        md,
+        slide_content,
         title=f"[{theme.text_muted}]Slide {slide_num + 1}/{total_slides}[/]",
         title_align="right",
         border_style=Style(color=theme.primary),
@@ -149,6 +154,13 @@ def render_slide_to_svg(
     else:
         svg = console.export_svg(code_format=SVG_FORMAT_NO_CHROME)
 
+    # Add emoji font fallbacks to font-family declarations
+    # Rich only specifies "Fira Code, monospace" which lacks emoji glyphs
+    svg = svg.replace(
+        "font-family: Fira Code, monospace",
+        'font-family: Fira Code, "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", monospace',
+    )
+
     # Add background color to SVG (Rich doesn't set it by default)
     # Insert a rect element right after the opening svg tag
     bg_rect = f'<rect width="100%" height="100%" fill="{theme.background}"/>'
@@ -386,6 +398,16 @@ HTML_TEMPLATE = """\
             max-width: 100%;
             height: auto;
         }}
+        /* Multi-column layouts */
+        .columns {{
+            display: flex;
+            gap: 2rem;
+            align-items: flex-start;
+        }}
+        .columns > div {{
+            flex: 1;
+            min-width: 0;
+        }}
         .notes {{
             margin-top: 2rem;
             padding: 1rem;
@@ -500,7 +522,10 @@ def export_to_html(
     # Render each slide
     slides_html = []
     for i, slide in enumerate(presentation.slides):
-        content_html = render_slide_to_html(slide.content)
+        # Use raw_content and clean with keep_divs=True to preserve column layouts
+        slide_content, _ = extract_notes(slide.raw_content)
+        cleaned_content = clean_marp_directives(slide_content, keep_divs=True)
+        content_html = render_slide_to_html(cleaned_content)
 
         # Handle notes
         notes_html = ""

prezo/layout.py

@@ -0,0 +1,464 @@
+"""Layout parsing and rendering for multi-column slides.
+
+Supports Pandoc-style fenced div syntax:
+
+    ::: columns
+    ::: column
+    Left content
+    :::
+    ::: column
+    Right content
+    :::
+    :::
+
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from io import StringIO
+from typing import TYPE_CHECKING, Literal
+
+from rich.console import Console, ConsoleOptions, Group, RenderResult
+from rich.markdown import Markdown
+from rich.measure import Measurement
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from rich.console import RenderableType
+
+# -----------------------------------------------------------------------------
+# Data Types
+# -----------------------------------------------------------------------------
+
+
+@dataclass
+class LayoutBlock:
+    """A block of content with layout information."""
+
+    type: Literal["plain", "columns", "column", "center"]
+    content: str = ""  # Raw markdown content (for leaf blocks)
+    children: list[LayoutBlock] = field(default_factory=list)
+    width_percent: int = 0  # For column blocks (0 = auto/equal)
+
+
+# -----------------------------------------------------------------------------
+# Parser
+# -----------------------------------------------------------------------------
+
+# Pattern for opening fenced div: ::: type [width]
+OPEN_PATTERN = re.compile(r"^:::\s*(\w+)(?:\s+(\d+))?\s*$")
+# Pattern for closing fenced div: :::
+CLOSE_PATTERN = re.compile(r"^:::\s*$")
+
+
+def parse_layout(content: str) -> list[LayoutBlock]:
+    """Parse markdown content into layout blocks.
+
+    Detects Pandoc-style fenced divs and builds a tree of LayoutBlocks.
+    Content outside fenced divs becomes plain blocks.
+
+    Args:
+        content: Markdown content possibly containing fenced divs.
+
+    Returns:
+        List of LayoutBlock objects representing the content structure.
+
+    """
+    lines = content.split("\n")
+    blocks: list[LayoutBlock] = []
+    i = 0
+
+    while i < len(lines):
+        line = lines[i]
+        match = OPEN_PATTERN.match(line)
+
+        if match:
+            block_type = match.group(1).lower()
+            width = int(match.group(2)) if match.group(2) else 0
+
+            # Find matching close and nested content
+            block, end_idx = _parse_fenced_block(lines, i, block_type, width)
+            if block:
+                blocks.append(block)
+                i = end_idx + 1
+                continue
+            # Unclosed block - treat as plain text, skip the opening line
+            i += 1
+            continue
+
+        # Not a fenced div - accumulate plain content
+        plain_lines = []
+        while i < len(lines):
+            if OPEN_PATTERN.match(lines[i]):
+                break
+            plain_lines.append(lines[i])
+            i += 1
+
+        if plain_lines:
+            plain_content = "\n".join(plain_lines).strip()
+            if plain_content:
+                blocks.append(LayoutBlock(type="plain", content=plain_content))
+
+    return blocks
+
+
+def _parse_fenced_block(
+    lines: list[str], start: int, block_type: str, width: int
+) -> tuple[LayoutBlock | None, int]:
+    """Parse a fenced div block starting at the given line.
+
+    Args:
+        lines: All lines of content.
+        start: Starting line index (the opening :::).
+        block_type: The type from ::: type.
+        width: Width percentage if specified.
+
+    Returns:
+        Tuple of (LayoutBlock or None, end line index).
+
+    """
+    depth = 1
+    i = start + 1
+    content_lines: list[str] = []
+
+    while i < len(lines) and depth > 0:
+        line = lines[i]
+
+        if CLOSE_PATTERN.match(line):
+            depth -= 1
+            if depth == 0:
+                break
+            content_lines.append(line)
+        elif OPEN_PATTERN.match(line):
+            depth += 1
+            content_lines.append(line)
+        else:
+            content_lines.append(line)
+        i += 1
+
+    if depth != 0:
+        # Unclosed block - treat as plain text
+        return None, start
+
+    inner_content = "\n".join(content_lines)
+
+    # For columns/column types, parse children
+    if block_type in ("columns", "column", "center"):
+        block = LayoutBlock(
+            type=block_type,  # type: ignore[arg-type]
+            width_percent=width,
+        )
+
+        if block_type == "columns":
+            # Parse children (should be column blocks)
+            block.children = parse_layout(inner_content)
+        elif block_type == "column":
+            # Column contains markdown content, but might have nested structure
+            # For now, treat as plain content
+            block.content = inner_content.strip()
+        elif block_type == "center":
+            block.content = inner_content.strip()
+
+        return block, i
+
+    # Unknown block type - treat content as plain
+    return LayoutBlock(type="plain", content=inner_content.strip()), i
+
+
+def has_layout_blocks(content: str) -> bool:
+    """Check if content contains any layout directives.
+
+    Quick check to avoid parsing overhead for simple slides.
+
+    Args:
+        content: Markdown content to check.
+
+    Returns:
+        True if content contains ::: directives.
+
+    """
+    return ":::" in content
+
+
+# -----------------------------------------------------------------------------
+# Renderer
+# -----------------------------------------------------------------------------
+
+
+class ColumnsRenderable:
+    """Rich renderable that displays columns side-by-side."""
+
+    def __init__(
+        self,
+        columns: list[LayoutBlock],
+        gap: int = 2,
+    ) -> None:
+        """Initialize columns renderable.
+
+        Args:
+            columns: List of column LayoutBlocks.
+            gap: Number of spaces between columns.
+
+        """
+        self.columns = columns
+        self.gap = gap
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render columns side-by-side."""
+        if not self.columns:
+            return
+
+        # Blank line before columns
+        yield Text("")
+
+        max_width = options.max_width
+        num_cols = len(self.columns)
+
+        # Calculate column widths
+        widths = self._calculate_widths(max_width, num_cols)
+
+        # Render each column to lines
+        column_outputs: list[list[str]] = []
+        for col, width in zip(self.columns, widths, strict=False):
+            lines = self._render_column(col, width, console)
+            column_outputs.append(lines)
+
+        # Merge columns side-by-side
+        merged = self._merge_columns(column_outputs, widths)
+
+        for line in merged:
+            yield Text.from_ansi(line)
+
+        # Blank line after columns
+        yield Text("")
+
+    def _calculate_widths(self, total_width: int, num_cols: int) -> list[int]:
+        """Calculate width for each column.
+
+        Args:
+            total_width: Total available width.
+            num_cols: Number of columns.
+
+        Returns:
+            List of widths for each column.
+
+        """
+        # Account for gaps between columns
+        total_gap = self.gap * (num_cols - 1)
+        available = total_width - total_gap
+
+        # Check if any columns have explicit widths
+        explicit_widths = [c.width_percent for c in self.columns]
+        total_explicit = sum(w for w in explicit_widths if w > 0)
+
+        if total_explicit > 0:
+            # Use explicit percentages
+            widths = []
+            remaining = available
+            auto_count = sum(1 for w in explicit_widths if w == 0)
+
+            for w in explicit_widths:
+                if w > 0:
+                    col_width = max(1, (available * w) // 100)
+                    widths.append(col_width)
+                    remaining -= col_width
+                else:
+                    widths.append(0)  # Placeholder
+
+            # Distribute remaining to auto columns
+            if auto_count > 0:
+                auto_width = remaining // auto_count
+                widths = [w if w > 0 else auto_width for w in widths]
+        else:
+            # Equal distribution
+            col_width = available // num_cols
+            widths = [col_width] * num_cols
+
+        return widths
+
+    def _render_column(
+        self, column: LayoutBlock, width: int, console: Console
+    ) -> list[str]:
+        """Render a single column to a list of lines.
+
+        Args:
+            column: The column LayoutBlock.
+            width: Width in characters.
+            console: Rich console for rendering.
+
+        Returns:
+            List of rendered lines (with ANSI codes).
+
+        """
+        # Create a console with fixed width for rendering
+        col_console = Console(
+            width=width,
+            force_terminal=True,
+            color_system=console.color_system,
+            record=True,
+            file=StringIO(),
+        )
+
+        # Render markdown content
+        if column.content:
+            md = Markdown(column.content)
+            col_console.print(md)
+
+        # Get rendered lines
+        output = col_console.export_text(styles=True)
+        lines = output.split("\n")
+
+        # Ensure each line is padded to column width
+        # Note: This is tricky with ANSI codes. For now, we'll do basic padding.
+        padded = []
+        for line in lines:
+            # Strip trailing whitespace but preserve ANSI
+            stripped = line.rstrip()
+            padded.append(stripped)
+
+        return padded
+
+    def _merge_columns(
+        self, column_outputs: list[list[str]], widths: list[int]
+    ) -> list[str]:
+        """Merge column outputs side-by-side.
+
+        Args:
+            column_outputs: List of line lists for each column.
+            widths: Width of each column.
+
+        Returns:
+            Merged lines.
+
+        """
+        if not column_outputs:
+            return []
+
+        # Find max height
+        max_height = max(len(col) for col in column_outputs)
+
+        # Pad shorter columns
+        for col in column_outputs:
+            while len(col) < max_height:
+                col.append("")
+
+        # Merge line by line
+        result = []
+        gap_str = " " * self.gap
+
+        for row_idx in range(max_height):
+            parts = []
+            for col_idx, col in enumerate(column_outputs):
+                line = col[row_idx] if row_idx < len(col) else ""
+                # Pad to column width (accounting for ANSI codes)
+                visible_len = _visible_length(line)
+                padding = widths[col_idx] - visible_len
+                if padding > 0:
+                    line = line + " " * padding
+                parts.append(line)
+
+            result.append(gap_str.join(parts))
+
+        return result
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        """Return the measurement of this renderable."""
+        return Measurement(1, options.max_width)
+
+
+class CenterRenderable:
+    """Rich renderable that centers content horizontally."""
+
+    def __init__(self, content: str) -> None:
+        """Initialize center renderable.
+
+        Args:
+            content: Markdown content to center.
+
+        """
+        self.content = content
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render centered content."""
+        # Blank line before centered content
+        yield Text("")
+
+        # Use Markdown with center justification
+        md = Markdown(self.content, justify="center")
+        yield md
+
+        # Blank line after centered content
+        yield Text("")
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        """Return the measurement of this renderable."""
+        return Measurement(1, options.max_width)
+
+
+def render_layout(
+    blocks: list[LayoutBlock],
+) -> RenderableType:
+    """Render layout blocks to a Rich renderable.
+
+    Args:
+        blocks: List of LayoutBlocks from parse_layout().
+
+    Returns:
+        Rich renderable representing the layout.
+
+    """
+    renderables: list[RenderableType] = []
+
+    for block in blocks:
+        match block.type:
+            case "plain":
+                renderables.append(Markdown(block.content))
+            case "columns":
+                # Filter to only column children
+                columns = [c for c in block.children if c.type == "column"]
+                if columns:
+                    renderables.append(ColumnsRenderable(columns))
+                # Also render any non-column children (plain text between columns)
+                for child in block.children:
+                    if child.type == "plain":
+                        renderables.append(Markdown(child.content))
+            case "center":
+                renderables.append(CenterRenderable(block.content))
+            case "column":
+                # Standalone column (shouldn't happen normally)
+                renderables.append(Markdown(block.content))
+
+    if len(renderables) == 1:
+        return renderables[0]
+    return Group(*renderables)
+
+
+# -----------------------------------------------------------------------------
+# Utilities
+# -----------------------------------------------------------------------------
+
+# ANSI escape sequence pattern
+_ANSI_PATTERN = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _visible_length(text: str) -> int:
+    """Calculate visible length of text, excluding ANSI codes.
+
+    Args:
+        text: Text possibly containing ANSI escape codes.
+
+    Returns:
+        Visible character count.
+
+    """
+    return len(_ANSI_PATTERN.sub("", text))

prezo/parser.py

@@ -346,13 +346,19 @@ def _parse_marp_image_directive(alt_text: str) -> _ImageDirectives:
     return result
 
 
-def clean_marp_directives(content: str) -> str:
+def clean_marp_directives(content: str, *, keep_divs: bool = False) -> str:
     """Remove MARP-specific directives that don't render in TUI.
 
     Cleans up:
     - MARP HTML comments (<!-- _class: ... -->, <!-- _header: ... -->, etc.)
     - MARP image directives (![bg ...])
     - Empty HTML divs with only styling
+    - All HTML divs (unless keep_divs=True for HTML export)
+
+    Args:
+        content: Slide content to clean.
+        keep_divs: If True, preserve structural divs (for HTML export).
+
     """
     # Remove MARP directive comments
     content = re.sub(r"<!--\s*_\w+:.*?-->\s*\n?", "", content)
@@ -363,9 +369,10 @@ def clean_marp_directives(content: str) -> str:
     # Remove empty divs with only style attributes
     content = re.sub(r'<div[^>]*style="[^"]*"[^>]*>\s*</div>\s*\n?', "", content)
 
-    # Remove inline HTML divs (keep the content)
-    content = re.sub(r"<div[^>]*>\s*\n?", "", content)
-    content = re.sub(r"\s*</div>", "", content)
+    if not keep_divs:
+        # Remove inline HTML divs (keep the content) - for TUI display
+        content = re.sub(r"<div[^>]*>\s*\n?", "", content)
+        content = re.sub(r"\s*</div>", "", content)
 
     # Clean up multiple blank lines
     return re.sub(r"\n{3,}", "\n\n", content)

prezo/widgets/__init__.py

@@ -4,6 +4,14 @@ from __future__ import annotations
 
 from .image_display import ImageDisplay
 from .slide_button import SlideButton
+from .slide_content import SlideContent
 from .status_bar import ClockDisplay, ProgressBar, StatusBar
 
-__all__ = ["ClockDisplay", "ImageDisplay", "ProgressBar", "SlideButton", "StatusBar"]
+__all__ = [
+    "ClockDisplay",
+    "ImageDisplay",
+    "ProgressBar",
+    "SlideButton",
+    "SlideContent",
+    "StatusBar",
+]

prezo/widgets/slide_content.py

@@ -0,0 +1,81 @@
+"""Slide content widget with layout support."""
+
+from __future__ import annotations
+
+from rich.markdown import Markdown as RichMarkdown
+from textual.widgets import Static
+
+from prezo.layout import has_layout_blocks, parse_layout, render_layout
+
+
+class SlideContent(Static):
+    """Widget that renders slide content with optional layout support.
+
+    Handles both plain markdown and Pandoc-style fenced div layouts:
+    - Plain markdown is rendered using Rich's Markdown
+    - Layout blocks (columns, center) are rendered using the layout module
+
+    Inherits from Static to properly handle Rich renderable display.
+    """
+
+    DEFAULT_CSS = """
+    SlideContent {
+        width: 100%;
+        height: auto;
+    }
+    """
+
+    def __init__(
+        self,
+        content: str = "",
+        *,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the slide content widget.
+
+        Args:
+            content: Markdown content to display.
+            name: Widget name.
+            id: Widget ID.
+            classes: CSS classes.
+
+        """
+        # Initialize Static with the rendered content
+        super().__init__("", name=name, id=id, classes=classes)
+        self._raw_content = content
+        if content:
+            self._update_renderable()
+
+    @property
+    def raw_content(self) -> str:
+        """Get the current raw markdown content."""
+        return self._raw_content
+
+    def set_content(self, content: str) -> None:
+        """Set the markdown content and refresh the widget.
+
+        Args:
+            content: New markdown content to display.
+
+        """
+        self._raw_content = content
+        self._update_renderable()
+
+    def _update_renderable(self) -> None:
+        """Update the internal renderable based on content."""
+        if not self._raw_content:
+            super().update("")
+            return
+
+        # Check for layout directives
+        if has_layout_blocks(self._raw_content):
+            blocks = parse_layout(self._raw_content)
+            renderable = render_layout(blocks)
+        else:
+            # Plain markdown
+            renderable = RichMarkdown(self._raw_content)
+
+        # Use Static's update to set the renderable
+        super().update(renderable)

{prezo-2026.1.1.dist-info → prezo-2026.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prezo
-Version: 2026.1.1
+Version: 2026.1.2
 Summary: A TUI-based presentation tool for the terminal, built with Textual.
 Author: Stefane Fermigier
 Author-email: Stefane Fermigier <sf@fermigier.com>
@@ -16,9 +16,10 @@ A TUI-based presentation tool for the terminal, built with [Textual](https://tex
 
 Display presentations written in Markdown using conventions similar to those of [MARP](https://marp.app/) or [Deckset](https://www.deckset.com/).
 
-## Features (v0.3)
+## Features
 
 - **Markdown presentations** - MARP/Deckset format with `---` slide separators
+- **Column layouts** - Pandoc-style fenced divs for multi-column slides (`::: columns`)
 - **Live reload** - Auto-refresh when file changes (1s polling)
 - **Keyboard navigation** - Vim-style keys, arrow keys, and more
 - **Slide overview** - Grid view for quick navigation (`o`)
@@ -130,12 +131,32 @@ Presenter notes go here (after ???)
 
 # Third Slide
 
+::: columns
+::: column
+**Left Column**
+- Point A
+- Point B
+:::
+
+::: column
+**Right Column**
+- Point C
+- Point D
+:::
+:::
+
+---
+
+# Fourth Slide
+
 <!-- notes: Alternative notes syntax -->
 
-More content...
+::: center
+**Centered content**
+:::
 ```
 
-See the [Writing Presentations in Markdown](docs/tutorial.md) tutorial for a complete guide on creating presentations, including images, presenter notes, and configuration directives.
+See the [Writing Presentations in Markdown](docs/tutorial.md) tutorial for a complete guide on creating presentations, including column layouts, images, presenter notes, and configuration directives.
 
 ## Themes
 

{prezo-2026.1.1.dist-info → prezo-2026.1.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 prezo/__init__.py,sha256=blmZoW_bPndFLVT4UZzrfAp8IaGuvmFhtNGUs0nHpFQ,6434
-prezo/app.py,sha256=5K1tcinaTSI-X24bqV7W7fuwC0Wtw6IH_Gfy2RI3WMo,32086
+prezo/app.py,sha256=Uk4Wn8Q9_lJVMwHhGvBLrZ_ARCvtwUpX9X_KDyJ-OXs,32144
 prezo/config.py,sha256=byBBFHZU3fkq3dRfg5h4zG_eihbi7lHZkriSv-g-ogY,6672
-prezo/export.py,sha256=1npeBV3m9_eTGhYHG7G-ekDGIRX4vNBgtt2RwpjLydc,23324
+prezo/export.py,sha256=BNqN3a9XXlh22ELJAXnxw_fp0VMas_t-7DWLqyg1kbc,24430
 prezo/images/__init__.py,sha256=xrWSR3z0SXYpLtjIvR2VOMxiJGkxEsls5-EOs9GecFA,324
 prezo/images/ascii.py,sha256=aNz02jN4rkDw0WzmkGDrAGw1R1dY5QGREvIIPI6jwow,7613
 prezo/images/base.py,sha256=STuS57AVSJ2lzwyn0QrIceGaSd2IWEiLGN-elT3u3AM,2749
@@ -11,7 +11,8 @@ prezo/images/kitty.py,sha256=mWR-tIE_WDP5BjOkQydPpxWBBGNaZL8PkMICesWQid8,10883
 prezo/images/overlay.py,sha256=lWIAvINxZrKembtB0gzWWaUoedNt7beFU4OhErfwWaw,9600
 prezo/images/processor.py,sha256=zMcfwltecup_AX2FhUIlPdO7c87a9jw7P9tLTIkr54U,4069
 prezo/images/sixel.py,sha256=2IeKDiMsWU1Tn3HYI3PC972ygxKGqpfz6tnhQcM_sVM,5604
-prezo/parser.py,sha256=bD2MecHm7EssHd5LB2Bw6JuUqbjWPztWUu2meYwsyIQ,14793
+prezo/layout.py,sha256=dQHp-9TV-vCp1yqt3WeiS1mrghAh9HPw3aap5DKOeoE,13551
+prezo/parser.py,sha256=f1eJtr9xVnxa35jgQ3GvKwNa6TvaXrIKQWgBB_geVAI,15058
 prezo/screens/__init__.py,sha256=xHG9jNJz4vi1tpneSEVlD0D9I0M2U4gAGk6-R9xbUf4,508
 prezo/screens/base.py,sha256=2n6Uj8evfIbcpn4AVYNG5iM_k7rIJ3Vwmor_xrQPU9E,2057
 prezo/screens/blackout.py,sha256=wPSdD9lgu8ykAIQjU1OesnmjQoQEn9BdC4TEpABYxW4,1640
@@ -22,11 +23,12 @@ prezo/screens/search.py,sha256=3YG9WLGEIKW3YHpM0K1lgwhuqBveXd8ZoQZ178_zGd4,7809
 prezo/screens/toc.py,sha256=8WYb5nbgP9agY-hUTATxLU4X1uka_bc2MN86hFW4aRg,8241
 prezo/terminal.py,sha256=Z3DuuighY-qfF6GWH_AkR5RnAc5Gj3LsPS266VNj7Pk,3638
 prezo/themes.py,sha256=3keUgheOsNGjS0uCjRv7az9sVSnrz5tc-jZ58YNB7tg,3070
-prezo/widgets/__init__.py,sha256=UeTHBgPDvqTkK5tTsPXhdJXP3qZefnltKtUtvJBx9m0,295
+prezo/widgets/__init__.py,sha256=6qAbVVWG2fb4DLv0EzMQ-Qbi74SviXIo-7D7DyDwnrI,378
 prezo/widgets/image_display.py,sha256=8IKncaoC2iWebmJQp_QomF7UVgRxD4WThOshN1Nht2M,3361
 prezo/widgets/slide_button.py,sha256=g5mvtCZSorTIZp_PXgHYeYeeCSNFy0pW3K7iDlZu7yA,2012
+prezo/widgets/slide_content.py,sha256=AO3doIuPBSo5vec_d1xE5F8YMJWxzOq5IFO7gSYSWNw,2300
 prezo/widgets/status_bar.py,sha256=Wcun71kg2Q4s5aduPwTvS4kDHZj5p-zDmD7Cx3_ZFP4,8136
-prezo-2026.1.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-prezo-2026.1.1.dist-info/entry_points.txt,sha256=74ShZJ_EKjzi63JyPynVnc0uCHGNjIWjAVs8vU_qTyA,38
-prezo-2026.1.1.dist-info/METADATA,sha256=b1ymsfoTcOMGVvcoTbb3OSucstuN2QmPz-te-beEjSM,5061
-prezo-2026.1.1.dist-info/RECORD,,
+prezo-2026.1.2.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+prezo-2026.1.2.dist-info/entry_points.txt,sha256=74ShZJ_EKjzi63JyPynVnc0uCHGNjIWjAVs8vU_qTyA,38
+prezo-2026.1.2.dist-info/METADATA,sha256=EVYgqxUj2L3lvUNia9MKC6RjKQXFAaijrnfSD7WRwDg,5320
+prezo-2026.1.2.dist-info/RECORD,,