prawn-svg 0.39.0 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c524e2dc0d6754bcd60ca3d4e056f64069621b4412ff90b2f07c01123837e80
-  data.tar.gz: 3edb96730b5a94d0c5db17ac5cd47e6dd4ab4af4e93b409555fc94e69b12dde4
+  metadata.gz: d49edc3094a7c32e0a28d5652485f9f41760559041b5dbf75fd2deebe0861059
+  data.tar.gz: 74ac334d02477ae3cb00173b4dd04b5fde9a614cc17a57bfaf102d5e81b756e0
 SHA512:
-  metadata.gz: 344edee9e2156c94d4d82aa995d38df4a73cad64966979d70da1220a30875da3837dbc962d968347b52d1bc55ee843e141275f62e013de31362ea064fbc24f92
-  data.tar.gz: a65858effa7cabdff362876b3e877bed5d1e35a9b9dcc70fbc68d23849faea060f14f63fe710baf510e011e5f5433014b365146ac47acef4fd35f2ad02221fbd
+  metadata.gz: 8d65777391564f1e2515b3f695d97b9d517a368c5b0e2d9af62c47866da82174f0ba25146ab29251af90175c95d0400443d5a2e1171bddebe113eeba9b75df7e
+  data.tar.gz: 890c36c783060f51f1ff6e80e7455b314b2a3acb948a427e985bfd29825de5f0b6bdcddd646e29f699180f85a85f05656759e107a8d1ff3ce3b075f098085aa0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    prawn-svg (0.38.1)
+    prawn-svg (0.40.0)
       css_parser (~> 1.6)
       matrix (~> 0.4.2)
       prawn (>= 0.11.1, < 3)

data/README.md

@@ -1,16 +1,14 @@
 # prawn-svg
 
 [![Gem Version](https://badge.fury.io/rb/prawn-svg.svg)](https://badge.fury.io/rb/prawn-svg)
-![Build Status](https://github.com/mogest/prawn-svg/actions/workflows/test.yml/badge.svg?branch=master)
+![Build Status](https://github.com/mogest/prawn-svg/actions/workflows/test.yml/badge.svg?branch=main)
 
-An SVG renderer for the Prawn PDF library.
+An SVG renderer for the [Prawn PDF library](https://github.com/prawnpdf/prawn).
 
-This will take an SVG document as input and render it into your PDF.  Find out more about the Prawn PDF library at:
+This will take an SVG document as input and render it into your PDF, along with whatever else you build with Prawn.
 
-  http://github.com/prawnpdf/prawn
-
-prawn-svg is compatible with all versions of Prawn from 0.11.1 onwards, including the 1.x and 2.x series.
-The minimum Ruby version required is 2.7.
+prawn-svg is compatible with all versions of Prawn from 0.11.1 onwards, including the 1.x and 2.x series, although
+you'll need version 2.2.0 onwards if you want color gradients.  The minimum Ruby version required is 2.7.
 
 ## Using prawn-svg
 
@@ -30,11 +28,13 @@ Option      | Data type | Description
 :vposition  | :top, :center, :bottom, integer | If :at not specified, specifies the vertical position to show the SVG.  Defaults to current cursor position.
 :width      | integer   | Desired width of the SVG.  Defaults to horizontal space available.
 :height     | integer   | Desired height of the SVG.  Defaults to vertical space available.
-:enable_web_requests | boolean | If true, prawn-svg will make http and https requests to fetch images.  Defaults to true.
-:enable_file_requests_with_root | string | If not nil, prawn-svg will serve `file:` URLs from your local disk if the file is located under the specified directory. It is very dangerous to specify the root path ("/") if you're not fully in control of your input SVG.  Defaults to `nil` (off).
+:enable_web_requests | boolean | If true, prawn-svg will make http and https requests to fetch images, `@font-face` fonts, and external `<use>` references.<br><br>Defaults to true, but will **default to false** in the upcoming 1.0 release.  It's recommended you explicitly set this option for now.
+:enable_file_requests_with_root | string | If not nil, prawn-svg will serve `file:` URLs and relative paths from your local disk if the file is located under the specified directory. Required for `@font-face` fonts and external `<use>` references loaded via file paths.<br><br>It is very dangerous to specify the root path ("/") if you're not fully in control of your input SVG.  Defaults to `nil` (off).
 :cache_images | boolean   | If true, prawn-svg will cache the result of all URL requests. Defaults to false.
 :fallback_font_name | string | A font name which will override the default fallback font of Times-Roman.  If this value is set to `nil`, prawn-svg will ignore a request for an unknown font and log a warning.
 :color_mode | :rgb, :cmyk | Output color mode.  Defaults to :rgb.
+:language   | string    | BCP 47 language tag for `<switch>` `systemLanguage` matching.  Defaults to `"en"`.
+:log_warnings | boolean | If true, warnings that occur when parsing/rendering the SVG are output to stderr via `warn`.  Use this when you're not getting the output you expect.  Defaults to false.
 
 ## Examples
 
@@ -47,27 +47,25 @@ Option      | Data type | Description
 
   # Render the logo at the current Y cursor position, and serve file: links relative to its directory
   root_path = "/apps/myapp/current/images"
-  svg IO.read("#{root_path}/logo.svg"), enable_file_requests_with_root: root_path
+  svg IO.read("#{root_path}/logo.svg"), enable_file_requests_with_root: root_path, log_warnings: true
 ```
 
 ## Supported features
 
-prawn-svg supports most but not all of the full SVG 1.1 specification.  It currently supports:
-
- - `<line>`, `<polyline>`, `<polygon>`, `<circle>` and `<ellipse>`
+prawn-svg supports almost all of the full SVG 1.1 specification:
 
- - `<rect>`.  Rounded rects are supported, but only one radius is applied to all corners.
+ - `<line>`, `<polyline>`, `<rect>`, `<polygon>`, `<circle>` and `<ellipse>`
 
- - `<path>` supports all commands defined in SVG 1.1, although the
-   implementation of elliptical arc is a bit rough at the moment.
+ - `<path>`
 
- - `<text>`, `<tspan>` and `<tref>` with attributes `x`, `y`, `dx`, `dy`, `rotate`, `textLength`, `lengthAdjust`,
-   and with extra properties `text-anchor`, `text-decoration` (underline only), `font`, `font-size`, `font-family`,
-   `font-weight`, `font-style`, `letter-spacing`, `dominant-baseline` (middle only)
+ - `<text>`, `<tspan>`, `<tref>` and `<textPath>` with attributes `x`, `y`, `dx`, `dy`, `rotate`, `textLength`,
+   `lengthAdjust`, and with extra properties `text-anchor`, `text-decoration`, `font`, `font-size`, `font-family`,
+   `font-weight`, `font-style`, `font-stretch`, `kerning`, `letter-spacing`, `word-spacing`, `dominant-baseline`, `alignment-baseline`, `baseline-shift`.
+   `<textPath>` supports `href`/`xlink:href` and `startOffset`.
 
  - `<svg>`, `<g>` and `<symbol>`
 
- - `<use>`
+ - `<use>` with local and external references (e.g. `other.svg#elementId`), subject to `enable_web_requests` and `enable_file_requests_with_root`
 
  - `<style>` (see CSS section below)
 
@@ -75,7 +73,7 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
    `data:image/png;base64`, `data:image/svg+xml;base64` and `file:` schemes (`file:` is disabled by default for
    security reasons, see Options section above)
 
- - `<clipPath>`
+ - `<clipPath>` with `clipPathUnits` attribute and text content
 
  - `<mask>` with attributes `maskUnits` and `maskContentUnits`
 
@@ -84,14 +82,21 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
  - `<linearGradient>` and `<radialGradient>` are implemented on Prawn 2.2.0+ with attributes `gradientUnits` and
    `gradientTransform`
 
- - `<switch>` and `<foreignObject>`, although prawn-svg cannot handle any data that is not SVG so `<foreignObject>`
-   tags are always ignored.
+ - `<pattern>` with attributes `patternUnits`, `patternContentUnits`, `patternTransform`, `viewBox`,
+   `preserveAspectRatio`, and `href` inheritance.  Patterns can be used for both fill and stroke.
+   Nested patterns (a pattern whose content references another pattern) are not supported.
+
+ - `<switch>` with conditional processing (`requiredFeatures`, `requiredExtensions`, `systemLanguage`).
+   `<foreignObject>` tags are always ignored as prawn-svg cannot handle non-SVG data.
+
+ - `<view>` element for defining named views.  Fragment identifiers (`#viewId` and `#svgView(...)`) on
+   `<image>` hrefs select which view to render an external SVG with.
 
- - properties: `clip-path`, `color`, `display`, `fill`, `fill-opacity`, `fill-rule`, `opacity`, `overflow`,
-   `stroke`, `stroke-dasharray`, `stroke-linecap`, `stroke-linejoin`, `stroke-opacity`, `stroke-width`,
+ - properties: `clip-path`, `clip-rule`, `color`, `display`, `fill`, `fill-opacity`, `fill-rule`, `opacity`, `overflow`,
+   `stroke`, `stroke-dasharray`, `stroke-dashoffset`, `stroke-linecap`, `stroke-linejoin`, `stroke-miterlimit`, `stroke-opacity`, `stroke-width`,
    `visibility`
 
- - properties on lines, polylines, polygons and paths: `marker-end`, `marker-mid`, `marker-start`
+ - properties on lines, polylines, polygons and paths: `marker`, `marker-end`, `marker-mid`, `marker-start`
 
  - attributes on all elements: `class`, `id`, `style`, `transform`, `xml:space`
 
@@ -106,25 +111,40 @@ prawn-svg supports most but not all of the full SVG 1.1 specification.  It curre
 
  - measurements specified in `pt`, `cm`, `dm`, `ft`, `in`, `m`, `mm`, `yd`, `pc`, `%`
 
- - fonts: generic CSS fonts, built-in PDF fonts, and any TTF fonts in your fonts path, specified in any of the
-   measurements above plus `em` or `rem`
+ - fonts: generic CSS fonts, built-in PDF fonts, and any TTF or TTC fonts in your fonts path, specified in any of
+   the measurements above plus `em` or `rem`
+
+ - `@font-face` in `<style>` blocks: `url()` sources (TTF/OTF formats) and `local()` references, with `font-weight`,
+   `font-style` and `font-stretch` descriptors.  Font loading is subject to the `enable_web_requests` and
+   `enable_file_requests_with_root` options.
 
 ## CSS
 
-prawn-svg supports CSS, both in `<style>` blocks and `style` attributes.
+prawn-svg fully supports CSS2, both in `<style>` blocks and `style` attributes.
+
+`@import` rules are supported for loading external stylesheets (requires `enable_web_requests` or
+`enable_file_requests_with_root` options enabled).
 
 In CSS selectors you can use element names, IDs, classes, attributes (existence, `=`, `^=`, `$=`, `*=`, `~=`, `|=`)
-and all combinators (` `, `>`, `+`, `~`).
-The pseudo-classes `:first-child`, `:last-child` and `:nth-child(n)` (where n is a number) also work.
-`!important` is supported.
+and all combinators (` `, `>`, `+`, `~`). The pseudo-classes `:first-child`, `:last-child`, `:link`, `:nth-child()`
+and `:lang()` also work.  `:visited`, `:hover`, `:active`, and `:focus` are never matched. `!important` is
+supported.
 
-Pseudo-elements and the other pseudo-classes are not supported.
+We made the call to ignore `@media` because it's not clear whether you're making a PDF to print it or show it on
+the screen.
 
 ## Not supported
 
-prawn-svg does not support patterns or filters.
+prawn-svg does not support filters, as rasterised effects is not something the PDF format was designed to handle.
+
+writing-mode is partially supported: vertical-rl and vertical-lr rotate the text 90 degrees, which
+handles the common case of sideways Latin text.  CJK upright glyph orientation is not supported.
+
+direction and unicode-bidi are not supported.
 
-It does not support text in the clip area, but you can clip shapes and text by any shape.
+Features that will probably never be supported because either they don't make sense for PDF, they were deprecated
+in SVG 2, and/or they are rarely used: filters, SVG fonts, altGlyph, font-size-adjust, glyph-orientation, rendering
+hints, ICC color profiles, color-interpolation, enable-background, deprecated CSS clip, @media.
 
 ## Configuration
 

data/lib/prawn/svg/attributes/clip_path.rb

@@ -8,9 +8,39 @@ module Prawn::SVG::Attributes::ClipPath
     if clip_path_element.nil?
       document.warnings << 'Could not resolve clip-path URI to a clipPath element'
     else
+      clip_calls = clip_path_element.build_clip_calls(self)
+      return if clip_calls.nil?
+
       add_call_and_enter 'save_graphics_state'
-      add_calls_from_element clip_path_element
-      add_call 'clip'
+
+      if clip_path_contains_text?(clip_calls)
+        # Text in clip paths is implemented using a PDF soft mask. The text
+        # renders in white fill inside the mask to define the visible region.
+        # This correctly unions multiple text elements, unlike PDF text
+        # rendering mode 7 which intersects separate text objects.
+        @calls << ['soft_mask', [], {}, clip_calls]
+      else
+        @calls.concat clip_calls
+
+        # SVG's clip-rule applies per-element (determining each shape's interior),
+        # then elements are unioned. PDF's W* applies even-odd to the entire combined
+        # path, which incorrectly creates holes between separate shapes. Only use W*
+        # when there's a single child element, where self-intersection matters.
+        child_elements = clip_path_element.svg_child_elements
+        if child_elements.length == 1 && clip_path_element.computed_properties.clip_rule == 'evenodd'
+          add_call 'clip', clip_rule: :even_odd
+        else
+          add_call 'clip'
+        end
+      end
+    end
+  end
+
+  private
+
+  def clip_path_contains_text?(calls)
+    calls.any? do |call, _arguments, _kwarguments, children|
+      call == 'svg:render' || clip_path_contains_text?(children)
     end
   end
 end

data/lib/prawn/svg/attributes/stroke.rb

@@ -17,6 +17,10 @@ module Prawn::SVG::Attributes::Stroke
       add_call('join_style', JOIN_STYLE_TRANSLATIONS.fetch(linejoin, :miter))
     end
 
+    if (miterlimit = properties.stroke_miterlimit) && miterlimit != 'inherit'
+      add_call('miter_limit', miterlimit)
+    end
+
     if (dasharray = properties.stroke_dasharray)
       case dasharray
       when 'inherit'
@@ -30,7 +34,13 @@ module Prawn::SVG::Attributes::Stroke
         if values.inject(0) { |a, b| a + b }.zero?
           add_call('undash')
         else
-          add_call('dash', values)
+          options = {}
+          offset = computed_properties.stroke_dashoffset
+          if offset && offset != 0 && offset != 'inherit'
+            phase = pixels(offset)
+            options[:phase] = phase unless phase.zero?
+          end
+          add_call('dash', values, **options)
         end
       else
         raise "Unknown dasharray value: #{dasharray.inspect}"

data/lib/prawn/svg/calculators/arc_to_bezier_curve.rb

@@ -4,7 +4,10 @@ module Prawn::SVG::Calculators
 
     # Convert the elliptical arc to a cubic bézier curve using this algorithm:
     # http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
-    def calculate_bezier_curve_points_for_arc(cx, cy, a, b, lambda_1, lambda_2, theta)
+    #
+    # eta_1 and eta_2 are the eccentric anomaly angles (the parametric angles on the
+    # unit circle that map to points on the ellipse). theta is the ellipse rotation angle.
+    def calculate_bezier_curve_points_for_arc(cx, cy, a, b, eta_1, eta_2, theta)
       e = lambda do |eta|
         [
           cx + (a * Math.cos(theta) * Math.cos(eta)) - (b * Math.sin(theta) * Math.sin(eta)),
@@ -20,97 +23,35 @@ module Prawn::SVG::Calculators
       end
 
       iterations = 1
-      d_lambda = lambda_2 - lambda_1
+      d_eta = eta_2 - eta_1
 
       while iterations < 1024
-        if d_lambda.abs <= Math::PI / 2.0
-          # TODO : run error algorithm, see whether it meets threshold or not
-          # puts "error = #{calculate_curve_approximation_error(a, b, eta1, eta1 + d_eta)}"
-          break
-        end
+        break if d_eta.abs <= Math::PI / 2.0
 
         iterations *= 2
-        d_lambda = (lambda_2 - lambda_1) / iterations
+        d_eta = (eta_2 - eta_1) / iterations
       end
 
       (0...iterations).collect do |iteration|
-        eta_a, eta_b = calculate_eta_from_lambda(a, b, lambda_1 + (iteration * d_lambda),
-          lambda_1 + ((iteration + 1) * d_lambda))
-        d_eta = eta_b - eta_a
+        seg_eta_a = eta_1 + (iteration * d_eta)
+        seg_eta_b = eta_1 + ((iteration + 1) * d_eta)
+        seg_d_eta = seg_eta_b - seg_eta_a
 
-        alpha = Math.sin(d_eta) * ((Math.sqrt(4 + (3 * (Math.tan(d_eta / 2)**2))) - 1) / 3)
+        alpha = Math.sin(seg_d_eta) * ((Math.sqrt(4 + (3 * (Math.tan(seg_d_eta / 2)**2))) - 1) / 3)
 
-        x1, y1 = e[eta_a]
-        x2, y2 = e[eta_b]
+        x1, y1 = e[seg_eta_a]
+        x2, y2 = e[seg_eta_b]
 
-        ep_eta1_x, ep_eta1_y = ep[eta_a]
+        ep_eta1_x, ep_eta1_y = ep[seg_eta_a]
         q1_x = x1 + (alpha * ep_eta1_x)
         q1_y = y1 + (alpha * ep_eta1_y)
 
-        ep_eta2_x, ep_eta2_y = ep[eta_b]
+        ep_eta2_x, ep_eta2_y = ep[seg_eta_b]
         q2_x = x2 - (alpha * ep_eta2_x)
         q2_y = y2 - (alpha * ep_eta2_y)
 
         { p2: [x2, y2], q1: [q1_x, q1_y], q2: [q2_x, q2_y] }
       end
     end
-
-    private
-
-    ERROR_COEFFICIENTS_A = [
-      [
-        [3.85268, -21.229, -0.330434, 0.0127842],
-        [-1.61486, 0.706564, 0.225945, 0.263682],
-        [-0.910164, 0.388383, 0.00551445, 0.00671814],
-        [-0.630184, 0.192402, 0.0098871, 0.0102527]
-      ],
-      [
-        [-0.162211, 9.94329, 0.13723, 0.0124084],
-        [-0.253135, 0.00187735, 0.0230286, 0.01264],
-        [-0.0695069, -0.0437594, 0.0120636, 0.0163087],
-        [-0.0328856, -0.00926032, -0.00173573, 0.00527385]
-      ]
-    ].freeze
-
-    ERROR_COEFFICIENTS_B = [
-      [
-        [0.0899116, -19.2349, -4.11711, 0.183362],
-        [0.138148, -1.45804, 1.32044, 1.38474],
-        [0.230903, -0.450262, 0.219963, 0.414038],
-        [0.0590565, -0.101062, 0.0430592, 0.0204699]
-      ],
-      [
-        [0.0164649, 9.89394, 0.0919496, 0.00760802],
-        [0.0191603, -0.0322058, 0.0134667, -0.0825018],
-        [0.0156192, -0.017535, 0.00326508, -0.228157],
-        [-0.0236752, 0.0405821, -0.0173086, 0.176187]
-      ]
-    ].freeze
-
-    def calculate_curve_approximation_error(a, b, eta1, eta2)
-      b_over_a = b / a
-      coefficents = b_over_a < 0.25 ? ERROR_COEFFICIENTS_A : ERROR_COEFFICIENTS_B
-
-      c = lambda do |i|
-        (0..3).inject(0) do |accumulator, j|
-          coef = coefficents[i][j]
-          accumulator + ((((coef[0] * (b_over_a**2)) + (coef[1] * b_over_a) + coef[2]) / (b_over_a * coef[3])) * Math.cos(j * (eta1 + eta2)))
-        end
-      end
-
-      (((0.001 * (b_over_a**2)) + (4.98 * b_over_a) + 0.207) / (b_over_a * 0.0067)) * a * Math.exp(c[0] + (c[1] * (eta2 - eta1)))
-    end
-
-    def calculate_eta_from_lambda(a, b, lambda_1, lambda_2)
-      # 2.2.1
-      eta1 = Math.atan2(Math.sin(lambda_1) / b, Math.cos(lambda_1) / a)
-      eta2 = Math.atan2(Math.sin(lambda_2) / b, Math.cos(lambda_2) / a)
-
-      # ensure eta1 <= eta2 <= eta1 + 2*PI
-      eta2 -= 2 * Math::PI * ((eta2 - eta1) / (2 * Math::PI)).floor
-      eta2 += 2 * Math::PI if lambda_2 - lambda_1 > Math::PI && eta2 - eta1 < Math::PI
-
-      [eta1, eta2]
-    end
   end
 end

data/lib/prawn/svg/calculators/path_length.rb

@@ -0,0 +1,168 @@
+module Prawn::SVG::Calculators
+  class PathLength
+    Segment = Struct.new(:start_point, :end_point, :type, :control_points, :segment_length, :cumulative_length, :lookup_table)
+
+    SUBDIVISION_TOLERANCE = 0.01
+    LOOKUP_TABLE_STEPS = 64
+
+    attr_reader :total_length
+
+    def initialize(commands)
+      @segments = []
+      @total_length = 0.0
+
+      current_point = nil
+      subpath_start = nil
+
+      commands.each do |command|
+        case command
+        when Prawn::SVG::Pathable::Move
+          current_point = command.destination
+          subpath_start = current_point
+
+        when Prawn::SVG::Pathable::Close
+          if current_point && subpath_start && current_point != subpath_start
+            add_line_segment(current_point, subpath_start)
+            current_point = subpath_start
+          end
+
+        when Prawn::SVG::Pathable::Line
+          if current_point
+            add_line_segment(current_point, command.destination)
+            current_point = command.destination
+          end
+
+        when Prawn::SVG::Pathable::Curve
+          if current_point
+            add_curve_segment(current_point, command.point1, command.point2, command.destination)
+            current_point = command.destination
+          end
+        end
+      end
+    end
+
+    def point_at(distance)
+      return nil if distance.negative? || distance > @total_length || @segments.empty?
+
+      @segments.each do |segment|
+        start_distance = segment.cumulative_length - segment.segment_length
+
+        next unless distance <= segment.cumulative_length
+
+        local_distance = distance - start_distance
+
+        case segment.type
+        when :line
+          t = segment.segment_length.positive? ? local_distance / segment.segment_length : 0.0
+          x = segment.start_point[0] + (t * (segment.end_point[0] - segment.start_point[0]))
+          y = segment.start_point[1] + (t * (segment.end_point[1] - segment.start_point[1]))
+          dx = segment.end_point[0] - segment.start_point[0]
+          dy = segment.end_point[1] - segment.start_point[1]
+          angle = Math.atan2(dy, dx) * 180.0 / Math::PI
+          return [x, y, angle]
+
+        when :curve
+          t = find_t_for_distance(segment, local_distance)
+          p0, p1, p2, p3 = segment.start_point, *segment.control_points, segment.end_point
+          x, y = evaluate_cubic(p0, p1, p2, p3, t)
+          dx, dy = evaluate_cubic_derivative(p0, p1, p2, p3, t)
+          angle = Math.atan2(dy, dx) * 180.0 / Math::PI
+          return [x, y, angle]
+        end
+      end
+
+      # Exactly at the end
+      segment = @segments.last
+      [segment.end_point[0], segment.end_point[1], end_angle(segment)]
+    end
+
+    private
+
+    def add_line_segment(start_point, end_point)
+      length = Math.sqrt(((end_point[0] - start_point[0])**2) + ((end_point[1] - start_point[1])**2))
+      @total_length += length
+      @segments << Segment.new(start_point, end_point, :line, nil, length, @total_length, nil)
+    end
+
+    def add_curve_segment(start_point, control1, control2, end_point)
+      lookup_table = build_lookup_table(start_point, control1, control2, end_point)
+      length = lookup_table.last
+      @total_length += length
+      @segments << Segment.new(start_point, end_point, :curve, [control1, control2], length, @total_length, lookup_table)
+    end
+
+    def build_lookup_table(p0, p1, p2, p3)
+      table = [0.0]
+      prev_point = p0
+      cumulative = 0.0
+
+      1.upto(LOOKUP_TABLE_STEPS) do |i|
+        t = i.to_f / LOOKUP_TABLE_STEPS
+        point = evaluate_cubic(p0, p1, p2, p3, t)
+        cumulative += Math.sqrt(((point[0] - prev_point[0])**2) + ((point[1] - prev_point[1])**2))
+        table << cumulative
+        prev_point = point
+      end
+
+      table
+    end
+
+    def find_t_for_distance(segment, target_distance)
+      table = segment.lookup_table
+      return 0.0 if target_distance <= 0
+      return 1.0 if target_distance >= segment.segment_length
+
+      # Binary search in the lookup table
+      low = 0
+      high = LOOKUP_TABLE_STEPS
+
+      while low < high - 1
+        mid = (low + high) / 2
+        if table[mid] < target_distance
+          low = mid
+        else
+          high = mid
+        end
+      end
+
+      # Linear interpolation between low and high
+      d_low = table[low]
+      d_high = table[high]
+      fraction = d_high > d_low ? (target_distance - d_low) / (d_high - d_low) : 0.0
+      (low + fraction) / LOOKUP_TABLE_STEPS
+    end
+
+    def evaluate_cubic(p0, p1, p2, p3, t)
+      mt = 1.0 - t
+      mt2 = mt * mt
+      mt3 = mt2 * mt
+      t2 = t * t
+      t3 = t2 * t
+
+      x = (mt3 * p0[0]) + (3 * mt2 * t * p1[0]) + (3 * mt * t2 * p2[0]) + (t3 * p3[0])
+      y = (mt3 * p0[1]) + (3 * mt2 * t * p1[1]) + (3 * mt * t2 * p2[1]) + (t3 * p3[1])
+      [x, y]
+    end
+
+    def evaluate_cubic_derivative(p0, p1, p2, p3, t)
+      mt = 1.0 - t
+
+      dx = (3 * mt * mt * (p1[0] - p0[0])) + (6 * mt * t * (p2[0] - p1[0])) + (3 * t * t * (p3[0] - p2[0]))
+      dy = (3 * mt * mt * (p1[1] - p0[1])) + (6 * mt * t * (p2[1] - p1[1])) + (3 * t * t * (p3[1] - p2[1]))
+      [dx, dy]
+    end
+
+    def end_angle(segment)
+      case segment.type
+      when :line
+        dx = segment.end_point[0] - segment.start_point[0]
+        dy = segment.end_point[1] - segment.start_point[1]
+        Math.atan2(dy, dx) * 180.0 / Math::PI
+      when :curve
+        p0, p1, p2, p3 = segment.start_point, *segment.control_points, segment.end_point
+        dx, dy = evaluate_cubic_derivative(p0, p1, p2, p3, 1.0)
+        Math.atan2(dy, dx) * 180.0 / Math::PI
+      end
+    end
+  end
+end

data/lib/prawn/svg/calculators/pixels.rb

@@ -39,4 +39,19 @@ module Prawn::SVG::Calculators::Pixels
     value && Measurement.to_pixels(value, state.viewport_sizing.viewport_height,
       font_size: computed_properties.numeric_font_size)
   end
+
+  def percentage_or_proportion(string, default = 0)
+    string = string.to_s.strip
+    percentage = false
+
+    if string[-1] == '%'
+      percentage = true
+      string = string[0..-2]
+    end
+
+    value = Float(string, exception: false)
+    return default unless value
+
+    percentage ? value / 100.0 : value
+  end
 end

data/lib/prawn/svg/css/font_face_parser.rb

@@ -0,0 +1,72 @@
+module Prawn::SVG::CSS
+  class FontFaceParser
+    SUPPORTED_FORMATS = %w[truetype opentype].freeze
+
+    class << self
+      def parse_src(src)
+        split_sources(src).filter_map { |entry| parse_source_entry(entry.strip) }
+      end
+
+      private
+
+      def split_sources(value)
+        entries = []
+        current = +''
+        depth = 0
+        in_quote = nil
+
+        value.each_char do |char|
+          if in_quote
+            current << char
+            in_quote = nil if char == in_quote
+          elsif ['"', "'"].include?(char)
+            in_quote = char
+            current << char
+          elsif char == '('
+            depth += 1
+            current << char
+          elsif char == ')'
+            depth -= 1
+            current << char
+          elsif char == ',' && depth.zero?
+            entries << current
+            current = +''
+          else
+            current << char
+          end
+        end
+
+        entries << current unless current.strip.empty?
+        entries
+      end
+
+      def parse_source_entry(entry)
+        parts = Prawn::SVG::CSS::ValuesParser.parse(entry)
+        return if parts.empty?
+
+        first = parts[0]
+        return unless first.is_a?(Array)
+
+        case first[0]
+        when 'url'
+          url = first[1][0]
+          return unless url
+
+          format = extract_format(parts[1])
+          { type: :url, url: url, format: format }
+        when 'local'
+          name = first[1][0]
+          return unless name
+
+          { type: :local, name: name }
+        end
+      end
+
+      def extract_format(part)
+        return unless part.is_a?(Array) && part[0] == 'format'
+
+        part[1][0]
+      end
+    end
+  end
+end