postsvg 0.2.6 → 0.3.0

data/lib/postsvg/translation/handlers.rb

@@ -17,8 +17,7 @@ module Postsvg
       autoload :TextHandler, "postsvg/translation/handlers/text_handler"
       autoload :ImageHandler, "postsvg/translation/handlers/image_handler"
       autoload :DefsHandler, "postsvg/translation/handlers/defs_handler"
-      autoload :ClipPathHandler,
-               "postsvg/translation/handlers/clip_path_handler"
+      autoload :ClipPathHandler, "postsvg/translation/handlers/clip_path_handler"
       autoload :OpenHandler, "postsvg/translation/handlers/open_handler"
       autoload :Shared, "postsvg/translation/handlers/shared"
     end

data/lib/postsvg/translation/ps_renderer.rb

@@ -72,12 +72,10 @@ module Postsvg
 
       def compute_viewport_bbox
         if document.viewbox
-          x, y, width, height = document.viewbox
-          BoundingBox.new(min_x: x, min_y: y, max_x: x + width,
-                          max_y: y + height)
+          llx, lly, urx, ury = document.viewbox
+          BoundingBox.new(min_x: llx, min_y: lly, max_x: urx, max_y: ury)
         elsif document.width && document.height
-          BoundingBox.new(min_x: 0, min_y: 0, max_x: document.width,
-                          max_y: document.height)
+          BoundingBox.new(min_x: 0, min_y: 0, max_x: document.width, max_y: document.height)
         else
           BoundingBox.empty
         end
@@ -87,17 +85,6 @@ module Postsvg
         registry.translate(element, context)
       end
 
-      # SVG's y axis points down; PostScript's points up. Convert once at
-      # the document boundary, before any authored element transforms.
-      def coordinate_conversion(bbox)
-        emitter = RecordEmitter.new
-        emitter.emit(Model::Operators::Transformations::Translate.new(
-                       tx: 0, ty: bbox[3] - bbox[1],
-                     ))
-        emitter.emit(Model::Operators::Transformations::Scale.new(sx: 1, sy: -1))
-        emitter.records
-      end
-
       def build_program(emitter, context)
         bbox = context.bounding_box
         header_bbox =
@@ -111,8 +98,7 @@ module Postsvg
           epsf: eps,
           title: "Translated by Postsvg #{::Postsvg::VERSION}",
         )
-        Model::Program.new(header: header,
-                           body: coordinate_conversion(header_bbox) + emitter.records)
+        Model::Program.new(header: header, body: emitter.records)
       end
     end
   end

data/lib/postsvg/translation/record_emitter.rb

@@ -7,54 +7,6 @@ module Postsvg
     # surface so handlers don't all need to know how the program is
     # stored.
     class RecordEmitter
-      NUMBER_OPERANDS = lambda do |record|
-        record.operand_values.map { |value| Model::Literals::Number.new(value) }
-      end
-      NO_OPERANDS = ->(_record) { [] }
-
-      OPERAND_BUILDERS = {
-        Model::Operators::Color::Setgray => NUMBER_OPERANDS,
-        Model::Operators::Color::Setrgbcolor => NUMBER_OPERANDS,
-        Model::Operators::GraphicsState::Setlinewidth => NUMBER_OPERANDS,
-        Model::Operators::Path::Moveto => NUMBER_OPERANDS,
-        Model::Operators::Path::Rmoveto => lambda do |record|
-          [Model::Literals::Number.new(record.dx), Model::Literals::Number.new(record.dy)]
-        end,
-        Model::Operators::Path::Lineto => NUMBER_OPERANDS,
-        Model::Operators::Path::Rlineto => NUMBER_OPERANDS,
-        Model::Operators::Path::Curveto => NUMBER_OPERANDS,
-        Model::Operators::Path::Rcurveto => NUMBER_OPERANDS,
-        Model::Operators::Path::Arc => NUMBER_OPERANDS,
-        Model::Operators::Path::Arcn => NUMBER_OPERANDS,
-        Model::Operators::Transformations::Translate => NUMBER_OPERANDS,
-        Model::Operators::Transformations::Scale => NUMBER_OPERANDS,
-        Model::Operators::Font::Findfont => lambda do |record|
-          # findfont accepts strings as well as names; whitespace must not
-          # split a family name into separate PostScript tokens.
-          if record.name.match?(/\s/)
-            [Model::Literals::StringLiteral.new(record.name)]
-          else
-            [Model::Literals::Name.new(record.name, literal: true)]
-          end
-        end,
-        Model::Operators::Font::Scalefont => lambda do |record|
-          [Model::Literals::Number.new(record.size)]
-        end,
-        Model::Operators::Font::Show => lambda do |record|
-          [Model::Literals::StringLiteral.new(record.text)]
-        end,
-        Model::Operators::GraphicsState::Setlinecap => lambda do |record|
-          [Model::Literals::Number.new(record.cap_code)]
-        end,
-        Model::Operators::GraphicsState::Setlinejoin => lambda do |record|
-          [Model::Literals::Number.new(record.join_code)]
-        end,
-        Model::Operators::Transformations::Concat => lambda do |record|
-          elements = record.matrix.map { |value| Model::Literals::Number.new(value) }
-          [Model::Literals::ArrayLiteral.new(elements)]
-        end,
-      }.freeze
-
       attr_reader :records
 
       def initialize
@@ -62,12 +14,6 @@ module Postsvg
       end
 
       def emit(record)
-        # Operators built by the svg -> ps handlers carry their
-        # operands as attributes; the serializer writes keywords only
-        # and expects the operands as separate literal statements
-        # ahead of the keyword (the shape the PS parse path produces).
-        # Splice them in so the record stream round-trips.
-        @records.concat(OPERAND_BUILDERS.fetch(record.class, NO_OPERANDS).call(record))
         @records << record
         self
       end

data/lib/postsvg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Postsvg
-  VERSION = "0.2.6"
+  VERSION = "0.3.0"
 end

data/lib/postsvg/visitors/ps_visitor/arithmetic.rb

@@ -12,19 +12,19 @@ module Postsvg
         def visit_add(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << (a + b)
+          @stack << a + b
         end
 
         def visit_sub(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << (a - b)
+          @stack << a - b
         end
 
         def visit_mul(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << (a * b)
+          @stack << a * b
         end
 
         def visit_div(_op, _ctx)
@@ -32,7 +32,7 @@ module Postsvg
           a = pop_runtime_number
           raise RenderError, "division by zero" if divisor.zero?
 
-          @stack << (a.to_f / divisor)
+          @stack << (a.to_f / divisor.to_f)
         end
 
         def visit_idiv(_op, _ctx)
@@ -85,7 +85,7 @@ module Postsvg
         def visit_atan(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << (Math.atan2(a.to_f, b.to_f) * (180.0 / Math::PI))
+          @stack << Math.atan2(a.to_f, b.to_f) * (180.0 / Math::PI)
         end
 
         def visit_cos(_op, _ctx)
@@ -107,7 +107,7 @@ module Postsvg
         def visit_exp(_op, _ctx)
           b = pop_runtime_number
           a = pop_runtime_number
-          @stack << (a.to_f**b.to_f)
+          @stack << a.to_f**b.to_f
         end
 
         private

data/lib/postsvg/visitors/ps_visitor/color.rb

@@ -7,25 +7,22 @@ module Postsvg
       # GraphicsContext; the next paint operator reads the new colors.
       module Color
         def visit_setgray(op, _ctx)
-          color = Postscript::Color.gray(op.gray.to_f)
+          color = Postsvg::Color.gray(op.gray.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
         def visit_setrgbcolor(op, _ctx)
-          color = Postscript::Color.rgb(op.red.to_f, op.green.to_f,
-                                        op.blue.to_f)
+          color = Postsvg::Color.rgb(op.red.to_f, op.green.to_f, op.blue.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
         def visit_setcmykcolor(op, _ctx)
-          color = Postscript::Color.cmyk(op.cyan.to_f, op.magenta.to_f,
-                                         op.yellow.to_f, op.key.to_f)
+          color = Postsvg::Color.cmyk(op.cyan.to_f, op.magenta.to_f, op.yellow.to_f, op.key.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
         def visit_sethsbcolor(op, _ctx)
-          color = hsb_to_color(op.hue.to_f, op.saturation.to_f,
-                               op.brightness.to_f)
+          color = hsb_to_color(op.hue.to_f, op.saturation.to_f, op.brightness.to_f)
           @graphics.update(fill_color: color, stroke_color: color)
         end
 
@@ -48,7 +45,7 @@ module Postsvg
             when 4 then [t, p, v]
             else        [v, p, q]
             end
-          Postscript::Color.rgb(r, g, b)
+          Postsvg::Color.rgb(r, g, b)
         end
       end
     end

data/lib/postsvg/visitors/ps_visitor/common.rb

@@ -13,7 +13,7 @@ module Postsvg
         def normalize_key(key)
           case key
           when Model::Literals::Name then key.value
-          when String then key.to_s.delete_prefix("/")
+          when String then key.to_s.sub(/\A\//, "")
           else key.to_s
           end
         end
@@ -25,6 +25,7 @@ module Postsvg
           when String then node
           when Model::Literals::StringLiteral then node.value
           when Model::Literals::HexLiteral then node.bytes
+          else nil
           end
         end
 

data/lib/postsvg/visitors/ps_visitor/container.rb

@@ -44,25 +44,25 @@ module Postsvg
           @stack << value
         end
 
-        def visit_put(_op, _ctx)
+        def visit_put(op, _ctx)
           # PS put mutates in place. Our value objects are immutable.
           # Marked as a comment in the output so the gap is visible.
           @builder.comment("put: in-place mutation not supported")
         end
 
         def visit_getinterval(op, _ctx)
-          @stack << case op.operand
-                    when String
-                      op.operand[op.start, op.count]
-                    when Array
-                      op.operand[op.start, op.count]
-                    when Model::Literals::StringLiteral
-                      op.operand.value[op.start, op.count]
-                    when Model::Literals::ArrayLiteral
-                      op.operand.elements[op.start, op.count]
-                    else
-                      ""
-                    end
+          case op.operand
+          when String
+            @stack << op.operand[op.start, op.count]
+          when Array
+            @stack << op.operand[op.start, op.count]
+          when Model::Literals::StringLiteral
+            @stack << op.operand.value[op.start, op.count]
+          when Model::Literals::ArrayLiteral
+            @stack << op.operand.elements[op.start, op.count]
+          else
+            @stack << ""
+          end
         end
 
         def visit_putinterval(_op, _ctx)

data/lib/postsvg/visitors/ps_visitor/control_flow.rb

@@ -39,7 +39,7 @@ module Postsvg
           body = @stack.pop
           LOOP_LIMIT.times do
             descend_into_procedure(body)
-          rescue Postscript::ExitSignal
+          rescue Postsvg::ExitSignal
             break
           end
         end
@@ -74,11 +74,11 @@ module Postsvg
         end
 
         def visit_exit(_op, _ctx)
-          raise Postscript::ExitSignal
+          raise Postsvg::ExitSignal
         end
 
         def visit_quit(_op, _ctx)
-          raise Postscript::QuitSignal
+          raise Postsvg::QuitSignal
         end
 
         def visit_exec(_op, _ctx)

data/lib/postsvg/visitors/ps_visitor/dictionary.rb

@@ -72,14 +72,10 @@ module Postsvg
 
         def visit_maxlength(op, _ctx)
           # PS dictionaries can grow dynamically; report current size.
-          @stack << dict_size(op.operand)
-        end
-
-        def dict_size(operand)
-          case operand
-          when Hash then operand.length
-          when Model::Literals::Dictionary then operand.entries.length
-          else 0
+          case op.operand
+          when Hash then @stack << op.operand.length
+          when Model::Literals::Dictionary then @stack << op.operand.entries.length
+          else @stack << 0
           end
         end
 

data/lib/postsvg/visitors/ps_visitor/font.rb

@@ -31,26 +31,15 @@ module Postsvg
         end
 
         def visit_scalefont(op, _ctx)
-          size = op.size.to_i
-          consume_numeric_operands(op.size)
+          size = op.size.to_i || op.size.to_f
           font = @stack.pop
-          base = if font.is_a?(FontRef)
-                   font
-                 else
-                   FontRef.new(name: "Helvetica",
-                               size: nil)
-                 end
+          base = font.is_a?(FontRef) ? font : FontRef.new(name: "Helvetica", size: nil)
           @stack << FontRef.new(name: base.name, size: size.to_f)
         end
 
         def visit_setfont(_op, _ctx)
           font = @stack.pop
-          ref = if font.is_a?(FontRef)
-                  font
-                else
-                  FontRef.new(name: "Helvetica",
-                              size: 12.0)
-                end
+          ref = font.is_a?(FontRef) ? font : FontRef.new(name: "Helvetica", size: 12.0)
           @graphics.update(font_name: ref.name || "Helvetica",
                            font_size: ref.size || 12.0)
         end
@@ -78,7 +67,7 @@ module Postsvg
             y: -screen_pos[:y],
             font_family: @graphics.current.font_name,
             font_size: @graphics.current.font_size,
-            color: color || Postscript::Color::BLACK,
+            color: color || Postsvg::Color::BLACK,
             transform: "scale(1 -1)",
           )
           @path.reset

data/lib/postsvg/visitors/ps_visitor/graphics_state.rb

@@ -7,17 +7,15 @@ module Postsvg
       # dash attribute setters.
       module GraphicsState
         def visit_gsave(_op, _ctx)
-          @saved_paths << @path.dup
           @graphics.gsave
         end
 
         def visit_grestore(_op, _ctx)
-          @path = @saved_paths.pop if @graphics.depth > 1 && !@saved_paths.empty?
           @graphics.grestore
         end
 
         def visit_grestoreall(_op, _ctx)
-          visit_grestore(nil, nil) while @graphics.depth > 1
+          @graphics.grestore while @graphics.depth > 1
         end
 
         def visit_setlinewidth(op, _ctx)
@@ -25,14 +23,12 @@ module Postsvg
         end
 
         def visit_setlinecap(op, _ctx)
-          name = { 0 => :butt, 1 => :round, 2 => :square }.fetch(op.cap_code,
-                                                                 :butt)
+          name = { 0 => :butt, 1 => :round, 2 => :square }.fetch(op.cap_code, :butt)
           @graphics.update(line_cap: name)
         end
 
         def visit_setlinejoin(op, _ctx)
-          name = { 0 => :miter, 1 => :round, 2 => :bevel }.fetch(op.join_code,
-                                                                 :miter)
+          name = { 0 => :miter, 1 => :round, 2 => :bevel }.fetch(op.join_code, :miter)
           @graphics.update(line_join: name)
         end
 
@@ -48,6 +44,8 @@ module Postsvg
               pattern.map { |v| FormatNumber.call(v.to_f) }.join(" ")
             when Numeric
               FormatNumber.call(pattern.to_f)
+            else
+              nil
             end
           @graphics.update(dash: dash_str)
         end

data/lib/postsvg/visitors/ps_visitor/painting.rb

@@ -25,7 +25,7 @@ module Postsvg
         def visit_clip(_op, _ctx)
           return if @path.empty?
 
-          path_d = @path.to_path_d(@graphics.current.ctm)
+          path_d = @path.to_path_d
           clip_id = @builder.register_clip_path(path_d)
           @graphics.update(clip_paths: @graphics.current.clip_paths + [clip_id])
           @path.reset
@@ -43,7 +43,7 @@ module Postsvg
         def flush_path(mode)
           return if @path.empty?
 
-          d = @path.to_path_d(@graphics.current.ctm)
+          d = @path.to_path_d
           ctx = @graphics.current
           transform_str = build_transform_string(ctx)
           clip_id = ctx.clip_paths.last
@@ -66,7 +66,7 @@ module Postsvg
             line_cap: ctx.line_cap,
             line_join: ctx.line_join,
             dash: ctx.dash,
-            clip_path_id: clip_path_id
+            clip_path_id: clip_path_id,
           )
         end
 

data/lib/postsvg/visitors/ps_visitor/path.rb

@@ -5,29 +5,25 @@ module Postsvg
     class PsVisitor
       # Path construction operator handlers. Each appends a command to
       # +@path+ (PathState). CTM-aware: when the current CTM is not
-      # identity, the renderer wraps painted paths in a <g transform=>.
-      # Arcs retain their construction CTM and are mapped into the paint CTM
-      # at emission, whether or not the temporary transform was restored.
-      # Other mid-path CTM changes retain the existing paint-time behavior.
+      # identity, the renderer will wrap emitted paths in a
+      # <g transform=>. Points are stored in user-space coordinates;
+      # the visitor delegates to the SvgBuilder for transform emission.
       module Path
         def visit_newpath(_op, _ctx)
           @path.reset
         end
 
         def visit_moveto(op, _ctx)
-          @path.matrix ||= @graphics.current.ctm
           @path.move_to(op.x, op.y)
           @graphics.update(last_text_position: { x: op.x, y: op.y })
         end
 
         def visit_rmoveto(op, _ctx)
-          @path.matrix ||= @graphics.current.ctm
           @path.move_to_rel(op.dx, op.dy)
           pos = @graphics.current.last_text_position
           base_x = pos ? pos[:x] : 0
           base_y = pos ? pos[:y] : 0
-          @graphics.update(last_text_position: { x: base_x + op.dx,
-                                                 y: base_y + op.dy })
+          @graphics.update(last_text_position: { x: base_x + op.dx, y: base_y + op.dy })
         end
 
         def visit_lineto(op, _ctx)
@@ -69,61 +65,46 @@ module Postsvg
         # are parametrised by center, radius, angle range. SVG arcs
         # are parametrised by endpoint, radii, large-arc/sweep flags.
         def append_arc(cx, cy, radius, angle1, angle2, sweep:)
-          consume_numeric_operands(cx, cy, radius, angle1, angle2)
           r = radius.abs
           return if r.zero?
 
-          construction_matrix = @graphics.current.ctm
-          @path.matrix ||= construction_matrix
-          point_matrix = @path.matrix.invert.multiply(construction_matrix)
-          end_x, end_y = arc_point(point_matrix, cx, cy, r, angle2)
-          starts_path = @path.empty?
-          command = lambda do |paint_matrix|
-            matrix = paint_matrix.invert.multiply(construction_matrix)
-            render_arc(cx, cy, r, angle1, angle2, sweep: sweep,
-                       matrix: matrix, starts_path: starts_path)
+          start_rad = angle1 * Math::PI / 180.0
+          start_x = cx + (r * Math.cos(start_rad))
+          start_y = cy + (r * Math.sin(start_rad))
+          end_rad = angle2 * Math::PI / 180.0
+          end_x = cx + (r * Math.cos(end_rad))
+          end_y = cy + (r * Math.sin(end_rad))
+
+          # If the current path is empty, the arc implicitly starts
+          # with a moveto to its starting point.
+          if @path.empty? || last_command_starts_with?("M")
+            @path.move_to(start_x, start_y) if @path.empty?
           end
-          @path.append_deferred(command, end_x, end_y)
-        end
 
-        def render_arc(cx, cy, radius, angle1, angle2, sweep:, matrix:, starts_path:)
-          path = PathState.new
-          start_x, start_y = arc_point(matrix, cx, cy, radius, angle1)
-          end_x, end_y = arc_point(matrix, cx, cy, radius, angle2)
-          path.move_to(start_x, start_y) if starts_path
-          delta = sweep ? (angle2 - angle1) % 360 : (angle1 - angle2) % 360
-          rx, ry, rotation = arc_radii(matrix, radius)
-          reflected = ((matrix.a * matrix.d) - (matrix.b * matrix.c)).negative?
-          svg_sweep = sweep != reflected
+          delta = (angle2 - angle1) % 360
+          delta += 360 if delta.negative?
+          large_arc = delta > 180
+
+          # SVG sweep flag is 1 when the arc is drawn clockwise.
+          svg_sweep = sweep ? (delta.positive? ? 1 : 0) : 0
           if delta.abs < 1e-6
-            # Full circles need two arcs; retain the corpus's large-arc spelling.
-            mid_x, mid_y = arc_point(matrix, cx, cy, radius, angle1 + 180)
-            path.arc_to(rx, ry, rotation, true, svg_sweep, mid_x, mid_y)
-            path.arc_to(rx, ry, rotation, true, svg_sweep, start_x, start_y)
-            path.close
+            # Full circle: emit two arcs.
+            mid_angle = angle1 + 180
+            mid_rad = mid_angle * Math::PI / 180.0
+            mid_x = cx + (r * Math.cos(mid_rad))
+            mid_y = cy + (r * Math.sin(mid_rad))
+            @path.arc_to(r, r, 0, 0, svg_sweep, mid_x, mid_y)
+            @path.arc_to(r, r, 0, 0, svg_sweep, start_x, start_y)
+            @path.close
           else
-            path.arc_to(rx, ry, rotation, delta > 180, svg_sweep, end_x, end_y)
+            @path.arc_to(r, r, 0, large_arc ? 1 : 0, svg_sweep, end_x, end_y)
           end
-          path.to_path_d
         end
 
-        def arc_point(matrix, cx, cy, radius, angle)
-          radians = angle * Math::PI / 180.0
-          matrix.apply_point(cx + (radius * Math.cos(radians)),
-                             cy + (radius * Math.sin(radians))).values_at(:x, :y)
-        end
+        def last_command_starts_with?(prefix)
+          return false if @path.commands.empty?
 
-        # Singular values give the ellipse radii even when its frame is rotated
-        # or sheared. The principal eigenvector gives its SVG axis rotation.
-        def arc_radii(matrix, radius)
-          xx = (matrix.a**2) + (matrix.c**2)
-          xy = (matrix.a * matrix.b) + (matrix.c * matrix.d)
-          yy = (matrix.b**2) + (matrix.d**2)
-          root = Math.hypot(xx - yy, 2 * xy)
-          rx = radius * Math.sqrt([(xx + yy + root) / 2, 0].max)
-          ry = radius * Math.sqrt([(xx + yy - root) / 2, 0].max)
-          rotation = root < 1e-12 ? 0.0 : Math.atan2(2 * xy, xx - yy) * 90 / Math::PI
-          [rx, ry, rotation]
+          @path.commands.last.start_with?(prefix)
         end
       end
     end

data/lib/postsvg/visitors/ps_visitor/transformations.rb

@@ -6,19 +6,12 @@ module Postsvg
       # Coordinate transformation operator handlers. Each returns a
       # new CTM via Matrix composition and updates the GraphicsContext.
       module Transformations
-        # A matrix this visitor produced (`matrix`, `currentmatrix`). The
-        # runtime stack also holds values nothing popped (`def` operands,
-        # unresolved names, path operands), so only these are trusted as a
-        # matrix the parser could not see.
-        class StackMatrix < Array; end
-
         def visit_translate(op, _ctx)
           new_ctm = @graphics.current.ctm.translate(op.tx.to_f, op.ty.to_f)
           @graphics.update(ctm: new_ctm)
         end
 
         def visit_scale(op, _ctx)
-          consume_numeric_operands(op.sx, op.sy)
           new_ctm = @graphics.current.ctm.scale(op.sx.to_f, op.sy.to_f)
           @graphics.update(ctm: new_ctm)
         end
@@ -29,7 +22,7 @@ module Postsvg
         end
 
         def visit_concat(op, _ctx)
-          matrix = matrix_from_operand(matrix_operand(op))
+          matrix = matrix_from_operand(op.matrix)
           return unless matrix
 
           new_ctm = @graphics.current.ctm.multiply(matrix)
@@ -37,17 +30,16 @@ module Postsvg
         end
 
         def visit_matrix(_op, _ctx)
-          @stack << StackMatrix[1, 0, 0, 1, 0, 0]
+          @stack << [1, 0, 0, 1, 0, 0]
         end
 
         def visit_currentmatrix(_op, _ctx)
-          @stack.pop if @stack.last.is_a?(StackMatrix)
           ctm = @graphics.current.ctm
-          @stack << StackMatrix[ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f]
+          @stack << [ctm.a, ctm.b, ctm.c, ctm.d, ctm.e, ctm.f]
         end
 
         def visit_setmatrix(op, _ctx)
-          matrix = matrix_from_operand(matrix_operand(op))
+          matrix = matrix_from_operand(op.matrix)
           return unless matrix
 
           @graphics.update(ctm: matrix)
@@ -93,46 +85,16 @@ module Postsvg
 
         private
 
-        # Parsed literal operands remain on the visitor stack. Consume only
-        # an exact numeric suffix, leaving directly constructed operators alone.
-        def consume_numeric_operands(*values)
-          @stack.pop(values.length) if @stack.last(values.length) == values
-        end
-
-        # A literal matrix was also pushed by visit_array; consume that copy
-        # so a later operator does not apply it again. A computed matrix is
-        # taken from the stack only when this visitor produced it.
-        def matrix_operand(op)
-          unless op.matrix.is_a?(Model::Computed)
-            @stack.pop if literal_on_stack?(op.matrix)
-            return op.matrix
-          end
-
-          @stack.pop if @stack.last.is_a?(StackMatrix)
-        end
-
-        def literal_on_stack?(matrix)
-          matrix.is_a?(Model::Literals::ArrayLiteral) && @stack.last.equal?(matrix.elements)
-        end
-
-        # Arrays on the runtime stack hold either plain numbers or parsed
-        # Number literals. Anything other than six numbers is not a matrix.
         def matrix_from_operand(operand)
           case operand
           when Matrix then operand
-          when Model::Literals::ArrayLiteral then matrix_from_operand(operand.elements)
           when Array
-            numbers = operand.map { |element| matrix_number(element) }
-            return nil unless numbers.length == 6 && numbers.all?
+            return nil unless operand.length == 6
 
-            Matrix.new(a: numbers[0], b: numbers[1], c: numbers[2],
-                       d: numbers[3], e: numbers[4], f: numbers[5])
+            Matrix.new(a: operand[0], b: operand[1], c: operand[2],
+                       d: operand[3], e: operand[4], f: operand[5])
           end
         end
-
-        def matrix_number(element)
-          numeric_value(element) if element.is_a?(Numeric) || element.is_a?(Model::Literals::Number)
-        end
       end
     end
   end