fontisan 0.4.46 → 0.4.48

data/lib/fontisan/variation/instancing/item_variation_store.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # Evaluates HVAR advance-width deltas (ItemVariationStore plus the
+      # optional DeltaSetIndexMap) at a normalized location.
+      class ItemVariationStore
+        # @param hvar [String] raw HVAR table
+        def initialize(hvar)
+          @hvar = hvar
+          store_offset, @advance_map_offset = hvar[4, 8].unpack("NN")
+          @store = hvar.byteslice(store_offset..)
+          region_list_offset, data_count = @store[2, 6].unpack("Nn")
+          @regions = parse_regions(region_list_offset)
+          @data_offsets = @store[8, data_count * 4].unpack("N*")
+        end
+
+        # @return [Float] advance-width delta for +gid+
+        def advance_delta(gid, coords)
+          outer, inner = delta_index(gid)
+          delta(outer, inner, coords)
+        end
+
+        private
+
+        def parse_regions(offset)
+          axis_count, region_count = @store[offset, 4].unpack("nn")
+          Array.new(region_count) do |r|
+            pos = offset + 4 + (r * axis_count * 6)
+            @store[pos, axis_count * 6].unpack("s>*").map { |v| v / 16384.0 }
+              .each_slice(3).to_a
+          end
+        end
+
+        def delta_index(gid)
+          return [0, gid] if @advance_map_offset.zero?
+
+          format, entry_format = @hvar[@advance_map_offset, 2].unpack("CC")
+          if format.zero?
+            count = @hvar[@advance_map_offset + 2, 2].unpack1("n")
+            pos = @advance_map_offset + 4
+          else
+            count = @hvar[@advance_map_offset + 2, 4].unpack1("N")
+            pos = @advance_map_offset + 6
+          end
+          inner_bits = (entry_format & 0x0F) + 1
+          size = ((entry_format & 0x30) >> 4) + 1
+          entry_gid = [gid, count - 1].min
+          entry = @hvar[pos + (entry_gid * size), size].bytes.inject(0) { |a, b| (a << 8) | b }
+          [entry >> inner_bits, entry & ((1 << inner_bits) - 1)]
+        end
+
+        def delta(outer, inner, coords)
+          offset = @data_offsets[outer]
+          return 0.0 unless offset
+
+          item_count, word_field, region_count = @store[offset, 6].unpack("nnn")
+          return 0.0 if inner >= item_count
+
+          long = word_field.anybits?(0x8000)
+          word_count = word_field & 0x7FFF
+          indexes = @store[offset + 6, region_count * 2].unpack("n*")
+          big = long ? 4 : 2
+          small = long ? 2 : 1
+          row_size = (word_count * big) + ((region_count - word_count) * small)
+          pos = offset + 6 + (region_count * 2) + (inner * row_size)
+          words = @store[pos, word_count * big].unpack(long ? "l>*" : "s>*")
+          rest = @store[pos + (word_count * big), (region_count - word_count) * small]
+            .unpack(long ? "s>*" : "c*")
+          (words + rest).each_with_index.sum do |d, i|
+            d * region_scalar(@regions[indexes[i]], coords)
+          end
+        end
+
+        def region_scalar(region, coords)
+          scalar = 1.0
+          region.each_with_index do |(lower, peak, upper), i|
+            v = coords[i]
+            next if peak.zero? || lower > peak || peak > upper
+            next if lower.negative? && upper.positive?
+            next if v == peak
+            return 0.0 if v <= lower || upper <= v
+
+            scalar *= v < peak ? (v - lower) / (peak - lower) : (upper - v) / (upper - peak)
+          end
+          scalar
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/name_rewriter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # Rewrites a name table so it describes one instance of a family.
+      class NameRewriter
+        Record = Struct.new(:platform, :encoding, :language, :name_id, :text)
+
+        # @param name_data [String] raw name table
+        def initialize(name_data)
+          @records = parse(name_data)
+        end
+
+        def lookup(name_id)
+          same = @records.select { |r| r.name_id == name_id }
+          rec = same.find { |r| r.platform == 3 && r.language == 0x409 } ||
+            same.find { |r| r.platform == 3 } || same.first
+          rec&.text
+        end
+
+        # Names the instance +label+ (e.g. "Light") of the family.
+        def rename(label)
+          family = lookup(16) || lookup(1) || "Font"
+          legacy = ["Regular", "Bold", "Italic", "Bold Italic"].include?(label)
+          full = "#{family} #{label}".strip
+          ps = "#{family}-#{label}".delete(" ")
+          set(1, legacy ? family : full)
+          set(2, legacy ? label : "Regular")
+          set(3, "#{lookup(5) || ''};#{ps}".delete_prefix(";"))
+          set(4, full)
+          set(6, ps)
+          set(16, family)
+          set(17, label)
+          @records.reject! { |r| r.name_id == 25 }
+          self
+        end
+
+        def to_binary
+          recs = @records.sort_by { |r| [r.platform, r.encoding, r.language, r.name_id] }
+          strings = +"".b
+          entries = recs.map do |r|
+            bin = encode(r)
+            off = strings.bytesize
+            strings << bin
+            [r.platform, r.encoding, r.language, r.name_id, bin.bytesize, off]
+          end
+          header = [0, recs.size, 6 + (recs.size * 12)].pack("nnn")
+          header + entries.map { |e| e.pack("n6") }.join + strings
+        end
+
+        private
+
+        def set(name_id, text)
+          same = @records.select { |r| r.name_id == name_id }
+          same.each { |r| r.text = text }
+          return if same.any? { |r| r.platform == 3 }
+
+          @records << Record.new(3, 1, 0x409, name_id, text)
+        end
+
+        def parse(data)
+          count, str_off = data[2, 4].unpack("nn")
+          recs = Array.new(count) do |i|
+            plat, enc, lang, nid, len, off = data[6 + (i * 12), 12].unpack("n6")
+            raw = data[str_off + off, len]
+            Record.new(plat, enc, lang, nid, decode(plat, raw))
+          end
+          recs.reject { |r| r.language >= 0x8000 }
+        end
+
+        def decode(platform, raw)
+          if [0, 3].include?(platform)
+            raw.dup.force_encoding("UTF-16BE").encode("UTF-8", invalid: :replace)
+          else
+            raw.dup.force_encoding("ISO-8859-1").encode("UTF-8")
+          end
+        end
+
+        def encode(rec)
+          if [0, 3].include?(rec.platform)
+            rec.text.encode("UTF-16BE").b
+          else
+            rec.text.encode("ISO-8859-1", invalid: :replace, undef: :replace).b
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing/true_type_instancer.rb

@@ -0,0 +1,326 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Variation
+    module Instancing
+      # Produces a static TrueType font from a gvar-based variable font by
+      # applying gvar deltas (with IUP for untouched points) to glyf, HVAR or
+      # phantom-point deltas to hmtx, and updating OS/2 and name for the
+      # chosen location. cvar, GPOS/GDEF variations and MVAR are not applied.
+      class TrueTypeInstancer
+        DROPPED = %w[fvar gvar avar HVAR VVAR MVAR STAT cvar DSIG].freeze
+        # Tables read by #call besides the variation tables checked below.
+        REQUIRED = %w[head hhea hmtx maxp loca].freeze
+        WIDTH_CLASSES = [50, 62.5, 75, 87.5, 100, 112.5, 125, 150, 200].freeze
+
+        # @param tables [Hash{String=>String}] raw tables of the variable font
+        # @param coordinates [Hash{String=>Numeric}] axis tag => user value
+        def initialize(tables, coordinates)
+          @tables = tables
+          @coordinates = coordinates
+          check_font!
+          @space = AxisSpace.new(tables["fvar"], tables["avar"])
+          @location = @space.validate(coordinates)
+          @norm = @space.normalize(@location)
+        end
+
+        # @return [Hash{String=>String}] raw tables of the static instance
+        def call
+          num_glyphs = @tables["maxp"][4, 2].unpack1("n")
+          read_metrics(num_glyphs)
+          glyphs = Array.new(num_glyphs) { |gid| instance_glyph(gid) }
+          resolve_bounds(glyphs)
+          out = @tables.except(*DROPPED)
+          write_glyf_loca(out, glyphs)
+          write_hmtx(out, glyphs)
+          update_head_hhea(out, glyphs)
+          update_os2(out)
+          update_name(out)
+          out
+        end
+
+        private
+
+        Glyph = Struct.new(:outline, :points, :advance, :bbox, :data)
+
+        def check_font!
+          unless @tables["fvar"]
+            raise MissingVariationTableError.new(table: "fvar")
+          end
+          unless @tables["gvar"] && @tables["glyf"]
+            raise MissingVariationTableError.new(
+              table: "gvar",
+              message: "Static instancing needs TrueType outlines with gvar " \
+                       "(CFF2 variable fonts are not supported yet)",
+            )
+          end
+
+          REQUIRED.each do |tag|
+            next if @tables[tag]
+
+            raise MissingTableError, "Font missing required #{tag} table"
+          end
+        end
+
+        def read_metrics(num_glyphs)
+          nhm = @tables["hhea"][34, 2].unpack1("n")
+          hmtx = @tables["hmtx"]
+          @advances = []
+          @lsbs = []
+          num_glyphs.times do |gid|
+            if gid < nhm
+              @advances << hmtx[gid * 4, 2].unpack1("n")
+              @lsbs << hmtx[(gid * 4) + 2, 2].unpack1("s>")
+            else
+              @advances << @advances.last
+              @lsbs << hmtx[(nhm * 4) + ((gid - nhm) * 2), 2].unpack1("s>")
+            end
+          end
+          long = @tables["head"][50, 2].unpack1("s>") == 1
+          @loca = long ? @tables["loca"].unpack("N*") : @tables["loca"].unpack("n*").map { |v| v * 2 }
+          @gvar = GvarReader.new(@tables["gvar"])
+          @hvar = @tables["HVAR"] ? ItemVariationStore.new(@tables["HVAR"]) : nil
+        end
+
+        def raw_glyph(gid)
+          @tables["glyf"].byteslice(@loca[gid]...@loca[gid + 1]) || "".b
+        end
+
+        def instance_glyph(gid)
+          outline = GlyphOutline.parse(raw_glyph(gid))
+          orig = outline.points
+          n = orig.size
+          xmin = outline.empty? ? 0 : raw_glyph(gid)[2, 2].unpack1("s>")
+          pp1x = xmin - @lsbs[gid]
+          total = Array.new(n + 4) { [0.0, 0.0] }
+          @gvar.tuples_for(gid, n + 4).each do |t|
+            s = tuple_scalar(t)
+            next if s.zero?
+
+            dx, dy = expand_deltas(t, outline, orig)
+            (n + 4).times do |i|
+              total[i][0] += s * dx[i]
+              total[i][1] += s * dy[i]
+            end
+          end
+          pts = orig.each_with_index.map do |(x, y), i|
+            [round(x + total[i][0]), round(y + total[i][1])]
+          end
+          advance = if @hvar
+                      @advances[gid] + round(@hvar.advance_delta(gid, @norm))
+                    else
+                      round(pp1x + @advances[gid] + total[n + 1][0]) -
+                        round(pp1x + total[n][0])
+                    end
+          Glyph.new(outline, pts, [advance, 0].max, nil, nil)
+        end
+
+        def round(value)
+          (value + 0.5).floor
+        end
+
+        def tuple_scalar(tuple)
+          scalar = 1.0
+          tuple.peak.each_with_index do |peak, i|
+            next if peak.zero?
+
+            v = @norm[i]
+            next if v == peak
+
+            lo, hi = if tuple.intermediate?
+                       [tuple.start[i], tuple.end[i]]
+                     else
+                       [0.0, peak].minmax
+                     end
+            next if lo > peak || peak > hi || (lo.negative? && hi.positive?)
+            return 0.0 if v <= lo || hi <= v
+
+            scalar *= v < peak ? (v - lo) / (peak - lo) : (hi - v) / (hi - peak)
+          end
+          scalar
+        end
+
+        # Full per-point delta arrays (length n + 4), IUP applied when only
+        # some points were given.
+        def expand_deltas(tuple, outline, orig)
+          total = orig.size + 4
+          return [tuple.dx, tuple.dy] if tuple.points.nil?
+
+          dx = Array.new(total)
+          dy = Array.new(total)
+          tuple.points.each_with_index do |p, i|
+            next if p >= total
+
+            dx[p] = tuple.dx[i]
+            dy[p] = tuple.dy[i]
+          end
+          unless outline.composite?
+            iup(orig.map(&:first), dx, outline.end_pts)
+            iup(orig.map(&:last), dy, outline.end_pts)
+          end
+          [dx.map { |v| v || 0 }, dy.map { |v| v || 0 }]
+        end
+
+        def iup(coords, deltas, ends)
+          start = 0
+          ends.each do |last|
+            touched = (start..last).select { |i| deltas[i] }
+            if touched.empty?
+              (start..last).each { |i| deltas[i] = 0 }
+            elsif touched.size == 1
+              (start..last).each { |i| deltas[i] = deltas[touched.first] }
+            else
+              touched.each_with_index do |t, k|
+                nxt = touched[(k + 1) % touched.size]
+                i = t
+                loop do
+                  i = i == last ? start : i + 1
+                  break if i == nxt
+
+                  deltas[i] = iup_value(coords[i], coords[t], deltas[t],
+                                        coords[nxt], deltas[nxt])
+                end
+              end
+            end
+            start = last + 1
+          end
+        end
+
+        def iup_value(coord, ref1, delta1, ref2, delta2)
+          return (delta1 == delta2 ? delta1 : 0) if ref1 == ref2
+
+          ref1, delta1, ref2, delta2 = ref2, delta2, ref1, delta1 if ref1 > ref2
+          return delta1 if coord <= ref1
+          return delta2 if coord >= ref2
+
+          delta1 + ((coord - ref1) * (delta2 - delta1) / (ref2 - ref1).to_f)
+        end
+
+        # Bounding boxes; composites derive theirs from their components.
+        def resolve_bounds(glyphs)
+          glyphs.each_index { |gid| bbox_for(glyphs, gid, []) }
+        end
+
+        def bbox_for(glyphs, gid, stack)
+          g = glyphs[gid]
+          return g.bbox if g.bbox
+          return g.bbox = [0, 0, 0, 0] if g.outline.empty? || stack.include?(gid)
+
+          if g.outline.composite?
+            corners = []
+            g.outline.components.each_with_index do |c, i|
+              sub = bbox_for(glyphs, c.gid, stack + [gid])
+              next if glyphs[c.gid].outline.empty?
+
+              corners.concat(transform_corners(sub, c, g.points[i]))
+            end
+            g.bbox = corners.empty? ? [0, 0, 0, 0] : g.outline.bounds_of(corners).map(&:round)
+          else
+            g.bbox = g.outline.bounds_of(g.points)
+          end
+        end
+
+        def transform_corners(bbox, comp, offset)
+          xmin, ymin, xmax, ymax = bbox
+          t = comp.transform
+          a, b, c, d = case t.bytesize
+                       when 2 then s = t.unpack1("s>") / 16384.0
+                                   [s, 0, 0, s]
+                       when 4 then sx, sy = t.unpack("s>s>").map { |v| v / 16384.0 }
+                                   [sx, 0, 0, sy]
+                       when 8 then xs, s01, s10, ys = t.unpack("s>4").map { |v| v / 16384.0 }
+                                   [xs, s01, s10, ys]
+                       else [1, 0, 0, 1]
+                       end
+          [[xmin, ymin], [xmin, ymax], [xmax, ymin], [xmax, ymax]].map do |x, y|
+            [(a * x) + (c * y) + offset[0], (b * x) + (d * y) + offset[1]]
+          end
+        end
+
+        def write_glyf_loca(out, glyphs)
+          glyf = +"".b
+          loca = [0]
+          glyphs.each do |g|
+            data = g.outline.serialize(g.points, g.bbox)
+            data << "\0".b until (data.bytesize % 4).zero?
+            glyf << data
+            loca << glyf.bytesize
+          end
+          out["glyf"] = glyf
+          out["loca"] = loca.pack("N*")
+          head = out["head"].dup
+          head[50, 2] = [1].pack("s>")
+          out["head"] = head
+        end
+
+        def write_hmtx(out, glyphs)
+          hmtx = +"".b
+          glyphs.each_with_index do |g, gid|
+            lsb = g.outline.empty? ? @lsbs[gid] : g.bbox[0]
+            g.data = [g.advance, lsb]
+            hmtx << [g.advance, lsb].pack("ns>")
+          end
+          out["hmtx"] = hmtx
+          hhea = out["hhea"].dup
+          hhea[34, 2] = [glyphs.size].pack("n")
+          out["hhea"] = hhea
+        end
+
+        def update_head_hhea(out, glyphs)
+          drawn = glyphs.reject { |g| g.outline.empty? }
+          return if drawn.empty?
+
+          head = out["head"].dup
+          head[36, 8] = [drawn.map { |g| g.bbox[0] }.min, drawn.map { |g| g.bbox[1] }.min,
+                         drawn.map { |g| g.bbox[2] }.max, drawn.map { |g| g.bbox[3] }.max].pack("s>4")
+          out["head"] = head
+          hhea = out["hhea"].dup
+          min_lsb = drawn.map { |g| g.data[1] }.min
+          min_rsb = drawn.map { |g| g.data[0] - g.data[1] - (g.bbox[2] - g.bbox[0]) }.min
+          max_ext = drawn.map { |g| g.data[1] + (g.bbox[2] - g.bbox[0]) }.max
+          hhea[10, 8] = [glyphs.map(&:advance).max, min_lsb, min_rsb, max_ext].pack("ns>s>s>")
+          out["hhea"] = hhea
+        end
+
+        def update_os2(out)
+          return unless out["OS/2"]
+
+          os2 = out["OS/2"].dup
+          if @location.key?("wght")
+            os2[4, 2] = [@location["wght"].round.clamp(1, 1000)].pack("n")
+          end
+          if @location.key?("wdth")
+            nearest = WIDTH_CLASSES.each_index.min_by { |i| (WIDTH_CLASSES[i] - @location["wdth"]).abs }
+            os2[6, 2] = [nearest + 1].pack("n")
+          end
+          out["OS/2"] = os2
+        end
+
+        def update_name(out)
+          return unless out["name"]
+
+          rewriter = NameRewriter.new(out["name"])
+          out["name"] = rewriter.rename(instance_label(rewriter)).to_binary
+        end
+
+        def instance_label(rewriter)
+          match = AxisSpace.named_instances(@tables["fvar"]).find do |inst|
+            @space.tags.each_with_index.all? do |tag, i|
+              (inst[:values][i] - @location[tag]).abs < 1e-6
+            end
+          end
+          named = match && rewriter.lookup(match[:name_id])
+          return named if named
+
+          parts = @space.axes.reject { |a| @location[a.tag] == a.default }
+            .map { |a| "#{a.tag.capitalize}#{format_value(@location[a.tag])}" }
+          parts.empty? ? "Regular" : parts.join(" ")
+        end
+
+        def format_value(value)
+          value == value.to_i ? value.to_i.to_s : value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/variation/instancing.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Autoload hub for the Fontisan::Variation::Instancing namespace.
+
+module Fontisan
+  module Variation
+    # Static instancing of TrueType variable fonts: gvar/HVAR delta
+    # application, glyf/hmtx rebuilding and OS/2 + name updates.
+    module Instancing
+      autoload :AxisSpace, "fontisan/variation/instancing/axis_space"
+      autoload :GlyphOutline, "fontisan/variation/instancing/glyph_outline"
+      autoload :GvarReader, "fontisan/variation/instancing/gvar_reader"
+      autoload :ItemVariationStore,
+               "fontisan/variation/instancing/item_variation_store"
+      autoload :NameRewriter, "fontisan/variation/instancing/name_rewriter"
+      autoload :TrueTypeInstancer,
+               "fontisan/variation/instancing/true_type_instancer"
+    end
+  end
+end

data/lib/fontisan/variation/variable_svg_generator.rb

@@ -107,6 +107,20 @@ module Fontisan
       # Returns all axes at their default values.
       #
       # @return [Hash<String, Float>] Default coordinates
+      # Out-of-range requests are pulled to the nearest axis limit and
+      # unknown axes dropped, so SVG preview stays tolerant.
+      def clamp_to_axes(coords)
+        return coords unless @font.has_table?("fvar")
+
+        by_tag = @font.table("fvar").axes.to_h { |a| [a.axis_tag.to_s, a] }
+        coords.each_with_object({}) do |(tag, value), clamped|
+          axis = by_tag[tag.to_s]
+          next unless axis
+
+          clamped[tag.to_s] = Float(value).clamp(axis.min_value, axis.max_value)
+        end
+      end
+
       def default_coordinates
         return {} unless @font.has_table?("fvar")
 
@@ -164,7 +178,11 @@ module Fontisan
       # @return [Hash<String, String>] Instance tables
       def generate_static_instance
         # Use coordinates or defaults if none specified
-        coords = @coordinates.empty? ? default_coordinates : @coordinates
+        coords = if @coordinates.empty?
+                   default_coordinates
+                 else
+                   clamp_to_axes(@coordinates)
+                 end
 
         instance_generator = InstanceGenerator.new(@font, coords)
         instance_generator.generate

data/lib/fontisan/variation.rb

@@ -15,6 +15,7 @@ module Fontisan
     autoload :InstanceGenerator, "fontisan/variation/instance_generator"
     autoload :InstanceFontWrapper, "fontisan/variation/instance_font_wrapper"
     autoload :InstanceWriter, "fontisan/variation/instance_writer"
+    autoload :Instancing, "fontisan/variation/instancing"
     autoload :Interpolator, "fontisan/variation/interpolator"
     autoload :MetricsAdjuster, "fontisan/variation/metrics_adjuster"
     autoload :Optimizer, "fontisan/variation/optimizer"

data/lib/fontisan/version.rb

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

data/lib/fontisan/woff2/collection_decoder.rb

@@ -59,15 +59,29 @@ module Fontisan
         # the glyf was transformed.
         font_entries.map do |fe|
           font_tables = {}
+          glyf_transformed = false
           fe.table_indices.each do |idx|
             entry = table_entries.fetch(idx)
             font_tables[entry.tag] = entry.raw_bytes
+            glyf_transformed = !entry.transform_length.nil? if entry.tag == "glyf"
           end
-          reconstruct_glyf_loca!(font_tables) if font_tables.key?("glyf")
+          reconstruct_glyf_loca!(font_tables) if glyf_transformed
           { flavor: fe.flavor, tables: font_tables }
         end
       end
 
+      # Number of fonts, read from the CollectionDirectory alone: no Brotli
+      # inflate, so it works where the `brotli` gem is absent (JRuby).
+      #
+      # @return [Integer]
+      def font_count
+        validate_signature!
+        validate_collection_flavor!
+
+        _entries, post_dir_pos = read_table_directory
+        read_collection_directory(post_dir_pos).first.length
+      end
+
       private
 
       def validate_signature!

data/lib/fontisan/woff2/collection_encoder.rb

@@ -21,10 +21,15 @@ module Fontisan
     # adjacent (loca immediately follows glyf) in the directory.
     class CollectionEncoder
       TTC_FLAVOR = 0x74746366 # 'ttcf'
+      # Largest padded glyf a short (uint16, offset / 2) loca can index.
+      SHORT_LOCA_GLYF_MAX = 0x1FFFE
 
       # @param brotli_quality [Integer] 0-11
-      def initialize(brotli_quality: 11)
+      # @param timestamp [Integer, nil] Unix seconds stamped into every
+      #   head.modified; nil uses the clock
+      def initialize(brotli_quality: 11, timestamp: nil)
         @brotli_quality = brotli_quality
+        @timestamp = timestamp
       end
 
       # Encode an array of fonts as a WOFF2 collection.
@@ -58,7 +63,7 @@ module Fontisan
           tables[tag] = data
         end
 
-        EncoderRules.apply!(tables)
+        EncoderRules.apply!(tables, timestamp: @timestamp)
         loca_orig_length = apply_glyf_loca_transform!(tables, font)
 
         { index:, tables:, loca_orig_length: }
@@ -73,12 +78,30 @@ module Fontisan
         head = font.table("head")
         return nil unless maxp && head
 
-        loca_orig_length = tables["loca"].bytesize
+        glyf = tables["glyf"]
+        loca = tables["loca"]
+        index_format = head.index_to_loc_format
+        # The WOFF2 decoder pads every glyph to 4 bytes; a short loca
+        # (offset / 2 as uint16) wraps once that padded glyf passes
+        # SHORT_LOCA_GLYF_MAX, so such a member is re-emitted with a long loca.
+        if index_format.zero? &&
+            glyf.bytesize + 3 * maxp.num_glyphs > SHORT_LOCA_GLYF_MAX
+          canonical = GlyfCanonicalizer.new(
+            glyf_data: glyf, loca_data: loca, num_glyphs: maxp.num_glyphs,
+            source_format: 0, target_format: 1
+          ).canonical
+          glyf = canonical[:glyf]
+          loca = canonical[:loca]
+          index_format = 1
+          EncoderRules.set_head_index_to_loc_format!(tables, 1)
+        end
+
+        loca_orig_length = loca.bytesize
         tables["glyf"] = GlyfLocaTransform.new(
-          glyf_data: tables["glyf"],
-          loca_data: tables["loca"],
+          glyf_data: glyf,
+          loca_data: loca,
           num_glyphs: maxp.num_glyphs,
-          index_format: head.index_to_loc_format,
+          index_format:,
         ).transform
         tables.delete("loca")
         loca_orig_length