fontisan 0.4.32 → 0.4.34

data/lib/fontisan/tables/cff2/table_reader.rb

@@ -235,25 +235,7 @@ module Fontisan
           Cff::Index.new(@io, start_offset: offset)
         end
 
-        private
-
-        # Read bytes safely with EOF checking
-        #
-        # @param bytes [Integer] Number of bytes to read
-        # @param description [String] Description for error messages
-        # @return [String] Binary data
-        # @raise [EOFError] If not enough bytes available
-        def read_safely(bytes, description)
-          data = @io.read(bytes)
-          if data.nil? || data.bytesize < bytes
-            raise EOFError,
-                  "Unexpected EOF while reading #{description}"
-          end
-
-          data
-        end
-
-        # Parse DICT structure
+        # Parse a DICT structure (public: reused by the CFF2 subsetter).
         #
         # @param data [String] DICT binary data
         # @return [Hash] Parsed operators and values
@@ -281,20 +263,37 @@ module Fontisan
           dict
         end
 
+        private
+
+        # Read bytes safely with EOF checking
+        #
+        # @param bytes [Integer] Number of bytes to read
+        # @param description [String] Description for error messages
+        # @return [String] Binary data
+        # @raise [EOFError] If not enough bytes available
+        def read_safely(bytes, description)
+          data = @io.read(bytes)
+          if data.nil? || data.bytesize < bytes
+            raise EOFError,
+                  "Unexpected EOF while reading #{description}"
+          end
+
+          data
+        end
+
         # Check if byte is an operator
         #
-        # CFF2 extends the operator range to include operator 24 (vstore)
+        # CFF/CFF2 DICT operator bytes are 0-21 (with 12 as the two-byte
+        # escape prefix) and 24 (vstore, CFF2-specific). Number encoding
+        # prefixes (28, 29, 30) and ranges (32-254) are NOT operators.
         #
         # @param byte [Integer] Byte value
         # @return [Boolean] True if operator
         def operator_byte?(byte)
-          # Standard DICT operators (0-21, excluding number markers)
-          return true if byte <= 21 && ![12, 28, 29, 30, 31].include?(byte)
-
-          # CFF2-specific operators
-          return true if byte == VSTORE_OPERATOR
+          return false if (28..30).cover?(byte) # number prefixes
+          return false if (32..254).cover?(byte) # number ranges
 
-          false
+          true # 0-27 (incl. 12 escape), 31, 255 — treat as operator
         end
 
         # Read DICT operator

data/lib/fontisan/tables/cff2.rb

@@ -26,6 +26,7 @@ module Fontisan
       autoload :CharstringParser, "fontisan/tables/cff2/charstring_parser"
       autoload :FdSelect, "fontisan/tables/cff2/fd_select"
       autoload :Header, "fontisan/tables/cff2/header"
+      autoload :Index, "fontisan/tables/cff2/index"
       autoload :IndexBuilder, "fontisan/tables/cff2/index_builder"
       autoload :DictEncoder, "fontisan/tables/cff2/dict_encoder"
       autoload :OperandStack, "fontisan/tables/cff2/operand_stack"

data/lib/fontisan/type1/charstrings.rb

@@ -42,6 +42,39 @@ module Fontisan
       def initialize(private_dict = nil)
         @private_dict = private_dict || PrivateDict.new
         @charstrings = {}
+        @encoding_override = nil
+      end
+
+      # Build a CharStrings from a pre-built glyph-name → charstring-bytecode
+      # hash. Useful for constructing test fixtures without parsing a full
+      # Type 1 font. Optionally accepts +encoding:+ to override the default
+      # Adobe Standard Encoding (char code → glyph name).
+      #
+      # @param charstrings_hash [Hash{String=>String}]
+      # @param encoding [Hash{Integer=>String}, nil]
+      # @param private_dict [PrivateDict, nil]
+      # @return [CharStrings]
+      def self.from_hash(charstrings_hash, encoding: nil, private_dict: nil)
+        cs = new(private_dict)
+        charstrings_hash.each { |name, data| cs.register(name, data) }
+        cs.set_encoding(encoding) if encoding
+        cs
+      end
+
+      # Register (or replace) a glyph's charstring data.
+      #
+      # @param glyph_name [String]
+      # @param charstring_data [String] binary charstring bytecode
+      def register(glyph_name, charstring_data)
+        @charstrings[glyph_name] = charstring_data
+      end
+
+      # Override the default Adobe Standard Encoding with a custom
+      # +char_code → glyph_name+ map.
+      #
+      # @param encoding [Hash{Integer=>String}]
+      def set_encoding(encoding)
+        @encoding_override = encoding
       end
 
       # Parse CharStrings dictionary from decrypted Type 1 font data
@@ -72,7 +105,7 @@ module Fontisan
       #
       # @return [Hash] Character code to glyph name mapping
       def encoding
-        @encoding ||= build_standard_encoding
+        @encoding_override || (@encoding ||= build_standard_encoding)
       end
 
       # Iterate over all charstrings

data/lib/fontisan/type1/seac_expander.rb

@@ -2,6 +2,10 @@
 
 module Fontisan
   module Type1
+    # Error raised when a seac reference cannot be resolved (the referenced
+    # glyph is missing, or a cycle is detected in nested seac).
+    class SeacReferenceError < Fontisan::Error; end
+
     # Expands Type 1 seac composite glyphs into base + accent outlines
     #
     # [`SeacExpander`](lib/fontisan/type1/seac_expander.rb) handles the
@@ -9,6 +13,10 @@ module Fontisan
     # The seac operator combines two glyphs (a base character and an accent)
     # with a positioning offset, which must be decomposed for CFF conversion.
     #
+    # Supports nested seac: if a base or accent glyph is itself a seac
+    # composite, it is recursively expanded. Cycles are detected and raise
+    # {SeacReferenceError}.
+    #
     # The seac operator format is:
     # ```
     # seac asb adx ady bchar achar
@@ -28,6 +36,8 @@ module Fontisan
     #
     # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
     class SeacExpander
+      MAX_DEPTH = 16
+
       # @return [CharStrings] Type 1 CharStrings dictionary
       attr_reader :charstrings
 
@@ -43,67 +53,15 @@ module Fontisan
         @private_dict = private_dict
       end
 
-      # Decompose a seac composite glyph into base + accent outlines
-      #
-      # This method:
-      # 1. Parses the seac operator to extract components
-      # 2. Gets CharStrings for base and accent glyphs
-      # 3. Parses both CharStrings into outline commands
-      # 4. Transforms the accent by (adx, ady) offset
-      # 5. Merges base and accent outlines into a single path
-      # 6. Returns the decomposed CharString data
+      # Decompose a seac composite glyph into base + accent outlines.
+      # Handles nested seac recursively.
       #
       # @param glyph_name [String] Name of the composite glyph to decompose
       # @return [String, nil] Decomposed CharString bytecode, or nil if not a seac composite
-      # @raise [Fontisan::Error] If base or accent glyphs are not found
-      #
-      # @example Decompose "Agrave" glyph
-      #   expander.decompose("Agrave")
+      # @raise [SeacReferenceError] If base or accent glyphs are not found,
+      #   or if a cycle is detected
       def decompose(glyph_name)
-        components = @charstrings.components_for(glyph_name)
-        return nil unless components
-
-        # Use the encoding map to lookup glyph names from character codes
-        base_glyph_name = @charstrings.encoding[components[:base]]
-        accent_glyph_name = @charstrings.encoding[components[:accent]]
-
-        if base_glyph_name.nil?
-          raise Fontisan::Error,
-                "Base glyph for char code #{components[:base]} not found"
-        end
-
-        if accent_glyph_name.nil?
-          raise Fontisan::Error,
-                "Accent glyph for char code #{components[:accent]} not found"
-        end
-
-        # Get CharStrings for base and accent
-        base_charstring = @charstrings[base_glyph_name]
-        accent_charstring = @charstrings[accent_glyph_name]
-
-        if base_charstring.nil?
-          raise Fontisan::Error,
-                "CharString not found for base glyph #{base_glyph_name}"
-        end
-
-        if accent_charstring.nil?
-          raise Fontisan::Error,
-                "CharString not found for accent glyph #{accent_glyph_name}"
-        end
-
-        # Parse both CharStrings into command sequences
-        base_commands = parse_charstring_to_commands(base_charstring)
-        accent_commands = parse_charstring_to_commands(accent_charstring)
-
-        # Transform accent by (adx, ady) offset
-        accent_commands = transform_commands(accent_commands, components[:adx],
-                                             components[:ady])
-
-        # Merge base and accent commands
-        merged_commands = merge_outline_commands(base_commands, accent_commands)
-
-        # Convert merged commands back to CharString bytecode
-        generate_charstring(merged_commands)
+        decompose_with_visited(glyph_name, Set.new)
       end
 
       # Check if a glyph is a seac composite
@@ -123,6 +81,59 @@ module Fontisan
 
       private
 
+      # Recursive decomposition with cycle detection via +visited+ set.
+      def decompose_with_visited(glyph_name, visited)
+        return nil unless composite?(glyph_name)
+
+        if visited.include?(glyph_name)
+          raise SeacReferenceError,
+                "Cycle detected in seac references: #{visited.to_a.join(' → ')} → #{glyph_name}"
+        end
+
+        if visited.size >= MAX_DEPTH
+          raise SeacReferenceError,
+                "seac nesting depth exceeds #{MAX_DEPTH} at #{glyph_name}"
+        end
+
+        visited_next = visited.dup.add(glyph_name)
+        components = @charstrings.components_for(glyph_name)
+
+        base_name = resolve_char_code(components[:base], "base", glyph_name)
+        accent_name = resolve_char_code(components[:accent], "accent", glyph_name)
+
+        base_commands = resolve_glyph_commands(base_name, visited_next)
+        accent_commands = resolve_glyph_commands(accent_name, visited_next)
+        accent_commands = transform_commands(accent_commands, components[:adx],
+                                             components[:ady])
+        merged = merge_outline_commands(base_commands, accent_commands)
+        generate_charstring(merged)
+      end
+
+      # Resolve a char code to a glyph name via the font's encoding.
+      def resolve_char_code(char_code, role, parent)
+        name = @charstrings.encoding[char_code]
+        return name if name
+
+        raise SeacReferenceError,
+              "#{role} glyph for char code #{char_code} (in #{parent}) not found in encoding"
+      end
+
+      # Get outline commands for a glyph, recursively expanding nested seac.
+      def resolve_glyph_commands(glyph_name, visited)
+        charstring = @charstrings[glyph_name]
+        if charstring.nil?
+          raise SeacReferenceError,
+                "CharString not found for glyph #{glyph_name}"
+        end
+
+        if composite?(glyph_name)
+          nested = decompose_with_visited(glyph_name, visited)
+          parse_charstring_to_commands(nested)
+        else
+          parse_charstring_to_commands(charstring)
+        end
+      end
+
       # Parse Type 1 CharString into drawing commands
       #
       # Converts Type 1 CharString bytecode into a list of drawing commands

data/lib/fontisan/ufo/compile/cff2.rb

@@ -33,42 +33,143 @@ module Fontisan
 
         # @param font [Fontisan::Ufo::Font]
         # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @param masters [Array<Hash>, nil] variation masters for variable
+        #   CFF2. Each hash: { font:, axes: }. When present, charstrings
+        #   emit blend operators and a VariationStore is embedded.
+        # @param axis_count [Integer, nil] number of variation axes
         # @param variation_store [String, nil] ItemVariationStore bytes
         #   for variable CFF2 fonts. When present, embedded between the
         #   GlobalSubr INDEX and CharStrings INDEX, and referenced from
         #   the Top DICT via operator 24.
         # @return [String] CFF2 table bytes
-        def self.build(_font, glyphs:, variation_store: nil)
+        def self.build(font, glyphs:, masters: nil, axis_count: nil,
+                       variation_store: nil)
+          if masters&.any?
+            build_variable(font, glyphs, masters, axis_count)
+          else
+            build_static(font, glyphs, variation_store:)
+          end
+        end
+
+        # Build a static CFF2 table (no variation data).
+        def self.build_static(font, glyphs, variation_store:)
           charstrings = glyphs.map { |g| charstring_for(g) }
           global_subr_index = empty_global_subr_index
           font_dict = build_font_dict(private_size: 0, private_offset: 0)
           font_dict_index = Tables::Cff2::IndexBuilder.build([font_dict])
           vs_bytes = variation_store&.b
 
-          # Fixed-point iteration: encode Top DICT, compute offsets, repeat.
-          top_dict = encode_top_dict(
-            charstrings_offset: 0, font_dict_index_offset: 0,
-            variation_store_offset: vs_bytes ? 0 : nil
+          layout = converge_layout(
+            charstrings:, global_subr_index:, font_dict_index:,
+            variation_store: vs_bytes
           )
-          layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
-                                  font_dict_index:, variation_store: vs_bytes)
+          assemble(layout:)
+        end
 
-          10.times do
-            top_dict = encode_top_dict(
-              charstrings_offset: layout[:charstrings_offset],
-              font_dict_index_offset: layout[:font_dict_index_offset],
-              variation_store_offset: layout[:variation_store_offset],
-            )
-            next_layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
-                                         font_dict_index:, variation_store: vs_bytes)
-            break if same_offsets?(layout, next_layout)
+        # Build a variable CFF2 table with blend operators and a VStore.
+        #
+        # Each glyph gets a variable charstring with blend operators when
+        # master outlines are available for it. Glyphs without masters fall
+        # back to static charstrings. The VStore contains one region per
+        # master, each peaking at the master's axis location.
+        def self.build_variable(font, glyphs, masters, axis_count)
+          num_regions = masters.size
+          vstore = build_variation_store(masters, axis_count)
 
-            layout = next_layout
+          master_glyph_sets = masters.map do |m|
+            { font: m[:font], by_name: m[:font].glyphs }
+          end
+
+          charstrings = glyphs.map.with_index do |glyph, _idx|
+            master_outlines = master_glyph_sets.filter_map do |mg|
+              mg[:by_name][glyph.name]&.to_outline
+            end
+
+            if master_outlines.size == num_regions && glyph.contours.any?
+              Tables::Cff::Cff2CharStringBuilder.build_variable(
+                glyph.to_outline,
+                master_outlines: master_outlines,
+                num_regions: num_regions,
+                width: glyph.width.to_i,
+              )
+            else
+              charstring_for(glyph)
+            end
           end
 
+          global_subr_index = empty_global_subr_index
+          font_dict = build_font_dict(private_size: 0, private_offset: 0)
+          font_dict_index = Tables::Cff2::IndexBuilder.build([font_dict])
+
+          layout = converge_layout(
+            charstrings:, global_subr_index:, font_dict_index:,
+            variation_store: vstore
+          )
           assemble(layout:)
         end
 
+        # Build the ItemVariationStore for CFF2: one region per master,
+        # each peaking at the master's axis location.
+        def self.build_variation_store(masters, axis_count)
+          ac = axis_count || masters.first&.dig(:axes)&.size || 1
+          regions = masters.each_with_index.map do |_master, midx|
+            Array.new(ac) do |aidx|
+              if aidx == midx
+                { start: -1.0, peak: 1.0, end: 1.0 }
+              else
+                { start: -1.0, peak: 0.0, end: 1.0 }
+              end
+            end
+          end
+
+          region_list = serialize_region_list(regions, ac)
+          # One ItemVariationData with all regions referenced but zero items.
+          # The actual deltas live in charstrings (pushed via blend operands).
+          var_data = serialize_empty_variation_data(regions.size)
+
+          header_size = 8
+          offsets_array_size = 4
+          region_list_offset = header_size + offsets_array_size
+          var_data_offset = region_list_offset + region_list.bytesize
+
+          store = +""
+          store << [1].pack("n")
+          store << [region_list_offset].pack("N")
+          store << [1].pack("n")
+          store << [var_data_offset].pack("N")
+          store << region_list
+          store << var_data
+          store
+        end
+
+        def self.serialize_region_list(regions, axis_count)
+          io = +""
+          io << [axis_count].pack("n")
+          io << [regions.size].pack("n")
+          regions.each do |region|
+            region.each do |coords|
+              io << [f2dot14(coords[:start]), f2dot14(coords[:peak]),
+                     f2dot14(coords[:end])].pack("nnn")
+            end
+          end
+          io
+        end
+
+        # Serialize an ItemVariationData with all regions referenced but
+        # zero items. CFF2 charstrings push their own deltas via blend.
+        def self.serialize_empty_variation_data(region_count)
+          io = +""
+          io << [0].pack("n")               # itemCount = 0
+          io << [region_count].pack("n")    # shortDeltaCount
+          io << [region_count].pack("n")    # regionIndexCount
+          region_count.times { |i| io << [i].pack("n") }
+          io
+        end
+
+        def self.f2dot14(value)
+          (value.to_f * 16384).to_i.clamp(-16384, 16384)
+        end
+
         # ---------- charstring per-glyph ----------
 
         def self.charstring_for(glyph)
@@ -148,6 +249,43 @@ module Fontisan
           }
         end
 
+        # Iteratively encode the Top DICT and recompute offsets until the
+        # layout stabilizes. After convergence, performs one final
+        # encode + compute pass so +layout[:top_dict]+ carries the
+        # converged offsets (not the stale initial placeholder).
+        def self.converge_layout(charstrings:, global_subr_index:,
+                                 font_dict_index:, variation_store: nil)
+          has_vs = !variation_store.nil?
+          top_dict = encode_top_dict(
+            charstrings_offset: 0, font_dict_index_offset: 0,
+            variation_store_offset: has_vs ? 0 : nil
+          )
+          layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
+                                  font_dict_index:, variation_store:)
+
+          10.times do
+            top_dict = encode_top_dict(
+              charstrings_offset: layout[:charstrings_offset],
+              font_dict_index_offset: layout[:font_dict_index_offset],
+              variation_store_offset: layout[:variation_store_offset],
+            )
+            next_layout = compute_layout(top_dict:, charstrings:, global_subr_index:,
+                                         font_dict_index:, variation_store:)
+            break if same_offsets?(layout, next_layout)
+
+            layout = next_layout
+          end
+
+          # Final encode ensures layout[:top_dict] matches converged offsets
+          final_td = encode_top_dict(
+            charstrings_offset: layout[:charstrings_offset],
+            font_dict_index_offset: layout[:font_dict_index_offset],
+            variation_store_offset: layout[:variation_store_offset],
+          )
+          compute_layout(top_dict: final_td, charstrings:, global_subr_index:,
+                         font_dict_index:, variation_store:)
+        end
+
         def self.same_offsets?(a, b)
           a[:charstrings_offset] == b[:charstrings_offset] &&
             a[:font_dict_index_offset] == b[:font_dict_index_offset] &&
@@ -173,8 +311,12 @@ module Fontisan
 
         private_class_method :charstring_for, :empty_charstring,
                              :encode_top_dict, :build_font_dict,
-                             :compute_layout, :same_offsets?,
-                             :empty_global_subr_index, :assemble
+                             :compute_layout, :converge_layout,
+                             :same_offsets?,
+                             :empty_global_subr_index, :assemble,
+                             :build_static, :build_variable,
+                             :build_variation_store, :serialize_region_list,
+                             :serialize_empty_variation_data, :f2dot14
       end
     end
   end

data/lib/fontisan/ufo/compile/feature_compiler.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Minimal Adobe FEA (features.fea) parser. Extracts the two most
+      # common feature constructs from UFO sources:
+      #
+      #   feature liga { sub f i by fi; } liga;    → LigatureSubst
+      #   feature kern { pos A V -50; } kern;       → PairPos
+      #
+      # Unsupported constructs are collected and surfaced via
+      # {ParsedFeatures#unsupported} so the caller can decide whether
+      # to warn or raise. This is the "limited fea subset" approach
+      # from TODO #10b — expand as real-world fonts demand.
+      #
+      # The parser is deliberately simple: it tokenizes on whitespace
+      # and semicolons, recognizes `feature <tag> { ... } <tag>;` blocks,
+      # and dispatches per-statement to registered rule handlers (OCP —
+      # new rule kinds are one handler addition).
+      #
+      # @example
+      #   parsed = FeatureCompiler.parse(fea_text)
+      #   parsed.ligatures_for("liga")  # => [{sequence: ["f", "i"], result: "fi"}]
+      class FeatureCompiler
+        # @param text [String] features.fea content
+        # @return [ParsedFeatures]
+        def self.parse(text)
+          new.parse(text)
+        end
+
+        # @param text [String]
+        # @return [ParsedFeatures]
+        def parse(text)
+          @parsed = ParsedFeatures.new
+          tokenize_blocks(text || "")
+          @parsed
+        end
+
+        private
+
+        # Split text into `feature <tag> { body } <tag>;` blocks and
+        # pass each block body to the statement dispatcher.
+        def tokenize_blocks(text)
+          # Strip comments (# to end of line)
+          cleaned = text.gsub(%r{#[^\n]*}, "")
+          # Match feature blocks: feature TAG { ... } TAG;
+          cleaned.scan(/feature\s+([A-Za-z0-9]{4})\s*\{([^}]*)\}\s*\1\s*;/m) do |tag, body|
+            parse_body(tag, body)
+          end
+        end
+
+        # Parse statements within a feature block.
+        def parse_body(tag, body)
+          statements = body.split(";").map(&:strip).reject(&:empty?)
+          statements.each do |stmt|
+            tokens = stmt.split(/\s+/)
+            dispatch(tag, tokens, stmt)
+          end
+        end
+
+        # Dispatch a statement to the appropriate handler based on the
+        # leading keyword. Unknown statements are collected as unsupported.
+        def dispatch(tag, tokens, raw)
+          case tokens.first
+          when "sub" then handle_sub(tag, tokens)
+          when "pos" then handle_pos(tag, tokens)
+          else
+            @parsed.add_unsupported(tag, raw)
+          end
+        end
+
+        # `sub A B C by ABC;` → ligature substitution
+        def handle_sub(tag, tokens)
+          # tokens: ["sub", "A", "B", ..., "by", "ABC"]
+          by_idx = tokens.index("by")
+          unless by_idx && by_idx > 1 && tokens.size > by_idx + 1
+            @parsed.add_unsupported(tag, tokens.join(" "))
+            return
+          end
+
+          sequence = tokens[1, by_idx - 1]
+          result = tokens[by_idx + 1]
+          return if sequence.nil? || sequence.empty? || result.nil?
+
+          if sequence.size == 1
+            # Single substitution: `sub A by A.alt;` — unsupported for now
+            @parsed.add_unsupported(tag, tokens.join(" "))
+            return
+          end
+
+          @parsed.add_ligature(tag, sequence: sequence, result: result)
+        end
+
+        # `pos A B -50;` → pair positioning
+        def handle_pos(tag, tokens)
+          # tokens: ["pos", "A", "B", "-50"] or ["pos", "A", "B", "<", "0", "-50", "0", ">"]
+          return unless tokens.size >= 4
+
+          left = tokens[1]
+          right = tokens[2]
+          value = parse_pos_value(tokens[3])
+          return unless value
+
+          @parsed.add_pair(tag, left:, right:, value:)
+        end
+
+        # Parse a positioning value: either a bare integer or the start
+        # of a ValueRecord (we only handle the bare integer case for now).
+        def parse_pos_value(token)
+          Integer(token)
+        rescue ArgumentError
+          nil
+        end
+      end
+
+      # Result of parsing features.fea. Aggregates ligature and pair
+      # rules by feature tag, plus any unsupported statements.
+      class ParsedFeatures
+        attr_reader :ligatures, :pairs, :unsupported
+
+        def initialize
+          @ligatures = Hash.new { |h, k| h[k] = [] }
+          @pairs = Hash.new { |h, k| h[k] = [] }
+          @unsupported = Hash.new { |h, k| h[k] = [] }
+        end
+
+        # @param tag [String] feature tag
+        # @return [Array<Hash>] ligature rules: {sequence: [names], result: name}
+        def ligatures_for(tag)
+          @ligatures[tag] || []
+        end
+
+        # @param tag [String] feature tag
+        # @return [Array<Hash>] pair rules: {left:, right:, value:}
+        def pairs_for(tag)
+          @pairs[tag] || []
+        end
+
+        # @return [Boolean] true if no features were parsed
+        def empty?
+          @ligatures.empty? && @pairs.empty?
+        end
+
+        # ---- mutation (used by FeatureCompiler) ----
+
+        def add_ligature(tag, sequence:, result:)
+          @ligatures[tag] << { sequence: sequence, result: result }
+        end
+
+        def add_pair(tag, left:, right:, value:)
+          @pairs[tag] << { left: left, right: right, value: value }
+        end
+
+        def add_unsupported(tag, statement)
+          @unsupported[tag] << statement
+        end
+      end
+    end
+  end
+end