stationery 0.7.0 → 0.9.0

data/lib/stationery/document.rb

@@ -24,7 +24,7 @@ module Stationery
                       superclass.config.transform_values(&:dup)
                     else
                       { page: { size: :letter, margin: 36 }, families: {}, fallbacks: [], text: {}, metadata: {},
-                        templates: [], regions: [], strict: false, tagged: false, images: {} }
+                        templates: [], regions: [], strict: false, tagged: false, images: {}, attachments: [] }
                     end
       end
 
@@ -58,6 +58,14 @@ module Stationery
         config[:page_labels] = spec
       end
 
+      # Embeds a file in every render: `attach_file "invoice.xml", xml,
+      # mime: "text/xml", description: "Factur-X", relationship: :alternative`.
+      # `relationship:` is :alternative, :source, :data, :supplement or
+      # :unspecified (the /AFRelationship); `modified_at:` a Time.
+      def attach_file(name, data, **)
+        config[:attachments] << PDF::Attachments.build(name, data, **)
+      end
+
       # Bitmap defaults: `max_ppi:` (300; nil disables) is the resolution
       # above twice of which a drawn image is reported as oversized, and
       # `downscale: true` resamples PNGs to it. See Layout::Image.
@@ -77,6 +85,43 @@ module Stationery
         config[:tagged] = value
       end
 
+      # Claims PDF/A-2b, PDF/A-3b and/or PDF/UA-1 (`conformance :pdf_a3b,
+      # :pdf_ua1`) and writes what the level asks for; a render that cannot
+      # keep the claim raises. See PDF::Conformance.
+      def conformance(*levels)
+        PDF::Conformance.for(levels)
+        config[:conformance] = levels.flatten
+      end
+
+      # Makes every render a Factur-X / ZUGFeRD e-invoice: PDF/A-3b with the
+      # invoice XML embedded and identified in XMP. `xml` is the Cross
+      # Industry Invoice as a String, or a method name or block answering it
+      # for the document being rendered: `factur_x(profile: :en16931) {
+      # invoice.to_cii }`. See PDF::FacturX for profiles and options.
+      def factur_x(xml = nil, **options, &block)
+        source = xml || block
+        raise ArgumentError, "factur_x needs the invoice XML, a method name or a block" unless source
+
+        PDF::FacturX.profile(options.fetch(:profile, :en16931))
+        PDF::FacturX.new(source, **options) if source.is_a?(String)
+        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. 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(**)
@@ -109,9 +154,18 @@ module Stationery
     def metadata = self.class.config[:metadata]
 
     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])
+               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], sign: self.class.config[:sign])
+      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:)
+      options = { strict:, debug:, encrypt:, tagged: tagged || conformance&.pdf_ua?, page_labels:, attachments:,
+                  xmp: xmp || !conformance.nil?, conformance:, invoice:,
+                  signature: PDF::Signature.for(sign, self) }
       Stationery.instrument("render.stationery", document: self.class.name) do |event|
-        write(render_pdf(event, strict:, debug:, encrypt:, tagged:, page_labels:), target)
+        write(render_pdf(event, **options), target)
       end
     end
 
@@ -136,7 +190,7 @@ module Stationery
     def builder_for(book) = Builder.new(book:, text: self.class.config[:text], images: self.class.config[:images])
 
     # The PDF bytes; `event` is the render.stationery payload it fills in.
-    def render_pdf(event, strict:, debug:, encrypt:, tagged:, page_labels:)
+    def render_pdf(event, strict:, debug:, tagged:, conformance:, **assembly)
       tagging = Tagging::Tree.new if tagged
       warnings = Warnings.new
       book = Fonts::FontBook.new(self.class.config[:families], fallbacks: self.class.config[:fallbacks], warnings:)
@@ -147,18 +201,24 @@ module Stationery
       outline = builder.outline.resolve(Structure.resolve(pages, warnings:, resources:, book:, tagging:))
       tagging&.audit(pages, warnings, lang: metadata[:lang])
       @warnings = warnings
+      conformance&.audit!(pages, resources:, warnings:)
       @fields = Forms::AcroForm.values(pages)
       event[:pages] = pages.size
       event[:warnings] = warnings.size
       raise WarningsError, warnings if strict && warnings.any?
 
-      assemble(pages, resources, outline, encrypt:, tagging:, page_labels:).tap { |pdf| event[:bytes] = pdf.bytesize }
+      pdf = assemble(pages, resources, outline, tagging:, conformance:, **assembly)
+      event[:bytes] = pdf.bytesize
+      pdf
     end
 
-    def assemble(pages, resources, outline, encrypt:, tagging:, page_labels:)
+    def assemble(pages, resources, outline, encrypt:, tagging:, page_labels:, attachments:, xmp:, conformance:,
+                 invoice:, signature:)
       encryption = encrypt && PDF::Encryption::StandardSecurity.new(**encrypt)
-      assembler = PDF::Assembler.new(pages:, resources:, info:, outline:, encryption:, tagging:,
-                                     lang: metadata[:lang], page_labels: PDF::PageLabels.entries(page_labels))
+      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, signature:)
       Stationery.instrument("write.stationery", document: self.class.name) do |event|
         assembler.render.tap { |pdf| event[:bytes] = pdf.bytesize }
       end
@@ -184,7 +244,7 @@ module Stationery
     end
 
     def info
-      metadata.except(:lang).to_h do |key, value|
+      metadata.except(:lang, :xmp).to_h do |key, value|
         [INFO_KEYS.fetch(key.to_sym) { key.to_sym }, value.is_a?(Array) ? value.join(", ") : value]
       end
     end

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,29 @@ 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.
+    def html(source, max_depth: 64, **)
       require_relative "../html/document"
-      rich(HTML.parse(source.to_s), styles:, gap:, images:, base_path:, bookmarks:, links:)
+      rich(HTML.parse(source.to_s, max_depth:) { |depth| nesting_limit(depth, max_depth) }, **)
     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

@@ -95,9 +95,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 +152,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]

data/lib/stationery/errors.rb

@@ -20,4 +20,17 @@ module Stationery
       super("#{lines.size} #{noun}:\n#{lines.join("\n")}")
     end
   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
+    attr_reader :levels, :issues
+
+    def initialize(levels, issues)
+      @levels = levels
+      @issues = issues
+      super("not #{levels.map { |level| Stationery::PDF::Conformance.label(level) }.join(" + ")}:\n" \
+            "#{issues.map { |issue| "  #{issue}" }.join("\n")}")
+    end
+  end
 end

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)