fontisan 0.2.23 → 0.3.0

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `CFF ` table from UFO glyphs.
+      #
+      # Pipeline:
+      #   1. Convert each UFO glyph's contours to a Models::Outline
+      #      (cubic Bezier commands).
+      #   2. Encode each outline as a Type 2 charstring via the
+      #      existing `Tables::Cff::CharStringBuilder`.
+      #   3. Build the CFF structural INDEXes (Name, Top DICT, String,
+      #      Global Subr, CharStrings) with correct offsets.
+      #
+      # The Top DICT references absolute offsets to the charset,
+      # charstrings, and private dict. Those offsets depend on the
+      # size of everything that comes before them — including the Top
+      # DICT itself. We resolve the circular dependency with a
+      # fixed-point iteration: build the Top DICT, compute offsets,
+      # rebuild the Top DICT with the new offsets, repeat until it
+      # converges (typically 2 iterations).
+      module Cff
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [String] CFF table bytes
+        def self.build(font, glyphs:)
+          name = font.info.postscript_font_name || font.info.family_name || "Untitled"
+          charstrings = glyphs.map { |g| charstring_for(g) }
+          private_dict = +""
+
+          layout = compute_layout(name: name, glyphs: glyphs,
+                                  charstrings: charstrings,
+                                  private_dict: private_dict)
+
+          assemble(layout: layout)
+        end
+
+        # ---------- charstring per-glyph ----------
+
+        def self.charstring_for(glyph)
+          return empty_charstring(glyph.width.to_i) if glyph.contours.empty?
+
+          builder = Fontisan::Tables::Cff::CharStringBuilder.new
+          builder.build(glyph.to_outline, width: glyph.width.to_i)
+        rescue StandardError
+          # Any failure (e.g., too-short contours, unsupported curve
+          # combination): fall back to an empty charstring so the
+          # INDEX stays valid.
+          empty_charstring(glyph.width.to_i)
+        end
+
+        def self.empty_charstring(width)
+          Fontisan::Tables::Cff::CharStringBuilder.build_empty(width: width.zero? ? nil : width)
+        end
+
+        # ---------- layout ----------
+
+        # Compute the byte offsets of every CFF structural section.
+        # Iterates until the Top DICT's encoded size stabilizes.
+        def self.compute_layout(name:, glyphs:, charstrings:, private_dict:)
+          name_index = index_bytes([name.b])
+          string_index = index_bytes([])
+          global_subr_index = index_bytes([])
+          charset = charset_bytes(glyphs)
+          charstrings_index = index_bytes(charstrings)
+
+          # First guess: Top DICT encoded with all-zero offsets.
+          top_dict = top_dict_bytes(0, 0, 0, 0)
+          top_dict_index = index_bytes([top_dict])
+
+          charset_offset = 0
+          charstrings_offset = 0
+          private_offset = 0
+
+          10.times do
+            header_size = 4
+            post_top_dict = header_size + name_index.bytesize +
+              top_dict_index.bytesize + string_index.bytesize +
+              global_subr_index.bytesize
+
+            charset_offset = post_top_dict
+            charstrings_offset = charset_offset + charset.bytesize
+            private_offset = charstrings_offset + charstrings_index.bytesize
+
+            new_top_dict = top_dict_bytes(
+              charset_offset,
+              charstrings_offset,
+              private_dict.bytesize,
+              private_offset,
+            )
+            new_top_dict_index = index_bytes([new_top_dict])
+
+            if new_top_dict_index.bytesize == top_dict_index.bytesize
+              # Converged. Use the freshly-encoded Top DICT so the
+              # layout hash is self-consistent with the offsets.
+              top_dict_index = new_top_dict_index
+              break
+            end
+
+            top_dict_index = new_top_dict_index
+          end
+
+          {
+            name_index: name_index,
+            top_dict_index: top_dict_index,
+            string_index: string_index,
+            global_subr_index: global_subr_index,
+            charset_offset: charset_offset,
+            charstrings_offset: charstrings_offset,
+            private_offset: private_offset,
+            charset: charset,
+            charstrings_index: charstrings_index,
+            private_dict: private_dict,
+          }
+        end
+
+        # ---------- byte emission ----------
+
+        def self.assemble(layout:)
+          io = StringIO.new("".b)
+
+          io.write([1, 0, 4, 1].pack("CCCC")) # CFF header (v1.0, hdrSize=4, offSize=1)
+
+          io.write(layout[:name_index])
+          io.write(layout[:top_dict_index])
+          io.write(layout[:string_index])
+          io.write(layout[:global_subr_index])
+
+          io.write(layout[:charset])
+          io.write(layout[:charstrings_index])
+          io.write(layout[:private_dict])
+
+          io.string
+        end
+
+        # Top DICT bytes with the three standard offset operators.
+        # Operators: charset(15), CharStrings(17), Private(18).
+        # Encoding (operator 16) is implicit for OpenType fonts.
+        def self.top_dict_bytes(charset_offset, charstrings_offset,
+                                private_size, private_offset)
+          bytes = +""
+          bytes << encode_int(charset_offset) << "\x0f"     # charset
+          bytes << encode_int(charstrings_offset) << "\x11" # CharStrings
+          bytes << encode_int(private_size) << encode_int(private_offset) << "\x12" # Private
+          bytes
+        end
+
+        # Format 0 charset: 1 format byte + (n-1) SIDs.
+        # Gid 0 is implicit .notdef.
+        def self.charset_bytes(glyphs)
+          return +"" if glyphs.size <= 1
+
+          bytes = +"\x00"
+          (1...glyphs.size).each { |_| bytes << [0].pack("n") } # SID 0 placeholder
+          bytes
+        end
+
+        # ---------- INDEX helpers ----------
+
+        def self.index_bytes(items)
+          io = StringIO.new("".b)
+          if items.empty?
+            io.write([0].pack("n"))
+            return io.string
+          end
+
+          count = items.size
+          offsets = [1]
+          items.each { |item| offsets << offsets.last + item.bytesize }
+          max_offset = offsets.last
+          off_size = byte_size_for(max_offset)
+
+          io.write([count, off_size].pack("nC"))
+          offsets.each { |o| io.write(pack_offset(o, off_size)) }
+          items.each { |item| io.write(item) }
+          io.string
+        end
+
+        def self.byte_size_for(max_value)
+          return 1 if max_value <= 0xFF
+          return 2 if max_value <= 0xFFFF
+          return 3 if max_value <= 0xFFFFFF
+
+          4
+        end
+
+        def self.pack_offset(value, size)
+          case size
+          when 1 then [value].pack("C")
+          when 2 then [value].pack("n")
+          when 3
+            [(value >> 16) & 0xFF, (value >> 8) & 0xFF, value & 0xFF].pack("CCC")
+          when 4 then [value].pack("N")
+          end
+        end
+
+        # CFF DICT integer encoding (CFF spec section 3.1).
+        def self.encode_int(value)
+          if value.between?(-107, 107)
+            [value + 139].pack("C")
+          elsif value.between?(108, 1131)
+            v = value - 108
+            [(v / 256) + 247, v % 256].pack("CC")
+          elsif value.between?(-1131, -108)
+            v = -value - 108
+            [-(v / 256) - 247, v % 256].pack("CC")
+          elsif value.between?(-32_768, 32_767)
+            [28, value].pack("Cn")
+          else
+            [29, value].pack("CN")
+          end
+        end
+
+        private_class_method :charstring_for, :empty_charstring,
+                             :compute_layout, :assemble, :top_dict_bytes,
+                             :charset_bytes, :index_bytes, :byte_size_for,
+                             :pack_offset, :encode_int
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `cmap` (character-to-glyph mapping) table.
+      # Emits two subtables:
+      #   - Format 4 (BMP), platform 3 encoding 1 (Windows Unicode BMP)
+      #   - Format 12 (full Unicode), platform 3 encoding 10 (Windows Unicode full)
+      #
+      # Both subtables share the same segment list (capped to BMP for
+      # format 4); format 4 is required by Windows even though format
+      # 12 is more capable.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cmap
+      module Cmap
+        PLATFORM_WINDOWS = 3
+        ENCODING_WINDOWS_BMP = 1
+        ENCODING_WINDOWS_FULL = 10
+
+        # @param _font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [String] cmap table bytes
+        def self.build(_font, glyphs:)
+          mappings = {}
+          glyphs.each_with_index do |glyph, gid|
+            glyph.unicodes.each do |cp|
+              mappings[cp] = gid unless mappings.key?(cp)
+            end
+          end
+
+          subtable_bmp = format4_subtable(mappings.reject { |cp, _| cp > 0xFFFF })
+          subtable_full = format12_subtable(mappings)
+
+          header_size = 4 + (2 * 8) # version + numTables + 2 records
+          offset_bmp = header_size
+          offset_full = header_size + subtable_bmp.bytesize
+
+          header = [0, 2].pack("nn")
+          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_BMP, offset_bmp)
+          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_FULL, offset_full)
+          header + subtable_bmp + subtable_full
+        end
+
+        def self.subtable_record(platform_id, encoding_id, offset)
+          [platform_id, encoding_id, offset].pack("nnN")
+        end
+
+        # Group adjacent (cp, gid) pairs into contiguous ranges where
+        # both cp and gid advance by 1 each step.
+        # @return [Array<Range>] Array of inclusive cp ranges
+        def self.build_segments(cp_to_gid)
+          sorted = cp_to_gid.sort
+          return [] if sorted.empty?
+
+          segments = []
+          seg_start_cp, prev_gid = sorted.first
+          prev_cp = seg_start_cp
+
+          sorted[1..].each do |cp, gid|
+            contiguous = cp == prev_cp + 1 && gid == prev_gid + 1
+            unless contiguous
+              segments << (seg_start_cp..prev_cp)
+              seg_start_cp = cp
+            end
+            prev_cp = cp
+            prev_gid = gid
+          end
+          segments << (seg_start_cp..prev_cp)
+          segments
+        end
+
+        # Format 4 segment-encoded cmap subtable for the BMP.
+        def self.format4_subtable(mappings)
+          segments = build_segments(mappings) + [0xFFFF..0xFFFF] # sentinel
+          seg_count = segments.size
+          search_range = largest_pow2_le(seg_count) * 2
+          entry_selector = (Math.log([1, search_range / 2].max) / Math.log(2)).to_i
+          range_shift = seg_count * 2 - search_range
+
+          end_codes = segments.map(&:end)
+          start_codes = segments.map(&:begin)
+          # id_delta[i] = (gid_at_start - start_code) mod 65536
+          id_deltas = segments.map do |range|
+            start_cp = range.begin
+            gid = mappings.fetch(start_cp, 0)
+            # For the sentinel segment (0xFFFF..0xFFFF) with no mapping,
+            # delta 1 maps 0xFFFF → gid 0 (.notdef).
+            gid_delta = start_cp == 0xFFFF && gid.zero? ? 1 : (gid - start_cp)
+            gid_delta & 0xFFFF
+          end
+
+          body = +""
+          body << [seg_count * 2, search_range, entry_selector, range_shift].pack("nnnn")
+          body << end_codes.pack("n*")
+          body << [0].pack("n") # reservedPad
+          body << start_codes.pack("n*")
+          body << id_deltas.pack("n*")
+          body << Array.new(seg_count, 0).pack("n*") # idRangeOffset (all 0)
+
+          length = 14 + body.bytesize # 14-byte header
+          [4, length, 0].pack("nnn") + body
+        end
+
+        # Format 12 sparse-coverage subtable for full Unicode.
+        def self.format12_subtable(mappings)
+          segments = build_segments(mappings)
+
+          body = +""
+          segments.each do |range|
+            start_gid = mappings.fetch(range.begin, 0)
+            body << [range.begin, range.end, start_gid].pack("NNN")
+          end
+
+          length = 16 + body.bytesize # 16-byte header
+          [12, 0].pack("nn") + [length, 0, segments.size].pack("NNN") + body
+        end
+
+        def self.largest_pow2_le(n)
+          return 0 if n <= 0
+
+          1 << (n.bit_length - 1)
+        end
+        private_class_method :subtable_record, :build_segments,
+                             :format4_subtable, :format12_subtable,
+                             :largest_pow2_le
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/cubic_to_quadratic.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Converts cubic Bezier curves to quadratic. TrueType outlines
+        # only support quadratic Beziers; UFO sources typically use
+        # cubic. This filter walks each contour, finds cubic segments
+        # (two consecutive off-curve points followed by an on-curve),
+        # and replaces them with one or more quadratic approximations.
+        #
+        # Algorithm (fontTools-compatible):
+        #   For cubic (P0, C1, C2, P3):
+        #     Q1 = (3*C1 - P0) / 2
+        #     Q2 = (3*C2 - P3) / 2
+        #     Q  = midpoint(Q1, Q2)
+        #     Error ≈ |Q1 - Q2| / 3
+        #     If error ≤ tolerance: emit one quadratic (P0, Q, P3)
+        #     Else: subdivide at t=0.5, recurse each half.
+        module CubicToQuadratic
+          DEFAULT_TOLERANCE = 1.0
+
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @param tolerance [Float] max deviation in font units
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array, mutated
+          def self.run(glyphs, tolerance: DEFAULT_TOLERANCE, **_opts)
+            glyphs.each do |glyph|
+              glyph.contours.each_with_index do |contour, _ci|
+                contour.points = convert_contour(contour.points, tolerance)
+              end
+            end
+            glyphs
+          end
+
+          # Walk a contour's point list and replace cubic segments
+          # with quadratic approximations. Preserves on-curve points
+          # (lines, moves); only touches (off, off, on) triplets.
+          #
+          # @param points [Array<Fontisan::Ufo::Point>]
+          # @param tolerance [Float]
+          # @return [Array<Fontisan::Ufo::Point>] new point array
+          def self.convert_contour(points, tolerance)
+            return points if points.size < 4
+
+            result = []
+            i = 0
+
+            while i < points.size
+              # Check if we have a cubic segment: off, off, on-curve
+              if i + 2 < points.size &&
+                  off_curve?(points[i]) &&
+                  off_curve?(points[i + 1]) &&
+                  on_curve?(points[i + 2])
+                # The previous on-curve point (P0) is the last on-curve
+                # before this segment. If result is empty, use the last
+                # point in the original contour (contour wraps around).
+                p0 = result.empty? ? last_on_curve(points) : result.last
+
+                if p0
+                  c1 = points[i]
+                  c2 = points[i + 1]
+                  p3 = points[i + 2]
+
+                  quads = subdivide_cubic(p0, c1, c2, p3, tolerance)
+                  quads.each { |q| result << q }
+                  i += 3
+                else
+                  result << points[i]
+                  i += 1
+                end
+              else
+                result << points[i]
+                i += 1
+              end
+            end
+
+            result
+          end
+
+          # Recursive cubic-to-quadratic subdivision.
+          # Returns a list of Points: alternating off-curve control
+          # points and on-curve endpoints.
+          def self.subdivide_cubic(p0, c1, c2, p3, tolerance)
+            q1x = (3.0 * c1.x - p0.x) / 2.0
+            q1y = (3.0 * c1.y - p0.y) / 2.0
+            q2x = (3.0 * c2.x - p3.x) / 2.0
+            q2y = (3.0 * c2.y - p3.y) / 2.0
+
+            # Error metric: half the distance between Q1 and Q2
+            dx = (q1x - q2x).abs
+            dy = (q1y - q2y).abs
+            error = [dx, dy].max / 3.0
+
+            if error <= tolerance
+              # Single quadratic approximation
+              mid_x = (q1x + q2x) / 2.0
+              mid_y = (q1y + q2y) / 2.0
+              [
+                Point.new(x: mid_x, y: mid_y, type: "offcurve"),
+                Point.new(x: p3.x, y: p3.y, type: p3.type, smooth: p3.smooth),
+              ]
+            else
+              # Subdivide at t=0.5
+              midpoint_on_cubic(p0, c1, c2, p3, 0.5)
+
+              # Left half: P0, L1, L2, M
+              Point.new(x: (p0.x + c1.x) / 2.0,
+                        y: (p0.y + c1.y) / 2.0, type: "offcurve")
+              Point.new(x: (c1.x + c2.x) / 4.0 + (p0.x + c1.x) / 4.0,
+                        y: (c1.y + c2.y) / 4.0 + (p0.y + c1.y) / 4.0,
+                        type: "offcurve")
+              # Actually, proper De Casteljau subdivision:
+              l1x = (p0.x + c1.x) / 2.0
+              l1y = (p0.y + c1.y) / 2.0
+              mx = (c1.x + c2.x) / 2.0
+              my = (c1.y + c2.y) / 2.0
+              r2x = (c2.x + p3.x) / 2.0
+              r2y = (c2.y + p3.y) / 2.0
+              l2x = (l1x + mx) / 2.0
+              l2y = (l1y + my) / 2.0
+              r1x = (mx + r2x) / 2.0
+              r1y = (my + r2y) / 2.0
+              mid_x = (l2x + r1x) / 2.0
+              mid_y = (l2y + r1y) / 2.0
+
+              left_p0 = p0
+              left_c1 = Point.new(x: l1x, y: l1y, type: "offcurve")
+              left_c2 = Point.new(x: l2x, y: l2y, type: "offcurve")
+              left_p3 = Point.new(x: mid_x, y: mid_y, type: "qcurve")
+
+              right_p0 = left_p3
+              right_c1 = Point.new(x: r1x, y: r1y, type: "offcurve")
+              right_c2 = Point.new(x: r2x, y: r2y, type: "offcurve")
+              right_p3 = p3
+
+              left = subdivide_cubic(left_p0, left_c1, left_c2, left_p3, tolerance)
+              right = subdivide_cubic(right_p0, right_c1, right_c2, right_p3, tolerance)
+
+              # Drop the duplicated midpoint point between halves
+              left + right
+            end
+          end
+
+          # Evaluate a point on a cubic Bezier at parameter t.
+          def self.midpoint_on_cubic(p0, c1, c2, p3, t)
+            mt = 1.0 - t
+            x = mt * mt * mt * p0.x + 3 * mt * mt * t * c1.x +
+              3 * mt * t * t * c2.x + t * t * t * p3.x
+            y = mt * mt * mt * p0.y + 3 * mt * mt * t * c1.y +
+              3 * mt * t * t * c2.y + t * t * t * p3.y
+            Point.new(x: x, y: y, type: "qcurve")
+          end
+
+          def self.last_on_curve(points)
+            points.reverse_each.find { |p| on_curve?(p) }
+          end
+
+          def self.on_curve?(point)
+            ["line", "move", "curve", "qcurve"].include?(point.type)
+          end
+
+          def self.off_curve?(point)
+            point.type == "offcurve"
+          end
+
+          private_class_method :convert_contour, :subdivide_cubic,
+                               :midpoint_on_cubic, :last_on_curve,
+                               :on_curve?, :off_curve?
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/decompose_components.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Decomposes composite glyphs (those with Components) into
+        # simple glyphs by resolving each component reference to its
+        # base glyph's contours and applying the component's
+        # transformation matrix.
+        #
+        # For MVP: components are silently dropped (the glyph retains
+        # its own contours but loses component-derived outlines).
+        # Full resolution requires the full glyph-name → glyph lookup
+        # that the compiler provides. TODO.full/07b will wire this.
+        module DecomposeComponents
+          def self.run(glyphs, **_opts)
+            glyphs.each do |glyph|
+              # Drop components; keep contours only.
+              # Full implementation would:
+              #   1. Look up each component's base glyph by name
+              #   2. Clone its contours
+              #   3. Apply the component's Transformation matrix
+              #   4. Merge into this glyph's contours
+              glyph.components.clear
+            end
+            glyphs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/flatten_components.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Flattens nested component references. If glyph A references
+        # glyph B which references glyph C, this filter makes A
+        # directly reference C (one level deep only).
+        #
+        # For MVP: same as DecomposeComponents — components are
+        # cleared. Full implementation lands with TODO.full/07b.
+        module FlattenComponents
+          def self.run(glyphs, **_opts)
+            glyphs.each { |g| g.components.clear }
+            glyphs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/reverse_contour_direction.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Reverses the point order in every contour. TrueType fonts
+        # use clockwise winding for outer contours (opposite of the
+        # PostScript/UFO convention). Applying this filter before
+        # TTF compilation ensures correct glyph rendering.
+        module ReverseContourDirection
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array,
+          #   mutated in place
+          def self.run(glyphs, **_opts)
+            glyphs.each do |glyph|
+              glyph.contours.each do |contour|
+                contour.points.reverse!
+              end
+            end
+            glyphs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Glyph-processing filters applied between the UFO model and the
+      # binary table compilers. Each filter is a stateless module
+      # with `.run(glyphs, **opts)` that mutates the glyph list
+      # (or returns a new one).
+      #
+      # OCP: adding a filter = new module + one REGISTRY entry.
+      # The compiler picks which filters to run based on the output
+      # format — not a switch statement in compiler code.
+      module Filters
+        autoload :ReverseContourDirection,
+                 "fontisan/ufo/compile/filters/reverse_contour_direction"
+        autoload :CubicToQuadratic,
+                 "fontisan/ufo/compile/filters/cubic_to_quadratic"
+        autoload :DecomposeComponents,
+                 "fontisan/ufo/compile/filters/decompose_components"
+        autoload :FlattenComponents,
+                 "fontisan/ufo/compile/filters/flatten_components"
+
+        # Filters that MUST run for TTF output (TrueType only
+        # supports quadratic curves + clockwise outer winding).
+        TTF_REQUIRED = %i[
+          cubic_to_quadratic
+          reverse_contour_direction
+        ].freeze
+
+        # Filters that MUST run for OTF output (CFF handles cubic
+        # natively, so no curve conversion needed; winding is
+        # already correct for PostScript).
+        OTF_REQUIRED = [].freeze
+
+        REGISTRY = {
+          reverse_contour_direction: ReverseContourDirection,
+          cubic_to_quadratic: CubicToQuadratic,
+          decompose_components: DecomposeComponents,
+          flatten_components: FlattenComponents,
+        }.freeze
+
+        # @param names [Array<Symbol>] filter names from REGISTRY
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] glyphs to filter
+        # @param opts [Hash] per-filter options
+        # @return [Array<Fontisan::Ufo::Glyph>] the (possibly mutated) glyphs
+        def self.apply(names, glyphs, **)
+          Array(names).reduce(glyphs) do |current, name|
+            klass = REGISTRY[name.to_sym] or
+              raise ArgumentError, "unknown filter: #{name.inspect}"
+            klass.run(current, **)
+          end
+        end
+      end
+    end
+  end
+end