emfsvg 0.1.3 → 0.1.4

data/lib/emfsvg/renderer.rb

@@ -17,6 +17,30 @@ module Emfsvg
   #   7. </svg>
   class Renderer
     MAX_OUTPUT_BYTES = 500 * 1024 * 1024
+    # Downstream collection policy, independent of parser input/array limits.
+    MAX_RECORDS = 1_000_000
+
+    # Records that set pathDrawn=true in libemf2svg's U_emf_onerec_analyse
+    # pre-pass. Used to distinguish wtBefore from wtAfter.
+    DRAWING_PATH_RECORDS = %w[
+      PolyBezier Polygon Polyline PolyBezierTo PolylineTo PolyPolyline PolyPolygon
+      SetWindowExtEx LineTo ArcTo PolyDraw
+      PolyBezier16 Polygon16 Polyline16 PolyBezierTo16 PolylineTo16
+      PolyPolyline16 PolyPolygon16 PolyDraw16
+    ].freeze
+
+    # Unqualified wire class name => the role a record plays in build_path_analysis.
+    PATH_RECORD_KINDS = {
+      "BeginPath" => :begin_path,
+      "EndPath" => :end_path,
+      "AbortPath" => :abort_path,
+      "FillPath" => :fill_path,
+      "StrokePath" => :stroke_path,
+      "StrokeAndFillPath" => :stroke_and_fill_path,
+      "SetWorldTransform" => :set_world_transform,
+      "ModifyWorldTransform" => :modify_world_transform,
+      **DRAWING_PATH_RECORDS.to_h { |name| [name, :drawing] }
+    }.freeze
 
     def self.call(metafile, options)
       new(metafile, options).call
@@ -25,12 +49,12 @@ module Emfsvg
     def initialize(metafile, options)
       @metafile = metafile
       @options = options
+      compute_header_params
       @builder = SvgBuilder.new
       @dc = DeviceContext.new
       @object_table = ObjectTable.new
       @transform_stack = TransformStack.new
       BsdRand.reset
-      compute_header_params
     end
 
     def call
@@ -40,10 +64,7 @@ module Emfsvg
           visit_records
         end
       end
-      result = @builder.to_s
-      raise RenderError, "SVG output exceeds #{MAX_OUTPUT_BYTES} bytes" if result.bytesize > MAX_OUTPUT_BYTES
-
-      result
+      @builder.to_s
     end
 
     private
@@ -52,8 +73,34 @@ module Emfsvg
 
     def compute_header_params
       b = @metafile.header.bounds
-      @fix_broken_y = (b.top * b.bottom).negative?
+      validate_header_dimensions!(b)
+      @fix_broken_y = (b.top.negative? && b.bottom.positive?) || (b.top.positive? && b.bottom.negative?)
+
+      compute_output_dimensions(b)
+
+      bounds_width = (b.right - b.left).abs
+      @scaling = bounds_width.zero? ? 1.0 : @img_width / bounds_width.to_f
+      @ref_x = b.left.to_f
+      @ref_y = b.top.to_f
+
+      dev = @metafile.header.device_pixels
+      mm = @metafile.header.device_mm
+      @px_per_mm = mm.cx.zero? ? 1.0 : dev.cx.to_f / mm.cx
+
+      @open_groups = 0
+    end
+
+    def validate_header_dimensions!(b)
+      [b.left, b.top, b.right, b.bottom].each do |coordinate|
+        raise RenderError, "Header coordinates must be finite" unless coordinate.to_f.finite?
+      end
+      validate_dimension!((b.right - b.left).abs.to_f, "Header width")
+      validate_dimension!((b.bottom - b.top).abs.to_f, "Header height")
+      validate_dimension!(@options.width.to_f, "Output width") if @options.width
+      validate_dimension!(@options.height.to_f, "Output height") if @options.height
+    end
 
+    def compute_output_dimensions(b)
       ratio_xy = (b.right - b.left).to_f / (b.bottom - b.top)
 
       if @options.width && @options.height
@@ -76,16 +123,14 @@ module Emfsvg
         @img_height = (b.bottom - b.top).abs.to_f
       end
 
-      bounds_width = (b.right - b.left).abs
-      @scaling = bounds_width.zero? ? 1.0 : @img_width / bounds_width.to_f
-      @ref_x = b.left.to_f
-      @ref_y = b.top.to_f
+      validate_dimension!(@img_width, "Output width")
+      validate_dimension!(@img_height, "Output height")
+    end
 
-      dev = @metafile.header.device_pixels
-      mm = @metafile.header.device_mm
-      @px_per_mm = mm.cx.zero? ? 1.0 : dev.cx.to_f / mm.cx
+    def validate_dimension!(value, label)
+      return if value.finite? && value.positive?
 
-      @open_groups = 0
+      raise RenderError, "#{label} must be finite and positive"
     end
 
     def emit_xml_declaration
@@ -131,13 +176,13 @@ module Emfsvg
     end
 
     def visit_records
-      records = @metafile.to_a
+      records = bounded_records
       path_actions, path_transforms = build_path_analysis(records)
       visitor = Visitors::EmrVisitor.new(
         @builder, @dc, @object_table, @transform_stack,
         @metafile.header.bounds, @fix_broken_y, @options,
-        scaling: @scaling, ref_x: @ref_x, ref_y: @ref_y,
-        px_per_mm: @px_per_mm,
+        frame: Visitors::EmrVisitor::Frame.new(scaling: @scaling, ref_x: @ref_x, ref_y: @ref_y,
+                                               px_per_mm: @px_per_mm),
         path_actions: path_actions,
         path_transforms: path_transforms
       )
@@ -149,6 +194,17 @@ module Emfsvg
       @open_groups = visitor.open_group_count
     end
 
+    def bounded_records
+      records = []
+      @metafile.each do |record|
+        records << record
+        next unless records.length > MAX_RECORDS
+
+        raise ResourceLimitError.new(resource: :records, limit: MAX_RECORDS, actual: records.length)
+      end
+      records
+    end
+
     # Pre-scan records to build two maps keyed by BeginPath record index:
     #   path_actions:    { idx => :fill|:stroke|:stroke_fill|:end|:abort }
     #   path_transforms: { idx => { wt_before: PathTransform?, wt_after: PathTransform? } }
@@ -162,7 +218,8 @@ module Emfsvg
     # SetWorldTransform (just assign) or 1/2/3 for ModifyWorldTransform
     # (MWT_IDENTITY/LEFTMULTIPLY/RIGHTMULTIPLY).
     def build_path_analysis(records)
-      actions = {}
+      kinds = record_kinds(records)
+      actions = path_actions_for(kinds)
       transforms = {}
       in_path = false
       path_drawn = false
@@ -170,31 +227,30 @@ module Emfsvg
       wt_before = nil
       wt_after = nil
       records.each_with_index do |r, i|
-        name = r.wire.class.name.split("::").last
-        case name
-        when "BeginPath"
-          actions[i] = find_path_action(records, i)
+        case kinds[i]
+        when :begin_path
           cur_begin = i
           wt_before = nil
           wt_after = nil
           in_path = true
           path_drawn = false
-        when "EndPath", "AbortPath"
+        when :end_path, :abort_path
           transforms[cur_begin] = { wt_before: wt_before, wt_after: wt_after } if cur_begin
           in_path = false
           path_drawn = false
           cur_begin = nil
-        when "SetWorldTransform"
+        when :set_world_transform
           next unless in_path
 
-          pt = path_transform_for(r.wire, 0)
+          pt = path_transform_for(path_fields(r), 0)
           path_drawn ? (wt_before = pt) : (wt_after = pt)
-        when "ModifyWorldTransform"
+        when :modify_world_transform
           next unless in_path
 
-          pt = path_transform_for(r.wire, r.wire.modify_mode)
+          fields = path_fields(r)
+          pt = path_transform_for(fields, fields.modify_mode)
           path_drawn ? (wt_before = pt) : (wt_after = pt)
-        when *DRAWING_PATH_RECORDS
+        when :drawing
           path_drawn = true if in_path
         end
       end
@@ -203,40 +259,43 @@ module Emfsvg
 
     PathTransform = Struct.new(:matrix, :mode, keyword_init: true)
 
+    def path_fields(record)
+      RecordAccess.fields(record, RecordAccess.wire_class(record))
+    end
+
     def path_transform_for(wire, mode)
       matrix = Emf::Model::Geometry::Matrix.from_wire(wire.xform)
       PathTransform.new(matrix: matrix, mode: mode)
     end
 
-    def find_path_action(records, start)
-      action = :end
-      ((start + 1)...records.size).each do |j|
-        name = records[j].wire.class.name.split("::").last
-        case name
-        when "EndPath"
-          next
-        when "FillPath"
-          return :fill
-        when "StrokePath"
-          return :stroke
-        when "StrokeAndFillPath"
-          return :stroke_fill
-        when "AbortPath"
-          return :abort
-        when "BeginPath"
-          return :end
-        end
+    # Path-analysis kind per record (see PATH_RECORD_KINDS; nil when the
+    # record is irrelevant to the analysis), computed once per wire class.
+    def record_kinds(records)
+      cache = {}
+      records.map do |r|
+        klass = RecordAccess.wire_class(r)
+        cache.fetch(klass) { cache[klass] = PATH_RECORD_KINDS[klass.name.split("::").last] }
       end
-      action
     end
 
-    # Records that set pathDrawn=true in libemf2svg's U_emf_onerec_analyse
-    # pre-pass. Used to distinguish wtBefore from wtAfter.
-    DRAWING_PATH_RECORDS = %w[
-      PolyBezier Polygon Polyline PolyBezierTo PolylineTo PolyPolyline PolyPolygon
-      SetWindowExtEx LineTo ArcTo PolyDraw
-      PolyBezier16 Polygon16 Polyline16 PolyBezierTo16 PolylineTo16
-      PolyPolyline16 PolyPolygon16 PolyDraw16
-    ].freeze
+    # Resolve each BeginPath's action in one backward pass. The action is set
+    # by the first Fill/Stroke/StrokeAndFill/AbortPath after the BeginPath;
+    # another BeginPath first, or none at all, leaves it :end.
+    def path_actions_for(kinds)
+      actions = {}
+      following = :end
+      (kinds.size - 1).downto(0) do |i|
+        case kinds[i]
+        when :begin_path
+          actions[i] = following
+          following = :end
+        when :fill_path then following = :fill
+        when :stroke_path then following = :stroke
+        when :stroke_and_fill_path then following = :stroke_fill
+        when :abort_path then following = :abort
+        end
+      end
+      actions
+    end
   end
 end

data/lib/emfsvg/svg/clip_path_registry.rb

@@ -11,24 +11,48 @@ module Emfsvg
 
       def initialize
         @clip_paths = {}
+        @references = {}
+        @resolved = {}
+        @exports = {}
+        @imports = {}
+        @selected = {}
+        @unused_selected = {}
+        @interval_starts = {}
+        @interval_ends = {}
+        @interval_groups = {}
       end
 
       def register(clip_path)
+        @resolved.clear
         @clip_paths[clip_path.id] = clip_path
       end
 
+      def referenced?(id)
+        @references.key?(id)
+      end
+
+      def reference(clip_path_attr)
+        match = clip_path_attr&.match(URL_RE)
+        @references[match[1]] = @references.fetch(match[1], 0) + 1 if match
+      end
+
+      # Shapes reference the same few clips over and over, so each
+      # distinct attribute value is resolved once (until the next
+      # registration).
       def lookup(clip_path_attr)
         return nil if clip_path_attr.nil?
 
-        match = clip_path_attr.match(URL_RE)
-        return nil unless match
-
-        @clip_paths[match[1]]
+        @resolved.fetch(clip_path_attr) { @resolved[clip_path_attr] = resolve(clip_path_attr) }
       end
 
       def self.from_document(document)
         registry = new
         collect_clip_paths(document.root_element, registry)
+        registry.plan_sibling_clips(document.root_element)
+        registry.plan_selected_clips(document.root_element)
+        registry.plan_clip_intervals(document.header_translate_group)
+        registry.plan_text_clip_intervals(document.root_element)
+        registry.plan_pending_clips(document.root_element, document.header_translate_group)
         registry
       end
 
@@ -36,8 +60,267 @@ module Emfsvg
         return unless element
 
         registry.register(element) if element.is_a?(Elements::ClipPath)
+        registry.reference(element.clip_path) if element.respond_to?(:clip_path)
         element.children.each { |c| collect_clip_paths(c, registry) }
       end
+
+      def exported_clip(group)
+        @exports[group]
+      end
+
+      def imported_clip(group)
+        @imports[group]
+      end
+
+      def selected_clip(group)
+        @selected[group]
+      end
+
+      # A pending native path and its definition must agree exactly, and every
+      # remaining child must reference it. RestoreDC then bounds its lifetime.
+      def plan_selected_clips(group)
+        return unless group
+
+        group.children.each { |child| plan_selected_clips(child) }
+        clip = selected_group_clip(group)
+        @selected[group] = clip if clip
+      end
+
+      # A canonical identity group containing only a definition can carry its
+      # clip into the immediately following canonical drawing group. The sole
+      # reference bounds the lifetime; Context also requires a known-empty clip.
+      def plan_sibling_clips(parent)
+        return unless parent
+
+        parent.children.each { |child| plan_sibling_clips(child) }
+        return unless parent.is_a?(Elements::Group) && parent.transform_matrix.identity?
+
+        parent.children.each_cons(2) do |source, target|
+          clip = sibling_clip(source, target)
+          next unless clip
+
+          @exports[source] = clip
+          @imports[target] = clip
+        end
+      end
+
+      def interval_group?(element)
+        @interval_groups.key?(element)
+      end
+
+      def interval_start(element)
+        @interval_starts[element]
+      end
+
+      def interval_end(element)
+        @interval_ends[element]
+      end
+
+      def unused_selected_clip?(clip)
+        @unused_selected.key?(clip)
+      end
+
+      # A definition immediately following its exact pending native path can
+      # select that path. Exclusive adjacent image or path uses bound its lifetime;
+      # an unused selection is reset before any later drawing.
+      def plan_pending_clips(parent, header)
+        return unless parent
+
+        parent.children.each { |child| plan_pending_clips(child, header) }
+        return unless parent.equal?(header) ||
+                      (parent.is_a?(Elements::Group) && parent.canonical_matrix? && parent.transform_matrix.identity?)
+
+        parent.children.each_cons(2).with_index do |(path, defs), index|
+          next unless defs.is_a?(Elements::Defs) && defs.children.size == 1
+
+          clip = defs.children.first
+          next unless clip.is_a?(Elements::ClipPath) && matching_pending_clip?(path, clip)
+
+          if referenced?(clip.id)
+            plan_pending_draw_interval(parent.children.drop(index + 2), defs, clip)
+          else
+            @unused_selected[clip] = true
+          end
+        end
+      end
+
+      # A canonical rectangle may surround nested clips and then be reused.
+      # Only flat, fully explicit built-in drawings participate. Unused defs
+      # and text transformed under a different clip remain boundaries.
+      def plan_clip_intervals(parent)
+        return unless parent
+
+        parent.children.grep(Elements::Group).each do |group|
+          plan_clip_intervals(group) if group.canonical_matrix?
+        end
+
+        children = parent.children
+        positions = children.each_index.group_by { |index| lookup(children[index].clip_path) }
+        occupied = []
+        candidates = positions.reject { |clip, indices| !clip || indices.size < 2 }
+        candidates.sort_by { |_, indices| -(indices.last - indices.first) }.each do |clip, indices|
+          range = indices.first..indices.last
+          next unless compatible_interval?(range, occupied, children, clip)
+          next unless clip.unused_rectangle_bounds
+          next unless children[range].all? { |child| interval_child?(child, clip) }
+
+          @interval_starts[children[range.begin]] = clip
+          @interval_ends[children[range.end]] = clip
+          occupied << range
+          @interval_groups[parent] = true
+        end
+      end
+
+      # Canonical text draws can share a clip across a painted native path,
+      # whose renderer spelling omits the clipping attribute. The exact three
+      # drawing sequence and exclusive references bound this scope.
+      def plan_text_clip_intervals(parent)
+        return unless parent
+
+        parent.children.each { |child| plan_text_clip_intervals(child) }
+        return unless parent.is_a?(Elements::Group) && parent.canonical_matrix?
+
+        parent.children.each_cons(5) do |previous, defs, first, path, last|
+          clip = text_interval_clip(previous, defs, first, path, last)
+          next unless clip
+
+          # The general rectangle planner may already start this same interval
+          # at its first text. Move that start to the definition instead of
+          # opening two native scopes with only one shared end.
+          @interval_starts.delete(first) if @interval_starts[first].equal?(clip)
+          @interval_starts[defs] = clip
+          @interval_ends[last] = clip
+        end
+      end
+
+      private
+
+      def plan_pending_draw_interval(children, defs, clip)
+        draws = children.take_while do |draw|
+          supported = draw.instance_of?(Elements::Image) ||
+                      (draw.instance_of?(Elements::Path) && draw.stroke && draw.fill &&
+                        draw.path_record_kind != :end_path)
+          supported && lookup(draw.clip_path).equal?(clip)
+        end
+        return if draws.empty? || @references[clip.id] != draws.size
+
+        @interval_starts[defs] = clip
+        @interval_ends[draws.last] = clip
+      end
+
+      # Crossing ranges cannot form native scopes. A nested range contains
+      # only its own clip, so its final RestoreDC returns to the outer scope
+      # even for renderers which retain restored snapshots.
+      def compatible_interval?(range, occupied, children, clip)
+        return false if occupied.any? do |prior|
+          prior.cover?(range.begin) != prior.cover?(range.end)
+        end
+
+        parents = occupied.count { |prior| prior.cover?(range.begin) && prior.cover?(range.end) }
+        uniform = children[range].all? { |child| child.is_a?(Elements::Defs) || lookup(child.clip_path).equal?(clip) }
+        return !uniform if parents.zero?
+
+        parents == 1 && uniform
+      end
+
+      def interval_child?(child, outer)
+        return interval_definitions?(child) if child.is_a?(Elements::Defs)
+
+        classes = [Elements::Path, Elements::Rect, Elements::Ellipse, Elements::Line,
+                   Elements::Polyline, Elements::Polygon, Elements::Text, Elements::Image]
+        return false unless classes.include?(child.class)
+        return false if child.is_a?(Elements::Text) && child.transformed? && !lookup(child.clip_path).equal?(outer)
+        return true if child.is_a?(Elements::Path) && !child.clip_path && child.stroke&.null_pen_fallback
+
+        bounds = lookup(child.clip_path)&.unused_rectangle_bounds
+        return false unless bounds
+
+        left, top, right, bottom = outer.unused_rectangle_bounds
+        bounds[0] >= left && bounds[1] >= top && bounds[2] <= right && bounds[3] <= bottom
+      end
+
+      def interval_definitions?(defs)
+        # Creating an unselected canonical brush does not change the active clip.
+        return true if defs.unused_pattern
+
+        defs.children.all? do |clip|
+          clip.is_a?(Elements::ClipPath) && clip.unused_rectangle_bounds && referenced?(clip.id)
+        end
+      end
+
+      def text_interval_clip(previous, defs, first, path, last)
+        return unless defs.is_a?(Elements::Defs) && defs.children.size == 1
+
+        clip = defs.children.first
+        return unless clip.is_a?(Elements::ClipPath) && @references[clip.id] == 2
+        return unless [first, last].all? do |text|
+          text.instance_of?(Elements::Text) && !text.transformed? && lookup(text.clip_path).equal?(clip)
+        end
+        return unless path.instance_of?(Elements::Path) && !path.clip_path
+        return unless path.path_record_kind == :stroke_and_fill_path
+        return clip if clip.unused_rectangle_bounds
+
+        clip if matching_pending_clip?(previous, clip)
+      end
+
+      def matching_pending_clip?(path, clip)
+        clip.selected_path_data && path.instance_of?(Elements::Path) &&
+          path.path_record_kind == :end_path && !path.clip_path && matching_clip_path?(path, clip)
+      end
+
+      def selected_group_clip(group)
+        return unless group.is_a?(Elements::Group) && group.canonical_matrix? && group.transform_matrix.identity?
+
+        unused, path, defs, *draws = group.children
+        return unless unused_clip_definitions?(unused)
+        return unless path.is_a?(Elements::Path) && path.path_record_kind == :end_path && !path.clip_path
+        return unless defs.is_a?(Elements::Defs) && defs.children.size == 1 && !draws.empty?
+
+        clip = defs.children.first
+        return unless clip.is_a?(Elements::ClipPath) && clip.selected_path_data
+        return unless matching_clip_path?(path, clip)
+        return unless exclusive_clip_draws?(draws, clip)
+
+        clip
+      end
+
+      def exclusive_clip_draws?(draws, clip)
+        @references[clip.id] == draws.size && draws.all? do |draw|
+          draw.is_a?(Elements::Path) && lookup(draw.clip_path).equal?(clip)
+        end
+      end
+
+      def unused_clip_definitions?(defs)
+        defs.is_a?(Elements::Defs) && !defs.children.empty? && defs.children.all? do |child|
+          child.is_a?(Elements::ClipPath) && child.unused_rectangle_bounds && !referenced?(child.id)
+        end
+      end
+
+      def matching_clip_path?(path, clip)
+        commands = Svg::PathData::Parser.parse(clip.selected_path_data)
+        path.commands.map { |cmd| [cmd.letter, cmd.args] } == commands.map { |cmd| [cmd.letter, cmd.args] }
+      end
+
+      def sibling_clip(source, target)
+        return unless source.is_a?(Elements::Group) && source.canonical_matrix? && source.transform_matrix.identity?
+        return unless target.is_a?(Elements::Group) && target.canonical_matrix?
+        return unless source.children.size == 1 && target.children.size == 1
+
+        defs = source.children.first
+        path = target.children.first
+        return unless defs.is_a?(Elements::Defs) && defs.children.size == 1 && path.is_a?(Elements::Path)
+
+        clip = defs.children.first
+        return unless clip.is_a?(Elements::ClipPath) && clip.unused_rectangle_bounds
+        return unless @references[clip.id] == 1 && lookup(path.clip_path).equal?(clip)
+
+        clip
+      end
+
+      def resolve(clip_path_attr)
+        match = clip_path_attr.match(URL_RE)
+        match && @clip_paths[match[1]]
+      end
     end
   end
 end

data/lib/emfsvg/svg/color.rb

@@ -29,6 +29,19 @@ module Emfsvg
         Emf::Model::Geometry::Color.new(red: red, green: green, blue: blue)
       end
 
+      # The ColorRef reserved byte emfsvg has always written for a colour.
+      WIRE_RESERVED = 255
+
+      # Attribute-hash form of #to_emf_wire(...).to_wire: a record field
+      # accepts it and builds the ColorRef in place, without first
+      # constructing a model colour and a wire object that the record
+      # would only copy.
+      #
+      # A Color never changes, so the one frozen Hash is returned each time.
+      def wire_attrs
+        @wire_attrs ||= { red: red, green: green, blue: blue, reserved: WIRE_RESERVED }.freeze
+      end
+
       def ==(other)
         other.is_a?(self.class) && red == other.red && green == other.green && blue == other.blue
       end
@@ -38,12 +51,16 @@ module Emfsvg
         [self.class, red, green, blue].hash
       end
 
+      NULL_WIRE_ATTRS = { red: 0, green: 0, blue: 0, reserved: WIRE_RESERVED }.freeze
+      private_constant :NULL_WIRE_ATTRS
+
       NULL = NullColor = Class.new do
         def null? = true
         def red = 0
         def green = 0
         def blue = 0
         def to_emf_wire = Emf::Model::Geometry::Color.new(red: 0, green: 0, blue: 0)
+        def wire_attrs = NULL_WIRE_ATTRS
         def ==(other) = other.is_a?(self.class)
         alias_method :eql?, :==
         def hash = NullColor.hash
@@ -71,19 +88,25 @@ module Emfsvg
         "cyan" => [0x00, 0xFF, 0xFF]
       }.freeze
 
+      HEX3_RE = /\A#\h{3}\z/
+      HEX6_RE = /\A#\h{6}\z/
+      RGB_RE = /\Argb\(\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*(-?\d+)\s*\)\z/i
+
       def self.parse(value)
-        return NULL if value.nil? || value.strip == "none" || value.strip.empty?
+        return NULL if value.nil?
 
         v = value.strip
-        if (m = v.match(/\A#([0-9a-fA-F]{3})\z/))
-          expand_short_hex(m[1])
-        elsif (m = v.match(/\A#([0-9a-fA-F]{6})\z/))
-          new(red: m[1][0, 2].to_i(16), green: m[1][2, 2].to_i(16), blue: m[1][4, 2].to_i(16))
-        elsif (m = v.match(/\Argb\(\s*(-?\d+)\s*,\s*(-?\d+)\s*,\s*(-?\d+)\s*\)\z/i))
+        return NULL if v.empty? || v == "none"
+
+        if v.match?(HEX3_RE)
+          expand_short_hex(v[1, 3])
+        elsif v.match?(HEX6_RE)
+          rgb = v[1, 6].to_i(16)
+          new(red: rgb >> 16, green: (rgb >> 8) & 0xFF, blue: rgb & 0xFF)
+        elsif (m = RGB_RE.match(v))
           new(red: m[1].to_i, green: m[2].to_i, blue: m[3].to_i)
-        elsif NAMED_COLORS.key?(v.downcase)
-          r, g, b = NAMED_COLORS[v.downcase]
-          new(red: r, green: g, blue: b)
+        elsif (rgb = NAMED_COLORS[v.downcase])
+          new(red: rgb[0], green: rgb[1], blue: rgb[2])
         else
           raise FormatError, "unsupported SVG color: #{value.inspect}"
         end

data/lib/emfsvg/svg/document.rb

@@ -36,6 +36,13 @@ module Emfsvg
         candidate
       end
 
+      # True when the header translate group carries the legacy broken-Y
+      # marker (see Elements::Group::LEGACY_BROKEN_Y_TRANSFORM).
+      def legacy_broken_y_header?
+        group = header_translate_group
+        !group.nil? && group.legacy_broken_y?
+      end
+
       # A matrix equivalent to a pure translate: identity 2×2 portion
       # (modulo floating-point rounding).
       IDENTITY_TOLERANCE = 1e-9