stationery 0.8.0 → 0.10.0

data/lib/stationery/document.rb

@@ -107,6 +107,22 @@ module Stationery
         config[:factur_x] = { xml: source, **options }
       end
 
+      # Signs every render with a digital signature over the whole file:
+      # `sign certificate: pem, key: pem, reason: "Approved"`. A value may be
+      # a block or callable answering it for the document being rendered (a
+      # method name for certificate:, key:, chain: and passphrase:), and a
+      # block may answer all of them, so keys are read when they are needed.
+      # `field:` names the signature_field it fills; without it the
+      # signature is invisible. `timestamp:` is the URL of a time-stamping
+      # authority whose token makes it PAdES baseline B-T. See PDF::Signature.
+      def sign(**options, &block)
+        raise ArgumentError, "sign needs certificate: and key:, or a block answering them" unless block || options.any?
+
+        options = PDF::Signature.check(options)
+        PDF::Signature.new(**options) unless block || PDF::Signature.deferred?(options)
+        config[:sign] = block || options
+      end
+
       # Encrypts every render with the standard security handler; see
       # PDF::Encryption::StandardSecurity for the options.
       def encrypt(**)
@@ -138,18 +154,28 @@ module Stationery
     def page_options = self.class.config[:page]
     def metadata = self.class.config[:metadata]
 
+    # The PDF as a binary String, also written to `target` when given: a
+    # path or an IO. With a block the file is streamed to it in pieces as it
+    # is written and the call answers the number of bytes: the first bytes
+    # leave before the last page is assembled and no output buffer is built.
+    # Layout runs in full first either way, so peak memory does not drop.
     def to_pdf(target = nil, strict: self.class.config[:strict], debug: false, encrypt: self.class.config[:encrypt],
                tagged: self.class.config[:tagged], page_labels: self.class.config[:page_labels], attachments: [],
                xmp: metadata[:xmp] != false, conformance: self.class.config[:conformance],
-               factur_x: self.class.config[:factur_x])
+               factur_x: self.class.config[:factur_x], sign: self.class.config[:sign], &block)
       invoice = PDF::FacturX.for(factur_x, self)
       attachments = PDF::Attachments.merge(self.class.config[:attachments], attachments, invoice&.attachment)
       conformance = PDF::Conformance.for(invoice ? invoice.conformance(conformance) : conformance)
       conformance&.validate!(encrypt:, metadata:, attachments:)
+      signature = PDF::Signature.for(sign, self)
+      raise ArgumentError, "a signed document cannot be streamed to a block: sign needs the whole file" if
+        signature && block
+      raise ArgumentError, "pass a target or a block, not both" if target && block
+
       options = { strict:, debug:, encrypt:, tagged: tagged || conformance&.pdf_ua?, page_labels:, attachments:,
-                  xmp: xmp || !conformance.nil?, conformance:, invoice: }
+                  xmp: xmp || !conformance.nil?, conformance:, invoice:, signature:, sink: block }
       Stationery.instrument("render.stationery", document: self.class.name) do |event|
-        write(render_pdf(event, **options), target)
+        block ? render_pdf(event, **options) : write(render_pdf(event, **options), target)
       end
     end
 
@@ -192,22 +218,24 @@ module Stationery
       raise WarningsError, warnings if strict && warnings.any?
 
       pdf = assemble(pages, resources, outline, tagging:, conformance:, **assembly)
-      event[:bytes] = pdf.bytesize
+      event[:bytes] = byte_count(pdf)
       pdf
     end
 
     def assemble(pages, resources, outline, encrypt:, tagging:, page_labels:, attachments:, xmp:, conformance:,
-                 invoice:)
+                 invoice:, signature:, sink:)
       encryption = encrypt && PDF::Encryption::StandardSecurity.new(**encrypt)
       assembler = PDF::Assembler.new(pages:, resources:, info:, outline:, encryption:, tagging:, xmp:,
                                      lang: metadata[:lang], page_labels: PDF::PageLabels.entries(page_labels),
                                      attachments:, conformance:, xmp_extensions: invoice&.xmp_extensions || {},
-                                     xmp_schemas: [invoice&.xmp_schema].compact)
+                                     xmp_schemas: [invoice&.xmp_schema].compact, signature:, sink:)
       Stationery.instrument("write.stationery", document: self.class.name) do |event|
-        assembler.render.tap { |pdf| event[:bytes] = pdf.bytesize }
+        assembler.render.tap { |pdf| event[:bytes] = byte_count(pdf) }
       end
     end
 
+    def byte_count(pdf) = pdf.is_a?(String) ? pdf.bytesize : pdf
+
     def paginate(root, book:, resources:, warnings:, debug:, tagging:)
       Stationery.instrument("paginate.stationery", document: self.class.name) do |event|
         regions = Regions.new(self.class.config[:regions], measure: region_measure(book))

data/lib/stationery/elements/forms.rb

@@ -3,44 +3,49 @@
 module Stationery
   # Interactive form fields. Each takes a name (dotted names group fields,
   # "address.city") and lays out like a box, or at a fixed page position with
-  # `at: [x, y]`.
+  # `at: [x, y]`. Their appearances are set in the text style in effect (the
+  # document's fonts, embedded), and `tooltip:` names a field for assistive
+  # technology (its label or name by default).
   module Elements
     # A text input. `width:` is :full or points; `multiline:`, `max_length:`,
     # `comb:` (a cell count, or true with max_length:), `read_only:`,
     # `required:`, `font_size:`, `border:`, `background:` and `radius:`.
     def text_field(name, value: "", width: :full, height: 22, at: nil, **)
-      field_node(Forms::Field.new(:text, name, value: value.to_s, **), width:, height:, at:)
+      field_node(Forms::Field.new(:text, name, value: value.to_s, typeface: field_typeface, **), width:, height:, at:)
     end
 
     # A check box `size` points square, with an optional label to its right.
     def checkbox(name, checked: false, size: 12, label: nil, at: nil, **)
-      field = Forms::Field.new(:checkbox, name, value: checked == true, **)
+      field = Forms::Field.new(:checkbox, name, value: checked == true, typeface: field_typeface, tooltip: label, **)
       field_node(field, width: size, height: size, at:, label:)
     end
 
     # One choice of the radio group `name`; its `value` becomes the group's
     # value when checked.
     def radio(name, value, checked: false, size: 12, label: nil, at: nil, **)
-      field = Forms::Field.new(:radio, name, value: value.to_s, checked:, **)
+      field = Forms::Field.new(:radio, name, value: value.to_s, checked:, typeface: field_typeface, **)
       field_node(field, width: size, height: size, at:, label:)
     end
 
     # A drop-down (combo box) of `options`; `editable: true` also accepts
     # typed values.
     def select(name, options:, value: nil, width: :full, height: 22, at: nil, **)
-      field = Forms::Field.new(:select, name, value: value&.to_s, options: options.map(&:to_s), **)
+      field = Forms::Field.new(:select, name, value: value&.to_s, options: options.map(&:to_s),
+                                              typeface: field_typeface, **)
       field_node(field, width:, height:, at:)
     end
 
     # An empty signature field for the signer to fill, drawn as a rule over
     # the label.
     def signature_field(name, width: :full, height: 40, label: "Signature", at: nil, **)
-      field = Forms::Field.new(:signature, name, label: label.to_s, **)
+      field = Forms::Field.new(:signature, name, label: label.to_s, typeface: field_typeface, **)
       field_node(field, width:, height:, at:)
     end
 
     private
 
+    def field_typeface = Forms::Typeface.new(@_builder.book, @_builder.style)
+
     def field_node(field, width:, height:, at:, label: nil)
       label &&= field_label(label)
       node = Layout::Field.new(field, height:, width:, label:)

data/lib/stationery/elements/rich.rb

@@ -8,22 +8,37 @@ module Stationery
     # under `base_path:`. Remote images are never fetched. `links:` lists the
     # URL schemes written as links (default http, https, mailto and tel;
     # `#anchor` always is); `:all` keeps every href for trusted sources.
-    def html(source, styles: {}, gap: 6, images: nil, base_path: nil, bookmarks: false, links: nil)
+    # Elements nested deeper than `max_depth:` are flattened into the deepest
+    # one kept (text stays, structure goes) and reported as a NestingLimit
+    # warning, so content from users cannot exhaust the stack. `<style>`
+    # rules and inline styles are read for the properties HTML::Css knows;
+    # the rest is reported once as an UnsupportedCss warning.
+    def html(source, max_depth: 64, **)
       require_relative "../html/document"
-      rich(HTML.parse(source.to_s), styles:, gap:, images:, base_path:, bookmarks:, links:)
+      css = HTML::Css::Report.new
+      blocks = HTML.parse(source.to_s, max_depth:, css:) { |depth| nesting_limit(depth, max_depth) }
+      if css.any?
+        @_builder.warnings << Warnings::UnsupportedCss.new(properties: css.properties,
+                                                           selectors: css.selectors)
+      end
+      rich(blocks, **)
     end
 
     # CommonMark (plus GFM tables and strikethrough); options as for html.
-    def markdown(source, styles: {}, gap: 6, images: nil, base_path: nil, bookmarks: false, links: nil)
+    def markdown(source, max_depth: 64, **)
       require_relative "../markdown/document"
-      rich(Markdown.parse(source.to_s), styles:, gap:, images:, base_path:, bookmarks:, links:)
+      rich(Markdown.parse(source.to_s, max_depth:) { |depth| nesting_limit(depth, max_depth) }, **)
     end
 
     private
 
-    def rich(blocks, **)
+    def nesting_limit(depth, limit)
+      @_builder.warnings << Warnings::NestingLimit.new(depth:, limit:)
+    end
+
+    def rich(blocks, styles: {}, gap: 6, images: nil, base_path: nil, bookmarks: false, links: nil)
       require_relative "../rich/renderer"
-      Rich::Renderer.new(self, @_builder, **).render(blocks)
+      Rich::Renderer.new(self, @_builder, styles:, gap:, images:, base_path:, bookmarks:, links:).render(blocks)
     end
   end
 end

data/lib/stationery/elements.rb

@@ -3,18 +3,21 @@
 module Stationery
   # The element DSL available inside every component's view_template.
   module Elements
-    PARAGRAPH_DEFAULTS = { align: :left, leading: 0 }.freeze
+    PARAGRAPH_DEFAULTS = { align: :left, leading: 0, orphans: 1, widows: 1 }.freeze
 
     # A paragraph. Plain strings are always literal; pass `markup: true` to
     # read inline tags, or a block to build styled runs in Ruby. `heading: 1..6`
-    # tags it as a heading in a tagged PDF.
+    # tags it as a heading in a tagged PDF. `orphans:` and `widows:` are the
+    # fewest lines a page break may leave behind and carry over (default 1).
     def text(content = nil, markup: false, keep_with_next: nil, break_inside: nil, anchor: nil, bookmark: nil,
              heading: nil, **options, &)
-      settings = PARAGRAPH_DEFAULTS.merge(@_builder.text_defaults.slice(:align, :leading)).merge(options)
+      settings = PARAGRAPH_DEFAULTS.merge(@_builder.text_defaults.slice(:align, :leading, :orphans, :widows))
+                                   .merge(options)
       style = @_builder.style(options)
       runs = text_runs(content, style, markup, &)
       node = Layout::Text.new(runs, context: @_builder.context(style), align: settings[:align],
-                                    leading: settings[:leading], tag: Tagging::Element.new(Tagging.heading(heading)))
+                                    leading: settings[:leading], orphans: settings[:orphans], widows: settings[:widows],
+                                    tag: Tagging::Element.new(Tagging.heading(heading)))
       node.keep_with_next = keep_with_next
       node.break_inside = break_inside
       @_builder.add(mark(node, anchor, bookmark))
@@ -95,9 +98,7 @@ module Stationery
       name = source.to_s.lstrip.start_with?("<") ? "inline" : File.basename(source.to_s)
       source = File.read(source.to_s) unless name == "inline"
       document = SVG::Document.parse(source)
-      if document.unsupported.any?
-        @_builder.warnings << Warnings::UnsupportedSvg.new(elements: document.unsupported, source: name)
-      end
+      svg_warnings(document, name)
       node = Layout::Svg.new(document, width:, height:, color:, context: @_builder.context, alt:)
       @_builder.add(align ? Layout::Flow.new([node], align:) : node)
     end
@@ -154,6 +155,16 @@ module Stationery
 
     private
 
+    # What the drawing uses that is not drawn, and nesting that was flattened.
+    def svg_warnings(document, name)
+      if document.unsupported.any?
+        @_builder.warnings << Warnings::UnsupportedSvg.new(elements: document.unsupported, source: name)
+      end
+      return unless document.nesting
+
+      @_builder.warnings << Warnings::NestingLimit.new(depth: document.nesting, limit: SVG::Parser::MAX_DEPTH)
+    end
+
     # `bookmark:` is a title, or { title:, level:, open: }.
     def mark(node, anchor, bookmark)
       names = [anchor&.to_s]
@@ -175,10 +186,12 @@ module Stationery
       end
     end
 
+    # A Hash is a cell with options: `{ content:, background:, borders:, padding:, … }`.
     def cell_content(content)
       case content
       when Proc then container(&content)
       when Component then container { render content }
+      when Hash then content.merge(content: cell_content(content[:content]))
       else content
       end
     end

data/lib/stationery/errors.rb

@@ -21,6 +21,10 @@ module Stationery
     end
   end
 
+  # Raised when a signature cannot be made as asked: the time-stamping
+  # authority is unreachable, refuses, or answers for something else.
+  class SignatureError < Error; end
+
   # Raised when a render cannot keep the conformance it claims (PDF/A,
   # PDF/UA): `levels` are the claimed levels, `issues` what breaks them.
   class ConformanceError < Error

data/lib/stationery/fonts/fallback.rb

@@ -12,7 +12,7 @@ module Stationery
     # stay with their base; whitespace a font lacks draws as a blank of the
     # right width (see Font::WHITESPACE).
     class Fallback
-      CARRIED = /[\p{Space}­‌‍︀-️\p{M}]/
+      CARRIED = /[\p{Space}­​‌‍︀-️\p{M}]/
 
       def self.carried?(char) = CARRIED.match?(char)
 

data/lib/stationery/fonts/font.rb

@@ -33,9 +33,10 @@ module Stationery
         @pairs = {}
         @glyphs = {}
         @blanks = {}
-        @shapes = {}
-        @advances = {}
-        @kerns = {}
+        @shapes = {}.compare_by_identity
+        @metrics = {}.compare_by_identity
+        @keys = { true => {}, false => {} }
+        @frozen_keys = { true => {}.compare_by_identity, false => {}.compare_by_identity }
         @cid_keyed = ttf.cff? && ttf.cff.cid_keyed?
       end
 
@@ -49,10 +50,12 @@ module Stationery
       def width_of(text, size, letter_spacing: 0, kerning: false, ligatures: true, features: NO_FEATURES)
         ligatures &&= letter_spacing.zero?
         key = shape_key(ligatures, features)
-        width = scale(advance_units(text, key), size) + (letter_spacing * shape(text, key).first.size)
+        advance, kern = metrics(text, key)
+        width = scale(advance, size)
+        width += letter_spacing * shape(text, key).first.size unless letter_spacing.zero?
         return width unless kerning
 
-        width + (kerning_units(text, key) * size / 1000.0)
+        width + (kern * size / 1000.0)
       end
 
       # The GSUB feature tags this font can apply.
@@ -126,14 +129,22 @@ module Stationery
       private
 
       # The feature tags to substitute with: `liga` when ligatures are on, plus
-      # the requested features. Frozen and shared, so it keys the memos cheaply.
+      # the requested features. One Array per set of tags, so the memos are
+      # keyed by its identity: measuring a word hashes the word and nothing
+      # else. A style's frozen tags are looked up by identity too; any other
+      # Array is normalised first.
       def shape_key(ligatures, features)
-        features = Text::Style.features(features) unless features.frozen? && features.all?(String)
-        return features unless ligatures
-        return Gsub::LIGA if features.empty?
+        return ligatures ? Gsub::LIGA : NO_FEATURES if features.empty?
 
-        @keys ||= {}
-        @keys[features] ||= (features + Gsub::LIGA).sort.freeze
+        ligatures = ligatures ? true : false
+        return @frozen_keys[ligatures][features] ||= tags_for(ligatures, features) if features.frozen?
+
+        tags_for(ligatures, features)
+      end
+
+      def tags_for(ligatures, features)
+        features = Text::Style.features(features)
+        @keys[ligatures][features] ||= (ligatures ? (features + Gsub::LIGA).sort : features).freeze
       end
 
       # [gids, source text of each glyph, extra advance in font units after
@@ -170,17 +181,16 @@ module Stationery
         width - space
       end
 
-      def advance_units(text, tags)
-        (@advances[tags] ||= {})[text] ||= begin
+      # [advance in font units, kerning in thousandths of an em] of a string,
+      # remembered together so a measurement is one lookup.
+      def metrics(text, tags)
+        (@metrics[tags] ||= {})[text] ||= begin
           gids, _, blanks = shape(text, tags)
-          gids.sum { |gid| @ttf.advance(gid) } + blanks.sum { |units| units || 0 }
+          [gids.sum { |gid| @ttf.advance(gid) } + blanks.sum { |units| units || 0 },
+           gids.each_cons(2).sum { |left, right| pair(left, right) }].freeze
         end
       end
 
-      def kerning_units(text, tags)
-        (@kerns[tags] ||= {})[text] ||= shape(text, tags).first.each_cons(2).sum { |left, right| pair(left, right) }
-      end
-
       # Kerning between two glyphs in thousandths of an em.
       def pair(left, right)
         @pairs[(left << 16) | right] ||= @ttf.kerning.adjust(left, right) * 1000.0 / @ttf.units_per_em

data/lib/stationery/forms/acro_form.rb

@@ -3,14 +3,24 @@
 module Stationery
   module Forms
     # Collects the widgets pages place and writes the document's interactive
-    # form: one field per name, parent fields for dotted names, the shared
-    # Helvetica and ZapfDingbats resources and the catalog's /AcroForm.
+    # form: one field per name, parent fields for dotted names, the fonts the
+    # appearances draw with as default resources and the catalog's /AcroForm.
+    #
+    # The appearances themselves need no standard font: text is set in the
+    # document's embedded fonts and marks are paths. Only a form that asks
+    # viewers to regenerate appearances lists ZapfDingbats, which is what
+    # they redraw a check box or radio button's /MK caption with.
+    #
+    # A `signature:` (a PDF::Signature) becomes the value of the signature
+    # field it names, or of a field of its own whose widget nobody sees.
     class AcroForm
-      FONTS = { Helv: :Helvetica, ZaDb: :ZapfDingbats }.freeze
+      SYMBOLS = { ZaDb: { Type: :Font, Subtype: :Type1, BaseFont: :ZapfDingbats }.freeze }.freeze
+      # SignaturesExist and AppendOnly: what a signed form tells viewers.
+      SIGNED = 3
 
-      # A widget placed on a page: its field, PDF-space rect, page and the
-      # reference the page's /Annots already points at.
-      Widget = Data.define(:field, :rect, :page, :ref, :extra)
+      # A widget placed on a page: its field, appearance, PDF-space rect, page
+      # and the reference the page's /Annots already points at.
+      Widget = Data.define(:field, :appearance, :rect, :page, :ref, :extra)
 
       # A name segment: widgets when it is a field, children when a group.
       Node = Struct.new(:name, :widgets, :children)
@@ -24,35 +34,89 @@ module Stationery
         end
       end
 
-      def initialize(writer)
+      # `fonts` are the document's embedded fonts by resource name.
+      # `need_appearances: false` leaves out the flag asking viewers to
+      # regenerate every appearance (PDF/A and PDF/UA forbid it, and a
+      # signed file must not be redrawn).
+      def initialize(writer, fonts: {}, need_appearances: true, signature: nil)
         @writer = writer
+        @embedded = fonts
+        @need_appearances = need_appearances
+        @signature = signature
         @widgets = []
       end
 
-      # Reserves the widget annotation for `field` at `rect` on `page`.
-      # `extra` entries for the widget dictionary may be computed from its
-      # reference (a tagged PDF's /StructParent).
-      def add(field, rect, page)
+      # Reserves the widget annotation (a page annotation holding the field
+      # as :widget, its :appearance and :rect) on `page`. `extra` entries for
+      # the widget dictionary may be computed from its reference (a tagged
+      # PDF's /StructParent).
+      def add(annotation, page)
         ref = @writer.reserve
-        @widgets << Widget.new(field, rect, page, ref, block_given? ? yield(ref) : {})
+        appearance = annotation[:appearance] || Appearance.new(annotation[:widget], *size_of(annotation[:rect]))
+        @widgets << Widget.new(annotation[:widget], appearance, annotation[:rect], page, ref,
+                               block_given? ? yield(ref) : {})
+        ref
+      end
+
+      # Reserves the widget of a signature that fills no field: without a
+      # size or an appearance, printable and locked, on `page`. `taken` are
+      # the names the document's fields use.
+      def sign(page, taken: [])
+        name = (1..).lazy.map { |number| "Signature#{number}" }.find { |candidate| !taken.include?(candidate) }
+        ref = @writer.reserve
+        @widgets << Widget.new(Field.new(:signature, name, label: ""), nil, [0, 0, 0, 0], page, ref, {})
         ref
       end
 
       # Writes every field; returns the /AcroForm dictionary, or nil without
-      # fields.
+      # fields. /DR lists the fonts the appearances use, /DA selects the first.
       def write
+        @signed = signed
         return if @widgets.empty?
 
-        @fonts = FONTS.transform_values { |base| @writer.add(font(base)) }
+        @fonts = fonts
         fields = tree.children.values.map { |node| write_node(node, nil) }
-        { Fields: fields, NeedAppearances: true, DA: "/#{Field::FONT} 0 Tf 0 g", DR: { Font: @fonts } }
+        form = { Fields: fields }
+        form[:SigFlags] = SIGNED if @signed
+        form[:NeedAppearances] = true if @need_appearances
+        form[:DA] = "/#{@fonts.keys.first} 0 Tf 0 g" if @fonts.any?
+        resources = @fonts.merge(symbols)
+        form[:DR] = { Font: resources } if resources.any?
+        form
       end
 
       private
 
-      def font(base)
-        font = { Type: :Font, Subtype: :Type1, BaseFont: base }
-        base == :Helvetica ? font.merge(Encoding: :WinAnsiEncoding) : font
+      def size_of(rect) = [rect[2] - rect[0], rect[3] - rect[1]]
+
+      # The signature dictionary's reference, once the field it fills is
+      # known to exist; nil without a signature.
+      def signed
+        return unless @signature
+        return @writer.add(@signature.dictionary) if @widgets.any? { |widget| signs?(widget) }
+
+        raise ArgumentError, %(sign field: names "#{@signature.field}", but the document has no such signature_field)
+      end
+
+      def signs?(widget)
+        return widget.appearance.nil? if @signature.invisible?
+
+        widget.field.kind == :signature && widget.field.name == @signature.field
+      end
+
+      def symbols
+        return {} unless @need_appearances && @widgets.any? { |widget| widget.field.type == :Btn }
+
+        SYMBOLS.transform_values { |font| @writer.add(font) }
+      end
+
+      # The fonts the appearances name: the embedded ones, and the standard
+      # Helvetica when a field without a font book draws with it.
+      def fonts
+        names = @widgets.flat_map { |widget| widget.appearance&.font_names.to_a }.uniq
+        names.to_h do |name|
+          [name, @embedded.fetch(name) { @writer.add(Standard::FONT) }]
+        end
       end
 
       def tree
@@ -91,21 +155,27 @@ module Stationery
       # field's kids. A radio group's value is its checked choice.
       def write_field(widgets, own)
         field = widgets.first.field
+        default_appearance = widgets.first.appearance&.default_appearance
+        value = @signed && signs?(widgets.first) ? { V: @signed } : {}
         unless field.radio? || !widgets.one?
-          return @writer.set(widgets.first.ref, own.merge(field.field_entries, widget(widgets.first)))
+          entries = field.field_entries(default_appearance:)
+          return @writer.set(widgets.first.ref, own.merge(entries, value, widget(widgets.first)))
         end
 
         ref = @writer.reserve
-        value = field.radio? ? widgets.map(&:field).find(&:checked?)&.on_state || :Off : nil
-        widgets.each { |kid| @writer.set(kid.ref, widget(kid, value).merge(Parent: ref)) }
-        entries = value ? field.field_entries(value) : field.field_entries
-        @writer.set(ref, own.merge(entries, Kids: widgets.map(&:ref)))
+        choice = field.radio? ? widgets.map(&:field).find(&:checked?)&.on_state || :Off : nil
+        widgets.each { |kid| @writer.set(kid.ref, widget(kid, choice).merge(Parent: ref)) }
+        entries = choice ? field.field_entries(choice, default_appearance:) : field.field_entries(default_appearance:)
+        @writer.set(ref, own.merge(entries, value, Kids: widgets.map(&:ref)))
       end
 
       def widget(widget, group_value = nil)
-        x1, y1, x2, y2 = widget.rect
+        unless widget.appearance
+          return { Type: :Annot, Subtype: :Widget, F: PDF::Signature::INVISIBLE, Rect: widget.rect, P: widget.page }
+        end
+
         state = group_value && (widget.field.on_state == group_value ? group_value : :Off)
-        entries = widget.field.widget_entries(x2 - x1, y2 - y1, @fonts, state:)
+        entries = widget.field.widget_entries(widget.appearance, @fonts, state:)
         normal = entries.dig(:AP, :N)
         normal = normal.is_a?(Hash) ? normal.transform_values { |stream| @writer.add(stream) } : @writer.add(normal)
         entries.merge(AP: { N: normal }, Rect: widget.rect, P: widget.page, **widget.extra)