emfsvg 0.1.2 → 0.1.4

data/lib/emfsvg/svg/element.rb

@@ -6,7 +6,7 @@ module Emfsvg
     # carry typed semantic fields; the base provides a uniform interface
     # for the translation layer's dispatch.
     #
-    # Element instances are immutable: built once from a Nokogiri node
+    # Element instances are immutable: built once from a leptris node
     # via the .from_node factory. The node is not retained.
     class Element
       ELEMENT_NAME = "abstract"
@@ -38,12 +38,12 @@ module Emfsvg
           @registry[element_name] = subclass
         end
 
-        def from_node(node)
+        def from_node(node, &source_tag)
           subclass = @registry[node.name]
-          return subclass.from_node(node) if subclass
+          return subclass.from_node(node, &source_tag) if subclass
 
           OpenElement.new(name: node.name, children: node.element_children.map do |c|
-            from_node(c)
+            from_node(c, &source_tag)
           end)
         end
       end

data/lib/emfsvg/svg/elements/clip_path.rb

@@ -9,29 +9,90 @@ module Emfsvg
         ELEMENT_NAME = "clipPath"
         Element.register("clipPath", self)
 
-        attr_reader :id, :children
+        attr_reader :id, :children, :unused_rectangle_bounds, :selected_path_data
 
-        def initialize(id:, children:)
+        def initialize(id:, children:, unused_rectangle_bounds: nil, selected_path_data: nil)
           @id = id
           @children = children
+          @unused_rectangle_bounds = unused_rectangle_bounds
+          @selected_path_data = selected_path_data
         end
 
-        def self.from_node(node)
+        def self.from_node(node, &source_tag)
           new(
             id: node["id"],
-            children: node.element_children.map { |c| Element.from_node(c) }
+            selected_path_data: canonical_selected_path(node, &source_tag),
+            unused_rectangle_bounds: canonical_unused_rectangle(node, &source_tag),
+            children: node.element_children.map { |c| Element.from_node(c, &source_tag) }
           )
         end
 
+        def self.canonical_selected_path(node)
+          return unless node["id"]&.match?(/\Aclip-\d+\z/) && node.attribute_nodes.size == 1
+          return unless node.element_children.size == 1 && block_given?
+
+          path = node.element_children.first
+          return unless path.name == "path" && path.attribute_nodes.map(&:name) == ["d"]
+
+          number = "-?\\d+\\.\\d{4}"
+          point = "#{number},#{number}"
+          segment = "(?: L #{point}| C #{point} #{point} #{point})"
+          contour = "M #{point}(?: L #{point})+ Z "
+          return unless path["d"]&.match?(/\A(?:M #{point}(?:#{segment})+ |(?:#{contour}){2,})Z\z/)
+          return unless yield(path) == %(<path d="#{path['d']}" />)
+
+          path["d"].delete_suffix("Z")
+        end
+        private_class_method :canonical_selected_path
+
+        # Only the renderer's exact rectangle spelling supports preservation of
+        # an otherwise inert resource via IntersectClipRect followed by reset.
+        def self.canonical_unused_rectangle(node)
+          return unless node["id"]&.match?(/\Aclip-\d+\z/) && node.attribute_nodes.size == 1
+          return unless node.element_children.size == 1 && block_given?
+
+          path = node.element_children.first
+          return unless path.name == "path" && path.attribute_nodes.map(&:name) == ["d"]
+
+          number = "(-?\\d+\\.\\d{4})"
+          lines = " L #{number},#{number}" * 4
+          pattern = "\\AM #{number},#{number}#{lines} Z Z\\z"
+          match = path["d"]&.match(Regexp.new(pattern))
+          return unless match && yield(path) == %(<path d="#{path['d']}" />)
+
+          left, top, right, top2, right2, bottom, left2, bottom2, left3, top3 = match.captures.map(&:to_f)
+          return unless [left, top, right, bottom, left, top] == [left2, top2, right2, bottom2, left3, top3]
+          return unless left <= right && top <= bottom
+
+          [left, top, right, bottom]
+        end
+        private_class_method :canonical_unused_rectangle
+
         # Bounds [left, top, right, bottom] of the clip region for
         # IntersectClipRect emission. Handles three forms:
         #
         # 1. Single <rect> child — use rect bounds directly.
         # 2. Single <path> child whose d-string traces a rectangle
         #    (4 unique corners + close) — extract corner bounds.
-        # 3. Anything else — use the union bounding box of all child
-        #    geometry (lossy: curves flattened to bounds).
+        # Compound paths cannot use IntersectClipRect. Other single contours
+        # and multiple children retain the existing bounds fallback.
+        #
+        # Every shape that references the clip asks for these bounds, so
+        # they are computed once and the (frozen) result is reused.
         def clip_bounds
+          return @clip_bounds if defined?(@clip_bounds)
+
+          @clip_bounds = compute_clip_bounds&.freeze
+        end
+
+        # Alias retained for backward compatibility with shared_gdi.rb.
+        def rectangular_bounds
+          clip_bounds
+        end
+
+        private
+
+        def compute_clip_bounds
           return nil if children.empty?
 
           if children.size == 1
@@ -43,13 +104,6 @@ module Emfsvg
           bounding_box_of(children)
         end
 
-        # Alias retained for backward compatibility with shared_gdi.rb.
-        def rectangular_bounds
-          clip_bounds
-        end
-
-        private
-
         def rect_bounds(rect)
           [rect.x, rect.y, rect.x + rect.width, rect.y + rect.height]
         end
@@ -58,24 +112,38 @@ module Emfsvg
         # path: M X1,Y1 L X2,Y1 L X2,Y2 L X1,Y2 L X1,Y1 Z Z. Detect
         # that shape and recover (X1, Y1, X2, Y2).
         def path_rect_bounds(path)
+          return unless path.commands.one? { |command| command.letter == "M" }
+
           points = PathFlattenerForClip.new.flatten(path.commands)
-          return nil unless points && points.size >= 4
+          return unless points && points.size >= 4
 
           xs = points.map(&:first)
           ys = points.map(&:last)
-          [xs.min, ys.min, xs.max, ys.max]
+          bounds = [xs.min, ys.min, xs.max, ys.max]
+          # Preserve the established single-contour fallback outside the
+          # four-corner case. Multiple contours must never collapse to bounds.
+          return bounds unless points.uniq.size == 4
+          return unless path.commands.map(&:letter).join.match?(/\AM[LHV]{3,4}Z+\z/)
+
+          points.pop if points.last == points.first
+          return unless points.size == 4
+          return unless (points + [points.first]).each_cons(2).all? { |a, b| (a.first == b.first) ^ (a.last == b.last) }
+          return unless xs.uniq.size == 2 && ys.uniq.size == 2
+
+          bounds
         end
 
         def bounding_box_of(elements)
-          xs, ys = [], []
+          xs = []
+          ys = []
           elements.each do |e|
             case e
             when Elements::Rect
-              xs << e.x << e.x + e.width
-              ys << e.y << e.y + e.height
+              xs << e.x << (e.x + e.width)
+              ys << e.y << (e.y + e.height)
             when Elements::Ellipse
-              xs << e.cx - e.rx << e.cx + e.rx
-              ys << e.cy - e.ry << e.cy + e.ry
+              xs << (e.cx - e.rx) << (e.cx + e.rx)
+              ys << (e.cy - e.ry) << (e.cy + e.ry)
             when Elements::Path
               points = PathFlattenerForClip.new.flatten(e.commands)
               next unless points
@@ -101,10 +169,7 @@ module Emfsvg
             current = [0.0, 0.0]
             commands.each do |cmd|
               case cmd.letter
-              when "M"
-                current = cmd.args
-                points << current.dup
-              when "L"
+              when "M", "L"
                 current = cmd.args
                 points << current.dup
               when "H"

data/lib/emfsvg/svg/elements/defs.rb

@@ -9,15 +9,96 @@ module Emfsvg
         ELEMENT_NAME = "defs"
         Element.register("defs", self)
 
-        attr_reader :children
+        HREF_ATTRIBUTES = %w[href xlink:href].freeze
+        CanonicalPattern = Struct.new(:image, :id, keyword_init: true)
 
-        def initialize(children:)
+        attr_reader :children, :unused_pattern, :selected_pattern
+
+        def initialize(children:, unused_pattern: nil, selected_pattern: nil)
           @children = children
+          @unused_pattern = unused_pattern
+          @selected_pattern = selected_pattern
+        end
+
+        def self.from_node(node, &source_tag)
+          new(children: node.element_children.map { |c| Element.from_node(c, &source_tag) },
+              unused_pattern: canonical_unused_pattern(node),
+              selected_pattern: canonical_selected_pattern(node))
+        end
+
+        # The renderer emits this pair when a DIB brush is created, even if
+        # never selected. Keep that provenance separate from ordinary resources.
+        def self.canonical_unused_pattern(node, selected: false)
+          image, pattern = node.element_children
+          return unless node.element_children.size == 2 && node.attribute_nodes.empty?
+          return unless image.name == "image" && pattern.name == "pattern"
+
+          id = image["id"]
+          width = image["width"]
+          height = image["height"]
+          return unless id&.match?(/\Aimg-[1-9]\d*\z/)
+          return unless [width, height].all? { |v| v&.match?(/\A[1-9]\d*\z/) }
+          return unless canonical_image_attributes?(image, id, width, height)
+          return unless pattern.attribute_pairs == [["id", "#{id}-ref"], %w[x 0], %w[y 0],
+                                                    ["width", width], ["height", height],
+                                                    %w[patternUnits userSpaceOnUse]]
+
+          use = pattern.element_children.first
+          return unless pattern.element_children.size == 1 && use.name == "use"
+          return unless canonical_use?(use, id)
+
+          return unless canonical_pattern_reference?(node.document.root, id, use, selected)
+
+          CanonicalPattern.new(image: Image.from_node(image), id: "#{id}-ref").freeze
+        end
+        private_class_method :canonical_unused_pattern
+
+        def self.canonical_pattern_reference?(root, id, use, selected)
+          return selected_pattern_reference?(root, "#{id}-ref") if selected
+
+          !referenced_pattern?(root, [id, "#{id}-ref"], use)
+        end
+        private_class_method :canonical_pattern_reference?
+
+        def self.canonical_selected_pattern(node)
+          canonical_unused_pattern(node, selected: true)
+        end
+        private_class_method :canonical_selected_pattern
+
+        def self.selected_pattern_reference?(node, id)
+          supported = %w[rect ellipse circle polygon polyline path]
+          return true if supported.include?(node.name) && ["##{id}", "url(##{id})"].include?(node["fill"])
+
+          node.element_children.any? { |child| selected_pattern_reference?(child, id) }
         end
+        private_class_method :selected_pattern_reference?
+
+        def self.canonical_use?(use, id)
+          use.attribute_pairs == [["id", "#{id}-ign"], ["xlink:href", "##{id}"]] && use.element_children.empty?
+        end
+        private_class_method :canonical_use?
+
+        def self.canonical_image_attributes?(image, id, width, height)
+          image.element_children.empty? && image["xlink:href"]&.start_with?("data:image/png;base64,") &&
+            image.attribute_pairs == [["id", id], ["x", "0"], ["y", "0"], ["width", width], ["height", height],
+                                      ["xlink:href", image["xlink:href"]], ["preserveAspectRatio", "none"]]
+        end
+        private_class_method :canonical_image_attributes?
+
+        def self.referenced_pattern?(node, ids, internal_use)
+          return false if node == internal_use
+          # Stylesheets can select resources without a local presentation attribute.
+          return true if node.name == "style"
 
-        def self.from_node(node)
-          new(children: node.element_children.map { |c| Element.from_node(c) })
+          referenced = node.attribute_pairs.any? do |name, value|
+            ids.any? do |id|
+              ((HREF_ATTRIBUTES.include?(name) || name == "fill") && value == "##{id}") ||
+                value.match?(/url\(\s*["']?\##{Regexp.escape(id)}["']?\s*\)/)
+            end
+          end
+          referenced || node.element_children.any? { |child| referenced_pattern?(child, ids, internal_use) }
         end
+        private_class_method :referenced_pattern?
       end
     end
   end

data/lib/emfsvg/svg/elements/group.rb

@@ -11,22 +11,48 @@ module Emfsvg
         ELEMENT_NAME = "g"
         Element.register("g", self)
 
+        # Exact literal libemf2svg emits as the header group of a
+        # broken-Y (Sparx/Wine) metafile. Not valid SVG translate syntax.
+        LEGACY_BROKEN_Y_TRANSFORM = "translate(0.0000, 0.00 00)"
+
         attr_reader :children, :transform_matrix
 
-        def initialize(children:, transform_matrix: Emf::Model::Geometry::Matrix.identity)
+        def initialize(children:, transform_matrix: Emf::Model::Geometry::Matrix.identity,
+                       legacy_broken_y: false, canonical_matrix: false)
           @children = children
           @transform_matrix = transform_matrix
+          @legacy_broken_y = legacy_broken_y
+          @canonical_matrix = canonical_matrix
+        end
+
+        # True when the source transform was exactly the legacy literal.
+        def legacy_broken_y?
+          @legacy_broken_y
+        end
+
+        def canonical_matrix?
+          @canonical_matrix
         end
 
         def transformed?
           !transform_matrix.identity?
         end
 
-        def self.from_node(node)
-          children = node.element_children.map { |c| Element.from_node(c) }
+        def self.from_node(node, &source_tag)
+          children = node.element_children.map { |c| Element.from_node(c, &source_tag) }
           new(children: children,
-              transform_matrix: Svg::TransformParser.parse(node["transform"]))
+              transform_matrix: Svg::TransformParser.parse(node["transform"]),
+              legacy_broken_y: node["transform"] == LEGACY_BROKEN_Y_TRANSFORM,
+              canonical_matrix: canonical_matrix_node?(node))
+        end
+
+        def self.canonical_matrix_node?(node)
+          return false unless node.attribute_nodes.map(&:name) == ["transform"]
+
+          number = "-?\\d+\\.\\d{4}"
+          node["transform"]&.match?(Regexp.new("\\Amatrix\\(#{number}(?: #{number}){5}\\)\\z"))
         end
+        private_class_method :canonical_matrix_node?
       end
     end
   end

data/lib/emfsvg/svg/elements/path.rb

@@ -8,21 +8,257 @@ module Emfsvg
         ELEMENT_NAME = "path"
         Element.register("path", self)
 
-        attr_reader :commands, :fill, :stroke, :clip_path
+        attr_reader :commands, :fill, :stroke, :clip_path, :line_record_kind, :path_record_kind
 
-        def initialize(commands:, fill:, stroke:, clip_path: nil)
+        def initialize(commands:, fill:, stroke:, clip_path: nil, line_record_kind: nil, path_record_kind: nil)
           @commands = commands
           @fill = fill
           @stroke = stroke
           @clip_path = clip_path
+          @line_record_kind = line_record_kind
+          @path_record_kind = path_record_kind
         end
 
         def self.from_node(node)
+          source_tag = yield(node) if block_given?
+          style = Stylable.parse_style(node)
+          style[:stroke] = style[:stroke].with_canonical_cosmetic_dash(source_tag) if source_tag
+          path_record_kind = canonical_path_record_kind(node, source_tag) if source_tag
+          brush_fallback = source_tag && canonical_brush_fallback?(node, source_tag)
+          if brush_fallback
+            paint = style[:stroke].paint
+            style[:stroke] = Svg::Stroke.new(paint: paint, raw_width: "1px", fallback_brush: paint)
+          end
+          style[:fill] = Svg::Paint.from_fill(node["style"].delete_prefix("fill:")) if path_record_kind == :bitblt
           new(
             commands: Svg::PathData::Parser.parse(node["d"]),
-            **Stylable.parse_style(node)
+            line_record_kind: brush_fallback ? :polyline : canonical_line_record_kind(node, source_tag),
+            path_record_kind: path_record_kind,
+            **style
           )
         end
+
+        # A NULL pen uses its solid brush to draw open Polyline strokes. The
+        # renderer writes fill=none even though that independent brush is set.
+        def self.canonical_brush_fallback?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          return false unless node["d"]&.match?(/\AM #{number},#{number}(?: L #{number},#{number})+ \z/)
+          return false unless node["stroke"]&.match?(/\A#[0-9A-F]{6}\z/)
+
+          source_tag == %(<path d="#{node['d']}" stroke-width="1px" stroke="#{node['stroke']}" fill="none" />)
+        end
+        private_class_method :canonical_brush_fallback?
+
+        def self.canonical_path_record_kind(node, source_tag)
+          arc_kind = canonical_arc_kind(node, source_tag)
+          return arc_kind if arc_kind
+          return :end_path if canonical_pending_path?(node, source_tag)
+          return :fill_path if canonical_filled_curve?(node, source_tag) || canonical_filled_contours?(node, source_tag)
+          return :bitblt if canonical_bitblt?(node, source_tag)
+          return :polypolygon if canonical_poly_polygon?(node, source_tag)
+          return :stroke_and_fill_path if canonical_open_painted_path?(node, source_tag)
+          return :polybezier_to if canonical_stroked_curve?(node, source_tag)
+          return :stroke_path if canonical_cubic_figure?(node, source_tag)
+          return :stroke_path if canonical_orphan_or_empty_path?(node, source_tag)
+
+          nil
+        end
+        private_class_method :canonical_path_record_kind
+
+        # EndPath without a painting record has this exact invisible spelling.
+        # Its geometry remains available to a following SelectClipPath.
+        def self.canonical_pending_path?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          point = "#{number},#{number}"
+          segment = "(?: L #{point}| C #{point} #{point} #{point})"
+          contour = "M #{point}(?: L #{point})+ Z "
+          node["d"]&.match?(/\A(?:M #{point}(?:#{segment})+ |(?:#{contour}){2,})\z/) &&
+            source_tag == %(<path d="#{node['d']}" fill="none" stroke="none" />)
+        end
+        private_class_method :canonical_pending_path?
+
+        # A pure cubic FillPath omits PolyBezier's extra current-position move.
+        def self.canonical_filled_curve?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          curve = " C #{number},#{number} #{number},#{number} #{number},#{number}"
+          node["d"]&.match?(/\AM #{number},#{number}(?:#{curve})+ \z/) &&
+            node["fill"]&.match?(/\A#[0-9A-F]{6}\z/) &&
+            source_tag == %(<path d="#{node['d']}"  fill="#{node['fill']}" stroke="none" />)
+        end
+        private_class_method :canonical_filled_curve?
+
+        # FillPath retains every closed contour and has a fill-first tag with
+        # no pen attributes. Polygon's NULL-pen brush fallback draws an outline.
+        def self.canonical_filled_contours?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          point = "#{number},#{number}"
+          segment = "(?: L #{point}| C #{point} #{point} #{point})"
+          contour = "M #{point}(?:#{segment})+ Z "
+          node["d"]&.match?(/\A(?:#{contour})+\z/) &&
+            node["fill"]&.match?(/\A#[0-9A-F]{6}\z/) &&
+            source_tag == %(<path d="#{node['d']}"  fill="#{node['fill']}" stroke="none" />)
+        end
+        private_class_method :canonical_filled_contours?
+
+        # Path painting implicitly closes only the fill, retaining open strokes.
+        # Fill-first output distinguishes it from unfilled Polyline/PolyBezier.
+        def self.canonical_open_painted_path?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          point = "#{number},#{number}"
+          segment = "(?: L #{point}| C #{point} #{point} #{point})"
+          node["d"]&.match?(/\AM #{point}(?:#{segment})+ \z/) && canonical_fill_first_style?(node, source_tag)
+        end
+        private_class_method :canonical_open_painted_path?
+
+        # PolyBezier includes a separate current-position move in its output;
+        # PolyBezierTo emits only its existing current position.
+        def self.canonical_stroked_curve?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          point = "#{number},#{number}"
+          node["d"]&.match?(/\AM #{point}(?: C #{point} #{point} #{point})+ \z/) &&
+            canonical_stroked_path?(node, source_tag, fill_gap: true)
+        end
+        private_class_method :canonical_stroked_curve?
+
+        # StrokePath figures have one initial move and the ordinary fill gap.
+        # Cubics distinguish these from Polyline; PolyBezier has an extra move.
+        def self.canonical_cubic_figure?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          point = "#{number},#{number}"
+          segment = "(?: L #{point}| C #{point} #{point} #{point})"
+          node["d"]&.include?(" C ") &&
+            node["d"].match?(/\AM #{point}(?:#{segment})+(?: Z)? \z/) &&
+            canonical_stroked_path?(node, source_tag)
+        end
+        private_class_method :canonical_cubic_figure?
+
+        # A stroked EMF path can start with LineTo or contain no figures at
+        # all. Only the renderer's exact spelling carries that provenance.
+        def self.canonical_orphan_or_empty_path?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          data = node["d"]
+          return false unless data == "" || data&.match?(/\AL #{number},#{number}(?: [ML] #{number},#{number})* \z/)
+
+          canonical_stroked_path?(node, source_tag)
+        end
+        private_class_method :canonical_orphan_or_empty_path?
+
+        # Zero-source BitBlt emits a style-first rectangle without a trailing
+        # space after Z. Only that exact spelling carries record provenance.
+        def self.canonical_bitblt?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          rectangle = /
+            \AM[ ](?<x>#{number}),(?<y>#{number})
+            [ ]L[ ](?<right>#{number}),\k<y>
+            [ ]L[ ]\k<right>,(?<bottom>#{number})
+            [ ]L[ ]\k<x>,\k<bottom>[ ]Z\z
+          /x
+          node["style"]&.match?(/\Afill:#[0-9a-f]{6}\z/) &&
+            node["d"]&.match?(rectangle) &&
+            source_tag == %(<path style="#{node['style']}" d="#{node['d']}" />)
+        end
+        private_class_method :canonical_bitblt?
+
+        # PolylineTo starts at the current position and adds an extra space
+        # before fill. A single line shares that spelling with LineTo.
+        def self.canonical_line_record_kind(node, source_tag)
+          return unless source_tag
+          return :polyline if canonical_polyline?(node, source_tag)
+
+          number = "-?\\d+\\.\\d{4}"
+          return unless node["d"]&.match?(/\AM #{number},#{number}(?: L #{number},#{number}){2,} \z/)
+
+          :polyline_to if canonical_stroked_path?(node, source_tag, fill_gap: true)
+        end
+        private_class_method :canonical_line_record_kind
+
+        # Only the exact legacy renderer spelling provides record provenance.
+        # Ordinary SVG paths keep the existing translation strategy.
+        def self.canonical_polyline?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          return false unless node["d"]&.match?(/\AM #{number},#{number} L #{number},#{number} \z/)
+
+          canonical_stroked_path?(node, source_tag)
+        end
+        private_class_method :canonical_polyline?
+
+        def self.canonical_arc_kind(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          arc = /
+            \AM[ ]#{number},#{number}[ ]M[ ]#{number},#{number}
+            [ ]A[ ]#{number},#{number}[ ]0[ ](?<sweep>[01])[ ]\k<sweep>[ ]#{number},#{number}
+            [ ](?<closure>(?:L[ ]#{number},#{number}[ ])?Z[ ])?\z
+          /x
+          match = arc.match(node["d"].to_s)
+          return unless match
+
+          kind = if match[:closure]
+                   match[:closure].start_with?("L") ? :pie : :chord
+                 else
+                   :arc
+                 end
+          kind if canonical_stroked_path?(node, source_tag, fill_gap: true, closed: kind != :arc)
+        end
+        private_class_method :canonical_arc_kind
+
+        def self.canonical_stroked_path?(node, source_tag, fill_gap: false, closed: false)
+          number = "-?\\d+\\.\\d{4}"
+          return false unless node["stroke"]&.match?(/\A#[0-9A-Fa-f]{6}\z/)
+          return false unless node["stroke-width"]&.match?(/\A(?:#{number}|1px)\z/)
+          return false unless %w[round square butt].include?(node["stroke-linecap"])
+          return false unless %w[round bevel miter].include?(node["stroke-linejoin"])
+          return false unless closed ? node["fill"]&.match?(/\A#[0-9A-Fa-f]{6}\z/) : node["fill"] == "none"
+
+          expected = +"<path "
+          if node["clip-path"]
+            return false unless node["clip-path"].match?(/\Aurl\(#clip-\d+\)\z/)
+
+            expected << %( clip-path="#{node['clip-path']}" )
+          end
+          expected << %(d="#{node['d']}" stroke="#{node['stroke']}" stroke-width="#{node['stroke-width']}" )
+          expected << %(stroke-dasharray="#{node['stroke-dasharray']}" ) if node["stroke-dasharray"]
+          expected << %( stroke-linecap="#{node['stroke-linecap']}"  stroke-linejoin="#{node['stroke-linejoin']}" )
+          expected << %( stroke-miterlimit="#{node['stroke-miterlimit']}" ) if node["stroke-miterlimit"]
+          expected << " " if fill_gap
+          expected << %(fill="#{node['fill']}")
+          expected << " " if closed
+          expected << " />"
+          source_tag == expected
+        end
+        private_class_method :canonical_stroked_path?
+
+        # PolyPolygon's C renderer has a distinctive fill-first start tag and
+        # retains a trailing space after Z. Preserve that record only for the
+        # exact spelling emitted by the renderer; ordinary closed paths use
+        # Polygon as before.
+        def self.canonical_poly_polygon?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          node["d"]&.match?(/\AM #{number},#{number}(?: L #{number},#{number})+ Z \z/) &&
+            canonical_fill_first_style?(node, source_tag)
+        end
+        private_class_method :canonical_poly_polygon?
+
+        def self.canonical_fill_first_style?(node, source_tag)
+          number = "-?\\d+\\.\\d{4}"
+          return false unless node["fill"]&.match?(/\A#[0-9A-F]{6}\z/)
+          return false unless node["stroke"]&.match?(/\A#[0-9A-F]{6}\z/)
+          return false unless node["stroke-width"]&.match?(/\A(?:#{number}|1px)\z/)
+          return false unless %w[round square butt].include?(node["stroke-linecap"])
+          return false unless %w[round bevel miter].include?(node["stroke-linejoin"])
+          return false if node["stroke-dasharray"]
+
+          expected = %(<path d="#{node['d']}"  fill="#{node['fill']}" stroke="#{node['stroke']}" )
+          expected << %(stroke-width="#{node['stroke-width']}"  stroke-linecap="#{node['stroke-linecap']}" )
+          expected << %( stroke-linejoin="#{node['stroke-linejoin']}" )
+          if node["stroke-miterlimit"]
+            return false unless node["stroke-linejoin"] == "miter"
+
+            expected << %( stroke-miterlimit="#{node['stroke-miterlimit']}" )
+          end
+          expected << "/>"
+          source_tag == expected
+        end
+        private_class_method :canonical_fill_first_style?
       end
     end
   end

data/lib/emfsvg/svg/elements/rect.rb

@@ -9,9 +9,10 @@ module Emfsvg
         ELEMENT_NAME = "rect"
         Element.register("rect", self)
 
-        attr_reader :x, :y, :width, :height, :rx, :ry, :fill, :stroke, :clip_path
+        attr_reader :x, :y, :width, :height, :rx, :ry, :fill, :stroke, :clip_path, :serialization_hint
 
-        def initialize(x:, y:, width:, height:, rx:, ry:, fill:, stroke:, clip_path: nil)
+        def initialize(x:, y:, width:, height:, rx:, ry:, fill:, stroke:, clip_path: nil, serialization_hint: nil)
+          @serialization_hint = serialization_hint
           @x = x
           @y = y
           @width = width
@@ -24,7 +25,9 @@ module Emfsvg
         end
 
         def self.from_node(node)
+          source = yield(node) if block_given?
           new(
+            serialization_hint: DrawingHint.rectangle_values(source),
             x: AttributeParser.float(node["x"]),
             y: AttributeParser.float(node["y"]),
             width: AttributeParser.float(node["width"]),