stationery 0.9.0 → 0.10.0

data/lib/stationery/rich/nodes.rb

@@ -4,7 +4,9 @@ module Stationery
   # The block model rich-text parsers (HTML, Markdown) produce and elements render.
   module Rich
     # A run of text with its marks: any of bold:, italic:, underline:, strike:, code:, link: (href),
-    # script: (:sub/:sup) and break: true, a hard line break whose text is "".
+    # script: (:sub/:sup), color: (a colour), size: (points), scale: (a factor of the text size)
+    # and break: true, a hard line break whose text is "". A false bold:, italic:, underline: or
+    # strike: switches the mark off inside an element that has it.
     Inline = Data.define(:text, :marks) do
       def self.break = new(text: "", marks: { break: true })
 
@@ -12,15 +14,39 @@ module Stationery
       def break? = marks[:break] == true
     end
 
-    Paragraph = Data.define(:inlines)
-    Heading = Data.define(:level, :inlines)
-    List = Data.define(:ordered, :start, :items)
-    Blockquote = Data.define(:blocks)
-    CodeBlock = Data.define(:text, :language)
+    # Every block carries a `style` Hash from the source's CSS (see HTML::Css):
+    # align:, background:, padding:, margin:/margin_top:/margin_bottom:,
+    # border:, width:, break_before:, break_after:, keep_together:. Empty
+    # for Markdown and for HTML without styles.
+    Paragraph = Data.define(:inlines, :style) do
+      def initialize(inlines:, style: {}) = super
+    end
+    Heading = Data.define(:level, :inlines, :style) do
+      def initialize(level:, inlines:, style: {}) = super
+    end
+    List = Data.define(:ordered, :start, :items, :style) do
+      def initialize(ordered:, start:, items:, style: {}) = super
+    end
+    Blockquote = Data.define(:blocks, :style) do
+      def initialize(blocks:, style: {}) = super
+    end
+    CodeBlock = Data.define(:text, :language, :style) do
+      def initialize(text:, language:, style: {}) = super
+    end
     Rule = Data.define
-    Table = Data.define(:rows)
-    Cell = Data.define(:header, :align, :blocks)
-    Image = Data.define(:src, :alt, :width, :height)
+    Table = Data.define(:rows, :style) do
+      def initialize(rows:, style: {}) = super
+    end
+    Cell = Data.define(:header, :align, :blocks, :style) do
+      def initialize(header:, align:, blocks:, style: {}) = super
+    end
+    Image = Data.define(:src, :alt, :width, :height, :style) do
+      def initialize(src:, alt:, width:, height:, style: {}) = super
+    end
+    # A styled container (a `div` with a background, padding, margins or a
+    # page-break rule) holding blocks; an unstyled one flattens into its parent.
+    Container = Data.define(:blocks, :style)
+    PageBreak = Data.define
 
     # Operations on inline sequences shared by the parsers.
     module Inlines
@@ -42,12 +68,12 @@ module Stationery
       end
 
       # Groups inlines into paragraphs, with each image standing as a block between them.
-      def paragraphs(items)
+      def paragraphs(items, style: {})
         items.chunk_while { |a, b| !a.is_a?(Image) && !b.is_a?(Image) }.filter_map do |run|
           next run.first if run.first.is_a?(Image)
 
           inlines = merge(block_given? ? yield(run) : run)
-          Paragraph.new(inlines:) unless inlines.empty?
+          Paragraph.new(inlines:, style:) unless inlines.empty?
         end
       end
     end

data/lib/stationery/rich/renderer/boxes.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Rich
+    class Renderer
+      # What a block's CSS style becomes around the block: margins as spacers,
+      # a background and padding as a box, page-break rules as page breaks and
+      # kept-together groups, borders and widths as table options.
+      module Boxes
+        PADDING = { padding_top: 0, padding_right: 1, padding_bottom: 2, padding_left: 3 }.freeze
+
+        private
+
+        # Draws the block inside its margins and its box. A block styled with
+        # nothing but an alignment draws as it is.
+        def styled(style, &)
+          return yield if style.empty?
+
+          spaced(style) { boxed(style, &) }
+        end
+
+        # Page breaks and margins around the block, and the rule that keeps it
+        # on one page.
+        def spaced(style)
+          return yield unless spacing?(style)
+
+          top, bottom = margins(style)
+          @component.page_break if style[:break_before]
+          @component.group(keep_together: style[:keep_together] == true) do
+            @component.spacer(top) if top.positive?
+            yield
+            @component.spacer(bottom) if bottom.positive?
+          end
+          @component.page_break if style[:break_after]
+        end
+
+        def spacing?(style)
+          style[:break_before] || style[:break_after] || style[:keep_together] || margins(style).any?(&:positive?)
+        end
+
+        def margins(style)
+          all = style[:margin]
+          [style[:margin_top] || all&.[](0) || 0, style[:margin_bottom] || all&.[](2) || 0]
+        end
+
+        def boxed(style, &)
+          options = box_options(style)
+          options.empty? ? yield : @component.box(**options, &)
+        end
+
+        # The background and padding a style gives a box, to merge over a
+        # block's own (`styles[:blockquote]`, `styles[:pre]`).
+        def box_options(style)
+          options = {}
+          options[:background] = style[:background] if style[:background]
+          padding = padding_of(style)
+          options[:padding] = padding if padding
+          options
+        end
+
+        def padding_of(style)
+          sides = PADDING.select { |key, _| style[key] }
+          return style[:padding] if sides.empty?
+
+          padding = (style[:padding] || [0, 0, 0, 0]).dup
+          sides.each { |key, index| padding[index] = style[key] }
+          padding
+        end
+
+        def aligned(style) = style[:align] ? { align: style[:align] } : {}
+
+        def border_options(border)
+          return {} unless border
+          return { borders: [] } if border[:width].zero?
+
+          { border_width: border[:width], border_color: border[:color] }
+        end
+
+        def cell_options(style)
+          options = border_options(style[:border]).merge(box_options(style))
+          options[:borders] = %i[top right bottom left] if options[:border_width]
+          options
+        end
+
+        # Column widths from the first row, when every cell of it has one. A
+        # percentage is a share of the table, which then takes the full width
+        # unless it has a width of its own.
+        def column_widths(table)
+          widths = table.rows.first.map { |cell| cell.style[:width] }
+          return {} unless widths.all?
+
+          widths.any? { |width| fraction?(width) } && !table.style[:width] ? { widths:, width: :full } : { widths: }
+        end
+
+        # A table's own width: points, the full width for 100%, or a share of
+        # the space through a box of that width.
+        def sized(width)
+          return yield({}) unless width
+          return yield({ width: }) unless fraction?(width)
+          return yield({ width: :full }) if width >= 1
+
+          @component.box(width:) { yield({ width: :full }) }
+        end
+
+        def fraction?(value) = value.is_a?(Float) && value <= 1
+      end
+    end
+  end
+end

data/lib/stationery/rich/renderer/indents.rb

@@ -30,6 +30,7 @@ module Stationery
           blocks.map do |block|
             case block
             when Blockquote then 1 + indents_of(block.blocks)
+            when Container then indents_of(block.blocks)
             when List then 1 + (block.items.map { |item| indents_of(item) }.max || 0)
             when Table then block.rows.flatten.map { |cell| indents_of(cell.blocks) }.max || 0
             else 0

data/lib/stationery/rich/renderer/inlines.rb

@@ -15,8 +15,12 @@ module Stationery
           font: ->(value) { [:font, value] if value }
         }.freeze
 
+        # A true mark switches the style on, a false one (from CSS) switches it off again.
         MARK_STEPS = {
-          bold: [[:b]], italic: [[:i]], underline: [[:u]], strike: [[:strikethrough]]
+          bold: { true => [[:b]], false => [[:with, { weight: :regular }]] },
+          italic: { true => [[:i]], false => [[:with, { style: :normal }]] },
+          underline: { true => [[:u]], false => [[:with, { underline: false }]] },
+          strike: { true => [[:strikethrough]], false => [[:with, { strikethrough: false }]] }
         }.freeze
 
         def initialize(runs, styles, links = Links.new(:all, nil))
@@ -50,7 +54,10 @@ module Stationery
           when :link then [[:link, value], *style_steps(@styles[:a])]
           when :code then style_steps(@styles[:code])
           when :script then [[value]]
-          else MARK_STEPS.fetch(mark, [])
+          when :color then [[:color, value]]
+          when :size then [[:size, value]]
+          when :scale then [[:scale, value]]
+          else MARK_STEPS.dig(mark, value) || []
           end
         end
 

data/lib/stationery/rich/renderer.rb

@@ -5,6 +5,7 @@ require_relative "styles"
 require_relative "renderer/indents"
 require_relative "renderer/inlines"
 require_relative "renderer/links"
+require_relative "renderer/boxes"
 
 module Stationery
   module Rich
@@ -12,9 +13,12 @@ module Stationery
     # `images:` (a callable given the src, returning a path, an IO or nil) or
     # from files under `base_path:`; remote URLs are never fetched. Block
     # quotes and lists nested deeper than Indents::LIMIT stop indenting, which
-    # is reported as a NestingLimit warning.
+    # is reported as a NestingLimit warning. A block's `style` (from the
+    # source's CSS) adds margins, a box, an alignment or a page break around
+    # what `styles:` draws; a block without one draws exactly as before.
     class Renderer
       include Indents
+      include Boxes
 
       REMOTE = /\A[a-z][a-z0-9+.-]*:/i
       LINK_SCHEMES = %w[http https mailto tel].freeze
@@ -43,14 +47,16 @@ module Stationery
 
       def block(block)
         case block
-        when Paragraph then paragraph(block.inlines, **@styles[:p])
-        when Heading then heading(block)
-        when List then indented(block) { list(block) }
-        when Blockquote then indented(block) { blockquote(block) }
-        when CodeBlock then code(block)
+        when Paragraph then styled(block.style) { paragraph(block.inlines, **@styles[:p], **aligned(block.style)) }
+        when Heading then styled(block.style) { heading(block) }
+        when List then styled(block.style) { indented(block) { list(block) } }
+        when Blockquote then spaced(block.style) { indented(block) { blockquote(block) } }
+        when CodeBlock then spaced(block.style) { code(block) }
         when Rule then @component.rule(**@styles[:hr])
-        when Table then table(block)
+        when Table then styled(block.style.except(:border, :width)) { table(block) }
         when Image then image(block)
+        when Container then styled(block.style) { group(block.blocks) }
+        when PageBreak then @component.page_break
         end
       end
 
@@ -62,7 +68,8 @@ module Stationery
         style = @styles[:"h#{heading.level}"]
         size = style[:size] || (@builder.style.size * style.fetch(:scale, 1))
         bookmark = heading_bookmark(heading)
-        paragraph(heading.inlines, **style.except(:scale), size:, heading: heading.level, **({ bookmark: } if bookmark))
+        paragraph(heading.inlines, **style.except(:scale), size:, heading: heading.level,
+                                                           **aligned(heading.style), **({ bookmark: } if bookmark))
       end
 
       def heading_bookmark(heading)
@@ -72,7 +79,7 @@ module Stationery
       end
 
       def blockquote(quote)
-        @component.box(role: :blockquote, **@styles[:blockquote]) { group(quote.blocks) }
+        @component.box(role: :blockquote, **@styles[:blockquote], **box_options(quote.style)) { group(quote.blocks) }
       end
 
       def list(list)
@@ -86,18 +93,23 @@ module Stationery
 
       def code(block)
         font = @styles[:code][:font]
-        @component.box(**@styles[:pre]) { @component.text(block.text, **({ font: } if font)) }
+        @component.box(**@styles[:pre], **box_options(block.style)) do
+          @component.text(block.text, **({ font: } if font))
+        end
       end
 
       def table(table)
         header = table.rows.first&.all?(&:header) ? 1 : 0
         rows = table.rows.map { |row| row.map { |cell| cell_content(cell) } }
-        @component.table(rows, header:, cell: @styles[:table][:cell])
+        cell = @styles[:table][:cell].merge(border_options(table.style[:border]))
+        sized(table.style[:width]) { |width| @component.table(rows, header:, cell:, **width, **column_widths(table)) }
       end
 
       def cell_content(cell)
         style = cell.header ? @styles[:table][:header] : {}
-        -> { @component.text_style(**style, align: cell.align) { group(cell.blocks) } }
+        content = -> { @component.text_style(**style, align: cell.align) { group(cell.blocks) } }
+        options = cell_options(cell.style)
+        options.empty? ? content : { content:, **options }
       end
 
       def image(node)
@@ -105,7 +117,7 @@ module Stationery
         return unless source
 
         loaded = Images.load(source)
-        @component.image(loaded, alt: node.alt, **dimensions(node, loaded))
+        @component.image(loaded, alt: node.alt, **aligned(node.style), **dimensions(node, loaded))
       rescue UnsupportedImage => e
         skip(node.src, e.message)
       end
@@ -121,9 +133,14 @@ module Stationery
         File.file?(path) ? path : skip(src, "not found")
       end
 
+      # A CSS width wins over the width and height attributes (the height
+      # then follows the aspect ratio); a percentage is a share of the space.
       def dimensions(node, loaded)
-        width = node.width
-        height = node.height
+        styled = node.style[:width]
+        return { width: styled } if fraction?(styled)
+
+        width = styled || node.width
+        height = styled ? nil : node.height
         limit = @styles[:img][:max_width]
         natural = width || (height ? loaded.width * height.fdiv(loaded.height) : loaded.width)
         return { width:, height: } unless limit && natural > limit

data/lib/stationery/svg/style.rb

@@ -2,6 +2,9 @@
 
 module Stationery
   module SVG
+    Selector = CSS::Selector
+    Stylesheet = CSS::Stylesheet
+
     # Presentation attributes an element inherits from its ancestors, and the
     # transform it draws with. An element's own values cascade: presentation
     # attributes, then stylesheet rules, then its inline `style`. `color` sets
@@ -27,12 +30,7 @@ module Stationery
         NAMED.fetch(value.downcase, value)
       end
 
-      def self.declarations(style)
-        style.to_s.split(";").filter_map do |declaration|
-          key, value = declaration.split(":", 2).map(&:strip)
-          [key, value] if key && value
-        end.to_h
-      end
+      def self.declarations(style) = CSS.declarations(style)
 
       attr_reader :values, :matrix, :color
 

data/lib/stationery/testing/inspector.rb

@@ -12,6 +12,8 @@ module Stationery
     # Needs the pdf-reader gem, loaded on first use.
     class Inspector
       UTF16_BOM = "\xFE\xFF".b
+      # id-aa-signatureTimeStampToken: a signature's RFC 3161 timestamp.
+      TIMESTAMP_TOKEN = "1.2.840.113549.1.9.16.2.14"
       XMP_PROPERTY = %r{^\s*<((?!rdf:)[\w.-]+:[\w.-]+)>(.*?)</\1>$}
       XMP_ITEM = %r{<rdf:li[^>]*>(.*?)</rdf:li>}
       XMP_ENTITIES = { "&amp;" => "&", "&lt;" => "<", "&gt;" => ">", "&quot;" => '"' }.freeze
@@ -134,10 +136,13 @@ module Stationery
       end
 
       # Every signed signature field: `{ field:, name:, reason:, location:,
-      # signed_at:, subfilter:, byte_range:, signer:, valid: }`. `signer` is
-      # the signing certificate's subject ("CN=…,O=…"). `valid` is whether
-      # the signature covers the whole file and verifies against the
+      # signed_at:, subfilter:, byte_range:, signer:, valid:, timestamp: }`.
+      # `signer` is the signing certificate's subject ("CN=…,O=…"). `valid` is
+      # whether the signature covers the whole file and verifies against the
       # certificate it carries; the certificate's own trust is not judged.
+      # `timestamp` is nil, or `{ time:, tsa:, valid: }` for the RFC 3161 token
+      # a signature carries: `valid` when the token is over this signature
+      # and verifies against the TSA certificate it carries.
       def signatures
         form = catalog[:AcroForm]
         return [] unless form
@@ -207,13 +212,51 @@ module Stationery
       # parsed dictionary: it is the one string encryption leaves alone.
       def verdict(range)
         contents = pdf.byteslice(range[1], range[2] - range[1]).to_s
-        cms = OpenSSL::PKCS7.new(PDF::Signature.der([contents[1..-2]].pack("H*")))
+        der = PDF::Signature.der([contents[1..-2]].pack("H*"))
+        cms = OpenSSL::PKCS7.new(der)
         signed = pdf.byteslice(range[0], range[1]) + pdf.byteslice(range[2], range[3])
         flags = OpenSSL::PKCS7::NOVERIFY | OpenSSL::PKCS7::BINARY
         whole = range[0].zero? && range[2] + range[3] == pdf.bytesize && contents.start_with?("<")
-        { signer: signer(cms), valid: whole && cms.verify([], OpenSSL::X509::Store.new, signed, flags) }
+        { signer: signer(cms), valid: whole && cms.verify([], OpenSSL::X509::Store.new, signed, flags),
+          timestamp: timestamp(der) }
       rescue OpenSSL::OpenSSLError, ArgumentError, TypeError
-        { signer: nil, valid: false }
+        { signer: nil, valid: false, timestamp: nil }
+      end
+
+      # The timestamp token among the first SignerInfo's unsigned attributes,
+      # judged against that SignerInfo's signature value; nil without one.
+      def timestamp(der)
+        info = OpenSSL::ASN1.decode(der).value[1].value[0].value[4].value[0].value
+        unsigned = info[6..].to_a.find { |item| item.tag == 1 && item.tag_class == :CONTEXT_SPECIFIC }
+        attribute = unsigned&.value&.find { |one| one.value[0].oid == TIMESTAMP_TOKEN }
+        attribute && timestamp_verdict(attribute.value[1].value.first, info[5].value)
+      end
+
+      # The token verified as a TimeStampResp would be, against the signature
+      # value it should cover. The certificates it carries are the trust
+      # anchors (a TSA sends its chain, often without the root), so this
+      # says the token is sound, not that the TSA is one to trust.
+      def timestamp_verdict(token, signature)
+        granted = OpenSSL::ASN1::Sequence.new([OpenSSL::ASN1::Integer.new(0)])
+        response = OpenSSL::Timestamp::Response.new(OpenSSL::ASN1::Sequence.new([granted, token]).to_der)
+        info = response.token_info
+        covers = info.message_imprint == OpenSSL::Digest.digest(info.algorithm, signature)
+        { time: info.gen_time, tsa: signer(response.token), valid: covers && timestamp_verifies?(response) }
+      end
+
+      def timestamp_verifies?(response)
+        info = response.token_info
+        request = OpenSSL::Timestamp::Request.new
+        request.algorithm = info.algorithm
+        request.message_imprint = info.message_imprint
+        request.nonce = info.nonce if info.nonce
+        store = OpenSSL::X509::Store.new
+        store.flags = OpenSSL::X509::V_FLAG_PARTIAL_CHAIN
+        response.token.certificates.to_a.each { |certificate| store.add_cert(certificate) }
+        response.verify(request, store)
+        true
+      rescue OpenSSL::OpenSSLError
+        false
       end
 
       def signer(cms)

data/lib/stationery/text/breaks.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Text
+    # Where a line may break inside a word: between two ideographic
+    # characters (UAX #14 class ID: CJK ideographs, kana, Hangul, fullwidth
+    # forms), never before a closing mark or a character that must not start
+    # a line (、。」ー and the small kana: classes CL, CP, EX and NS), never
+    # after an opening bracket (「（: class OP). A word is cut into units at
+    # those points; Latin text stays one unit, so its breaking is unchanged.
+    module Breaks
+      ZERO_WIDTH_SPACE = "​"
+
+      IDEOGRAPHIC = [
+        0x1100..0x11FF,   # Hangul Jamo
+        0x2E80..0x2FDF,   # CJK radicals
+        0x3005..0x3007,   # 々 〆 〇
+        0x3021..0x3029,   # Hangzhou numerals
+        0x3031..0x3035,   # kana repeat marks
+        0x3038..0x303C,
+        0x3041..0x309A,   # Hiragana (the small kana are taken out below)
+        0x30A1..0x30FA,   # Katakana
+        0x3100..0x312F,   # Bopomofo
+        0x3130..0x318F,   # Hangul compatibility Jamo
+        0x3190..0x31FF,   # Kanbun, Bopomofo extended, CJK strokes, Katakana phonetic extensions
+        0x3200..0x33FF,   # enclosed CJK, CJK compatibility
+        0x3400..0x4DBF,   # CJK extension A
+        0x4E00..0x9FFF,   # CJK unified ideographs
+        0xA000..0xA4CF,   # Yi
+        0xA960..0xA97F,   # Hangul Jamo extended A
+        0xAC00..0xD7AF,   # Hangul syllables
+        0xF900..0xFAFF,   # CJK compatibility ideographs
+        0xFE30..0xFE4F,   # CJK compatibility forms
+        0xFF10..0xFF19,   # fullwidth digits
+        0xFF21..0xFF3A, 0xFF41..0xFF5A, # fullwidth Latin
+        0xFF66..0xFF6F, 0xFF71..0xFF9D, # halfwidth Katakana (ｰ and the small ones are NS)
+        0x1B000..0x1B16F, # Kana supplement and extended
+        0x20000..0x3134F  # CJK extensions B–G
+      ].freeze
+
+      # Never at the start of a line: closing brackets and quotes, sentence
+      # and clause punctuation, prolonged sound and iteration marks, small kana.
+      CLOSING = [
+        0x3001..0x3003, 0x3009, 0x300B, 0x300D, 0x300F, 0x3011, 0x3015, 0x3017, 0x3019, 0x301B, 0x301C,
+        0x301F, 0x303B, 0x309B..0x309E, 0x30A0, 0x30FB..0x30FE,
+        0x3041, 0x3043, 0x3045, 0x3047, 0x3049, 0x3063, 0x3083, 0x3085, 0x3087, 0x308E, 0x3095, 0x3096,
+        0x30A1, 0x30A3, 0x30A5, 0x30A7, 0x30A9, 0x30C3, 0x30E3, 0x30E5, 0x30E7, 0x30EE, 0x30F5, 0x30F6,
+        0x31F0..0x31FF,
+        0xFE50..0xFE52, 0xFE54..0xFE57, 0xFE5A, 0xFE5C, 0xFE5E,
+        0xFF01, 0xFF09, 0xFF0C, 0xFF0E, 0xFF1A, 0xFF1B, 0xFF1F, 0xFF3D, 0xFF5D, 0xFF60, 0xFF61, 0xFF63,
+        0xFF64, 0xFF65, 0xFF67..0xFF6F, 0xFF70, 0xFF9E, 0xFF9F,
+        0x2025, 0x2026
+      ].freeze
+
+      # Never at the end of a line: opening brackets and quotes.
+      OPENING = [
+        0x3008, 0x300A, 0x300C, 0x300E, 0x3010, 0x3014, 0x3016, 0x3018, 0x301A, 0x301D,
+        0xFE59, 0xFE5B, 0xFE5D,
+        0xFF08, 0xFF3B, 0xFF5B, 0xFF5F, 0xFF62
+      ].freeze
+
+      CLOSING_CODES = CLOSING.flat_map { |entry| Array(entry) }.to_h { |code| [code, true] }.freeze
+      OPENING_CODES = OPENING.flat_map { |entry| Array(entry) }.to_h { |code| [code, true] }.freeze
+
+      module_function
+
+      def ideographic?(char)
+        code = char.ord
+        !CLOSING_CODES.key?(code) && IDEOGRAPHIC.any? { |range| range.cover?(code) }
+      end
+
+      def closing?(char) = CLOSING_CODES.key?(char.ord)
+      def opening?(char) = OPENING_CODES.key?(char.ord)
+
+      # Whether `text` holds any character these rules know about, the cheap
+      # test that keeps Latin text on the fast path.
+      def cjk?(text) = text.match?(CJK)
+
+      CJK = /[ᄀ-ᇿ⺀-⿟、-ヿ㄀-鿿ꀀ-꓏ꥠ-꥿가-힯豈-﫿︰-﹞！-ﾟ\u{1B000}-\u{1B16F}\u{20000}-\u{3134F}‥…]/
+
+      # The word's break units in order, each `[text, glued]`: `glued` is true
+      # for a unit that must stay with the unit before it (it starts with a
+      # closing mark), so the caller joins it to whatever came before, even
+      # across styled runs. A word without CJK characters is one unit.
+      def units(word)
+        return [[word, false]] unless cjk?(word)
+
+        units = []
+        current = +""
+        glued = false
+        open = false # current holds opening brackets only, waiting for what they open
+        word.each_char do |char|
+          if closing?(char)
+            glued = true if current.empty?
+          elsif starts_unit?(char, current, open)
+            units << [current.freeze, glued] unless current.empty?
+            current = +""
+            glued = false
+          end
+          current << char
+          open = opening?(char) && (open || current.length == 1)
+        end
+        units << [current.freeze, glued] unless current.empty?
+        units
+      end
+
+      # Whether `char` opens a new unit after `current`: an opening bracket or
+      # an ideographic character does unless `current` is only opening
+      # brackets; Latin text does after a unit that ends in a CJK character
+      # (an opening bracket or Latin followed by a closing mark stay glued).
+      def starts_unit?(char, current, open)
+        return false if current.empty? || open
+        return true if opening?(char) || ideographic?(char)
+
+        cjk?(current[-1]) && !(closing?(current[-1]) && !ideographic_unit?(current))
+      end
+
+      # A unit that carries an ideographic character (as opposed to Latin text
+      # followed by a closing mark, such as "abc。").
+      def ideographic_unit?(text) = text.each_char.any? { |char| ideographic?(char) }
+    end
+  end
+end

data/lib/stationery/text/paragraph.rb

@@ -34,6 +34,14 @@ module Stationery
         [with_lines(@lines.first(count)), with_lines(@lines.drop(count))]
       end
 
+      # [first `count` lines, the rest]; nil for an empty side.
+      def split_at(count)
+        return [nil, self] if count <= 0
+        return [self, nil] if count >= @lines.size
+
+        [with_lines(@lines.first(count)), with_lines(@lines.drop(count))]
+      end
+
       # A paragraph that fits `max_height`: truncated to whole lines, shrunk
       # (never below 4pt) or left as is for :visible.
       def fit(max_height, overflow:)

data/lib/stationery/text/runs_builder.rb

@@ -46,6 +46,10 @@ module Stationery
       def size(value, text = nil, &) = styled({ size: value }, text, &)
       def font(family, text = nil, &) = styled({ family: family.to_s }, text, &)
       def link(url, text = nil, &) = styled({ link: url.to_s }, text, &)
+      # The current size multiplied: `scale(1.5) { … }` is one and a half times the text around it.
+      def scale(factor, text = nil, &) = styled({ size: @styles.last.size * factor }, text, &)
+      # Any style fields at once, also to switch a mark off: `with({ weight: :regular }) { … }`.
+      def with(overrides, text = nil, &) = styled(overrides, text, &)
 
       private