fontisan 0.4.22 → 0.4.23

data/lib/fontisan/tables/cblc_big_glyph_metrics.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # 8-byte bigGlyphMetrics record embedded in CBLC IndexSubTable formats
+    # 2 and 5 (constant-metrics strikes). Layout is smallGlyphMetrics (5
+    # bytes) plus four additional signed advance fields.
+    #
+    #   uint8 height
+    #   uint8 width
+    #   int8  bearing_x
+    #   int8  bearing_y
+    #   int8  advance
+    #   int8  reserved
+    #   int8  advance_lsb
+    #   int8  advance_rsb
+    class CblcBigGlyphMetrics < Binary::BaseRecord
+      uint8 :height
+      uint8 :width
+      int8 :bearing_x
+      int8 :bearing_y
+      int8 :advance
+      int8 :reserved
+      int8 :advance_lsb
+      int8 :advance_rsb
+    end
+  end
+end

data/lib/fontisan/tables/cblc_bitmap_size.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Tables
+    # BitmapSize record embedded in a CBLC table (48 bytes).
+    #
+    # Each BitmapSize describes one bitmap strike: a glyph range rendered
+    # at a specific ppem with a specific bit depth. It points (via
+    # `index_subtable_array_offset`) at a sequence of IndexSubTableArray
+    # records that further describe how to find the bitmap data for each
+    # glyph in CBDT.
+    #
+    # Layout (48 bytes):
+    #   uint32 index_subtable_array_offset
+    #   uint32 index_tables_size
+    #   uint32 number_of_index_subtables
+    #   uint32 color_ref
+    #   CblcSbitLineMetrics hori (12 bytes)
+    #   CblcSbitLineMetrics vert (12 bytes)
+    #   uint16 start_glyph_index
+    #   uint16 end_glyph_index
+    #   uint8  ppem_x
+    #   uint8  ppem_y
+    #   uint8  bit_depth
+    #   int8   flags
+    #
+    # Reference: OpenType CBLC spec, "BitmapSize" record.
+    class CblcBitmapSize < Binary::BaseRecord
+      uint32 :index_subtable_array_offset
+      uint32 :index_tables_size
+      uint32 :number_of_index_subtables
+      uint32 :color_ref
+      CblcSbitLineMetrics :hori, type: Fontisan::Tables::CblcSbitLineMetrics
+      CblcSbitLineMetrics :vert, type: Fontisan::Tables::CblcSbitLineMetrics
+      uint16 :start_glyph_index
+      uint16 :end_glyph_index
+      uint8 :ppem_x
+      uint8 :ppem_y
+      uint8 :bit_depth
+      int8 :flags
+
+      # Pixels per em, assuming square pixels (the common case).
+      #
+      # @return [Integer] ppem value
+      def ppem
+        ppem_x
+      end
+
+      # Glyph ID range covered by this strike.
+      #
+      # @return [Range<Integer>] inclusive glyph ID range
+      def glyph_range
+        start_glyph_index..end_glyph_index
+      end
+
+      # Whether the strike covers a specific glyph.
+      #
+      # @param glyph_id [Integer] source glyph ID
+      # @return [Boolean]
+      def includes_glyph?(glyph_id)
+        glyph_range.include?(glyph_id)
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cblc_glyph_bitmap_location.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # Immutable value object locating one glyph's bitmap inside a CBDT table.
+    #
+    # A CblcIndexSubTable produces one of these per glyph in its range.
+    # The subsetting pipeline reads them to know which CBDT byte range to
+    # retain, then computes fresh offsets for the subset output.
+    #
+    # @!attribute glyph_id
+    #   @return [Integer] source glyph ID
+    # @!attribute image_format
+    #   @return [Integer] CBDT image format (e.g. 17, 18, 19)
+    # @!attribute cbdt_offset
+    #   @return [Integer] absolute byte offset within the source CBDT
+    # @!attribute byte_length
+    #   @return [Integer] length of the bitmap block in CBDT
+    CblcGlyphBitmapLocation = Struct.new(:glyph_id, :image_format,
+                                         :cbdt_offset, :byte_length,
+                                         keyword_init: true) do
+      def initialize(*)
+        super
+        freeze
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cblc_index_subtable.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # Parsed IndexSubTable from a CBLC table.
+    #
+    # The IndexSubTable is the format-specific directory describing how to
+    # locate each glyph's bitmap inside CBDT. Five formats are defined by
+    # the OpenType spec:
+    #
+    #   1 — variable metrics, variable size (uint32 offset array)
+    #   2 — constant metrics, constant size (single imageSize for the range)
+    #   3 — variable metrics, variable size, 4-byte-aligned (uint16 offsets × 4)
+    #   4 — variable metrics, variable size, bit-packed offsets (rare)
+    #   5 — constant metrics, constant size, with explicit uint32 offsetArray
+    #
+    # Each parsed IndexSubTable exposes one [CblcGlyphBitmapLocation] per
+    # glyph in its range, plus the raw bytes so a subsetter can preserve
+    # unchanged subtables verbatim if needed.
+    #
+    # Format-specific parsing is delegated to
+    # [CblcIndexSubTableFormatParser]; this class only owns the data model.
+    #
+    # Reference: OpenType CBLC spec, IndexSubTable formats 1–5.
+    class CblcIndexSubTable
+      # @return [Integer] indexFormat field (1, 2, 3, or 5)
+      attr_reader :index_format
+
+      # @return [Integer] imageFormat field (e.g. 17 = small metrics + PNG)
+      attr_reader :image_format
+
+      # @return [Integer] absolute imageDataOffset from start of CBDT
+      attr_reader :image_data_offset
+
+      # @return [Integer] first glyph ID covered by this subtable
+      attr_reader :first_glyph_index
+
+      # @return [Integer] last glyph ID covered by this subtable
+      attr_reader :last_glyph_index
+
+      # @return [Array<CblcGlyphBitmapLocation>] one per glyph in range
+      attr_reader :locations
+
+      # @return [String] raw bytes of this IndexSubTable in the source CBLC
+      attr_reader :raw_bytes
+
+      def initialize(index_format:, image_format:, image_data_offset:,
+                     first_glyph_index:, last_glyph_index:, locations:,
+                     raw_bytes:)
+        @index_format = index_format
+        @image_format = image_format
+        @image_data_offset = image_data_offset
+        @first_glyph_index = first_glyph_index
+        @last_glyph_index = last_glyph_index
+        @locations = locations
+        @raw_bytes = raw_bytes
+      end
+
+      # Parse an IndexSubTable from a CBLC binary blob.
+      #
+      # @param cblc_bytes [String] the full CBLC table bytes
+      # @param index_subtable_offset [Integer] absolute byte offset within
+      #   `cblc_bytes` where this IndexSubTable begins
+      # @param first_glyph_index [Integer] first glyph ID covered
+      # @param last_glyph_index [Integer] last glyph ID covered
+      # @return [CblcIndexSubTable]
+      def self.parse(cblc_bytes, index_subtable_offset:, first_glyph_index:,
+                     last_glyph_index:)
+        header = CblcIndexSubTableHeader.read(
+          cblc_bytes[index_subtable_offset, 8],
+        )
+
+        new(
+          index_format: header.index_format,
+          image_format: header.image_format,
+          image_data_offset: header.image_data_offset,
+          first_glyph_index: first_glyph_index,
+          last_glyph_index: last_glyph_index,
+          locations: CblcIndexSubTableFormatParser.locations(
+            header: header,
+            bytes: cblc_bytes,
+            base: index_subtable_offset,
+            first: first_glyph_index,
+            last: last_glyph_index,
+          ),
+          raw_bytes: CblcIndexSubTableFormatParser.raw_bytes(
+            header: header,
+            bytes: cblc_bytes,
+            base: index_subtable_offset,
+            first: first_glyph_index,
+            last: last_glyph_index,
+          ),
+        )
+      end
+
+      # Number of glyphs covered by this subtable.
+      #
+      # @return [Integer]
+      def glyph_count
+        last_glyph_index - first_glyph_index + 1
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cblc_index_subtable_array_entry.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # Entry in a CBLC IndexSubTableArray (8 bytes).
+    #
+    # The IndexSubTableArray sits at `BitmapSize#index_subtable_array_offset`
+    # (relative to the start of CBLC) and contains `number_of_index_subtables`
+    # of these entries. Each entry points (via `additional_offset_to_index_subtable`,
+    # relative to the IndexSubTableArray's own location) at an IndexSubTable
+    # record describing how to find the bitmaps for a glyph range.
+    #
+    # Reference: OpenType CBLC spec, IndexSubTableArray record.
+    class CblcIndexSubTableArrayEntry < Binary::BaseRecord
+      uint16 :first_glyph_index
+      uint16 :last_glyph_index
+      uint32 :additional_offset_to_index_subtable
+    end
+  end
+end

data/lib/fontisan/tables/cblc_index_subtable_format_parser.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # Per-format CBLC IndexSubTable parser. Extracted as a sibling class so
+    # that CblcIndexSubTable remains a pure data model.
+    #
+    # The five OpenType formats differ in how the offset array encodes
+    # glyph lengths and CBDT offsets. This class hides that arithmetic
+    # behind a uniform [.locations] entry point that returns a flat list
+    # of CblcGlyphBitmapLocation objects (one per glyph in the range).
+    #
+    # Reference: OpenType CBLC spec, IndexSubTable formats 1–5.
+    class CblcIndexSubTableFormatParser
+      # Format 4 (bit-packed offsets) is rare and not currently parsed.
+      class UnsupportedFormat < Fontisan::Error; end
+
+      class << self
+        # Returns an Array of CblcGlyphBitmapLocation, one per glyph in
+        # the IndexSubTable's glyph range.
+        #
+        # @param header [CblcIndexSubTableHeader] the 8-byte IndexSubTable header
+        # @param bytes [String] the full CBLC table bytes
+        # @param base [Integer] absolute offset of this IndexSubTable within CBLC
+        # @param first [Integer] first glyph ID covered
+        # @param last [Integer] last glyph ID covered
+        # @return [Array<CblcGlyphBitmapLocation>]
+        def locations(header:, bytes:, base:, first:, last:)
+          case header.index_format
+          when 1 then format_1(header, bytes, base, first, last)
+          when 2 then format_2(header, bytes, base, first, last)
+          when 3 then format_3(header, bytes, base, first, last)
+          when 5 then format_5(header, bytes, base, first, last)
+          when 4
+            raise UnsupportedFormat,
+                  "CBLC IndexSubTable format 4 (bit-packed) is unsupported"
+          else
+            raise UnsupportedFormat,
+                  "Unknown CBLC IndexSubTable format: #{header.index_format}"
+          end
+        end
+
+        # Returns the raw bytes the IndexSubTable occupies in CBLC.
+        #
+        # @return [String]
+        def raw_bytes(header:, bytes:, base:, first:, last:)
+          count = last - first + 1
+          length = byte_length(header.index_format, count, bytes, base)
+          bytes[base, length]
+        end
+
+        private
+
+        # Format 1: variable metrics + variable size, uint32 offsetArray.
+        # offsets[0] is the first glyph's bitmap start (relative to
+        # imageDataOffset); offsets[i+1] - offsets[i] = glyph i's length.
+        def format_1(header, bytes, base, first, last)
+          count = last - first + 1
+          offsets = uint32_array(bytes, base + 8, count + 1)
+          build(first, count, offsets, header.image_format,
+                header.image_data_offset)
+        end
+
+        # Format 2: constant metrics + constant size. One imageSize field
+        # applies to every glyph; the i-th glyph's bitmap is at
+        # imageDataOffset + i * imageSize.
+        def format_2(header, bytes, base, first, last)
+          count = last - first + 1
+          image_size = bytes[base + 8, 4].unpack1("N")
+          Array.new(count) do |i|
+            CblcGlyphBitmapLocation.new(
+              glyph_id: first + i,
+              image_format: header.image_format,
+              cbdt_offset: header.image_data_offset + (i * image_size),
+              byte_length: image_size,
+            )
+          end
+        end
+
+        # Format 3: like format 1 but offsets are uint16 and stored as
+        # multiples of 4 (CBDT bitmap data is 4-byte aligned).
+        def format_3(header, bytes, base, first, last)
+          count = last - first + 1
+          raw = uint16_array(bytes, base + 8, count + 1)
+          offsets = raw.map { |v| v * 4 }
+          build(first, count, offsets, header.image_format,
+                header.image_data_offset)
+        end
+
+        # Format 5: constant metrics + constant size with an explicit
+        # uint32 offsetArray (count + 1 entries). Length per glyph is
+        # the constant imageSize; offset comes from the array.
+        def format_5(header, bytes, base, first, last)
+          count = last - first + 1
+          image_size = bytes[base + 8, 4].unpack1("N")
+          offset_array_start = base + 12 + 8 + 4
+          offsets = uint32_array(bytes, offset_array_start, count + 1)
+          Array.new(count) do |i|
+            start_off = offsets[i] || 0
+            CblcGlyphBitmapLocation.new(
+              glyph_id: first + i,
+              image_format: header.image_format,
+              cbdt_offset: header.image_data_offset + start_off,
+              byte_length: image_size,
+            )
+          end
+        end
+
+        def build(first, count, offsets, image_format, image_data_offset)
+          Array.new(count) do |i|
+            start_off = offsets[i] || 0
+            end_off = offsets[i + 1] || start_off
+            CblcGlyphBitmapLocation.new(
+              glyph_id: first + i,
+              image_format: image_format,
+              cbdt_offset: image_data_offset + start_off,
+              byte_length: end_off - start_off,
+            )
+          end
+        end
+
+        def byte_length(index_format, count, bytes, base)
+          case index_format
+          when 1, 3
+            entry_size = index_format == 1 ? 4 : 2
+            8 + (count + 1) * entry_size
+          when 2
+            8 + 4 + 8 # header + imageSize + bigGlyphMetrics
+          when 5
+            8 + 4 + 8 + 4 + (count + 1) * 4
+          else
+            bytes.bytesize - base
+          end
+        end
+
+        def uint32_array(bytes, offset, count)
+          return [] if count.zero?
+
+          bytes[offset, count * 4].unpack("N*")
+        end
+
+        def uint16_array(bytes, offset, count)
+          return [] if count.zero?
+
+          bytes[offset, count * 2].unpack("n*")
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/tables/cblc_index_subtable_header.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # 8-byte header common to all CBLC IndexSubTable formats.
+    #
+    #   uint16 indexFormat
+    #   uint16 imageFormat
+    #   uint32 imageDataOffset (absolute, from start of CBDT)
+    #
+    # Format-specific data follows immediately after this header.
+    class CblcIndexSubTableHeader < Binary::BaseRecord
+      uint16 :index_format
+      uint16 :image_format
+      uint32 :image_data_offset
+    end
+  end
+end

data/lib/fontisan/tables/cblc_sbit_line_metrics.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Tables
+    # SbitLineMetrics record embedded in CBLC BitmapSize records.
+    #
+    # Two of these (horizontal + vertical) appear in every BitmapSize,
+    # totalling 24 bytes per strike. The fields are signed/unsigned 8-bit
+    # integers; OpenType specifies signed values for some, unsigned for
+    # others, mirroring the EBDT/BDF layout.
+    #
+    # Reference: OpenType CBLC spec, "SbitLineMetrics" sub-structure.
+    class CblcSbitLineMetrics < Binary::BaseRecord
+      int8 :ascender
+      int8 :descender
+      uint8 :width_max
+      int8 :caret_slope_numerator
+      int8 :caret_slope_denominator
+      int8 :caret_offset
+      int8 :min_origin_sb
+      int8 :min_advance_sb
+      int8 :max_before_bl
+      int8 :min_after_bl
+      int8 :pad1
+      int8 :pad2
+    end
+  end
+end

data/lib/fontisan/tables.rb

@@ -4,6 +4,17 @@
 
 module Fontisan
   module Tables
+    autoload :CblcBigGlyphMetrics, "fontisan/tables/cblc_big_glyph_metrics"
+    autoload :CblcBitmapSize, "fontisan/tables/cblc_bitmap_size"
+    autoload :CblcGlyphBitmapLocation, "fontisan/tables/cblc_glyph_bitmap_location"
+    autoload :CblcIndexSubTable, "fontisan/tables/cblc_index_subtable"
+    autoload :CblcIndexSubTableArrayEntry,
+             "fontisan/tables/cblc_index_subtable_array_entry"
+    autoload :CblcIndexSubTableFormatParser,
+             "fontisan/tables/cblc_index_subtable_format_parser"
+    autoload :CblcIndexSubTableHeader,
+             "fontisan/tables/cblc_index_subtable_header"
+    autoload :CblcSbitLineMetrics, "fontisan/tables/cblc_sbit_line_metrics"
     autoload :Cbdt, "fontisan/tables/cbdt"
     autoload :Cblc, "fontisan/tables/cblc"
     autoload :Cff, "fontisan/tables/cff"

data/lib/fontisan/ufo/glyph_exists_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    # Raised by +Layer#add+ when a glyph with the same name is already
+    # present. Surfaces what would otherwise be a silent overwrite so
+    # the caller can decide between +Layer#put+ (intentional replace)
+    # and +Stitcher::UniqueGlyphName.in+ (auto-rename).
+    #
+    # Extracted as a sibling of +Layer+ (rather than nested inside it)
+    # so the namespace stays flat and the error can be referenced
+    # without pulling in the full Layer implementation.
+    class GlyphExistsError < StandardError
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+        super("a glyph named #{name.inspect} already exists; use #put " \
+              "to overwrite or UniqueGlyphName.in to deconflict")
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/layer.rb

@@ -5,8 +5,27 @@ module Fontisan
     # A single layer in a UFO source. A Layer holds a set of glyphs
     # keyed by name. The default layer is `public.default` per UFO 3.
     #
-    # glyphs is mutated in place by Reader and Writer; the Layer does
-    # not own serialization concerns.
+    # == Naming contract
+    #
+    # Glyph names are the layer's primary key. Two distinct glyphs with
+    # the same name cannot coexist — adding the second would silently
+    # destroy the first, a class of bug that has historically cost real
+    # data (e.g. CJK Ext G cmap loss when CBDT placeholders collided
+    # with outline glyphs sharing "gid{N}" names).
+    #
+    # To make that contract unbreakable, +#add+ RAISES +GlyphExistsError+
+    # on conflict. Callers who want one of the other two semantics pick
+    # the method that names it:
+    #
+    #   +#add+::    insert; raise if the name is taken (the safe default)
+    #   +#put+::    insert; overwrite any existing glyph with the same name
+    #
+    # Callers that need auto-renaming (insertion without giving up on a
+    # collision) call +Stitcher::UniqueGlyphName.in(target, base)+ first,
+    # then +#add+ the glyph under the returned name.
+    #
+    # The error class itself lives at +Fontisan::Ufo::GlyphExistsError+
+    # (sibling, not nested) so the namespace stays flat.
     class Layer
       DEFAULT_NAME = "public.default"
 
@@ -21,7 +40,28 @@ module Fontisan
         @glyphs[glyph_name.to_s]
       end
 
+      # Insert +glyph+. Raises +GlyphExistsError+ if a glyph with the
+      # same name is already present — this is the contract that keeps
+      # the layer's key namespace trustworthy.
+      #
+      # @param glyph [Glyph]
+      # @return [Glyph] the same glyph
+      # @raise [GlyphExistsError] if +glyph.name+ is already taken
       def add(glyph)
+        name = glyph.name.to_s
+        raise GlyphExistsError, name if @glyphs.key?(name)
+
+        @glyphs[name] = glyph
+        glyph
+      end
+
+      # Insert +glyph+, replacing any existing glyph with the same
+      # name. Use this when the caller has positively decided that the
+      # previous glyph (if any) should be discarded.
+      #
+      # @param glyph [Glyph]
+      # @return [Glyph] the same glyph
+      def put(glyph)
         @glyphs[glyph.name.to_s] = glyph
         glyph
       end

data/lib/fontisan/ufo.rb

@@ -17,7 +17,8 @@ module Fontisan
   #
   # Reference: https://unifiedfontobject.org
   module Ufo
-    autoload :Font,        "fontisan/ufo/font"
+    autoload :Font, "fontisan/ufo/font"
+    autoload :GlyphExistsError, "fontisan/ufo/glyph_exists_error"
     autoload :Info,        "fontisan/ufo/info"
     autoload :Layer,       "fontisan/ufo/layer"
     autoload :LayerSet,    "fontisan/ufo/layer_set"

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.22"
+  VERSION = "0.4.23"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.22
+  version: 0.4.23
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-08 00:00:00.000000000 Z
+date: 2026-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -440,6 +440,7 @@ files:
 - lib/fontisan/stitcher/collection_result.rb
 - lib/fontisan/stitcher/deduplicator.rb
 - lib/fontisan/stitcher/format_metadata.rb
+- lib/fontisan/stitcher/glyph_cloner.rb
 - lib/fontisan/stitcher/glyph_copier.rb
 - lib/fontisan/stitcher/glyph_limit.rb
 - lib/fontisan/stitcher/glyph_signature.rb
@@ -455,12 +456,35 @@ files:
 - lib/fontisan/stitcher/selector/gid.rb
 - lib/fontisan/stitcher/selector/range.rb
 - lib/fontisan/stitcher/source.rb
+- lib/fontisan/stitcher/unique_glyph_name.rb
 - lib/fontisan/stitcher_cli.rb
 - lib/fontisan/subset.rb
 - lib/fontisan/subset/builder.rb
 - lib/fontisan/subset/glyph_mapping.rb
 - lib/fontisan/subset/options.rb
 - lib/fontisan/subset/profile.rb
+- lib/fontisan/subset/shared_state.rb
+- lib/fontisan/subset/subset_context.rb
+- lib/fontisan/subset/table_strategy.rb
+- lib/fontisan/subset/table_strategy/cbdt.rb
+- lib/fontisan/subset/table_strategy/cblc.rb
+- lib/fontisan/subset/table_strategy/cmap.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_placement.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_strike_plan.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_subset_plan.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_subsetter.rb
+- lib/fontisan/subset/table_strategy/color_bitmap_subtable_plan.rb
+- lib/fontisan/subset/table_strategy/glyf.rb
+- lib/fontisan/subset/table_strategy/glyf_loca_builder.rb
+- lib/fontisan/subset/table_strategy/head.rb
+- lib/fontisan/subset/table_strategy/hhea.rb
+- lib/fontisan/subset/table_strategy/hmtx.rb
+- lib/fontisan/subset/table_strategy/loca.rb
+- lib/fontisan/subset/table_strategy/maxp.rb
+- lib/fontisan/subset/table_strategy/name.rb
+- lib/fontisan/subset/table_strategy/os2.rb
+- lib/fontisan/subset/table_strategy/pass_through.rb
+- lib/fontisan/subset/table_strategy/post.rb
 - lib/fontisan/subset/table_subsetter.rb
 - lib/fontisan/svg.rb
 - lib/fontisan/svg/font_face_generator.rb
@@ -483,6 +507,14 @@ files:
 - lib/fontisan/tables.rb
 - lib/fontisan/tables/cbdt.rb
 - lib/fontisan/tables/cblc.rb
+- lib/fontisan/tables/cblc_big_glyph_metrics.rb
+- lib/fontisan/tables/cblc_bitmap_size.rb
+- lib/fontisan/tables/cblc_glyph_bitmap_location.rb
+- lib/fontisan/tables/cblc_index_subtable.rb
+- lib/fontisan/tables/cblc_index_subtable_array_entry.rb
+- lib/fontisan/tables/cblc_index_subtable_format_parser.rb
+- lib/fontisan/tables/cblc_index_subtable_header.rb
+- lib/fontisan/tables/cblc_sbit_line_metrics.rb
 - lib/fontisan/tables/cff.rb
 - lib/fontisan/tables/cff/cff2_charstring_builder.rb
 - lib/fontisan/tables/cff/cff_glyph.rb
@@ -657,6 +689,7 @@ files:
 - lib/fontisan/ufo/features.rb
 - lib/fontisan/ufo/font.rb
 - lib/fontisan/ufo/glyph.rb
+- lib/fontisan/ufo/glyph_exists_error.rb
 - lib/fontisan/ufo/guideline.rb
 - lib/fontisan/ufo/image.rb
 - lib/fontisan/ufo/image_set.rb