przn 0.1.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c6b2f14ade1a9803cb8d50af8ea637db4cc4455bd07c4274acadef61c0c24d4
-  data.tar.gz: 3cf2e893b448133d50c7d4283838d521b06ed1e9d129ea620e799925edfe0284
+  metadata.gz: b33677433cd4802ee75ef9d7eb821d2dbb6faf8b1d2364d535b6aa28bffa6eb3
+  data.tar.gz: 930ecad39096eea771759134cd6c7e4a83c55a00ae98c59ead5afea1dcc46f17
 SHA512:
-  metadata.gz: 0b0b41885598b6176fa0de0363f683ded12937a0f0365462fbfb9cffeb867f7c126dadaaecc93244b20e9ceebf94a7d582c076080176d40f7486a28d4792fc66
-  data.tar.gz: 814096bacf4013f4b225b30615176dc2579199bce5c08b8bfa718b00407c28c14a7e8b06958808e24a28b04dd4762c46d6baca8b1340ee2074e48f968c0a2b3e
+  metadata.gz: 08eafdea3c2f55a29ccfd879b3bfa1541576be74fbb042cc33c527e39289e3dcf1375a10df033820e37f69e9f6726f580cd19ae468d633d73c9d65a23736674b
+  data.tar.gz: fcbf194e2a090de86a823fd8a0076977db73cf69f857cea6f4406f9fe31c2f44dab60120d61dbda7f10545e2fd750089df8e34233f0808fefd096bcec3cc25e1

data/README.md

@@ -15,15 +15,30 @@ 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
 
+Two flavors:
+
 ```
-przn --export your_slides.md
+przn --export your_slides.md                       # vector capture (default)
 przn --export pdf your_slides.md
 przn --export pdf -o output.pdf your_slides.md
+
+przn --export prawn your_slides.md                 # Prawn (headless fallback)
+przn --export prawn -o output.pdf your_slides.md
 ```
 
-Requires a TrueType font (with `glyf` outlines) for proper rendering. Prawn does not support CFF-based fonts (most `.otf` files). Fonts are auto-detected in this order: NotoSansJP TTF, HackGen, Arial Unicode.
+**`--export pdf`** (default) drives the live renderer for each slide and asks the terminal to save the rendered pane as a one-page **vector PDF**, then concatenates the per-slide PDFs into a single multi-page PDF. Output is an exact match of what's on screen — gradients, proportional fonts, OSC 66 sized text, custom bullets, all show up exactly as you'd see them — but vector, so the file stays small, scales infinitely, and text remains selectable. Requires running inside a terminal that implements the OSC 7772 `capture` command to a `.pdf` path (currently [Echoes](https://github.com/amatsuda/echoes)). The slides flicker through the visible pane during export.
+
+**`--export prawn`** is the headless fallback: it renders the deck directly into a vector PDF via Prawn, without touching the terminal. Useful for CI or environments where Echoes isn't available, but diverges from the on-screen rendering for any feature the live renderer adds (OSC 66 sized text, OSC 7772 backgrounds, proportional fonts). Requires a TrueType font (with `glyf` outlines) for proper rendering — Prawn does not support CFF-based fonts (most `.otf` files). Fonts are auto-detected in this order: NotoSansJP TTF, HackGen, Arial Unicode.
 
 ### Key bindings
 
@@ -35,6 +50,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 +81,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 +146,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 +191,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 +230,75 @@ 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
+
+Theme resolution:
+
+1. **`theme.yml` in the deck's directory** — loaded automatically if present. No flag needed.
+2. **`--theme path/to/your.yml`** — overrides step 1 with any other file you point to.
+3. **`default_theme.yml`** (the file bundled with the gem) — used when neither of the above is found.
+
+All keys are optional — anything you don't set falls back to the bundled defaults.
+
+```yaml
+font:
+  family:                 # body text font; terminal: OSC 66 f=, PDF: Prawn font
+  size: 18                # base PDF font size in pt
+  color:                  # body text color; named ANSI or 6-digit hex
+
+title:                    # h1 typography (slide titles)
+  family:                 # font family
+  size:                   # OSC 66 scale: numeric (1–7) or named (xx-small … xxxx-large); default x-large
+  color:                  # named ANSI or 6-digit hex
+
+bullet:                   # unordered-list marker; also h2–h6 prefix
+  text: "・"              # the glyph
+  size:                   # OSC 66 scale (1–7) for the bullet; default = body text's scale
+
+background:               # default slide background (Echoes OSC 7772)
+  color:                  # solid, e.g. "#1a1a2e"
+  from:                   # gradient endpoint
+  to:                     # gradient endpoint
+  angle:                  # gradient angle in degrees
+
+colors:
+  code_bg: "313244"
+  dim: "6c7086"
+  inline_code: "a6e3a1"
+```
+
+Notes:
+
+- **`font.color`** — deck-wide default text color (terminal: ANSI fg; PDF: Prawn fg). Inline `<color=...>` / `<font color="...">` runs still win per-segment.
+- **`bullet`** — `bullet.text` is the character; `bullet.size` is the OSC 66 scale used to render it. When `bullet.size` is 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.
+- **`title`** — h1 typography. Each attribute is independent from `font`: `title.family` does **not** inherit `font.family`, `title.color` does **not** inherit `font.color`. `title.size` defaults to x-large (OSC 66 `s=4`). When `title.family` 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. h2–h6 stay body text.
+- **`background`** — the deck-wide default background. A per-slide `<bg .../>` directive overrides it for that slide. The Prawn fallback paints the PDF page in `background.color` when set; otherwise it leaves the page Prawn's default (white).
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/default_theme.yml

@@ -1,16 +1,35 @@
-# Default przn theme
+# Default przn theme. Used when there's neither a `theme.yml` alongside the
+# deck nor a `--theme path/to/file.yml` flag.
 #
-# Copy this file and pass your copy via --theme to customize.
+# To customize: drop a `theme.yml` next to your deck (loaded automatically),
+# or pass `--theme path/to/your.yml` to override that.
 # All keys are optional — unspecified values fall back to these defaults.
 
+font:
+  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
+  color:                # body text color (terminal: ANSI fg, PDF: Prawn fg); named ANSI or 6-digit hex
+
+title:                  # h1 typography (slide titles); each attribute is independent of `font`
+  family:               # font family (terminal: OSC 66 f=, requires Echoes)
+  size:                 # OSC 66 scale: numeric (1–7) or named (xx-small … xxxx-large); default x-large (4)
+  color:                # named ANSI or 6-digit hex; falls back to the terminal's default fg when unset
+
+bullet:                 # unordered-list marker; also h2–h6 heading prefix
+  text: "・"            # the glyph
+  size:                 # OSC 66 scale (1–7) for the bullet; default = body text's scale
+
+# 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.
+background:
+  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"
+
 colors:
-  background: "000000"
-  foreground: "ffffff"
-  heading:              # falls back to foreground
   code_bg: "313244"
   dim: "6c7086"
   inline_code: "a6e3a1"
-
-font:
-  family:               # auto-detect
-  size: 18              # base font size in pt for PDF export

data/exe/przn

@@ -8,7 +8,7 @@ require 'optparse'
 options = {}
 OptionParser.new do |opts|
   opts.banner = "Usage: przn [options] <presentation.md>"
-  opts.on('--export [FORMAT]', 'Export to a format (default: pdf)') { |v|
+  opts.on('--export [FORMAT]', 'Export to a format (pdf | prawn; default: pdf)') { |v|
     if v && v.end_with?('.md')
       ARGV.unshift(v)
       options[:export] = 'pdf'
@@ -28,17 +28,33 @@ 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
 
-theme = options[:theme] ? Przn::Theme.load(options[:theme]) : nil
+theme = if options[:theme]
+  Przn::Theme.load(options[:theme])
+else
+  Przn::Theme.auto_discover(near: file)
+end
 
-if options[:export] == 'pdf'
+case options[:export]
+when 'pdf'
   output = options[:output] || File.basename(file, File.extname(file)) + '.pdf'
   Przn.export_pdf(file, output, theme: theme)
+when 'prawn'
+  output = options[:output] || File.basename(file, File.extname(file)) + '.pdf'
+  Przn.export_pdf_prawn(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

@@ -55,12 +55,11 @@ module Przn
       @presentation = presentation
       @base_dir = base_dir
       @theme = theme || Theme.default
-      @bg_color = @theme.colors[:background]
-      @fg_color = @theme.colors[:foreground]
+      @bg_color = @theme.background && @theme.background[:color]
+      @fg_color = @theme.font[:color] || "000000"
       @code_bg = @theme.colors[:code_bg]
       @dim_color = @theme.colors[:dim]
       @inline_code_color = @theme.colors[:inline_code]
-      @heading_color = @theme.colors[:heading] || @fg_color
       base = (@theme.font[:size] || DEFAULT_FONT_SIZE).to_f
       ratio = base / DEFAULT_FONT_SIZE
       @scale_to_pt = DEFAULT_SCALE_TO_PT.transform_values { |v| v * ratio }
@@ -127,6 +126,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
@@ -237,6 +287,8 @@ module Przn
     end
 
     def draw_background(pdf)
+      return unless @bg_color
+
       pdf.canvas do
         pdf.fill_color @bg_color
         pdf.fill_rectangle [0, PAGE_HEIGHT], PAGE_WIDTH, PAGE_HEIGHT
@@ -270,7 +322,7 @@ module Przn
         y - h - heading_margin(pt)
       else
         pt = @scale_to_pt[DEFAULT_SCALE]
-        prefix = [{text: bullet, size: pt, color: @heading_color, styles: [:bold]}]
+        prefix = [{text: bullet, size: pt, color: @fg_color, styles: [:bold]}]
         formatted = prefix + build_formatted_text(text, pt)
         h = render_formatted(pdf, formatted, at: [margin_x, y], width: content_width)
         y - h - 4
@@ -455,6 +507,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 +609,7 @@ module Przn
     end
 
     def bullet
-      @font_registered ? "\u30FB" : "-"
+      @font_registered ? @theme.bullet[:text] : "-"
     end
 
   end