emfsvg 0.1.3 → 0.1.4

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

@@ -6,21 +6,51 @@ module Emfsvg
       # Common presentation attribute parsing shared by every shape.
       # Module function — call as `Stylable.parse_style(node)` from
       # an Element subclass's `.from_node` factory.
+      #
+      # Paint and Stroke are immutable value objects, and a drawing repeats
+      # a handful of distinct fill/stroke combinations across thousands of
+      # elements, so one instance per distinct attribute set is shared
+      # instead of parsing and allocating the same objects for every
+      # element.
       module Stylable
+        # Distinct attribute sets remembered; past this, parsing falls back
+        # to building a fresh pair, so a hostile document cannot grow it.
+        PAINT_CACHE_LIMIT = 1024
+        PAINT_CACHE_LOCK = Mutex.new
+        private_constant :PAINT_CACHE_LOCK, :PAINT_CACHE_LIMIT
+
+        @paint_cache = {}
+
         module_function
 
         def parse_style(node)
-          {
-            fill: Svg::Paint.from_fill(node["fill"]),
-            stroke: Svg::Stroke.parse(
-              stroke: node["stroke"],
-              width: node["stroke-width"],
-              dash_array: node["stroke-dasharray"],
-              line_cap: node["stroke-linecap"],
-              line_join: node["stroke-linejoin"]
-            ),
-            clip_path: node["clip-path"]
-          }
+          fill, stroke = paints(
+            node["fill"], node["stroke"], node["stroke-width"],
+            node["stroke-dasharray"], node["stroke-linecap"], node["stroke-linejoin"],
+            node["stroke-miterlimit"]
+          )
+          { fill: fill, stroke: stroke, clip_path: node["clip-path"] }
+        end
+
+        def paints(fill, stroke, width, dash_array, line_cap, line_join, miter_limit = nil)
+          key = [fill, stroke, width, dash_array, line_cap, line_join, miter_limit]
+          @paint_cache.fetch(key) do
+            fill_paint = Svg::Paint.from_fill(fill)
+            pair = [
+              fill_paint,
+              Svg::Stroke.parse(stroke: stroke, width: width, dash_array: dash_array,
+                                line_cap: line_cap, line_join: line_join,
+                                miter_limit: miter_limit, fill: fill_paint)
+            ].freeze
+            remember(key.freeze, pair)
+          end
+        end
+
+        def remember(key, pair)
+          PAINT_CACHE_LOCK.synchronize do
+            @paint_cache[key] = pair if @paint_cache.size < PAINT_CACHE_LIMIT
+          end
+          pair
         end
       end
     end

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

@@ -12,48 +12,133 @@ module Emfsvg
         ELEMENT_NAME = "text"
         Element.register("text", self)
 
-        attr_reader :x, :y, :content, :font_family, :font_size, :font_weight,
-                    :font_style, :text_anchor, :fill, :stroke, :clip_path,
-                    :transform_matrix
+        # Recovered LOGFONT rotation and vertical alignment, separate from SVG affine transforms.
+        Rotation = Struct.new(:angle, :vertical_alignment, :escapement, :native_height, :native_y, keyword_init: true)
 
-        def initialize(x:, y:, content:, font_family:, font_size:, font_weight:,
-                       font_style:, text_anchor:, fill:, stroke:, clip_path: nil,
-                       transform_matrix: Emf::Model::Geometry::Matrix.identity)
+        # The font attributes of a <text> element.
+        Font = Struct.new(:family, :point_size, :weight, :style, :rotation, keyword_init: true)
+
+        attr_reader :x, :y, :content, :font, :text_anchor, :fill, :stroke,
+                    :clip_path, :transform_matrix, :empty_cdata_content, :canonical_text_rotation
+
+        def initialize(x:, y:, content:, font:, text_anchor:, fill:, stroke:, clip_path: nil,
+                       transform_matrix: Emf::Model::Geometry::Matrix.identity,
+                       empty_cdata_content: false, canonical_text_rotation: nil)
           @x = x
           @y = y
           @content = content
-          @font_family = font_family
-          @font_size = font_size
-          @font_weight = font_weight
-          @font_style = font_style
+          @font = font
           @text_anchor = text_anchor
           @fill = fill
           @stroke = stroke
           @clip_path = clip_path
           @transform_matrix = transform_matrix
+          @empty_cdata_content = empty_cdata_content
+          @canonical_text_rotation = canonical_text_rotation
         end
 
+        def font_family = font.family
+
+        def font_size = font.point_size
+
+        def font_weight = font.weight
+
+        def font_style = font.style
+
         def transformed?
           !transform_matrix.identity?
         end
 
         def self.from_node(node)
+          rotation = canonical_rotation(node)
           new(
             x: AttributeParser.float(node["x"]),
             y: AttributeParser.float(node["y"]),
             content: node.text,
-            font_family: node["font-family"],
-            font_size: AttributeParser.float(node["font-size"], default: 12.0),
-            font_weight: parse_weight(node["font-weight"]),
-            font_style: node["font-style"],
+            empty_cdata_content: node.children.any? do |child|
+              child.is_a?(Leptris::XML::CDATA) && child.content.empty?
+            end,
+            font: Font.new(
+              family: node["font-family"],
+              point_size: AttributeParser.float(node["font-size"], default: 12.0),
+              weight: parse_weight(node["font-weight"]),
+              style: node["font-style"],
+              rotation: rotation&.angle
+            ),
             text_anchor: node["text-anchor"] || "start",
-            transform_matrix: Svg::TransformParser.parse(node["transform"]),
+            canonical_text_rotation: rotation,
+            transform_matrix: Svg::TransformParser.parse(rotation ? nil : node["transform"]),
             **Stylable.parse_style(node)
           )
         end
 
+        # Canonical LOGFONT output independently rounds size, pivot and offset.
+        # Intersect their four-decimal source intervals instead of inferring an
+        # arbitrary affine transform. TA_TOP prints the pivot as the displayed y.
+        def self.canonical_rotation(node)
+          return if node["dx"] || node["dy"]
+
+          decimal = "(-?\\d+\\.\\d{4})"
+          pattern = /\Arotate\((0|-?[1-9]\d*), #{decimal}, #{decimal}\) translate\(0, #{decimal}\)\z/
+          match = node["transform"]&.match(pattern)
+          return unless match
+
+          angle = match[1].to_i
+          return unless angle.between?(-359, 359)
+
+          x, pivot, offset = match.captures.drop(1).map(&:to_r)
+          return unless x == AttributeParser.float(node["x"]).to_s.to_r
+
+          y = AttributeParser.float(node["y"]).to_s.to_r
+          height = AttributeParser.float(node["font-size"], default: 12.0).to_s.to_r
+          half_unit = Rational(1, 20_000)
+          low = [(height - half_unit) * Rational(9, 10), offset - half_unit].max
+          high = [(height + half_unit) * Rational(9, 10), offset + half_unit].min
+          return unless low < high
+
+          alignment = if pivot == y
+                        height.zero? ? :baseline : :top
+                      elsif [low, pivot - y - (2 * half_unit)].max < [high, pivot - y + (2 * half_unit)].min
+                        :baseline
+                      end
+          return unless alignment
+
+          native_height, native_y = recover_baseline(height, y, pivot, offset) if alignment == :baseline
+          Rotation.new(angle: angle, vertical_alignment: alignment, escapement: angle.zero? ? 1 : -angle * 10,
+                       native_height: native_height, native_y: native_y)
+        end
+
+        # A four-decimal native grid cannot always reproduce independently rounded
+        # height, baseline and pivot. Choose an interior point of all four source
+        # intervals; the handler uses a finer native mapping only for this case.
+        def self.recover_baseline(height, y, pivot, offset)
+          # Match the mapped IEEE-754 values and C rounding used by the renderer.
+          mapped_height = (height * 10_000).round * 0.0001
+          mapped_y = (y * 10_000).round * 0.0001
+          return if FormatHelpers.fmt(mapped_y + (mapped_height * 0.9)) == FormatHelpers.fmt(pivot)
+
+          half = Rational(1, 20_000)
+          ratio = Rational(9, 10)
+          low = [height - half, (offset - half) / ratio, (pivot - y - (2 * half)) / ratio].max
+          high = [height + half, (offset + half) / ratio, (pivot - y + (2 * half)) / ratio].min
+          return unless low < high
+
+          native_height = ((low + high) / 2 * 1_000_000).round / 1_000_000.0
+          low_y = [y - half, pivot - half - (native_height.to_r * ratio)].max
+          high_y = [y + half, pivot + half - (native_height.to_r * ratio)].min
+          return unless low_y < high_y
+
+          native_y = ((low_y + high_y) / 2 * 1_000_000).round / 1_000_000.0
+          actual = [native_height, native_y, native_height * 0.9, native_y + (native_height * 0.9)]
+          expected = [height, y, offset, pivot].map { |value| FormatHelpers.fmt(value) }
+          return unless actual.map { |value| FormatHelpers.fmt(value) } == expected
+
+          [native_height, native_y]
+        end
+
         def self.parse_weight(value)
-          return 400 if value.nil? || value == "normal"
+          return 0 if value.nil?
+          return 400 if value == "normal"
 
           value == "bold" ? 700 : value.to_i
         end

data/lib/emfsvg/svg/paint.rb

@@ -10,19 +10,25 @@ module Emfsvg
     class Paint
       SOLID = 0
       NULL = 1
+      PATTERN = 3
 
-      def initialize(color:, style: SOLID)
+      def initialize(color:, style: SOLID, reference: nil)
         @style = style
         @color = color
+        @reference = reference
       end
 
-      attr_reader :style, :color
+      attr_reader :style, :color, :reference
 
       def null?
         style == NULL || color.null?
       end
 
       def self.from_fill(value)
+        if (match = /\A(?:#(img-[1-9]\d*-ref)|url\(#(img-[1-9]\d*-ref)\))\z/.match(value.to_s))
+          return new(style: PATTERN, color: Color.parse("black"), reference: match[1] || match[2])
+        end
+
         color = Color.parse(value)
         new(style: color.null? ? NULL : SOLID, color: color)
       end

data/lib/emfsvg/svg/parser.rb

@@ -22,14 +22,21 @@ module Emfsvg
         root = doc.root
         raise ParseError, "not an SVG document: missing root element" unless root
 
+        source = string.b
         Document.new(
           width: parse_dimension(root["width"]),
           height: parse_dimension(root["height"]),
           view_box: parse_view_box(root["viewBox"]),
-          root_element: Element.from_node(root)
+          root_element: Element.from_node(root) { |node| source_tag(source, node) }
         )
       end
 
+      # Node serialization normalizes spacing; the original start tag carries
+      # the canonical renderer's distinction between Polyline and LineTo.
+      def source_tag(string, node)
+        string.match(/\G<(?:path|rect)\b(?:[^"'>]|"[^"]*"|'[^']*')*>/m, node.byte_offset)&.to_s
+      end
+
       def parse_dimension(value)
         return 0.0 if value.nil? || value.empty?
 

data/lib/emfsvg/svg/path_data/command.rb

@@ -7,7 +7,7 @@ module Emfsvg
       # `letter` preserves case (absolute uppercase vs relative lowercase).
       Command = Struct.new(:letter, :args, keyword_init: true) do
         def absolute?
-          letter == letter.upcase
+          ARG_COUNTS.key?(letter) || (!LETTER_ARG_COUNTS.key?(letter) && letter == letter.upcase)
         end
       end
     end

data/lib/emfsvg/svg/path_data.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "strscan"
+
 module Emfsvg
   module Svg
     # Namespace for the SVG path-data parser. Pure parser, no EMF
@@ -14,6 +16,20 @@ module Emfsvg
         "Q" => 4, "T" => 2, "A" => 7, "Z" => 0
       }.freeze
 
+      # ARG_COUNTS keyed by the letter as written, so the parser does not
+      # upcase a fresh String per token to look it up.
+      LETTER_ARG_COUNTS = ARG_COUNTS.each_with_object({}) do |(letter, count), counts|
+        counts[letter] = count
+        counts[letter.downcase] = count
+      end.freeze
+
+      # Frozen command-letter Strings keyed by the Symbol the Scanner
+      # emits, shared by every Command rather than allocated per token.
+      LETTERS = LETTER_ARG_COUNTS.keys.to_h { |letter| [letter.to_sym, letter.freeze] }.freeze
+
+      # Shared by every zero-argument command (Z/z).
+      NO_ARGS = [].freeze
+
       # Stateful parser walks the string once, emitting Commands as
       # enough args accumulate for the current letter. Implicit repeats:
       # subsequent arg groups after M/m are treated as L/l.
@@ -26,24 +42,24 @@ module Emfsvg
           commands = []
           scanner = Scanner.new(string)
           current_letter = nil
-          args = []
+          args = nil
 
           while (token = scanner.next_token)
             case token
             when Symbol # command letter
               flush_command(commands, current_letter, args) if current_letter && args.any?
-              current_letter = token.to_s
+              current_letter = LETTERS.fetch(token) { token.to_s }
               args = []
               # Zero-arg commands (Z/z) emit immediately.
-              if ARG_COUNTS.fetch(current_letter.upcase, 1).zero?
-                emit_command(commands, current_letter, [])
+              if LETTER_ARG_COUNTS.fetch(current_letter, 1).zero?
+                emit_command(commands, current_letter, NO_ARGS)
                 current_letter = nil
               end
             when Numeric
               raise FormatError, "path data begins with a number: #{string.inspect}" if current_letter.nil?
 
               args << token
-              if args.size == ARG_COUNTS.fetch(current_letter.upcase)
+              if args.size == (LETTER_ARG_COUNTS[current_letter] || ARG_COUNTS.fetch(current_letter.upcase))
                 emit_command(commands, current_letter, args)
                 args = []
                 current_letter = implicit_repeat_letter(current_letter)
@@ -56,9 +72,9 @@ module Emfsvg
         end
 
         def emit_command(commands, letter, args)
-          raise FormatError, "unknown path command: #{letter}" unless ARG_COUNTS.key?(letter.upcase)
+          raise FormatError, "unknown path command: #{letter}" unless LETTER_ARG_COUNTS.key?(letter)
 
-          commands << Command.new(letter: letter, args: args.dup)
+          commands << Command.new(letter: letter, args: args)
         end
 
         def flush_command(_commands, letter, args)
@@ -86,48 +102,43 @@ module Emfsvg
       # as Symbols (e.g. :M, :z) and numbers as Floats.
       class Scanner
         NUMBER_RE = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/
+        SEPARATORS_RE = /[ \t\n\r,]+/
+
+        # The Symbol for each command-letter byte, so a letter is read
+        # without allocating a String for it.
+        LETTER_SYMBOLS = (("A".."Z").to_a + ("a".."z").to_a).to_h { |letter| [letter.ord, letter.to_sym] }.freeze
+        private_constant :LETTER_SYMBOLS
 
         def initialize(string)
           @string = string
-          @pos = 0
+          @scanner = StringScanner.new(string)
         end
 
         def next_token
-          skip_separators
-          return nil if @pos >= @string.length
-
-          char = @string[@pos]
-          if command_letter?(char)
-            @pos += 1
-            char.to_sym
-          else
-            read_number
-          end
-        end
+          @scanner.skip(SEPARATORS_RE)
+          return nil if @scanner.eos?
 
-        private
+          letter = LETTER_SYMBOLS[@string.getbyte(@scanner.pos)]
+          return read_number unless letter
 
-        def skip_separators
-          @pos += 1 while @pos < @string.length && separator?(@string[@pos])
+          @scanner.pos += 1
+          letter
         end
 
-        def separator?(char)
-          case char
-          when " ", "\t", "\n", "\r", "," then true
-          else false
-          end
-        end
-
-        def command_letter?(char)
-          ("A".."Z").cover?(char) || ("a".."z").cover?(char)
-        end
+        private
 
+        # A number is normally right at the cursor. Anything else is
+        # skipped up to the next number, as the scan has always done.
         def read_number
-          match = @string.match(NUMBER_RE, @pos)
-          raise FormatError, "expected number at position #{@pos} in path data" unless match
+          number = @scanner.scan(NUMBER_RE)
+          return number.to_f if number
+
+          position = @scanner.charpos
+          unless @scanner.skip_until(NUMBER_RE)
+            raise FormatError, "expected number at position #{position} in path data"
+          end
 
-          @pos = match.end(0)
-          match.to_s.to_f
+          @scanner.matched.to_f
         end
       end
     end

data/lib/emfsvg/svg/stroke.rb

@@ -3,7 +3,7 @@
 module Emfsvg
   module Svg
     # Parsed SVG stroke style: color, width, dash pattern, line cap,
-    # line join. Maps directly to the EMF LOGPEN / EXTLOGPEN32 fields.
+    # line join, and miter limit.
     #
     # Pen style bits (per MS-WMF 2.1.1.8 / emr_visitor.rb mirror):
     #
@@ -21,61 +21,123 @@ module Emfsvg
       END_CAP_BITS = { "butt" => 0x0200, "round" => 0x0000, "square" => 0x0100 }.freeze
       LINE_JOIN_BITS = { "miter" => 0x2000, "round" => 0x0000, "bevel" => 0x1000 }.freeze
       NULL_PEN_WIDTH_SENTINEL = "1px"
+      COSMETIC_DASH_PATTERNS = {
+        1 => [5, 5], 2 => [1, 1], 3 => [5, 5, 1, 5], 4 => [5, 5, 1, 1, 1, 5]
+      }.freeze
+      private_constant :COSMETIC_DASH_PATTERNS
 
-      attr_reader :paint, :width, :dash_array, :line_cap, :line_join, :raw_width,
-                  :line_cap_explicit, :line_join_explicit
+      attr_reader :paint, :width, :dash_array, :line_cap, :line_join, :miter_limit, :raw_width,
+                  :line_cap_explicit, :line_join_explicit, :null_pen_fallback, :fallback_brush, :canonical_cosmetic_dash
 
       def initialize(paint:, width: 1.0, dash_array: nil, line_cap: "round",
-                     line_join: "round", raw_width: nil,
-                     line_cap_explicit: false, line_join_explicit: false)
+                     line_join: "round", miter_limit: 10.0, raw_width: nil,
+                     line_cap_explicit: false, line_join_explicit: false,
+                     null_pen_fallback: true, fallback_brush: nil)
         @paint = paint
         @width = width.to_f
         @dash_array = dash_array
         @line_cap = line_cap
         @line_join = line_join
+        @miter_limit = miter_limit.to_f
         @raw_width = raw_width
         @line_cap_explicit = line_cap_explicit
         @line_join_explicit = line_join_explicit
+        @null_pen_fallback = null_pen_fallback
+        @fallback_brush = fallback_brush
       end
 
       def null_pen_sentinel?
         raw_width == NULL_PEN_WIDTH_SENTINEL &&
+          null_pen_fallback &&
           !line_cap_explicit &&
           !line_join_explicit
       end
 
+      # Recover only the exact unfilled Polyline spelling emitted for these
+      # legacy cosmetic pens. Ordinary SVG shares the parsed paint cache.
+      def with_canonical_cosmetic_dash(source_tag)
+        return self unless %w[1.0000 1px].include?(raw_width) && !paint.null? && dash_array
+
+        number = "-?\\d+\\.\\d{4}"
+        point = "#{number},#{number}"
+        data = source_tag&.[](/\A<path d="(M #{point}(?: L #{point})+ )"/, 1)
+        color = source_tag&.[](/ stroke="(#[0-9A-F]{6})"/, 1)
+        return self unless data && color
+
+        lengths = dash_array.map { |length| format("%.4f", length) }.join(",")
+        expected = %(<path d="#{data}" stroke="#{color}" stroke-width="#{raw_width}" )
+        expected << %(stroke-dasharray="#{lengths}"  stroke-linecap="round"  stroke-linejoin="round" fill="none" />)
+        return self unless source_tag == expected
+
+        COSMETIC_DASH_PATTERNS.each do |style, pattern|
+          stored_width = dash_array.first / pattern.first
+          next unless stored_width >= 1 && stored_width == stored_width.to_i
+          next unless dash_array == pattern.map { |length| length * stored_width }
+
+          return dup.tap { |copy| copy.canonical_cosmetic_dash = [stored_width, style].freeze }
+        end
+        self
+      end
+
+      protected
+
+      attr_writer :canonical_cosmetic_dash
+
+      public
+
       PS_GEOMETRIC = 0x00010000
 
+      # Cosmetic widths are device pixels, independent of logical coordinates.
+      def cosmetic_pixel_width?
+        raw_width == "1px" && !paint.null? && !null_pen_sentinel?
+      end
+
       # Pen style bitmask (full 32 bits). Includes:
       #   * dash style (bits 0-7)
       #   * end-cap (bits 8-11)
       #   * line-join (bits 12-15)
-      #   * pen type GEOMETRIC (bit 16) — set when width > 1, so
-      #     emfsvg's EMF→SVG renderer uses the actual pen.width
-      #     instead of hardcoding 1.
+      #   * pen type GEOMETRIC (bit 16) — set when width > 1 or an
+      #     explicit unitless width of 1 must survive SVG round trips.
       def pen_style
+        return canonical_cosmetic_dash[1] if canonical_cosmetic_dash
+
+        @pen_style ||= compute_pen_style
+      end
+
+      def compute_pen_style
         base = if paint.null? || null_pen_sentinel?
                  5 # PS_NULL
                else
                  dash_style
                end
-        type_bit = width > 1.0 && !paint.null? ? PS_GEOMETRIC : 0
+        type_bit = (width > 1.0 || explicit_unitless_one_width?) && !paint.null? ? PS_GEOMETRIC : 0
         base | type_bit | END_CAP_BITS.fetch(line_cap, 0x0000) | LINE_JOIN_BITS.fetch(line_join, 0x0000)
       end
+      private :compute_pen_style
 
-      def self.parse(stroke:, width:, dash_array:, line_cap:, line_join:)
+      def self.parse(stroke:, width:, dash_array:, line_cap:, line_join:, miter_limit: nil, fill: nil)
         new(
           paint: Paint.from_stroke(stroke),
           width: parse_width(width),
           dash_array: parse_dash_array(dash_array),
           line_cap: line_cap || "round",
           line_join: line_join || "round",
+          miter_limit: parse_miter_limit(miter_limit),
           raw_width: width,
           line_cap_explicit: !line_cap.nil?,
-          line_join_explicit: !line_join.nil?
+          line_join_explicit: !line_join.nil?,
+          null_pen_fallback: fill.nil? || !fill.null?
         )
       end
 
+      def self.parse_miter_limit(value)
+        return 10.0 if value.nil? || value.strip.empty?
+
+        Float(value)
+      rescue ArgumentError
+        10.0
+      end
+
       def self.parse_width(value)
         return 1.0 if value.nil? || value.strip.empty?
 
@@ -96,11 +158,15 @@ module Emfsvg
         first < (width * 2) ? 2 : 1 # PS_DOT=2, PS_DASH=1
       end
 
+      def explicit_unitless_one_width?
+        raw_width.to_s.match?(/\A\s*1(?:\.0+)?\s*\z/)
+      end
+
       def self.parse_dash_array(value)
         return nil if value.nil? || value.strip == "none" || value.strip.empty?
 
         parts = value.split(/[\s,]+/).map(&:to_f)
-        parts.empty? ? nil : parts
+        parts.empty? ? nil : parts.freeze
       end
     end
   end

data/lib/emfsvg/svg_builder.rb

@@ -6,7 +6,8 @@ module Emfsvg
   #   - self-closing elements use `/>` (no leading space)
   #   - callers control newlines explicitly via `rawln` / `newline`
   class SvgBuilder
-    def initialize
+    def initialize(max_output_bytes: Renderer::MAX_OUTPUT_BYTES)
+      @max_output_bytes = max_output_bytes
       @out = (+"").force_encoding("ASCII-8BIT")
     end
 
@@ -22,24 +23,25 @@ module Emfsvg
     end
 
     def text(content)
-      @out << escape_text(content)
+      append(escape_text(content))
       self
     end
 
     # Raw append, no newline.
     def raw(string)
-      @out << string
+      append(string)
       self
     end
 
     # Raw append with trailing newline.
     def rawln(string)
-      @out << string << "\n"
+      append(string)
+      append("\n")
       self
     end
 
     def newline
-      @out << "\n"
+      append("\n")
       self
     end
 
@@ -50,20 +52,46 @@ module Emfsvg
     private
 
     def open_tag(name, attrs, single:)
-      @out << "<" << name
+      append("<")
+      append(name)
       attrs.each do |k, v|
         next if v.nil?
 
-        @out << " " << k.to_s << '="' << escape_attr(v.to_s) << '"'
+        append(" ")
+        append(k.to_s)
+        append('="')
+        append(escape_attr(v.to_s))
+        append('"')
       end
-      @out << (single ? "/>" : ">")
+      append(single ? "/>" : ">")
     end
 
     def close_tag(name)
-      @out << "</" << name << ">"
+      append("</")
+      append(name)
+      append(">")
+    end
+
+    def append(string)
+      check_budget(string.bytesize)
+      @out << string
+    end
+
+    def check_budget(additional_bytes)
+      actual = @out.bytesize + additional_bytes
+      return if actual <= @max_output_bytes
+
+      raise ResourceLimitError.new(resource: :output_bytes, limit: @max_output_bytes, actual: actual)
+    end
+
+    def check_escaped_budget(value, attribute: false)
+      additional_bytes = value.bytesize + (value.count("&") * 4) + (value.count("<>") * 3)
+      additional_bytes += value.count('"') * 5 if attribute
+      check_budget(additional_bytes)
     end
 
     def escape_attr(value)
+      check_escaped_budget(value, attribute: true)
       value.gsub("&", "&amp;")
            .gsub("<", "&lt;")
            .gsub(">", "&gt;")
@@ -71,6 +99,7 @@ module Emfsvg
     end
 
     def escape_text(value)
+      check_escaped_budget(value)
       value.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
     end
   end