prezo 2026.1.3__py3-none-any.whl → 2026.1.4__py3-none-any.whl

prezo/__init__.py

@@ -159,6 +159,12 @@ def main() -> None:
         choices=["auto", "kitty", "sixel", "iterm", "ascii", "none"],
         help="Image rendering mode (auto, kitty, sixel, iterm, ascii, none)",
     )
+    parser.add_argument(
+        "-I",
+        "--incremental",
+        action="store_true",
+        help="Display lists incrementally, one item at a time (like Pandoc)",
+    )
 
     args = parser.parse_args()
 
@@ -236,4 +242,9 @@ def main() -> None:
         if args.file:
             file_path = _validate_file(Path(args.file))
 
-        run_app(file_path, watch=not args.no_watch, config=config)
+        run_app(
+            file_path,
+            watch=not args.no_watch,
+            config=config,
+            incremental=args.incremental,
+        )

prezo/app.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import base64
 import contextlib
 import os
+import re
 import subprocess
 import sys
 import tempfile
@@ -109,6 +110,121 @@ def _format_recent_files(recent_files: list[str], max_files: int = 5) -> str:
     return "\n".join(lines)
 
 
+# -----------------------------------------------------------------------------
+# Incremental List Helpers
+# -----------------------------------------------------------------------------
+
+# Pattern matching markdown list items (unordered and ordered)
+_LIST_ITEM_PATTERN = re.compile(r"^(\s*)([-*+]|\d+\.)\s+")
+
+# Pattern matching layout directive markers (:::)
+_LAYOUT_MARKER_PATTERN = re.compile(r"^\s*:::")
+
+
+def count_list_items(content: str) -> int:
+    """Count the number of top-level list items in markdown content.
+
+    Args:
+        content: Markdown content to analyze.
+
+    Returns:
+        Number of top-level list items found.
+
+    """
+    count = 0
+    for line in content.split("\n"):
+        match = _LIST_ITEM_PATTERN.match(line)
+        if match:
+            # Only count top-level items (no leading whitespace)
+            indent = match.group(1)
+            if not indent:
+                count += 1
+    return count
+
+
+# Braille Pattern Blank - invisible character with width, behaves like text for layout
+_INVISIBLE_CHAR = "\u2800"
+
+
+def _make_placeholder(text: str) -> str:
+    """Create an invisible placeholder that matches the visual width of text.
+
+    Uses Braille Pattern Blank characters which are invisible but have
+    width and wrap like normal text.
+    """
+    return _INVISIBLE_CHAR * len(text) if text else _INVISIBLE_CHAR
+
+
+def filter_list_items(content: str, max_items: int) -> str:
+    """Filter content to show only the first N list items.
+
+    Preserves layout directive markers (:::) and other structural elements.
+    Hidden items are replaced with placeholder text of the same length
+    to maintain visual height when text wraps.
+
+    Args:
+        content: Markdown content to filter.
+        max_items: Maximum number of top-level list items to show.
+
+    Returns:
+        Filtered content with only the first N list items visible.
+
+    """
+    if max_items < 0:
+        return content  # Show all
+
+    lines = content.split("\n")
+    result_lines = []
+    item_count = 0
+    in_hidden_item = False
+
+    for line in lines:
+        # Always preserve layout markers (:::)
+        if _LAYOUT_MARKER_PATTERN.match(line):
+            result_lines.append(line)
+            # Reset hidden state when entering/exiting a block
+            in_hidden_item = False
+            continue
+
+        match = _LIST_ITEM_PATTERN.match(line)
+
+        if match:
+            indent = match.group(1)  # Leading whitespace
+            marker = match.group(2)  # List marker (-, *, +, 1.)
+            text_start = match.end()
+            text = line[text_start:]  # The actual text content
+
+            if len(indent) == 0:
+                # Top-level item
+                item_count += 1
+                if item_count <= max_items:
+                    result_lines.append(line)
+                    in_hidden_item = False
+                else:
+                    # Replace with same-length placeholder
+                    placeholder = _make_placeholder(text)
+                    result_lines.append(f"{indent}{marker} {placeholder}")
+                    in_hidden_item = True
+            elif in_hidden_item:
+                # Nested item under hidden parent - also hide
+                placeholder = _make_placeholder(text)
+                result_lines.append(f"{indent}{marker} {placeholder}")
+            else:
+                # Nested item - show if parent is visible
+                result_lines.append(line)
+        elif in_hidden_item:
+            # Content continuation of hidden item - preserve length
+            stripped = line.lstrip()
+            leading = line[: len(line) - len(stripped)]
+            placeholder = _make_placeholder(stripped)
+            result_lines.append(f"{leading}{placeholder}")
+        else:
+            # Non-list line (could be continuation or other content)
+            result_lines.append(line)
+
+    return "\n".join(result_lines)
+
+
 class PrezoCommands(Provider):
     """Command provider for Prezo actions."""
 
@@ -342,6 +458,7 @@ class PrezoApp(App):
     current_slide: reactive[int] = reactive(0)
     notes_visible: reactive[bool] = reactive(False)
     app_theme: reactive[str] = reactive("dark")
+    reveal_index: reactive[int] = reactive(-1)  # -1 = show all, 0+ = show up to index
 
     TITLE = "Prezo"
 
@@ -351,6 +468,7 @@ class PrezoApp(App):
         *,
         watch: bool | None = None,
         config: Config | None = None,
+        incremental: bool = False,
     ) -> None:
         """Initialize the Prezo application.
 
@@ -358,6 +476,7 @@ class PrezoApp(App):
             presentation_path: Path to the Markdown presentation file.
             watch: Whether to enable file watching for live reload.
             config: Optional config override. Uses global config if None.
+            incremental: Whether to display lists incrementally (-I flag).
 
         """
         super().__init__()
@@ -367,6 +486,9 @@ class PrezoApp(App):
         self.presentation_path = Path(presentation_path) if presentation_path else None
         self.presentation: Presentation | None = None
 
+        # Incremental lists: CLI flag overrides config
+        self.incremental_cli = incremental
+
         # Use config for watch if not explicitly set
         if watch is None:
             self.watch_enabled = self.config.behavior.auto_reload
@@ -436,11 +558,20 @@ class PrezoApp(App):
             return
 
         old_slide = self.current_slide
+        old_reveal = self.reveal_index
         self.presentation = parse_presentation(self.presentation_path)
 
         if old_slide >= self.presentation.total_slides:
-            self.current_slide = max(0, self.presentation.total_slides - 1)
+            target_slide = max(0, self.presentation.total_slides - 1)
+            self._init_reveal_for_slide(target_slide, show_all=False)
+            self.current_slide = target_slide
         else:
+            # Preserve reveal position if still valid
+            list_count = self._get_list_count(old_slide)
+            if self._is_incremental_enabled(old_slide) and list_count > 0:
+                self.reveal_index = max(0, min(old_reveal, list_count - 1))
+            else:
+                self.reveal_index = -1
             self._update_display()
 
         self.notify("Presentation reloaded", timeout=2)
@@ -453,12 +584,16 @@ class PrezoApp(App):
         # Restore last position or start at 0
         abs_path = str(self.presentation_path.absolute())
         last_pos = self.state.get_position(abs_path)
-        if last_pos < self.presentation.total_slides:
-            self.current_slide = last_pos
+        target_slide = last_pos if last_pos < self.presentation.total_slides else 0
+
+        # Set the slide - the watcher will initialize reveal state
+        if self.current_slide == target_slide:
+            # Watcher won't fire, so initialize manually
+            self._init_reveal_for_slide(target_slide, show_all=False)
+            self._update_display()
         else:
-            self.current_slide = 0
+            self.current_slide = target_slide
 
-        self._update_display()
         self._update_progress_bar()
 
         if self.presentation.title:
@@ -479,6 +614,81 @@ class PrezoApp(App):
         self._apply_timer_config(status_bar)
         status_bar.reset_timer()
 
+    def _is_incremental_enabled(self, slide_index: int | None = None) -> bool:
+        """Check if incremental mode is enabled for a slide.
+
+        Priority: per-slide directive > CLI flag > config > presentation directive
+
+        Args:
+            slide_index: Slide index to check. Uses current_slide if None.
+
+        Returns:
+            True if incremental lists should be enabled.
+
+        """
+        if not self.presentation or not self.presentation.slides:
+            return False
+
+        idx = slide_index if slide_index is not None else self.current_slide
+        if idx < 0 or idx >= len(self.presentation.slides):
+            return False
+
+        slide = self.presentation.slides[idx]
+
+        # Per-slide directive takes highest priority
+        if slide.incremental is not None:
+            return slide.incremental
+
+        # CLI flag overrides config and presentation directives
+        if self.incremental_cli:
+            return True
+
+        # Presentation directive (from <!-- prezo --> block)
+        if self.presentation.directives.incremental_lists is not None:
+            return self.presentation.directives.incremental_lists
+
+        # Fall back to config
+        return self.config.behavior.incremental_lists
+
+    def _get_list_count(self, slide_index: int | None = None) -> int:
+        """Get the number of top-level list items in a slide.
+
+        Args:
+            slide_index: Slide index to check. Uses current_slide if None.
+
+        Returns:
+            Number of top-level list items.
+
+        """
+        if not self.presentation or not self.presentation.slides:
+            return 0
+
+        idx = slide_index if slide_index is not None else self.current_slide
+        if idx < 0 or idx >= len(self.presentation.slides):
+            return 0
+
+        slide = self.presentation.slides[idx]
+        return count_list_items(slide.content)
+
+    def _init_reveal_for_slide(
+        self, slide_index: int, *, show_all: bool = False
+    ) -> None:
+        """Initialize reveal state for a specific slide.
+
+        Args:
+            slide_index: The slide to initialize for.
+            show_all: If True, reveal all items. If False, start with first item.
+
+        """
+        if self._is_incremental_enabled(slide_index):
+            list_count = self._get_list_count(slide_index)
+            if list_count > 0:
+                self.reveal_index = (list_count - 1) if show_all else 0
+            else:
+                self.reveal_index = -1  # No list items, show all content
+        else:
+            self.reveal_index = -1  # Incremental disabled, show all
+
     def _apply_presentation_directives(self) -> None:
         """Apply presentation-specific directives on top of config."""
         if not self.presentation:
@@ -583,9 +793,13 @@ class PrezoApp(App):
                 image_widget.clear()
 
         # Use cleaned content (bg images already removed by parser)
-        self.query_one("#slide-content", SlideContent).set_content(
-            slide.content.strip()
-        )
+        content = slide.content.strip()
+
+        # Apply incremental filtering if enabled
+        if self._is_incremental_enabled() and self.reveal_index >= 0:
+            content = filter_list_items(content, self.reveal_index + 1)
+
+        self.query_one("#slide-content", SlideContent).set_content(content)
 
         container = self.query_one("#slide-container", VerticalScroll)
         container.scroll_home(animate=False)
@@ -594,7 +808,7 @@ class PrezoApp(App):
         self._update_notes()
 
     def _update_progress_bar(self) -> None:
-        """Update the progress bar."""
+        """Update the progress bar and reveal indicator."""
         if not self.presentation:
             return
 
@@ -602,6 +816,19 @@ class PrezoApp(App):
         status.current = self.current_slide
         status.total = self.presentation.total_slides
 
+        # Update reveal indicator
+        if self._is_incremental_enabled():
+            list_count = self._get_list_count()
+            if list_count > 0 and self.reveal_index >= 0:
+                status.reveal_current = self.reveal_index
+                status.reveal_total = list_count
+            else:
+                status.reveal_current = -1
+                status.reveal_total = 0
+        else:
+            status.reveal_current = -1
+            status.reveal_total = 0
+
     def _update_notes(self) -> None:
         """Update the notes panel content."""
         if not self.presentation or not self.presentation.slides:
@@ -617,6 +844,9 @@ class PrezoApp(App):
 
     def watch_current_slide(self, old_value: int, new_value: int) -> None:
         """React to slide changes."""
+        # Determine direction and initialize reveal state appropriately
+        going_back = new_value < old_value
+        self._init_reveal_for_slide(new_value, show_all=going_back)
         self._update_display()
         self._save_position()
 
@@ -636,15 +866,41 @@ class PrezoApp(App):
             notes_panel.remove_class("visible")
 
     def action_next_slide(self) -> None:
-        """Go to the next slide."""
-        if (
-            self.presentation
-            and self.current_slide < self.presentation.total_slides - 1
-        ):
+        """Go to the next slide or reveal next list item."""
+        if not self.presentation:
+            return
+
+        # Check if we should reveal next item instead of advancing slide
+        if self._is_incremental_enabled():
+            list_count = self._get_list_count()
+            if (
+                list_count > 0
+                and self.reveal_index >= 0
+                and self.reveal_index < list_count - 1
+            ):
+                self.reveal_index += 1
+                self._update_display()
+                self._update_progress_bar()
+                return
+
+        # No more items to reveal, go to next slide
+        if self.current_slide < self.presentation.total_slides - 1:
+            # The watcher will initialize reveal_index for the new slide
             self.current_slide += 1
 
     def action_prev_slide(self) -> None:
-        """Go to the previous slide."""
+        """Go to the previous slide or hide last revealed item."""
+        if not self.presentation:
+            return
+
+        # Check if we should hide last item instead of going back
+        if self._is_incremental_enabled() and self.reveal_index > 0:
+            self.reveal_index -= 1
+            self._update_display()
+            self._update_progress_bar()
+            return
+
+        # Go to previous slide (watcher will show all items)
         if self.current_slide > 0:
             self.current_slide -= 1
 
@@ -931,6 +1187,7 @@ def run_app(
     *,
     watch: bool | None = None,
     config: Config | None = None,
+    incremental: bool = False,
 ) -> None:
     """Run the Prezo application.
 
@@ -938,7 +1195,10 @@ def run_app(
         presentation_path: Path to the presentation file.
         watch: Whether to watch for file changes. Uses config default if None.
         config: Optional config override. Uses global config if None.
+        incremental: Whether to display lists incrementally (-I flag).
 
     """
-    app = PrezoApp(presentation_path, watch=watch, config=config)
+    app = PrezoApp(
+        presentation_path, watch=watch, config=config, incremental=incremental
+    )
     app.run()

prezo/config.py

@@ -69,6 +69,7 @@ class BehaviorConfig:
 
     auto_reload: bool = True
     reload_interval: float = 1.0
+    incremental_lists: bool = False  # Display lists one item at a time
 
 
 @dataclass

prezo/layout.py

@@ -538,11 +538,9 @@ class BoxRenderable:
         self, console: Console, options: ConsoleOptions
     ) -> RenderResult:
         """Render content in a bordered panel."""
-        yield Text("")
-        md = Markdown(self.content)
-        panel = Panel(md, title=self.title if self.title else None)
+        content = _render_box_content(self.content)
+        panel = Panel(content, title=self.title if self.title else None)
         yield panel
-        yield Text("")
 
     def __rich_measure__(
         self, console: Console, options: ConsoleOptions
@@ -644,7 +642,10 @@ def render_layout(
     """
     renderables: list[RenderableType] = []
 
-    for block in blocks:
+    for i, block in enumerate(blocks):
+        # Add spacing before box blocks (except the first one)
+        if block.type == "box" and i > 0:
+            renderables.append(Text(""))
         renderables.extend(_render_block(block))
 
     if len(renderables) == 1:
@@ -656,6 +657,96 @@ def render_layout(
 # Utilities
 # -----------------------------------------------------------------------------
 
+# Pattern for **bold** text
+_BOLD_PATTERN = re.compile(r"\*\*(.+?)\*\*")
+
+# Pattern for bullet list items
+_BULLET_PATTERN = re.compile(r"^[-*+]\s+(.*)$")
+
+# Pattern for numbered list items
+_NUMBERED_PATTERN = re.compile(r"^(\d+\.)\s+(.*)$")
+
+
+def _parse_inline_formatting(text: str) -> Text:
+    """Parse inline markdown formatting like **bold**.
+
+    Args:
+        text: Text with possible **bold** markers.
+
+    Returns:
+        Rich Text object with appropriate styling.
+
+    """
+    result = Text()
+    last_end = 0
+
+    for match in _BOLD_PATTERN.finditer(text):
+        # Add text before match
+        if match.start() > last_end:
+            result.append(text[last_end : match.start()])
+        # Add bold text
+        result.append(match.group(1), style="bold")
+        last_end = match.end()
+
+    # Add remaining text
+    if last_end < len(text):
+        result.append(text[last_end:])
+
+    return result
+
+
+def _render_box_content(content: str) -> Text:
+    """Render box content with compact spacing.
+
+    Handles the common pattern of a title line followed by a bullet list,
+    without the extra blank line that Rich's Markdown adds.
+
+    Args:
+        content: Markdown content for the box.
+
+    Returns:
+        Rich Text object with compact formatting.
+
+    """
+    lines = content.strip().split("\n")
+    if not lines:
+        return Text()
+
+    result = Text()
+
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+
+        if not stripped:
+            # Blank line - add single newline
+            if i > 0:
+                result.append("\n")
+            continue
+
+        # Add newline before this line (except first)
+        if i > 0 and result.plain and not result.plain.endswith("\n"):
+            result.append("\n")
+
+        # Check for bullet list item
+        bullet_match = _BULLET_PATTERN.match(stripped)
+        if bullet_match:
+            result.append("  • ")
+            result.append(_parse_inline_formatting(bullet_match.group(1)))
+            continue
+
+        # Check for numbered list item
+        numbered_match = _NUMBERED_PATTERN.match(stripped)
+        if numbered_match:
+            result.append(f"  {numbered_match.group(1)} ")
+            result.append(_parse_inline_formatting(numbered_match.group(2)))
+            continue
+
+        # Regular text line
+        result.append(_parse_inline_formatting(stripped))
+
+    return result
+
+
 # ANSI escape sequence pattern
 _ANSI_PATTERN = re.compile(r"\x1b\[[0-9;]*m")
 

prezo/parser.py

@@ -40,6 +40,7 @@ class Slide:
     raw_content: str = ""  # Original content for editing
     notes: str = ""
     images: list[ImageRef] = field(default_factory=list)
+    incremental: bool | None = None  # Per-slide override for incremental lists
 
 
 @dataclass
@@ -51,6 +52,7 @@ class PresentationConfig:
     show_elapsed: bool | None = None
     countdown_minutes: int | None = None
     image_mode: str | None = None
+    incremental_lists: bool | None = None
 
     def merge_to_dict(self) -> dict[str, Any]:
         """Convert non-None values to a config dict for merging."""
@@ -65,6 +67,10 @@ class PresentationConfig:
             result.setdefault("timer", {})["countdown_minutes"] = self.countdown_minutes
         if self.image_mode is not None:
             result.setdefault("images", {})["mode"] = self.image_mode
+        if self.incremental_lists is not None:
+            result.setdefault("behavior", {})["incremental_lists"] = (
+                self.incremental_lists
+            )
         return result
 
 
@@ -170,6 +176,24 @@ def extract_notes(content: str) -> tuple[str, str]:
     return content, ""
 
 
+def extract_slide_incremental(content: str) -> bool | None:
+    """Extract per-slide incremental directive from content.
+
+    Looks for:
+    - <!-- incremental --> to enable incremental lists for this slide
+    - <!-- no-incremental --> to disable incremental lists for this slide
+
+    Returns:
+        True if incremental enabled, False if disabled, None if not specified.
+
+    """
+    if re.search(r"<!--\s*incremental\s*-->", content, re.IGNORECASE):
+        return True
+    if re.search(r"<!--\s*no-incremental\s*-->", content, re.IGNORECASE):
+        return False
+    return None
+
+
 def extract_prezo_directives(content: str) -> PresentationConfig:
     """Extract Prezo-specific directives from presentation content.
 
@@ -217,6 +241,8 @@ def extract_prezo_directives(content: str) -> PresentationConfig:
                 config.countdown_minutes = int(value)
         elif key in ("image_mode", "imagemode", "images"):
             config.image_mode = value
+        elif key in ("incremental_lists", "incremental", "incrementallists"):
+            config.incremental_lists = value.lower() in ("true", "1", "yes", "on")
 
     return config
 
@@ -420,6 +446,8 @@ def _parse_content(text: str, source_path: Path | None) -> Presentation:
         slide_content, notes = extract_notes(raw_slide)
         # Extract images BEFORE cleaning (clean_marp_directives removes bg images)
         images = extract_images(slide_content)
+        # Extract per-slide incremental setting
+        incremental = extract_slide_incremental(slide_content)
         cleaned_content = clean_marp_directives(slide_content).strip()
         slide = Slide(
             content=cleaned_content,
@@ -427,6 +455,7 @@ def _parse_content(text: str, source_path: Path | None) -> Presentation:
             raw_content=raw_slide,
             notes=notes.strip(),
             images=images,
+            incremental=incremental,
         )
         presentation.slides.append(slide)
 

prezo/widgets/status_bar.py

@@ -56,6 +56,9 @@ class StatusBar(Static):
     show_elapsed: reactive[bool] = reactive(True)
     show_countdown: reactive[bool] = reactive(False)
     countdown_minutes: reactive[int] = reactive(0)
+    # Incremental reveal indicator
+    reveal_current: reactive[int] = reactive(-1)  # -1 = not in reveal mode
+    reveal_total: reactive[int] = reactive(0)
 
     def __init__(self, **kwargs) -> None:
         """Initialize the status bar."""
@@ -78,6 +81,13 @@ class StatusBar(Static):
         bar = format_progress_bar(self.current, self.total, width=20)
         progress = f"{bar} {self.current + 1}/{self.total}"
 
+        # Reveal indicator (shows remaining list items)
+        reveal = ""
+        if self.reveal_current >= 0 and self.reveal_total > 0:
+            remaining = self.reveal_total - self.reveal_current - 1
+            if remaining > 0:
+                reveal = f" [+{remaining}]"
+
         # Clock part
         clock_parts = []
         if self.show_clock:
@@ -100,8 +110,8 @@ class StatusBar(Static):
 
         # Combine with spacing
         if clock:
-            return f" {progress}    {clock} "
-        return f" {progress} "
+            return f" {progress}{reveal}    {clock} "
+        return f" {progress}{reveal} "
 
     def reset_timer(self) -> None:
         """Reset the elapsed timer."""
@@ -142,6 +152,14 @@ class StatusBar(Static):
         """React to elapsed time visibility changes."""
         self.refresh()
 
+    def watch_reveal_current(self, value: int) -> None:
+        """React to reveal indicator changes."""
+        self.refresh()
+
+    def watch_reveal_total(self, value: int) -> None:
+        """React to reveal total changes."""
+        self.refresh()
+
 
 # Keep these for backwards compatibility and separate use
 class ProgressBar(Static):

{prezo-2026.1.3.dist-info → prezo-2026.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prezo
-Version: 2026.1.3
+Version: 2026.1.4
 Summary: A TUI-based presentation tool for the terminal, built with Textual.
 Author: Stefane Fermigier
 Author-email: Stefane Fermigier <sf@fermigier.com>

{prezo-2026.1.3.dist-info → prezo-2026.1.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-prezo/__init__.py,sha256=RDpFh0F3DGdMB08n7G3HM-c14JAoqvElq4DyXLSPDQg,6740
-prezo/app.py,sha256=3RPSx56hjyyG55ueNWHvuUNe-KkQ3ZzidNgBRc3I2WQ,31713
-prezo/config.py,sha256=DLHUQkThxhmYXQE1AgpWkPvtNlDwOxQRSNjRrfJJEew,6646
+prezo/__init__.py,sha256=F91cPBSScY8J-ypfjhqSQ6vieknutK9ZreSa4jCT0Rc,7006
+prezo/app.py,sha256=ujWjq1UKH8wjlbu1r5v78T8QOfMI_MruPvCJZpdAGIQ,41278
+prezo/config.py,sha256=dVvXrcyDWmmYLt7otDrU386A6fJ2vAoVlCkRVLpJ3I8,6718
 prezo/export/__init__.py,sha256=jdf4Xu71aUKPBXUt8k8TEUzgMee4bfEh71iJGZXtVKE,1010
 prezo/export/common.py,sha256=W9Gn2_wjd3EPuenAECrs6pqsJEWFBJHtGs8y6-4VEKQ,2451
 prezo/export/html.py,sha256=GLRjTvZUEmvee6F2NlU3sn94H47PqLTLpaC3Ab_kxo8,8787
@@ -16,8 +16,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/layout.py,sha256=xy-UaZvU2ZDe0H7XjMCDb30tog4LRdZKB5OUh_r0aqo,19929
-prezo/parser.py,sha256=f1eJtr9xVnxa35jgQ3GvKwNa6TvaXrIKQWgBB_geVAI,15058
+prezo/layout.py,sha256=FN-nMX902jx9MA7TnySbPskmnyWAiziv_xBvTTYrFd0,22463
+prezo/parser.py,sha256=TY4btwASo45EhuZ62AU5mb2Ky_eo2dNL_LfQValWdWc,16247
 prezo/screens/__init__.py,sha256=xHG9jNJz4vi1tpneSEVlD0D9I0M2U4gAGk6-R9xbUf4,508
 prezo/screens/base.py,sha256=2n6Uj8evfIbcpn4AVYNG5iM_k7rIJ3Vwmor_xrQPU9E,2057
 prezo/screens/blackout.py,sha256=wPSdD9lgu8ykAIQjU1OesnmjQoQEn9BdC4TEpABYxW4,1640
@@ -32,8 +32,8 @@ 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.3.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-prezo-2026.1.3.dist-info/entry_points.txt,sha256=74ShZJ_EKjzi63JyPynVnc0uCHGNjIWjAVs8vU_qTyA,38
-prezo-2026.1.3.dist-info/METADATA,sha256=mv3i3_l0Rq03cmGDQzwBeZ9FiUIJ6enFmJNSvm83v2I,5320
-prezo-2026.1.3.dist-info/RECORD,,
+prezo/widgets/status_bar.py,sha256=RuyH_HeGfoecTzS3QhORwV2ahnKjhVDmGZZZrb_jm7k,8843
+prezo-2026.1.4.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+prezo-2026.1.4.dist-info/entry_points.txt,sha256=74ShZJ_EKjzi63JyPynVnc0uCHGNjIWjAVs8vU_qTyA,38
+prezo-2026.1.4.dist-info/METADATA,sha256=UvctCI2bOVGIgoHLdhl7CSgDNNiiN6nTREg8s-FyQQY,5320
+prezo-2026.1.4.dist-info/RECORD,,