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

prezo/layout.py

@@ -11,6 +11,13 @@ Supports Pandoc-style fenced div syntax:
     :::
     :::
 
+Additional layout blocks:
+    ::: center          - Horizontally centered content
+    ::: right           - Right-aligned content
+    ::: spacer [n]      - Vertical space (default 1 line)
+    ::: box [title]     - Bordered panel with optional title
+    ::: divider [style] - Horizontal rule (single/double/thick/dashed)
+
 """
 
 from __future__ import annotations
@@ -20,9 +27,12 @@ from dataclasses import dataclass, field
 from io import StringIO
 from typing import TYPE_CHECKING, Literal
 
+from rich.cells import cell_len
 from rich.console import Console, ConsoleOptions, Group, RenderResult
 from rich.markdown import Markdown
 from rich.measure import Measurement
+from rich.panel import Panel
+from rich.rule import Rule
 from rich.text import Text
 
 if TYPE_CHECKING:
@@ -33,22 +43,30 @@ if TYPE_CHECKING:
 # -----------------------------------------------------------------------------
 
 
+BlockType = Literal[
+    "plain", "columns", "column", "center", "right", "spacer", "box", "divider"
+]
+
+
 @dataclass
 class LayoutBlock:
     """A block of content with layout information."""
 
-    type: Literal["plain", "columns", "column", "center"]
+    type: BlockType
     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)
+    title: str = ""  # For box blocks
+    style: str = ""  # For divider blocks (single/double/thick/dashed)
 
 
 # -----------------------------------------------------------------------------
 # Parser
 # -----------------------------------------------------------------------------
 
-# Pattern for opening fenced div: ::: type [width]
-OPEN_PATTERN = re.compile(r"^:::\s*(\w+)(?:\s+(\d+))?\s*$")
+# Pattern for opening fenced div: ::: type [arg]
+# arg can be: a number (width %), a quoted string (title), or a word (style)
+OPEN_PATTERN = re.compile(r'^:::\s*(\w+)(?:\s+"([^"]+)"|\s+(\S+))?\s*$')
 # Pattern for closing fenced div: :::
 CLOSE_PATTERN = re.compile(r"^:::\s*$")
 
@@ -76,10 +94,14 @@ def parse_layout(content: str) -> list[LayoutBlock]:
 
         if match:
             block_type = match.group(1).lower()
-            width = int(match.group(2)) if match.group(2) else 0
+            # Group 2 is quoted string, Group 3 is unquoted arg
+            quoted_arg = match.group(2)  # For "title"
+            unquoted_arg = match.group(3)  # For width or style
 
             # Find matching close and nested content
-            block, end_idx = _parse_fenced_block(lines, i, block_type, width)
+            block, end_idx = _parse_fenced_block(
+                lines, i, block_type, quoted_arg, unquoted_arg
+            )
             if block:
                 blocks.append(block)
                 i = end_idx + 1
@@ -104,8 +126,59 @@ def parse_layout(content: str) -> list[LayoutBlock]:
     return blocks
 
 
+def _create_block(
+    block_type: str,
+    inner_content: str,
+    quoted_arg: str | None,
+    unquoted_arg: str | None,
+) -> LayoutBlock:
+    """Create a LayoutBlock from parsed fenced div content.
+
+    Args:
+        block_type: The type from ::: type.
+        inner_content: Content inside the fenced div.
+        quoted_arg: Quoted argument (e.g., title for box).
+        unquoted_arg: Unquoted argument (e.g., width or style).
+
+    Returns:
+        A LayoutBlock of the appropriate type.
+
+    """
+    content = inner_content.strip()
+    width = int(unquoted_arg) if unquoted_arg and unquoted_arg.isdigit() else 0
+
+    # Use a dispatch table for simple content blocks
+    simple_types = {"center", "right", "plain"}
+
+    if block_type == "columns":
+        block = LayoutBlock(type="columns")
+        block.children = parse_layout(inner_content)
+    elif block_type == "column":
+        block = LayoutBlock(type="column", content=content, width_percent=width)
+    elif block_type == "spacer":
+        lines_count = width if width > 0 else 1
+        block = LayoutBlock(type="spacer", width_percent=lines_count)
+    elif block_type == "box":
+        title = quoted_arg or unquoted_arg or ""
+        block = LayoutBlock(type="box", content=content, title=title)
+    elif block_type == "divider":
+        style = unquoted_arg if unquoted_arg else "single"
+        block = LayoutBlock(type="divider", style=style)
+    elif block_type in simple_types:
+        block = LayoutBlock(type=block_type, content=content)
+    else:
+        # Unknown block type - treat as plain
+        block = LayoutBlock(type="plain", content=content)
+
+    return block
+
+
 def _parse_fenced_block(
-    lines: list[str], start: int, block_type: str, width: int
+    lines: list[str],
+    start: int,
+    block_type: str,
+    quoted_arg: str | None,
+    unquoted_arg: str | None,
 ) -> tuple[LayoutBlock | None, int]:
     """Parse a fenced div block starting at the given line.
 
@@ -113,7 +186,8 @@ def _parse_fenced_block(
         lines: All lines of content.
         start: Starting line index (the opening :::).
         block_type: The type from ::: type.
-        width: Width percentage if specified.
+        quoted_arg: Quoted argument (e.g., title for box).
+        unquoted_arg: Unquoted argument (e.g., width or style).
 
     Returns:
         Tuple of (LayoutBlock or None, end line index).
@@ -143,28 +217,8 @@ def _parse_fenced_block(
         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
+    block = _create_block(block_type, inner_content, quoted_arg, unquoted_arg)
+    return block, i
 
 
 def has_layout_blocks(content: str) -> bool:
@@ -303,10 +357,17 @@ class ColumnsRenderable:
             file=StringIO(),
         )
 
-        # Render markdown content
+        # Render content - check for nested layout blocks
         if column.content:
-            md = Markdown(column.content)
-            col_console.print(md)
+            if has_layout_blocks(column.content):
+                # Parse and render nested layout blocks
+                blocks = parse_layout(column.content)
+                renderable = render_layout(blocks)
+                col_console.print(renderable)
+            else:
+                # Plain markdown
+                md = Markdown(column.content)
+                col_console.print(md)
 
         # Get rendered lines
         output = col_console.export_text(styles=True)
@@ -405,6 +466,168 @@ class CenterRenderable:
         return Measurement(1, options.max_width)
 
 
+class RightRenderable:
+    """Rich renderable that right-aligns content."""
+
+    def __init__(self, content: str) -> None:
+        """Initialize right-align renderable.
+
+        Args:
+            content: Markdown content to right-align.
+
+        """
+        self.content = content
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render right-aligned content."""
+        yield Text("")
+        md = Markdown(self.content, justify="right")
+        yield md
+        yield Text("")
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        """Return the measurement of this renderable."""
+        return Measurement(1, options.max_width)
+
+
+class SpacerRenderable:
+    """Rich renderable that creates vertical space."""
+
+    def __init__(self, lines: int = 1) -> None:
+        """Initialize spacer renderable.
+
+        Args:
+            lines: Number of blank lines to insert.
+
+        """
+        self.lines = max(1, lines)
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render vertical space."""
+        for _ in range(self.lines):
+            yield Text("")
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        """Return the measurement of this renderable."""
+        return Measurement(0, 0)
+
+
+class BoxRenderable:
+    """Rich renderable that displays content in a bordered panel."""
+
+    def __init__(self, content: str, title: str = "") -> None:
+        """Initialize box renderable.
+
+        Args:
+            content: Markdown content to display in the box.
+            title: Optional title for the box.
+
+        """
+        self.content = content
+        self.title = title
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render content in a bordered panel."""
+        content = _render_box_content(self.content)
+        panel = Panel(content, title=self.title if self.title else None)
+        yield panel
+
+    def __rich_measure__(
+        self, console: Console, options: ConsoleOptions
+    ) -> Measurement:
+        """Return the measurement of this renderable."""
+        return Measurement(1, options.max_width)
+
+
+# Divider style characters
+DIVIDER_STYLES = {
+    "single": "─",
+    "double": "═",
+    "thick": "━",
+    "dashed": "╌",
+}
+
+
+class DividerRenderable:
+    """Rich renderable that displays a horizontal rule."""
+
+    def __init__(self, style: str = "single") -> None:
+        """Initialize divider renderable.
+
+        Args:
+            style: Style of the divider (single, double, thick, dashed).
+
+        """
+        self.style = style if style in DIVIDER_STYLES else "single"
+
+    def __rich_console__(
+        self, console: Console, options: ConsoleOptions
+    ) -> RenderResult:
+        """Render horizontal rule."""
+        yield Text("")
+        char = DIVIDER_STYLES[self.style]
+        yield Rule(characters=char)
+        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_block(block: LayoutBlock) -> list[RenderableType]:
+    """Render a single block to Rich renderables.
+
+    Args:
+        block: A LayoutBlock to render.
+
+    Returns:
+        List of Rich renderables for this block.
+
+    """
+    if block.type == "columns":
+        result: list[RenderableType] = []
+        columns = [c for c in block.children if c.type == "column"]
+        if columns:
+            result.append(ColumnsRenderable(columns))
+        # Also render any non-column children (plain text between columns)
+        for child in block.children:
+            if child.type == "plain":
+                result.append(Markdown(child.content))
+        return result
+
+    if block.type == "spacer":
+        return [SpacerRenderable(block.width_percent)]
+
+    if block.type == "box":
+        return [BoxRenderable(block.content, block.title)]
+
+    if block.type == "divider":
+        return [DividerRenderable(block.style)]
+
+    # Simple content blocks: plain, center, right, column
+    renderable_map: dict[str, type] = {
+        "center": CenterRenderable,
+        "right": RightRenderable,
+    }
+    if block.type in renderable_map:
+        return [renderable_map[block.type](block.content)]
+
+    # Default: plain markdown (for "plain" and standalone "column")
+    return [Markdown(block.content)]
+
+
 def render_layout(
     blocks: list[LayoutBlock],
 ) -> RenderableType:
@@ -419,24 +642,11 @@ def render_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))
+    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:
         return renderables[0]
@@ -447,18 +657,115 @@ 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")
 
 
 def _visible_length(text: str) -> int:
-    """Calculate visible length of text, excluding ANSI codes.
+    """Calculate visible cell width of text, excluding ANSI codes.
+
+    Uses Rich's cell_len for proper Unicode width handling:
+    - Regular ASCII characters = 1 cell
+    - Wide characters (CJK, emoji) = 2 cells
+    - Zero-width characters = 0 cells
 
     Args:
         text: Text possibly containing ANSI escape codes.
 
     Returns:
-        Visible character count.
+        Visible cell width (terminal columns).
 
     """
-    return len(_ANSI_PATTERN.sub("", text))
+    # Strip ANSI codes first, then calculate cell width
+    clean_text = _ANSI_PATTERN.sub("", text)
+    return cell_len(clean_text)

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.2.dist-info → prezo-2026.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prezo
-Version: 2026.1.2
+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.2.dist-info → prezo-2026.1.4.dist-info}/RECORD

@@ -1,7 +1,12 @@
-prezo/__init__.py,sha256=blmZoW_bPndFLVT4UZzrfAp8IaGuvmFhtNGUs0nHpFQ,6434
-prezo/app.py,sha256=Uk4Wn8Q9_lJVMwHhGvBLrZ_ARCvtwUpX9X_KDyJ-OXs,32144
-prezo/config.py,sha256=byBBFHZU3fkq3dRfg5h4zG_eihbi7lHZkriSv-g-ogY,6672
-prezo/export.py,sha256=BNqN3a9XXlh22ELJAXnxw_fp0VMas_t-7DWLqyg1kbc,24430
+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
+prezo/export/images.py,sha256=TNTGIYNRTxwVjbHqZXYjIj0gouV_Dy1_DtenMlxsquE,7410
+prezo/export/pdf.py,sha256=9rzybk8o1vEu_JwvKB2abzrYoKfpEA8IP5pEFJHF5WM,13942
+prezo/export/svg.py,sha256=gxhRXpLiKcVr4NSF8nwaid74p8f9dvj4RwXwvMP0EbU,5698
 prezo/images/__init__.py,sha256=xrWSR3z0SXYpLtjIvR2VOMxiJGkxEsls5-EOs9GecFA,324
 prezo/images/ascii.py,sha256=aNz02jN4rkDw0WzmkGDrAGw1R1dY5QGREvIIPI6jwow,7613
 prezo/images/base.py,sha256=STuS57AVSJ2lzwyn0QrIceGaSd2IWEiLGN-elT3u3AM,2749
@@ -11,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=dQHp-9TV-vCp1yqt3WeiS1mrghAh9HPw3aap5DKOeoE,13551
-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
@@ -27,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.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,,
+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,,