fontisan 0.4.22 → 0.4.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 208fa8e2c44bdea2e800ecb13639d50e06e6914406822f6e3c92152d21414fd7
-  data.tar.gz: cdce57d3a157d5a5549b45104f93de38263697989bae6a66572907bc54b58bb0
+  metadata.gz: c7e00355898ff37e38b4948f9a607bf95b96b73df17225c81ebe0b6f6b757b1d
+  data.tar.gz: 9009d6fb96c8168a098236d7b80355749d6c65463376119695ab2a65c20de01d
 SHA512:
-  metadata.gz: c87e9ec10e9cadd168dda76b38ef225c1e286bc63501b75268a7cd29fcdfbef3d86abacac211052d529d153aebf1f8db29aaab7445c51a5a83e3eb091f752ab4
-  data.tar.gz: 4632d882fe8ab4897ed32722ec17efb942819ded33e2005bf51c3032384466164d2c2c09a1a8f4388f1889b5c169f42b9dc14ae5cafce72ef5680c94d2333c02
+  metadata.gz: 0c82bc6f0d6a871e84d85e4ac6bd51260a39f2b1d373b3055801354c89d99eda1ce3f78ba62ce640e5193eededeba9c8f5101146378124b5d5ac8e5c52bb60c0
+  data.tar.gz: 3e957b040dd2660ce7b8ddea3d4592cfef37ad8d434dd5e43d1be4417459992150fcd414f7547ead7f89a9ad8fd4ea8e01a847eb57ef352a70335e691cb386d6

data/.rubocop_todo.yml

@@ -88,6 +88,11 @@ Lint/UnusedMethodArgument:
     - 'lib/fontisan/tables/cff2/private_dict_blend_handler.rb'
     - 'lib/fontisan/variation/table_accessor.rb'
     - 'lib/fontisan/woff_font.rb'
+    # Subset strategies share a uniform (context:, tag:, table:) interface
+    # so the dispatcher can call every registered class the same way. Not
+    # every strategy reads every arg; the interface contract justifies the
+    # unused warnings here.
+    - 'lib/fontisan/subset/table_strategy/**/*'
 
 # Offense count: 5
 Lint/UselessConstantScoping:

data/lib/fontisan/config/subset_profiles.yml

@@ -55,6 +55,8 @@ web:
     - glyf
     - GSUB
     - GPOS
+    - CBDT
+    - CBLC
 
 # Minimal Profile: Absolute minimum tables for font rendering
 minimal:

data/lib/fontisan/stitcher/cbdt_propagator.rb

@@ -60,6 +60,19 @@ module Fontisan
       # Outline data is intentionally absent — the bitmap lives in
       # the CBDT table that #propagate_tables_into will copy later.
       #
+      # == Why placeholders are name-deconflicted
+      #
+      # Placeholders are named after the CBDT source's gid ("gid{N}").
+      # Outline donors compiled earlier into the same target use the
+      # SAME naming scheme (see Source#extract_truetype_glyph), so a
+      # CBDT placeholder at "gid110" would collide with an outline
+      # glyph at "gid110" from a different donor. Layer#add raises on
+      # conflict (it never silently overwrites — that path previously
+      # erased real outline glyphs and dropped their cmap entries,
+      # causing the CJK Ext G loss in Essenfont-Regular.ttc). We
+      # allocate a unique name via UniqueGlyphName so each placeholder
+      # lands at its own GID slot without touching the outlines.
+      #
       # Glyphs are NOT registered with the deduplicator: each CBDT
       # glyph is unique to its source, and deduplication would
       # incorrectly collapse distinct bitmaps.
@@ -69,7 +82,10 @@ module Fontisan
       def add_placeholder_glyphs(source, target)
         ufo = source.font.is_a?(Ufo::Font) ? source.font : nil
         if ufo
-          ufo.glyphs.each_value { |g| target.layers.default_layer.add(clone_glyph(g, name: g.name)) }
+          ufo.glyphs.each_value do |g|
+            name = UniqueGlyphName.in(target, g.name)
+            target.layers.default_layer.add(GlyphCloner.clone(g, name: name))
+          end
           return
         end
 
@@ -82,7 +98,8 @@ module Fontisan
         mappings.each { |cp, gid| gid_cps[gid] << cp }
 
         num_glyphs.times do |gid|
-          name = gid.zero? ? ".notdef" : "gid#{gid}"
+          base_name = gid.zero? ? ".notdef" : "gid#{gid}"
+          name = UniqueGlyphName.in(target, base_name)
           glyph = Ufo::Glyph.new(name: name)
           glyph.width = 0
           gid_cps[gid].each { |cp| glyph.add_unicode(cp) }
@@ -100,6 +117,31 @@ module Fontisan
       #
       # No-op when called with a non-CBDT source or nil.
       #
+      # == Limitation: GID stability
+      #
+      # The propagation copies CBDT/CBLC bytes verbatim. CBLC indexes
+      # glyphs by SOURCE GID — the GIDs of the CBDT donor. The compiled
+      # font's GIDs may differ because:
+      #
+      #   1. +add_placeholder_glyphs+ renames CBDT placeholders via
+      #      UniqueGlyphName when their default "gid{N}" name collides
+      #      with outline glyphs sharing the same donor-gid scheme
+      #      (see Layer's naming contract).
+      #   2. The compiler assigns GIDs in target-namespace order, which
+      #      is not the same as source-GID order once renaming happens.
+      #
+      # The bitmaps line up correctly only when the CBDT source and
+      # every outline source cover disjoint codepoint ranges (the
+      # Essenfont TTC case: emoji vs CJK Ext G). When ranges overlap,
+      # CBLC's source-GID-indexed bitmaps may point at the wrong
+      # compiled glyphs and the colour rendering for affected
+      # codepoints will fall back to outlines.
+      #
+      # A proper fix requires a CBLC rebuild pass: walk the compiled
+      # font's cmap to find the new GID for every CBDT-covered source
+      # glyph, then rewrite CBLC's IndexSubTableArray + IndexSubTable
+      # offsets to match. Tracked as a follow-up.
+      #
       # @param source [Stitcher::Source, nil] the CBDT source
       # @param path [String] compiled font file to rewrite
       def propagate_tables_into(source, path)
@@ -126,26 +168,6 @@ module Fontisan
         sfnt = tables.key?("CFF ") || tables.key?("CFF2") ? 0x4F54544F : 0x00010000
         FontWriter.write_to_file(tables, path, sfnt_version: sfnt)
       end
-
-      private
-
-      def clone_glyph(original, name:)
-        copy = Ufo::Glyph.new(name: name)
-        copy.width = original.width
-        copy.height = original.height
-        original.contours.each { |c| copy.add_contour(clone_contour(c)) }
-        original.components.each { |c| copy.add_component(c) }
-        original.anchors.each { |a| copy.add_anchor(a) }
-        original.guidelines.each { |g| copy.add_guideline(g) }
-        copy
-      end
-
-      def clone_contour(original)
-        points = original.points.map do |p|
-          Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
-        end
-        Ufo::Contour.new(points)
-      end
     end
   end
 end

data/lib/fontisan/stitcher/glyph_cloner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Deep-clone helper for UFO glyphs. Stateless — every call returns
+    # a fresh +Ufo::Glyph+ with copied contours, components, anchors,
+    # and guidelines plus the original's width/height.
+    #
+    # Extracted as a collaborator so +GlyphCopier+ and +CbdtPropagator+
+    # share one implementation of the clone algorithm. Both previously
+    # defined identical +clone_glyph+ / +clone_contour+ private methods
+    # — a DRY violation that risked drifting apart as the glyph model
+    # gained fields.
+    module GlyphCloner
+      # @param original [Ufo::Glyph] glyph to copy
+      # @param name [String, nil] name for the copy; defaults to the
+      #   original's name (used by callers that have already allocated
+      #   a unique name via +UniqueGlyphName+).
+      # @return [Ufo::Glyph] a fresh glyph with the original's geometry
+      #   and metrics, sharing no mutable state with it.
+      def self.clone(original, name: nil)
+        copy = Ufo::Glyph.new(name: name || original.name)
+        copy.width = original.width
+        copy.height = original.height
+        original.contours.each { |c| copy.add_contour(clone_contour(c)) }
+        original.components.each { |c| copy.add_component(c) }
+        original.anchors.each { |a| copy.add_anchor(a) }
+        original.guidelines.each { |g| copy.add_guideline(g) }
+        copy
+      end
+
+      def self.clone_contour(original)
+        points = original.points.map do |p|
+          Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
+        end
+        Ufo::Contour.new(points)
+      end
+      private_class_method :clone_contour
+    end
+  end
+end

data/lib/fontisan/stitcher/glyph_copier.rb

@@ -1,4 +1,4 @@
-# frozen_string: true
+# frozen_string_literal: true
 
 module Fontisan
   class Stitcher
@@ -74,7 +74,7 @@ module Fontisan
           if canonical && target.glyphs.key?(canonical)
             add_extra_unicode(target, canonical, binding[:codepoint])
           else
-            name = unique_target_name(target, glyph.name)
+            name = UniqueGlyphName.in(target, glyph.name)
             copy_glyph_into(target, name: name, source: binding[:source],
                                     donor_gid: binding[:donor_gid],
                                     codepoint: binding[:codepoint])
@@ -93,7 +93,7 @@ module Fontisan
         original = source.glyph_for_gid(donor_gid)
         return unless original
 
-        copy = clone_glyph(original, name: name)
+        copy = GlyphCloner.clone(original, name: name)
         copy.add_unicode(codepoint) if codepoint
         target_font.layers.default_layer.add(copy)
       end
@@ -104,36 +104,6 @@ module Fontisan
         glyph = target_font.glyph(glyph_name)
         glyph.add_unicode(codepoint) unless glyph.unicodes.include?(codepoint)
       end
-
-      def unique_target_name(target_font, base_name)
-        return base_name unless target_font.glyphs.key?(base_name)
-
-        suffix = 1
-        loop do
-          candidate = "#{base_name}.#{suffix}"
-          return candidate unless target_font.glyphs.key?(candidate)
-
-          suffix += 1
-        end
-      end
-
-      def clone_glyph(original, name:)
-        copy = Ufo::Glyph.new(name: name)
-        copy.width = original.width
-        copy.height = original.height
-        original.contours.each { |c| copy.add_contour(clone_contour(c)) }
-        original.components.each { |c| copy.add_component(c) }
-        original.anchors.each { |a| copy.add_anchor(a) }
-        original.guidelines.each { |g| copy.add_guideline(g) }
-        copy
-      end
-
-      def clone_contour(original)
-        points = original.points.map do |p|
-          Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
-        end
-        Ufo::Contour.new(points)
-      end
     end
   end
 end

data/lib/fontisan/stitcher/unique_glyph_name.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Fontisan
+  class Stitcher
+    # Stateless glyph-name deconfliction for the Stitcher's target UFO.
+    #
+    # The Layer's contract (see +Ufo::Layer+) is that two glyphs cannot
+    # share a name — +#add+ raises on conflict. Most Stitcher call sites
+    # already know the name they want is free (e.g. they just synthesised
+    # it). The two that don't — GlyphCopier (outline donors may share
+    # post-table names) and CbdtPropagator (placeholders named "gid{N}"
+    # collide with outline glyphs sharing the same donor-gid scheme) —
+    # ask this helper to allocate a non-colliding name first.
+    #
+    # Centralising the rule here keeps the deconfliction algorithm in
+    # one place: the suffix-search loop, the separator, the order in
+    # which candidates are tried. Changing the rule (e.g. to a UUID
+    # scheme) is a one-file edit.
+    module UniqueGlyphName
+      # Separator between the base name and the disambiguating suffix.
+      # A literal period so the generated name ("gid110.1") still
+      # reads as a variant of the original.
+      SUFFIX_SEPARATOR = "."
+
+      # @param target [Ufo::Font, #glyphs] the target whose +#glyphs+
+      #   hash is the namespace being deconflicted against. Accepts the
+      #   UFO font directly so callers don't have to dig out the layer.
+      # @param base_name [String, #to_s] the requested name.
+      # @return [String] +base_name+ unchanged if no glyph with that
+      #   name exists in +target.glyphs+; otherwise the first
+      #   +"base.1"+, +"base.2"+, ... that does not exist.
+      def self.in(target, base_name)
+        base = base_name.to_s
+        return base unless target.glyphs.key?(base)
+
+        suffix = 1
+        loop do
+          candidate = "#{base}#{SUFFIX_SEPARATOR}#{suffix}"
+          return candidate unless target.glyphs.key?(candidate)
+
+          suffix += 1
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/stitcher.rb

@@ -35,7 +35,9 @@ module Fontisan
     autoload :FormatMetadata,   "fontisan/stitcher/format_metadata"
     autoload :PartitionStrategy, "fontisan/stitcher/partition_strategy"
     autoload :CbdtPropagator,   "fontisan/stitcher/cbdt_propagator"
+    autoload :GlyphCloner,      "fontisan/stitcher/glyph_cloner"
     autoload :GlyphCopier,      "fontisan/stitcher/glyph_copier"
+    autoload :UniqueGlyphName,  "fontisan/stitcher/unique_glyph_name"
 
     # Internal: pairs a compiled loaded font with its stats so
     # +write_collection+ can build the collection and the result from a

data/lib/fontisan/subset/shared_state.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    # Per-subsetting shared state.
+    #
+    # Several subset strategies depend on values computed by earlier
+    # strategies during the same subsetting run:
+    #
+    #   - `subset_max_advance` is computed by the Hmtx strategy and read
+    #     by Hhea (because hhea is processed alphabetically before hmtx).
+    #   - `glyf_data`, `loca_offsets`, and `subset_bbox` are computed by
+    #     the Glyf strategy and consumed by Loca and Head.
+    #
+    # Rather than giving each TableStrategy access to the entire
+    # TableSubsetter (which would couple them to internals), the
+    # cross-strategy state lives here. Each strategy receives a Context
+    # exposing [font], [mapping], [options], and this [SharedState].
+    class SharedState
+      # @return [String, nil] binary glyf data built by the Glyf strategy
+      attr_accessor :glyf_data
+
+      # @return [Array<Integer>, nil] loca offsets produced by the Glyf strategy
+      attr_accessor :loca_offsets
+
+      # @return [Array(Integer, Integer, Integer, Integer), nil] union
+      #   xMin/yMin/xMax/yMax over the subset's glyphs
+      attr_accessor :subset_bbox
+
+      # @return [Integer] largest advanceWidth seen while subsetting hmtx
+      attr_accessor :subset_max_advance
+
+      # @return [TableStrategy::ColorBitmapSubsetter, nil] cached paired
+      #   CBDT+CBLC subsetter so both strategies reuse the same pass
+      attr_accessor :color_bitmap_subsetter
+
+      def initialize
+        @subset_max_advance = 0
+      end
+    end
+  end
+end

data/lib/fontisan/subset/subset_context.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    # Value object handed to every TableStrategy. Encapsulates the inputs
+    # (font, mapping, options) plus the cross-strategy [SharedState] so
+    # strategies don't need a back-reference to the TableSubsetter.
+    #
+    # @!attribute font
+    #   @return [SfntFont]
+    # @!attribute mapping
+    #   @return [GlyphMapping]
+    # @!attribute options
+    #   @return [Options]
+    # @!attribute state
+    #   @return [SharedState]
+    SubsetContext = Struct.new(:font, :mapping, :options, :state,
+                               keyword_init: true)
+  end
+end

data/lib/fontisan/subset/table_strategy/cbdt.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # CBDT strategy: delegate to [ColorBitmapSubsetter], which produces
+      # both CBDT and CBLC bytes in a single pass. The Cblc strategy
+      # reads from the same collaborator so the two tables stay
+      # consistent.
+      class Cbdt
+        # @param context [SubsetContext]
+        # @param tag [String] "CBDT"
+        # @param table [Cbdt] parsed CBDT table (unused)
+        # @return [String] subset CBDT bytes
+        def self.call(context:, tag:, table:)
+          color_bitmap_subsetter(context).cbdt_bytes
+        end
+
+        # @param context [SubsetContext]
+        # @return [ColorBitmapSubsetter] cached on the shared state so the
+        #   Cblc strategy reuses the same pass
+        def self.color_bitmap_subsetter(context)
+          context.state.color_bitmap_subsetter ||= ColorBitmapSubsetter.new(font: context.font,
+                                                                            mapping: context.mapping).build
+        end
+        private_class_method :color_bitmap_subsetter
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/cblc.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # CBLC strategy: delegate to [ColorBitmapSubsetter] (the same
+      # collaborator used by the Cbdt strategy) so both tables stay
+      # consistent. The subsetter is built lazily on first access and
+      # cached on [SharedState].
+      class Cblc
+        # @param context [SubsetContext]
+        # @param tag [String] "CBLC"
+        # @param table [Cblc] parsed CBLC table (unused)
+        # @return [String] subset CBLC bytes
+        def self.call(context:, tag:, table:)
+          color_bitmap_subsetter(context).cblc_bytes
+        end
+
+        def self.color_bitmap_subsetter(context)
+          context.state.color_bitmap_subsetter ||= ColorBitmapSubsetter.new(font: context.font,
+                                                                            mapping: context.mapping).build
+        end
+        private_class_method :color_bitmap_subsetter
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/cmap.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Cmap strategy: rebuild cmap containing only the (codepoint →
+      # new GID) mappings for codepoints whose original GID is retained.
+      # Emits a format-4 subtable for BMP codepoints and a format-12
+      # subtable for supplementary-plane codepoints.
+      class Cmap
+        # @param context [SubsetContext]
+        # @param tag [String] "cmap"
+        # @param table [Cmap] parsed cmap table
+        # @return [String] binary cmap bytes for the subset
+        def self.call(context:, tag:, table:)
+          new_mappings = {}
+          table.unicode_mappings.each do |char_code, old_gid|
+            new_gid = context.mapping.new_id(old_gid)
+            new_mappings[char_code] = new_gid if new_gid
+          end
+          Builder.new(new_mappings).build
+        end
+
+        # Builds a minimal valid cmap table from a {codepoint => gid} map.
+        # Extracted as a sibling class so [Cmap] stays focused on
+        # subsetting dispatch while the binary arithmetic lives
+        # separately.
+        class Builder
+          def initialize(mappings)
+            @mappings = mappings
+          end
+
+          def build
+            @mappings = { 0 => 0 } if @mappings.empty?
+
+            bmp = @mappings.select { |cp, _| cp <= 0xFFFF }
+            supp = @mappings.select { |cp, _| cp > 0xFFFF }
+
+            subtables = []
+            records = []
+
+            unless bmp.empty?
+              subtables << build_format_4(bmp)
+              idx = subtables.size - 1
+              records << [3, 1, idx] # Windows BMP
+              records << [0, 3, idx] # Unicode BMP
+            end
+
+            unless supp.empty?
+              subtables << build_format_12(@mappings)
+              idx = subtables.size - 1
+              records << [3, 10, idx] # Windows UCS-4
+              records << [0, 4, idx]  # Unicode full
+            end
+
+            assemble(records, subtables)
+          end
+
+          private
+
+          def assemble(records, subtables)
+            num_tables = records.size
+            header = [0, num_tables].pack("nn")
+            subtable_base = 4 + (8 * num_tables)
+
+            offsets = []
+            running = subtable_base
+            subtables.each do |st|
+              offsets << running
+              running += st.bytesize
+            end
+
+            record_bytes = +""
+            records.each do |pid, eid, idx|
+              record_bytes << [pid, eid, offsets[idx]].pack("nnN")
+            end
+
+            header + record_bytes + subtables.join
+          end
+
+          def build_format_4(bmp_mappings)
+            segments = coalesce_segments(bmp_mappings)
+            segments << { start_cp: 0xFFFF, end_cp: 0xFFFF, start_gid: 0 }
+
+            seg_count = segments.size
+            seg_count_x2 = seg_count * 2
+            search_range = 2**Math.log2(seg_count).floor * 2
+            search_range = 2 if search_range < 2
+            entry_selector = Math.log2(search_range / 2).to_i
+            range_shift = seg_count_x2 - search_range
+
+            end_codes = segments.map { |s| s[:end_cp] }
+            start_codes = segments.map { |s| s[:start_cp] }
+            id_deltas = segments.map do |s|
+              (s[:start_gid] - s[:start_cp]) & 0xFFFF
+            end
+            id_range_offsets = [0] * seg_count
+
+            subtable = +""
+            subtable << [4, 0, 0, seg_count_x2,
+                         search_range, entry_selector, range_shift].pack("n*")
+            subtable << end_codes.pack("n*")
+            subtable << [0].pack("n") # reservedPad
+            subtable << start_codes.pack("n*")
+            subtable << id_deltas.pack("n*")
+            subtable << id_range_offsets.pack("n*")
+
+            subtable[2, 2] = [subtable.bytesize].pack("n")
+            subtable
+          end
+
+          def build_format_12(all_mappings)
+            groups = coalesce_segments(all_mappings)
+            num_groups = groups.size
+
+            subtable = +""
+            subtable << [12, 0, 0, 0, num_groups].pack("nnNNN")
+            groups.each do |g|
+              subtable << [g[:start_cp], g[:end_cp], g[:start_gid]].pack("NNN")
+            end
+
+            subtable[4, 4] = [subtable.bytesize].pack("N")
+            subtable
+          end
+
+          def coalesce_segments(mappings)
+            sorted = mappings.sort_by { |cp, _| cp }
+            segments = []
+            current = nil
+            sorted.each do |cp, gid|
+              if current && cp == current[:end_cp] + 1 &&
+                  gid == current[:start_gid] + (cp - current[:start_cp])
+                current[:end_cp] = cp
+              else
+                segments << current if current
+                current = { start_cp: cp, end_cp: cp, start_gid: gid }
+              end
+            end
+            segments << current if current
+            segments
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/color_bitmap_placement.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Per-survivor placement: where the source bitmap lives and where it
+# ends up in the subset CBDT.
+module Fontisan
+  module Subset
+    module TableStrategy
+      ColorBitmapPlacement = Struct.new(:source_gid, :new_gid,
+                                        :source_offset, :byte_length,
+                                        :image_format, :strike_ppem,
+                                        :new_offset,
+                                        keyword_init: true) do
+        def initialize(*)
+          super
+          self.new_offset ||= 0
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/subset/table_strategy/color_bitmap_strike_plan.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Subset
+    module TableStrategy
+      # Plan for one strike emitted by [ColorBitmapSubsetter]: the source
+      # BitmapSize plus the list of contiguous new-gid runs (each run
+      # becomes one IndexSubTable in the output CBLC).
+      class ColorBitmapStrikePlan
+        attr_reader :source_strike, :subtable_plans
+
+        def initialize(source_strike)
+          @source_strike = source_strike
+          @subtable_plans = []
+        end
+
+        # Add a placement, grouping into contiguous new-gid runs. A new
+        # run starts when the new gid skips, the ppem changes, or the
+        # image format changes.
+        def add(placement)
+          current = @subtable_plans.last
+
+          if current && placement.new_gid == current.last_new_gid + 1
+            current.add(placement)
+          else
+            sub = ColorBitmapSubtablePlan.new(
+              strike_ppem: placement.strike_ppem,
+              image_format: placement.image_format,
+            )
+            sub.add(placement)
+            @subtable_plans << sub
+          end
+        end
+
+        def empty?
+          @subtable_plans.empty?
+        end
+
+        def subtable_count
+          @subtable_plans.size
+        end
+      end
+    end
+  end
+end