przn 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c6b2f14ade1a9803cb8d50af8ea637db4cc4455bd07c4274acadef61c0c24d4
-  data.tar.gz: 3cf2e893b448133d50c7d4283838d521b06ed1e9d129ea620e799925edfe0284
+  metadata.gz: 9bc9623dc391c5dee0540aeca9adb3dd20ad090299e5ff5f9395a37fe7643416
+  data.tar.gz: 743ecab777fa5729e4fb23f1b140963060335e8f88a03760524637195fd99b17
 SHA512:
-  metadata.gz: 0b0b41885598b6176fa0de0363f683ded12937a0f0365462fbfb9cffeb867f7c126dadaaecc93244b20e9ceebf94a7d582c076080176d40f7486a28d4792fc66
-  data.tar.gz: 814096bacf4013f4b225b30615176dc2579199bce5c08b8bfa718b00407c28c14a7e8b06958808e24a28b04dd4762c46d6baca8b1340ee2074e48f968c0a2b3e
+  metadata.gz: 8db1ed813eb6ba4d9e40f49bc31064a1acc736e3b37fc2bdf28dd11bacf79fe396cb01e92cc2956f80f25ee978b8a256c600c82289aeefde4601e59ace3448d2
+  data.tar.gz: a6fafabc2e40c4b8d1bb20e82ad0098a9b25b3e7413ffe3ba77bc64e04208510df2ffdfb5cb328953476a15b58fffada16c9d2d7c7a30421747145205e6d150d

data/README.md

@@ -15,6 +15,14 @@ gem install przn
 przn your_slides.md
 ```
 
+To open the presentation directly at a specific slide, append `@N` (1-based):
+
+```
+przn your_slides.md @42
+```
+
+Out-of-range numbers are clamped to the last slide, so `@9999` jumps to the end.
+
 ### PDF export
 
 ```
@@ -35,6 +43,10 @@ Requires a TrueType font (with `glyf` outlines) for proper rendering. Prawn does
 | `G` | Last slide |
 | `q` `Ctrl-C` | Quit |
 
+### Selecting and copying text
+
+`przn` doesn't capture mouse events, so drag-to-select and the terminal's own copy shortcut (Kitty: `Cmd+C` on macOS, `Ctrl+Shift+C` on Linux) work normally on a slide. Mouse-tracking modes that may have leaked from a previously crashed program are explicitly disabled on entry, so drag selection is reliable.
+
 ## Markdown format
 
 przn's Markdown format is compatible with [Rabbit](https://rabbit-shocker.org/)'s Markdown mode.
@@ -62,6 +74,8 @@ more content
 `inline code`
 ```
 
+Long lines wrap at whitespace boundaries (not mid-word) for English-style text. A single word that's longer than the line — a URL, a class name — still wraps at the character it has to. CJK runs without inter-character whitespace fall back to per-character splitting.
+
 ### Lists
 
 ```markdown
@@ -125,8 +139,41 @@ Uses Rabbit-compatible `{::tag}` notation. Supported size names: `xx-small`, `x-
 {::tag name="7"}Maximum size{:/tag}
 ```
 
+An XML-style alternative is also accepted:
+
+```markdown
+<size=x-large>Big text</size>
+<size=7>Maximum size</size>
+```
+
 On [Kitty](https://sw.kovidgoyal.net/kitty/)-compatible terminals, sized text is rendered using the OSC 66 text sizing protocol. On other terminals, the markup is silently ignored.
 
+### Color
+
+Named ANSI colors (`red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`, plus `bright_*` variants) and 6-digit hex. Use `{::tag name="..."}` (kramdown form) or the `color` attribute on `<font>` (see [Font](#font)).
+
+```markdown
+{::tag name="red"}warning{:/tag}
+{::tag name="ff5555"}custom hex{:/tag}
+
+<font color="red">warning</font>
+<font color="ff5555">custom hex</font>
+```
+
+### Font
+
+HTML 4-style `<font>` tag with `face`, `size`, and `color` attributes. Any subset, in any order. The kramdown shape is also accepted.
+
+```markdown
+<font face="Helvetica Neue">Title</font>
+<font face="Menlo" size="3">code</font>
+<font face="Menlo" size="3" color="red">flagged</font>
+
+{::font name="Helvetica Neue"}Title{:/font}
+```
+
+`face` requires a terminal that honors the OSC 66 `f=` extension (e.g. [Echoes](https://github.com/amatsuda/echoes)). For PDF export, the family is registered with Prawn via fontconfig — families that can't be found fall through to the default font.
+
 ### Alignment
 
 ```markdown
@@ -137,6 +184,33 @@ centered text
 right-aligned text
 ```
 
+XML form (single-line, paragraph-level):
+
+```markdown
+<center>centered <size=3>text</size></center>
+<right>right-aligned</right>
+```
+
+### Slide background
+
+Set a per-slide background — solid color or linear gradient — via a self-closing block-level directive. Uses the [Echoes](https://github.com/amatsuda/echoes) OSC 7772 extension; other terminals ignore the escape sequence.
+
+```markdown
+# Title
+
+<bg color="#1a1a2e"/>
+
+content...
+
+# Second slide
+
+<bg from="#1a1a2e" to="#16213e" angle="90"/>
+
+content...
+```
+
+The previous slide's background is cleared on every navigation, and on `przn` exit, so your shell isn't left tinted.
+
 ### Comments
 
 ```markdown
@@ -149,8 +223,66 @@ This text is hidden from the presentation.
 
 ```markdown
 Visible text {::note}(speaker note){:/note}
+Visible text <note>(speaker note)</note>
+```
+
+### Escaping `<`, `>`, `&`
+
+To show literal markup characters that would otherwise be interpreted as a tag, use HTML-style entity references:
+
+```markdown
+&lt;note&gt;            renders as: <note>
+2 &lt; 3                renders as: 2 < 3
+A &amp; B               renders as: A & B
+```
+
+A bare `<` not followed by a recognized tag name renders literally as well, so most accidental `<` characters are fine. The entities are only needed when you'd otherwise hit one of the tag patterns (`<size=...>`, `<font ...>`, `<note>`, `<wait/>`, `<center>`, `<right>`, `<bg .../>`).
+
+### Wait marker
+
+Self-closing presentation flow marker, consumed at parse time:
+
+```markdown
+{::wait/}
+<wait/>
 ```
 
+## Theming
+
+Pass a YAML file via `--theme path/to/theme.yml`. All keys are optional — anything you don't set falls back to the defaults baked in at `default_theme.yml`.
+
+```yaml
+colors:
+  background: "000000"
+  foreground: "ffffff"
+  heading:                # falls back to foreground
+  code_bg: "313244"
+  dim: "6c7086"
+  inline_code: "a6e3a1"
+
+font:
+  family:                 # body text font; terminal: OSC 66 f=, PDF: Prawn font
+  size: 18                # base PDF font size in pt
+
+bullet: "・"              # unordered-list marker; also h2–h6 prefix
+bullet_size:              # OSC 66 scale (1–7) for the bullet glyph
+
+heading_face:             # font family for h1 (slide titles)
+
+bg:                       # default slide background (Echoes OSC 7772)
+  color:                  # solid, e.g. "#1a1a2e"
+  from:                   # gradient endpoint
+  to:                     # gradient endpoint
+  angle:                  # gradient angle in degrees
+```
+
+Notes:
+
+- **`bullet`** / **`bullet_size`** — `bullet` is the character; `bullet_size` is the OSC 66 scale used to render it. When smaller than the body text scale, the bullet is rendered with fractional scaling and vertical centering so it still aligns with the body line.
+- **`font.family`** — applied to body text (terminal: via OSC 66 `f=`, requires Echoes; PDF: registered via fontconfig). Inline `<font face="...">` runs override it per-segment.
+- **`heading_face`** — independent from `font.family`. h1 uses `heading_face` if set, else falls back to the terminal's default font (it does **not** silently inherit `font.family`). h2–h6 are body text. When the chosen face is proportional, every h1 OSC 66 sequence is emitted with `h=2` so a terminal that honors centered horizontal alignment ([Echoes](https://github.com/amatsuda/echoes)) keeps the title visually centered against its reserved cell block.
+- **`bg`** — the deck-wide default background. A per-slide `<bg .../>` directive overrides it for that slide.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/default_theme.yml

@@ -12,5 +12,20 @@ colors:
   inline_code: "a6e3a1"
 
 font:
-  family:               # auto-detect
+  family:               # body text font; terminal: OSC 66 f= (Echoes); PDF: Prawn font (auto-detected if blank)
   size: 18              # base font size in pt for PDF export
+
+bullet: "・"            # used as the unordered-list marker and the h2–h6 heading prefix
+bullet_size:            # OSC 66 scale (1–7) for the bullet glyph; default = the body text's scale
+
+heading_face:           # font family for h1 (slide titles); inline <font face="..."> still wins per-run
+
+# Default slide background, applied when a slide has no <bg .../> directive.
+# Echoes-only (OSC 7772). Use either `color` (solid) or `from`/`to`/`angle`
+# (linear gradient). Both unset = no background override.
+bg:
+  color:                # solid color, e.g. "#1a1a2e"
+  from:                 # gradient endpoint, e.g. "#1a1a2e"
+  to:                   # gradient endpoint, e.g. "#16213e"
+  angle:                # gradient angle in degrees (0 = left→right, 90 = bottom→top)
+  type:                 # gradient type; defaults to "linear"

data/exe/przn

@@ -28,9 +28,17 @@ if options[:generate_theme]
   exit
 end
 
+# Extract a leading-`@N` positional like `przn deck.md @42` and treat it as
+# the slide to open the presentation at (1-based). Removed from ARGV so the
+# remaining positional is the deck file.
+start_at = nil
+if (idx = ARGV.index { |a| a =~ /\A@(\d+)\z/ })
+  start_at = ARGV.delete_at(idx)[1..].to_i
+end
+
 file = ARGV[0]
 unless file
-  $stderr.puts "Usage: przn [options] <presentation.md>"
+  $stderr.puts "Usage: przn [options] <presentation.md> [@N]"
   exit 1
 end
 
@@ -40,5 +48,5 @@ if options[:export] == 'pdf'
   output = options[:output] || File.basename(file, File.extname(file)) + '.pdf'
   Przn.export_pdf(file, output, theme: theme)
 else
-  Przn.start(file, theme: theme).run
+  Przn.start(file, theme: theme, start_at: start_at).run
 end

data/lib/przn/controller.rb

@@ -6,6 +6,7 @@ module Przn
       @presentation = presentation
       @terminal = terminal
       @renderer = renderer
+      @preload_gen = 0
     end
 
     def run
@@ -34,6 +35,9 @@ module Przn
         end
       end
     ensure
+      @preload_gen += 1
+      @preload_thread&.join
+      @terminal.write "\e]7772;bg-clear\a"
       @terminal.show_cursor
       @terminal.leave_alt_screen
     end
@@ -46,6 +50,29 @@ module Przn
         current: @presentation.current,
         total: @presentation.total
       )
+      schedule_preload
+    end
+
+    # Kick off a background thread that pre-uploads images for the slides the
+    # user is most likely to visit next (the immediate neighbors). Uses a
+    # generation counter so a navigation that lands while a preload is still
+    # running causes that preload to exit early instead of stacking work.
+    def schedule_preload
+      @preload_gen += 1
+      gen = @preload_gen
+      cur = @presentation.current
+      total = @presentation.total
+      indices = [cur + 1, cur - 1].select { |i| i.between?(0, total - 1) }
+      return if indices.empty?
+
+      @preload_thread = Thread.new do
+        indices.each do |idx|
+          break if gen != @preload_gen
+          @renderer.preload(@presentation.slides[idx])
+        end
+      rescue StandardError
+        # Background work must not crash the presentation.
+      end
     end
 
     def read_key

data/lib/przn/image_util.rb

@@ -65,6 +65,30 @@ module Przn
       ENV['TERM'] == 'xterm-kitty' || ENV['TERM_PROGRAM'] == 'kitty'
     end
 
+    PNG_MAGIC = "\x89PNG\r\n\x1a\n".b.freeze
+
+    def png?(path)
+      File.open(path, 'rb') { |f| f.read(8)&.b == PNG_MAGIC }
+    rescue Errno::ENOENT
+      false
+    end
+
+    # Kitty Graphics Protocol: upload a PNG file by path with the given id.
+    # Kitty reads the file directly from disk; we just send a small APC
+    # control sequence with the base64-encoded path. Use this once per
+    # image; subsequent renders only need a placement command.
+    # https://sw.kovidgoyal.net/kitty/graphics-protocol/
+    def kitty_upload_png(path, image_id:)
+      encoded = [File.expand_path(path)].pack('m0')
+      "\e_Ga=t,t=f,f=100,i=#{image_id},q=2;#{encoded}\e\\"
+    end
+
+    # Kitty Graphics Protocol: place a previously-uploaded image at the
+    # current cursor position, scaled to fit `cols` x `rows` cells.
+    def kitty_place(image_id:, cols:, rows:)
+      "\e_Ga=p,i=#{image_id},c=#{cols},r=#{rows},q=2\e\\"
+    end
+
     # Sixel via img2sixel
     def sixel_available?
       @sixel_available = system('command -v img2sixel > /dev/null 2>&1') if @sixel_available.nil?

data/lib/przn/kitty_text.rb

@@ -10,10 +10,13 @@ module Przn
 
     module_function
 
-    def sized(text, s:, h: nil, v: nil)
+    def sized(text, s:, h: nil, v: nil, n: nil, d: nil, f: nil)
       params = +"s=#{s}"
+      params << ":n=#{n}" if n
+      params << ":d=#{d}" if d
       params << ":h=#{h}" if h
       params << ":v=#{v}" if v
+      params << ":f=#{f}" if f
       "\e]66;#{params};#{text}\a"
     end
 

data/lib/przn/parser.rb

@@ -71,6 +71,17 @@ module Przn
         when /\A\s*\{:\.(\w+)\}\s*\z/
           blocks << {type: :align, align: Regexp.last_match(1).to_sym}
 
+        # Block alignment, XML form: <center>content</center> or <right>content</right>
+        when /\A\s*<(center|right)>(.*)<\/\1>\s*\z/
+          blocks << {type: :align, align: Regexp.last_match(1).to_sym}
+          blocks << {type: :paragraph, content: Regexp.last_match(2)}
+
+        # Slide background (Echoes OSC 7772):
+        #   <bg color="#..."/>                              — solid (bg-color)
+        #   <bg from="#..." to="#..." angle="N"/>           — linear gradient (bg-gradient)
+        when /\A\s*<bg((?:\s+\w+="[^"]+")*)\s*\/>\s*\z/
+          blocks << {type: :bg, attrs: parse_xml_attrs(Regexp.last_match(1))}
+
         # Fenced code block
         when /\A\s*```(\w*)\s*\z/
           lang = Regexp.last_match(1)
@@ -217,6 +228,25 @@ module Przn
       Slide.new(blocks)
     end
 
+    # HTML4-style <font face="..." size="..." color="..."> attributes.
+    # Kramdown's {::font name="..."} legacy spelling for the family is also
+    # accepted and folded into :face so the renderer has one shape to handle.
+    def parse_font_attrs(str)
+      attrs = parse_xml_attrs(str)
+      attrs[:face] = attrs.delete(:name) if attrs.key?(:name) && !attrs.key?(:face)
+      attrs.slice(:face, :size, :color)
+    end
+
+    # Generic attribute scanner — `key="value"` pairs, returned as a hash with
+    # symbolized keys. Doesn't validate which keys are allowed; callers slice.
+    def parse_xml_attrs(str)
+      attrs = {}
+      str.scan(/(\w+)="([^"]+)"/) do |key, value|
+        attrs[key.to_sym] = value
+      end
+      attrs
+    end
+
     def parse_image_attrs(str, attrs)
       str = str.sub(/\A:?\s*/, '')
       str.scan(/([\w-]+)=['"]([^'"]*)['"]/) do |key, value|
@@ -243,10 +273,24 @@ module Przn
       until scanner.eos?
         if scanner.scan(/\{::tag\s+name="([^"]+)"\}(.*?)\{:\/tag\}/)
           segments << [:tag, scanner[2], scanner[1]]
+        elsif scanner.scan(/<size=([^>\s]+)>(.*?)<\/size>/)
+          segments << [:tag, scanner[2], scanner[1]]
+        elsif scanner.scan(/<font((?:\s+\w+="[^"]+")+)\s*>(.*?)<\/font>/)
+          segments << [:font, scanner[2], parse_font_attrs(scanner[1])]
+        elsif scanner.scan(/\{::font((?:\s+\w+="[^"]+")+)\}(.*?)\{:\/font\}/)
+          segments << [:font, scanner[2], parse_font_attrs(scanner[1])]
         elsif scanner.scan(/\{::note\}(.*?)\{:\/note\}/)
           segments << [:note, scanner[1]]
-        elsif scanner.scan(/\{::wait\/\}/)
+        elsif scanner.scan(/<note>(.*?)<\/note>/)
+          segments << [:note, scanner[1]]
+        elsif scanner.scan(/\{::wait\/\}/) || scanner.scan(/<wait\s*\/>/)
           # skip wait markers in inline text
+        elsif scanner.scan(/&lt;/)
+          segments << [:text, "<"]
+        elsif scanner.scan(/&gt;/)
+          segments << [:text, ">"]
+        elsif scanner.scan(/&amp;/)
+          segments << [:text, "&"]
         elsif scanner.scan(/`([^`]+)`/)
           segments << [:code, scanner[1]]
         elsif scanner.scan(/\*\*(.+?)\*\*/)
@@ -256,7 +300,7 @@ module Przn
         elsif scanner.scan(/~~(.+?)~~/)
           segments << [:strikethrough, scanner[1]]
         else
-          segments << [:text, scanner.scan(/[^`*~{]+|./)]
+          segments << [:text, scanner.scan(/[^`*~{<&]+|./)]
         end
       end
 

data/lib/przn/pdf_exporter.rb

@@ -127,6 +127,57 @@ module Przn
       @font_registered = true
 
       register_emoji_fallback(pdf, font_path)
+      register_inline_fonts(pdf)
+    end
+
+    # Pre-register every font family referenced by an inline <font face="..."> /
+    # {::font name="..."} tag, so build_formatted_text can use it as a Prawn
+    # font: option. Families that fontconfig can't locate are silently dropped
+    # — those runs render in the default font instead of erroring.
+    def register_inline_fonts(pdf)
+      @registered_inline_fonts = {}
+      inline_font_families.each do |family|
+        next if @registered_inline_fonts.key?(family) || family == 'CJK'
+
+        path = fc_find(family)
+        next unless path
+        bold_path = find_bold_font(path, family)
+        pdf.font_families.update(family => {
+          normal: path,
+          bold: bold_path,
+          italic: path,
+        })
+        @registered_inline_fonts[family] = true
+      rescue
+        next
+      end
+    end
+
+    def inline_font_families
+      families = []
+      @presentation.slides.each do |slide|
+        slide.blocks.each do |b|
+          texts = []
+          texts << b[:content] if b[:content].is_a?(String)
+          texts << b[:term] if b[:term].is_a?(String)
+          texts << b[:definition] if b[:definition].is_a?(String)
+          if b[:items].is_a?(Array)
+            b[:items].each { |it| texts << it[:text] if it[:text].is_a?(String) }
+          end
+          if b[:rows].is_a?(Array)
+            (Array(b[:header]) + b[:rows].flatten).each { |c| texts << c if c.is_a?(String) }
+          end
+          texts.each do |text|
+            text.scan(/<font((?:\s+\w+="[^"]+")+)\s*>/) do
+              families << Parser.parse_font_attrs(Regexp.last_match(1))[:face]
+            end
+            text.scan(/\{::font((?:\s+\w+="[^"]+")+)\}/) do
+              families << Parser.parse_font_attrs(Regexp.last_match(1))[:face]
+            end
+          end
+        end
+      end
+      families.compact.uniq
     end
 
     def find_font
@@ -455,6 +506,25 @@ module Przn
           else
             {text: content, size: default_pt, color: @fg_color}
           end
+        when :font
+          attrs = segment[2].is_a?(Hash) ? segment[2] : {}
+          run = {text: content, size: default_pt, color: @fg_color}
+          if attrs[:face] && @registered_inline_fonts&.key?(attrs[:face])
+            run[:font] = attrs[:face]
+          end
+          if attrs[:size] && (scale = Parser::SIZE_SCALES[attrs[:size]])
+            run[:size] = @scale_to_pt[scale]
+          end
+          if attrs[:color]
+            run[:color] = if (hex = COLOR_MAP[attrs[:color]])
+                            hex
+                          elsif attrs[:color].match?(/\A[0-9a-fA-F]{6}\z/)
+                            attrs[:color].upcase
+                          else
+                            @fg_color
+                          end
+          end
+          run
         when :bold
           {text: content, size: default_pt, color: @fg_color, styles: [:bold]}
         when :italic
@@ -538,7 +608,7 @@ module Przn
     end
 
     def bullet
-      @font_registered ? "\u30FB" : "-"
+      @font_registered ? @theme.bullet : "-"
     end
 
   end

data/lib/przn/renderer.rb

@@ -18,37 +18,62 @@ module Przn
     def initialize(terminal, base_dir: '.', theme: nil)
       @terminal = terminal
       @base_dir = base_dir
-      @theme = theme
+      @theme = theme || Theme.default
+      @image_cache = {}
+      @kitty_uploads = {}
+      @mutex = Mutex.new
     end
 
     def render(slide, current:, total:)
-      @terminal.clear
-      w = @terminal.width
-      h = @terminal.height
+      @mutex.synchronize do
+        @terminal.clear
+        apply_slide_background(slide)
+        w = @terminal.width
+        h = @terminal.height
+
+        row = if current == 0
+          content_height = calculate_height(slide.blocks, w)
+          usable_height = h - 1
+          [(usable_height - content_height) / 2 + 1, 1].max
+        else
+          2
+        end
 
-      row = if current == 0
-        content_height = calculate_height(slide.blocks, w)
-        usable_height = h - 1
-        [(usable_height - content_height) / 2 + 1, 1].max
-      else
-        2
+        pending_align = nil
+        slide.blocks.each do |block|
+          if block[:type] == :align
+            pending_align = block[:align]
+          else
+            row = render_block(block, w, row, align: pending_align)
+            pending_align = nil
+          end
+        end
+
+        status = " #{current + 1} / #{total} "
+        @terminal.move_to(h, w - status.size)
+        @terminal.write "#{ANSI[:dim]}#{status}#{ANSI[:reset]}"
+
+        @terminal.flush
       end
+    end
 
-      pending_align = nil
-      slide.blocks.each do |block|
-        if block[:type] == :align
-          pending_align = block[:align]
-        else
-          row = render_block(block, w, row, align: pending_align)
-          pending_align = nil
+    # Warm caches for a slide we expect to navigate to soon. Uploads any PNG
+    # images on the Kitty Graphics Protocol so the next render only needs a
+    # placement command. Safe to call from a background thread; serialized
+    # against `render` via the renderer's mutex so terminal writes don't
+    # interleave.
+    def preload(slide)
+      return unless ImageUtil.kitty_terminal?
+
+      @mutex.synchronize do
+        slide.blocks.each do |block|
+          next unless block[:type] == :image
+          path = resolve_image_path(block[:path])
+          next unless File.exist?(path) && ImageUtil.png?(path)
+          ensure_kitty_uploaded(path)
         end
+        @terminal.flush
       end
-
-      status = " #{current + 1} / #{total} "
-      @terminal.move_to(h, w - status.size)
-      @terminal.write "#{ANSI[:dim]}#{status}#{ANSI[:reset]}"
-
-      @terminal.flush
     end
 
     private
@@ -65,32 +90,65 @@ module Przn
       when :table           then render_table(block, width, row)
       when :image           then render_image(block, width, row)
       when :blank           then row + DEFAULT_SCALE
+      when :bg              then row
       else row + 1
       end
     end
 
+    # Emit Echoes' OSC 7772 to set a slide-specific solid color or gradient,
+    # or clear any previous override. A `<bg .../>` block on the slide wins;
+    # otherwise the theme's `bg:` section is used as the deck-wide default.
+    # Other terminals ignore the OSC code, so this is a no-op outside Echoes.
+    def apply_slide_background(slide)
+      block = slide.blocks.find { |b| b[:type] == :bg }
+      attrs = block ? block[:attrs] : (@theme.bg || {})
+
+      @terminal.write "\e]7772;bg-clear\a"
+      return if attrs.empty?
+
+      if (color = attrs[:color])
+        @terminal.write "\e]7772;bg-color;#{color}\a"
+        return
+      end
+
+      colors = [attrs[:from], attrs[:to]].compact
+      return if colors.size < 2
+
+      type = attrs[:type] || 'linear'
+      angle = attrs[:angle] || 0
+      @terminal.write "\e]7772;bg-gradient;type=#{type}:angle=#{angle}:colors=#{colors.join(',')}\a"
+    end
+
     def render_heading(block, width, row)
       text = block[:content]
 
       if block[:level] == 1
         scale = KittyText::HEADING_SCALES[1]
-        visible_width = display_width(text) * scale
-        pad = [(width - visible_width) / 2, 0].max
-        @terminal.move_to(row, pad + 1)
-        @terminal.write "#{ANSI[:bold]}#{KittyText.sized(text, s: scale)}#{ANSI[:reset]}"
-        row + scale + 4
+        face = @theme.heading_face
+        max_w = max_text_width(width, 0, scale)
+        segments = Parser.parse_inline(text)
+        wrapped = wrap_segments(segments, max_w, scale)
+
+        wrapped.each do |line_segs|
+          vis = segments_visible_cells(line_segs, scale)
+          pad = [(width - vis) / 2, 0].max
+          @terminal.move_to(row, pad + 1)
+          @terminal.write "#{ANSI[:bold]}#{render_segments_scaled(line_segs, scale, default_face: face, default_h: 2)}#{ANSI[:reset]}"
+          row += scale
+        end
+        row + 4
       else
         left = content_left(width)
-        prefix = "・"
+        prefix = @theme.bullet
         prefix_w = display_width(prefix)
         max_w = max_text_width(width, left, DEFAULT_SCALE) - prefix_w
         segments = Parser.parse_inline(text)
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left)
           if li == 0
-            @terminal.write "#{KittyText.sized(prefix, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
+            @terminal.write "#{render_bullet(prefix)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           else
             @terminal.write "#{KittyText.sized(" " * prefix_w, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           end
@@ -112,7 +170,7 @@ module Przn
 
       max_w = max_text_width(width, left, scale)
       segments = Parser.parse_inline(text)
-      wrapped = wrap_segments(segments, max_w)
+      wrapped = wrap_segments(segments, max_w, scale)
 
       wrapped.each do |line_segs|
         @terminal.move_to(row, left + 1)
@@ -147,17 +205,17 @@ module Przn
       block[:items].each do |item|
         depth = item[:depth] || 0
         indent = "  " * depth
-        prefix = "#{indent}・"
+        prefix = "#{indent}#{@theme.bullet}"
         prefix_w = display_width(prefix)
         max_w = max_text_width(width, left, DEFAULT_SCALE) - prefix_w
 
         segments = Parser.parse_inline(item[:text])
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left)
           if li == 0
-            @terminal.write "#{KittyText.sized(prefix, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
+            @terminal.write "#{render_bullet(prefix)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           else
             @terminal.write "#{KittyText.sized(" " * prefix_w, s: DEFAULT_SCALE)}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}"
           end
@@ -178,7 +236,7 @@ module Przn
         max_w = max_text_width(width, left, DEFAULT_SCALE) - prefix_w
 
         segments = Parser.parse_inline(item[:text])
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left)
@@ -199,7 +257,7 @@ module Przn
       max_w = max_text_width(width, left, DEFAULT_SCALE)
 
       segments = Parser.parse_inline(block[:term])
-      wrapped = wrap_segments(segments, max_w)
+      wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
       wrapped.each do |line_segs|
         @terminal.move_to(row, left)
         @terminal.write "#{ANSI[:bold]}#{render_segments_scaled(line_segs, DEFAULT_SCALE)}#{ANSI[:reset]}"
@@ -209,7 +267,7 @@ module Przn
       def_max_w = [max_w - 4, 1].max
       block[:definition].each_line do |line|
         segments = Parser.parse_inline(line.chomp)
-        wrapped = wrap_segments(segments, def_max_w)
+        wrapped = wrap_segments(segments, def_max_w, DEFAULT_SCALE)
         wrapped.each do |line_segs|
           @terminal.move_to(row, left + 4)
           @terminal.write render_segments_scaled(line_segs, DEFAULT_SCALE)
@@ -228,7 +286,7 @@ module Przn
       block[:content].each_line do |line|
         text = line.chomp
         segments = [[:text, text]]
-        wrapped = wrap_segments(segments, max_w)
+        wrapped = wrap_segments(segments, max_w, DEFAULT_SCALE)
 
         wrapped.each_with_index do |line_segs, li|
           @terminal.move_to(row, left + 1)
@@ -303,14 +361,18 @@ module Przn
 
       x = [(width - target_cols) / 2, 0].max
 
-      if ImageUtil.kitty_terminal?
-        data = ImageUtil.kitty_icat(path, cols: target_cols, rows: target_rows, x: x, y: row - 1)
+      if ImageUtil.kitty_terminal? && ImageUtil.png?(path)
+        image_id = ensure_kitty_uploaded(path)
+        @terminal.move_to(row, x + 1)
+        @terminal.write ImageUtil.kitty_place(image_id: image_id, cols: target_cols, rows: target_rows)
+      elsif ImageUtil.kitty_terminal?
+        data = cached_kitty_icat(path, cols: target_cols, rows: target_rows, x: x, y: row - 1)
         @terminal.write data if data && !data.empty?
       elsif ImageUtil.sixel_available?
         @terminal.move_to(row, x + 1)
         target_pixel_w = target_cols * cell_w
         target_pixel_h = target_rows * cell_h
-        sixel = ImageUtil.sixel_encode(path, width: target_pixel_w, height: target_pixel_h)
+        sixel = cached_sixel_encode(path, width: target_pixel_w, height: target_pixel_h)
         @terminal.write sixel if sixel && !sixel.empty?
       end
 
@@ -322,6 +384,39 @@ module Przn
       File.expand_path(path, @base_dir)
     end
 
+    # Memoize the encoded escape-sequence bytes so revisiting a slide
+    # skips both the subprocess fork and the image decode/encode work.
+    # Keyed by file mtime so edits to the source image invalidate.
+    def cached_kitty_icat(path, cols:, rows:, x:, y:)
+      key = [:kitty, path, image_mtime(path), cols, rows, x, y]
+      return @image_cache[key] if @image_cache.key?(key)
+      @image_cache[key] = ImageUtil.kitty_icat(path, cols: cols, rows: rows, x: x, y: y)
+    end
+
+    def cached_sixel_encode(path, width:, height:)
+      key = [:sixel, path, image_mtime(path), width, height]
+      return @image_cache[key] if @image_cache.key?(key)
+      @image_cache[key] = ImageUtil.sixel_encode(path, width: width, height: height)
+    end
+
+    def image_mtime(path)
+      File.mtime(path).to_f
+    rescue Errno::ENOENT
+      nil
+    end
+
+    # Upload a PNG to the Kitty terminal once and return the assigned image
+    # id. Subsequent renders of the same file (same mtime) reuse the id and
+    # only emit a small placement command, skipping the file-transfer cost.
+    def ensure_kitty_uploaded(path)
+      key = [path, image_mtime(path)]
+      return @kitty_uploads[key] if @kitty_uploads.key?(key)
+
+      image_id = @kitty_uploads.size + 1
+      @terminal.write ImageUtil.kitty_upload_png(path, image_id: image_id)
+      @kitty_uploads[key] = image_id
+    end
+
     def content_left(width)
       width / 16
     end
@@ -364,7 +459,47 @@ module Przn
       end
     end
 
-    def render_segments_scaled(segments, para_scale)
+    # Render the list/heading bullet. When `bullet_size` is smaller than the
+    # body scale, use OSC 66 fractional scaling (n/d) with v=2 to keep the
+    # glyph's cell footprint at body scale but draw a smaller dot vertically
+    # centered. Plain `s=N` for a smaller bullet would top-align it inside
+    # the row, which looks wrong against the larger body text.
+    def render_bullet(prefix)
+      size = @theme.bullet_size
+      if size && size < DEFAULT_SCALE
+        KittyText.sized(prefix, s: DEFAULT_SCALE, n: size, d: DEFAULT_SCALE, v: 2)
+      else
+        KittyText.sized(prefix, s: size || DEFAULT_SCALE)
+      end
+    end
+
+    # Render a <font face="..." size="..." color="..."> run. The face goes out
+    # via OSC 66 f= (Echoes extension); the size resolves through the same
+    # SIZE_SCALES table that <size=N> uses; the color wraps in the same ANSI
+    # escape that <color=NAME> uses.
+    def render_font_segment(content, attrs, para_scale, default_face: nil, default_h: nil)
+      scale = (attrs[:size] && Parser::SIZE_SCALES[attrs[:size]]) || para_scale
+      base = KittyText.sized(content, s: scale, f: attrs[:face] || default_face, h: default_h)
+      color = attrs[:color]
+      return base unless color
+      "#{color_code(color)}#{base}#{ANSI[:reset]}"
+    end
+
+    # `default_face:` lets a caller (currently h1 rendering) override every
+    # OSC 66 emit's `f=` attribute. When unset, body text falls back to
+    # `theme.font.family`. To opt out of that body fallback (so a heading can
+    # render in the terminal's default font when its own `heading_face` is
+    # unset), pass `default_face:` explicitly — even `nil` is honored.
+    # Inline `<font face="...">` runs still win for their own segments.
+    #
+    # `default_h:` threads an OSC 66 `h=` (horizontal alignment) into every
+    # emit on the line. h1 uses h=2 so a proportional `heading_face` is
+    # centered within the reserved cell block — without it the glyphs left-
+    # align inside the block and the visible text drifts left of the center
+    # column we computed.
+    def render_segments_scaled(segments, para_scale, default_face: :body, default_h: nil)
+      f = default_face == :body ? @theme.font[:family] : default_face
+      h = default_h
       segments.map { |segment|
         type = segment[0]
         content = segment[1]
@@ -372,18 +507,19 @@ module Przn
         when :tag
           tag_name = segment[2]
           if (scale = Parser::SIZE_SCALES[tag_name])
-            KittyText.sized(content, s: scale)
+            KittyText.sized(content, s: scale, f: f, h: h)
           elsif Parser::NAMED_COLORS.key?(tag_name)
-            "#{color_code(tag_name)}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
+            "#{color_code(tag_name)}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}"
           else
-            KittyText.sized(content, s: para_scale)
+            KittyText.sized(content, s: para_scale, f: f, h: h)
           end
-        when :note          then "#{ANSI[:dim]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :bold          then "#{ANSI[:bold]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :italic        then "#{ANSI[:italic]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :strikethrough then "#{ANSI[:strikethrough]}#{KittyText.sized(content, s: para_scale)}#{ANSI[:reset]}"
-        when :code          then "#{ANSI[:gray_bg]}#{KittyText.sized(" #{content} ", s: para_scale)}#{ANSI[:reset]}"
-        when :text          then KittyText.sized(content, s: para_scale)
+        when :font          then render_font_segment(content, segment[2] || {}, para_scale, default_face: f, default_h: h)
+        when :note          then "#{ANSI[:dim]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}"
+        when :bold          then "#{ANSI[:bold]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}"
+        when :italic        then "#{ANSI[:italic]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}"
+        when :strikethrough then "#{ANSI[:strikethrough]}#{KittyText.sized(content, s: para_scale, f: f, h: h)}#{ANSI[:reset]}"
+        when :code          then "#{ANSI[:gray_bg]}#{KittyText.sized(" #{content} ", s: para_scale, f: f, h: h)}#{ANSI[:reset]}"
+        when :text          then KittyText.sized(content, s: para_scale, f: f, h: h)
         end
       }.join
     end
@@ -392,53 +528,92 @@ module Przn
       render_segments_scaled(Parser.parse_inline(text), para_scale)
     end
 
-    # Wrap parsed inline segments into lines that fit within max_width display units
-    def wrap_segments(segments, max_width)
+    # Wrap parsed inline segments into lines that fit within max_width units,
+    # where 1 unit = `para_scale` terminal cells. Per-segment scaling (e.g.
+    # size tags) is honored so a span with a larger scale consumes more budget.
+    def wrap_segments(segments, max_width, para_scale = DEFAULT_SCALE)
       return [segments] if max_width <= 0
 
+      max_cells = max_width * para_scale
       lines = [[]]
-      width = 0
+      used = 0
 
       segments.each do |seg|
         content = seg[1] || ""
-        seg_w = display_width(content)
+        next if content.empty?
+
+        seg_scale = effective_seg_scale(seg, para_scale)
+        seg_cells = display_width(content) * seg_scale
 
-        if width + seg_w <= max_width
+        if used + seg_cells <= max_cells
           lines.last << seg
-          width += seg_w
+          used += seg_cells
           next
         end
 
         remaining = content
         loop do
-          space = max_width - width
-          if space <= 0
+          space_cells = max_cells - used
+          if space_cells < seg_scale && used > 0
             lines << []
-            width = 0
-            space = max_width
+            used = 0
+            space_cells = max_cells
           end
 
-          chunk, remaining = split_by_display_width(remaining, space)
+          chunk_max_dw = [space_cells / seg_scale, 1].max
+          chunk, remaining = split_by_display_width(remaining, chunk_max_dw)
           lines.last << [seg[0], chunk, *Array(seg[2..])]
-          width += display_width(chunk)
+          used += display_width(chunk) * seg_scale
 
           break unless remaining
           lines << []
-          width = 0
+          used = 0
         end
       end
 
       lines
     end
 
+    def effective_seg_scale(seg, para_scale)
+      case seg[0]
+      when :tag
+        Parser::SIZE_SCALES[seg[2]] || para_scale
+      when :font
+        size = seg[2].is_a?(Hash) ? seg[2][:size] : nil
+        (size && Parser::SIZE_SCALES[size]) || para_scale
+      else
+        para_scale
+      end
+    end
+
+    def segments_visible_cells(segments, para_scale)
+      segments.sum { |seg|
+        content = seg[1] || ""
+        display_width(content) * effective_seg_scale(seg, para_scale)
+      }
+    end
+
+    # Split `text` so the first piece fits within `max_width` cells, preferring
+    # to break at the last whitespace before the overflow rather than mid-word.
+    # Falls back to a char-level split when no whitespace is available — single
+    # long words, CJK runs (no inter-character whitespace) — so a word that's
+    # itself longer than the line still wraps instead of overflowing.
     def split_by_display_width(text, max_width)
       w = 0
+      last_space = nil
       text.each_char.with_index do |c, i|
         cw = display_width(c)
         if w + cw > max_width && w > 0
-          return [text[0...i], text[i..]]
+          if c == ' '
+            return [text[0...i], text[(i + 1)..]]
+          elsif last_space && last_space > 0
+            return [text[0...last_space], text[(last_space + 1)..]]
+          else
+            return [text[0...i], text[i..]]
+          end
         end
         w += cw
+        last_space = i if c == ' '
       end
       [text, nil]
     end
@@ -511,6 +686,7 @@ module Przn
              (o >= 0xfe30 && o <= 0xfe6f) ||
              (o >= 0xff00 && o <= 0xff60) ||
              (o >= 0xffe0 && o <= 0xffe6) ||
+             (o >= 0x1f300 && o <= 0x1faff) ||  # emoji blocks; terminals render these as 2 cells
              (o >= 0x20000 && o <= 0x2fffd) ||
              (o >= 0x30000 && o <= 0x3fffd))
           2
@@ -529,6 +705,7 @@ module Przn
         .gsub(/\*(.+?)\*/, '\1')
         .gsub(/~~(.+?)~~/, '\1')
         .gsub(/`([^`]+)`/, '\1')
+        .gsub(/&(lt|gt|amp);/) { |_| {"lt" => "<", "gt" => ">", "amp" => "&"}[$1] }
     end
 
     def calculate_height(blocks, width)
@@ -572,6 +749,8 @@ module Przn
         image_block_height(block, width)
       when :align
         0
+      when :bg
+        0
       when :blank
         s
       else

data/lib/przn/terminal.rb

@@ -4,6 +4,8 @@ require 'io/console'
 
 module Przn
   class Terminal
+    MOUSE_OFF = "\e[?1006l\e[?1003l\e[?1002l\e[?1000l"
+
     def initialize(input: $stdin, output: $stdout)
       @in = input
       @out = output
@@ -45,9 +47,11 @@ module Przn
 
     def enter_alt_screen
       write "\e[?1049h"
+      write MOUSE_OFF
     end
 
     def leave_alt_screen
+      write MOUSE_OFF
       write "\e[?1049l"
     end
 

data/lib/przn/theme.rb

@@ -6,7 +6,7 @@ module Przn
   class Theme
     DEFAULT_PATH = File.expand_path('../../../default_theme.yml', __FILE__)
 
-    attr_reader :colors, :font
+    attr_reader :colors, :font, :bullet, :bullet_size, :bg, :heading_face
 
     def self.load(path)
       raise ArgumentError, "Theme file not found: #{path}" unless File.exist?(path)
@@ -16,6 +16,10 @@ module Przn
       merged = {
         colors: defaults[:colors].merge(overrides[:colors] || {}),
         font: defaults[:font].merge(overrides[:font] || {}),
+        bullet: overrides[:bullet] || defaults[:bullet],
+        bullet_size: overrides[:bullet_size] || defaults[:bullet_size],
+        bg: defaults[:bg].merge(overrides[:bg] || {}),
+        heading_face: overrides[:heading_face] || defaults[:heading_face],
       }
       new(merged)
     end
@@ -29,6 +33,10 @@ module Przn
       {
         colors: data[:colors] || {},
         font: data[:font] || {},
+        bullet: data[:bullet],
+        bullet_size: data[:bullet_size],
+        bg: (data[:bg] || {}).compact,
+        heading_face: data[:heading_face],
       }
     end
     private_class_method :load_yaml
@@ -36,6 +44,10 @@ module Przn
     def initialize(config)
       @colors = config[:colors]
       @font = config[:font]
+      @bullet = config[:bullet]
+      @bullet_size = config[:bullet_size]
+      @bg = config[:bg]
+      @heading_face = config[:heading_face]
     end
   end
 end

data/lib/przn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Przn
-  VERSION = "0.1.6"
+  VERSION = "0.2.0"
 end

data/lib/przn.rb

@@ -15,9 +15,10 @@ require_relative "przn/theme"
 module Przn
   class Error < StandardError; end
 
-  def self.start(file, theme: nil)
+  def self.start(file, theme: nil, start_at: nil)
     markdown = File.read(file)
     presentation = Parser.parse(markdown)
+    presentation.go_to(start_at - 1) if start_at
     terminal = Terminal.new
     base_dir = File.dirname(File.expand_path(file))
     renderer = Renderer.new(terminal, base_dir: base_dir, theme: theme)

metadata

@@ -1,76 +1,79 @@
 --- !ruby/object:Gem::Specification
 name: przn
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
-- Akira Matsuda
+  - Akira Matsuda
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: prawn
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: A terminal-based presentation tool that renders Markdown slides with
-  Kitty text sizing protocol support for beautifully scaled headers
+  - !ruby/object:Gem::Dependency
+    name: prawn
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+    type: :runtime
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+description: A terminal-based presentation tool that renders Markdown slides with Kitty text sizing protocol support for beautifully scaled headers
 email:
-- ronnie@dio.jp
+  - ronnie@dio.jp
 executables:
-- przn
+  - przn
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE.txt
-- README.md
-- Rakefile
-- default_theme.yml
-- exe/przn
-- lib/przn.rb
-- lib/przn/controller.rb
-- lib/przn/image_util.rb
-- lib/przn/kitty_text.rb
-- lib/przn/parser.rb
-- lib/przn/pdf_exporter.rb
-- lib/przn/presentation.rb
-- lib/przn/renderer.rb
-- lib/przn/slide.rb
-- lib/przn/terminal.rb
-- lib/przn/theme.rb
-- lib/przn/version.rb
-- sample/sample.md
-- sig/przn.rbs
-homepage: https://github.com/amatsuda/przn
+  - LICENSE.txt
+  - README.md
+  - Rakefile
+  - default_theme.yml
+  - exe/przn
+  - lib/przn.rb
+  - lib/przn/controller.rb
+  - lib/przn/image_util.rb
+  - lib/przn/kitty_text.rb
+  - lib/przn/parser.rb
+  - lib/przn/pdf_exporter.rb
+  - lib/przn/presentation.rb
+  - lib/przn/renderer.rb
+  - lib/przn/slide.rb
+  - lib/przn/terminal.rb
+  - lib/przn/theme.rb
+  - lib/przn/version.rb
+  - sample/sample.md
+  - sig/przn.rbs
+homepage: "https://github.com/amatsuda/przn"
 licenses:
-- MIT
+  - MIT
 metadata:
-  allowed_push_host: https://rubygems.org
-  source_code_uri: https://github.com/amatsuda/przn
-  homepage_uri: https://github.com/amatsuda/przn
+  allowed_push_host: "https://rubygems.org"
+  source_code_uri: "https://github.com/amatsuda/przn"
+  homepage_uri: "https://github.com/amatsuda/przn"
 rdoc_options: []
 require_paths:
-- lib
+  - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+    -
+      - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
 requirements: []
 rubygems_version: 4.1.0.dev
 specification_version: 4