Benötigte Pakete installiert

vendor/dompdf/php-svg-lib/AUTHORS.md

@@ -0,0 +1,17 @@
+SvgLib was designed and developed by Fabien Ménager.
+
+### Current Team
+
+* **Brian Sweeney** (maintainer)
+
+### Alumni
+
+* **Fabien Ménager** (creator)
+
+### Contributors
+* **ssddanbrown**
+* [and many more...](https://github.com/dompdf/php-svg-lib/graphs/contributors)
+
+### Thanks
+
+SvgLib would not have been possible without strong community support.

vendor/dompdf/php-svg-lib/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

vendor/dompdf/php-svg-lib/README.md

@@ -0,0 +1,12 @@
+# SVG file parsing / rendering library
+
+[![Build Status](https://github.com/dompdf/php-svg-lib/actions/workflows/test.yml/badge.svg)](https://github.com/dompdf/php-svg-lib/actions/workflows/test.yml)
+
+[![Latest Stable Version](https://poser.pugx.org/phenx/php-svg-lib/v/stable)](https://packagist.org/packages/phenx/php-svg-lib) 
+[![Total Downloads](https://poser.pugx.org/phenx/php-svg-lib/downloads)](https://packagist.org/packages/phenx/php-svg-lib) 
+[![Latest Unstable Version](https://poser.pugx.org/phenx/php-svg-lib/v/unstable)](https://packagist.org/packages/phenx/php-svg-lib) 
+[![License](https://poser.pugx.org/phenx/php-svg-lib/license)](https://packagist.org/packages/phenx/php-svg-lib)
+
+The main purpose of this lib is to rasterize SVG to a surface which can be an image or a PDF for example, through a `\Svg\Surface` PHP interface.
+
+This project was initialized by the need to render SVG documents inside PDF files for the [DomPdf](https://github.com/dompdf/dompdf) project.

vendor/dompdf/php-svg-lib/composer.json

@@ -0,0 +1,31 @@
+{
+  "name": "dompdf/php-svg-lib",
+  "type": "library",
+  "description": "A library to read, parse and export to PDF SVG files.",
+  "homepage": "https://github.com/dompdf/php-svg-lib",
+  "license": "LGPL-3.0-or-later",
+  "authors": [
+    {
+      "name": "The SvgLib Community",
+      "homepage": "https://github.com/dompdf/php-svg-lib/blob/master/AUTHORS.md"
+    }
+  ],
+  "autoload": {
+    "psr-4": {
+      "Svg\\": "src/Svg"
+    }
+  },
+  "autoload-dev": {
+    "psr-4": {
+      "Svg\\Tests\\": "tests/Svg"
+    }
+  },
+  "require": {
+    "php": "^7.1 || ^8.0",
+    "ext-mbstring": "*",
+    "sabberworm/php-css-parser": "^8.4"
+  },
+  "require-dev": {
+    "phpunit/phpunit": "^7.5 || ^8.5 || ^9.5"
+  }
+}

vendor/dompdf/php-svg-lib/src/Svg/CssLength.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace Svg;
+
+class CssLength
+{
+    /**
+     * Array of valid css length units.
+     * Should be pre-sorted by unit text length so no earlier length can be
+     * contained within a latter (eg. 'in' within 'vmin').
+     *
+     * @var string[]
+     */
+    protected static $units = [
+        'vmax',
+        'vmin',
+        'rem',
+        'px',
+        'pt',
+        'cm',
+        'mm',
+        'in',
+        'pc',
+        'em',
+        'ex',
+        'ch',
+        'vw',
+        'vh',
+        '%',
+        'q',
+    ];
+
+    /**
+     * A list of units that are inch-relative, and their unit division within an inch.
+     *
+     * @var array<string, float>
+     */
+    protected static $inchDivisions = [
+        'in' => 1,
+        'cm' => 2.54,
+        'mm' => 25.4,
+        'q' => 101.6,
+        'pc' => 6,
+        'pt' => 72,
+    ];
+
+    /**
+     * The CSS length unit indicator.
+     * Will be lower-case and one of the units listed in the '$units' array or empty.
+     *
+     * @var string
+     */
+    protected $unit = '';
+
+    /**
+     * The numeric value of the given length.
+     *
+     * @var float
+     */
+    protected $value = 0;
+
+    /**
+     * The original unparsed length provided.
+     *
+     * @var string
+     */
+    protected $unparsed;
+
+    public function __construct(string $length)
+    {
+        $this->unparsed = $length;
+        $this->parseLengthComponents($length);
+    }
+
+    /**
+     * Parse out the unit and value components from the given string length.
+     */
+    protected function parseLengthComponents(string $length): void
+    {
+        $length = strtolower($length);
+
+        foreach (self::$units as $unit) {
+            $pos = strpos($length, $unit);
+            if ($pos) {
+                $this->value = floatval(substr($length, 0, $pos));
+                $this->unit = $unit;
+                return;
+            }
+        }
+
+        $this->unit = '';
+        $this->value = floatval($length);
+    }
+
+    /**
+     * Get the unit type of this css length.
+     * Units are standardised to be lower-cased.
+     *
+     * @return string
+     */
+    public function getUnit(): string
+    {
+        return $this->unit;
+    }
+
+    /**
+     * Get this CSS length in the equivalent pixel count size.
+     *
+     * @param float $referenceSize
+     * @param float $dpi
+     *
+     * @return float
+     */
+    public function toPixels(float $referenceSize = 11.0, float $dpi = 96.0): float
+    {
+        // Standard relative units
+        if (in_array($this->unit, ['em', 'rem', 'ex', 'ch'])) {
+            return $this->value * $referenceSize;
+        }
+
+        // Percentage relative units
+        if (in_array($this->unit, ['%', 'vw', 'vh', 'vmin', 'vmax'])) {
+            return $this->value * ($referenceSize / 100);
+        }
+
+        // Inch relative units
+        if (in_array($this->unit, array_keys(static::$inchDivisions))) {
+            $inchValue = $this->value * $dpi;
+            $division = static::$inchDivisions[$this->unit];
+            return $inchValue / $division;
+        }
+
+        return $this->value;
+    }
+}

vendor/dompdf/php-svg-lib/src/Svg/DefaultStyle.php

@@ -0,0 +1,28 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg;
+
+class DefaultStyle extends Style
+{
+    public $color = [0, 0, 0, 1];
+    public $opacity = 1.0;
+    public $display = 'inline';
+
+    public $fill = [0, 0, 0, 1];
+    public $fillOpacity = 1.0;
+    public $fillRule = 'nonzero';
+
+    public $stroke = 'none';
+    public $strokeOpacity = 1.0;
+    public $strokeLinecap = 'butt';
+    public $strokeLinejoin = 'miter';
+    public $strokeMiterlimit = 4;
+    public $strokeWidth = 1.0;
+    public $strokeDasharray = 0;
+    public $strokeDashoffset = 0;
+}

vendor/dompdf/php-svg-lib/src/Svg/Document.php

@@ -0,0 +1,444 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg;
+
+use Svg\Surface\SurfaceInterface;
+use Svg\Tag\AbstractTag;
+use Svg\Tag\Anchor;
+use Svg\Tag\Circle;
+use Svg\Tag\Ellipse;
+use Svg\Tag\Group;
+use Svg\Tag\ClipPath;
+use Svg\Tag\Image;
+use Svg\Tag\Line;
+use Svg\Tag\LinearGradient;
+use Svg\Tag\Path;
+use Svg\Tag\Polygon;
+use Svg\Tag\Polyline;
+use Svg\Tag\Rect;
+use Svg\Tag\Stop;
+use Svg\Tag\Symbol;
+use Svg\Tag\Text;
+use Svg\Tag\StyleTag;
+use Svg\Tag\UseTag;
+
+class Document extends AbstractTag
+{
+    protected $filename;
+    protected $_defs_depth = 0;
+    public $inDefs = false;
+
+    protected $x;
+    protected $y;
+    protected $width;
+    protected $height;
+
+    protected $subPathInit;
+    protected $pathBBox;
+    protected $viewBox;
+
+    /** @var SurfaceInterface */
+    protected $surface;
+
+    /** @var AbstractTag[] */
+    protected $stack = array();
+
+    /** @var AbstractTag[] */
+    protected $defs = array();
+
+    /** @var \Sabberworm\CSS\CSSList\Document[] */
+    protected $styleSheets = array();
+
+    public $allowExternalReferences = true;
+
+    public function loadFile($filename)
+    {
+        $this->filename = $filename;
+    }
+
+    protected function initParser() {
+        $parser = xml_parser_create("utf-8");
+        xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, false);
+        xml_set_element_handler(
+            $parser,
+            array($this, "_tagStart"),
+            array($this, "_tagEnd")
+        );
+        xml_set_character_data_handler(
+            $parser,
+            array($this, "_charData")
+        );
+
+        return $parser;
+    }
+
+    public function __construct() {
+
+    }
+
+    /**
+     * Increase the nesting level for defs-like elements
+     *
+     * @return int
+     */
+    public function enterDefs () {
+        $this->_defs_depth++;
+        $this->inDefs = true;
+        return $this->_defs_depth;
+    }
+
+    /**
+     * Decrease the nesting level for defs-like elements
+     *
+     * @return int
+     */
+    public function exitDefs () {
+        $this->_defs_depth--;
+        if ($this->_defs_depth < 0) {
+            $this->_defs_depth = 0;
+        }
+        $this->inDefs = ($this->_defs_depth > 0 ? true : false);
+        return $this->_defs_depth;
+    }
+
+    /**
+     * @return SurfaceInterface
+     */
+    public function getSurface()
+    {
+        return $this->surface;
+    }
+
+    public function getStack()
+    {
+        return $this->stack;
+    }
+
+    public function getWidth()
+    {
+        return $this->width;
+    }
+
+    public function getHeight()
+    {
+        return $this->height;
+    }
+
+    public function getDiagonal()
+    {
+        return sqrt(($this->width)**2 + ($this->height)**2) / sqrt(2);
+    }
+
+    public function getDimensions() {
+        $rootAttributes = null;
+
+        $parser = xml_parser_create("utf-8");
+        xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, false);
+        xml_set_element_handler(
+            $parser,
+            function ($parser, $name, $attributes) use (&$rootAttributes) {
+                if ($name === "svg" && $rootAttributes === null) {
+                    $attributes = array_change_key_case($attributes, CASE_LOWER);
+
+                    $rootAttributes = $attributes;
+                }
+            },
+            function ($parser, $name) {}
+        );
+
+        $fp = fopen($this->filename, "r");
+        while ($line = fread($fp, 8192)) {
+            xml_parse($parser, $line, false);
+
+            if ($rootAttributes !== null) {
+                break;
+            }
+        }
+        xml_parse($parser, "", true);
+
+        xml_parser_free($parser);
+
+        return $this->handleSizeAttributes($rootAttributes);
+    }
+
+    public function handleSizeAttributes($attributes){
+        if ($this->width === null) {
+            if (isset($attributes["width"])) {
+                $width = $this->convertSize($attributes["width"], 400);
+                $this->width  = $width;
+            }
+
+            if (isset($attributes["height"])) {
+                $height = $this->convertSize($attributes["height"], 300);
+                $this->height = $height;
+            }
+
+            if (isset($attributes['viewbox'])) {
+                $viewBox = preg_split('/[\s,]+/is', trim($attributes['viewbox']));
+                if (count($viewBox) == 4) {
+                    $this->x = $viewBox[0];
+                    $this->y = $viewBox[1];
+
+                    if (!$this->width) {
+                        $this->width = $viewBox[2];
+                    }
+                    if (!$this->height) {
+                        $this->height = $viewBox[3];
+                    }
+                }
+            }
+        }
+
+        return array(
+            0        => $this->width,
+            1        => $this->height,
+
+            "width"  => $this->width,
+            "height" => $this->height,
+        );
+    }
+
+    public function getDocument(){
+        return $this;
+    }
+
+    /**
+     * Append a style sheet
+     *
+     * @param \Sabberworm\CSS\CSSList\Document $stylesheet
+     */
+    public function appendStyleSheet($stylesheet) {
+        $this->styleSheets[] = $stylesheet;
+    }
+
+    /**
+     * Get the document style sheets
+     *
+     * @return \Sabberworm\CSS\CSSList\Document[]
+     */
+    public function getStyleSheets() {
+        return $this->styleSheets;
+    }
+
+    protected function before($attributes)
+    {
+        $surface = $this->getSurface();
+
+        $style = new DefaultStyle($this);
+        $style->inherit($this);
+        $style->fromAttributes($attributes);
+
+        $this->setStyle($style);
+
+        $surface->setStyle($style);
+    }
+
+    public function render(SurfaceInterface $surface)
+    {
+        $this->_defs_depth = 0;
+        $this->inDefs = false;
+        $this->surface = $surface;
+
+        $parser = $this->initParser();
+
+        if ($this->x || $this->y) {
+            $surface->translate(-$this->x, -$this->y);
+        }
+
+        $fp = fopen($this->filename, "r");
+        while ($line = fread($fp, 8192)) {
+            xml_parse($parser, $line, false);
+        }
+
+        xml_parse($parser, "", true);
+
+        xml_parser_free($parser);
+    }
+
+    protected function svgOffset($attributes)
+    {
+        $this->attributes = $attributes;
+
+        $this->handleSizeAttributes($attributes);
+    }
+
+    public function getDef($id) {
+        $id = ltrim($id, "#");
+
+        return isset($this->defs[$id]) ? $this->defs[$id] : null;
+    }
+
+    private function _tagStart($parser, $name, $attributes)
+    {
+        $this->x = 0;
+        $this->y = 0;
+
+        $tag = null;
+
+        $attributes = array_change_key_case($attributes, CASE_LOWER);
+
+        switch (strtolower($name)) {
+            case 'defs':
+                $this->enterDefs();
+                return;
+
+            case 'svg':
+                if (count($this->attributes)) {
+                    $tag = new Group($this, $name);
+                }
+                else {
+                    $tag = $this;
+                    $this->svgOffset($attributes);
+                }
+                break;
+
+            case 'path':
+                $tag = new Path($this, $name);
+                break;
+
+            case 'rect':
+                $tag = new Rect($this, $name);
+                break;
+
+            case 'circle':
+                $tag = new Circle($this, $name);
+                break;
+
+            case 'ellipse':
+                $tag = new Ellipse($this, $name);
+                break;
+
+            case 'image':
+                $tag = new Image($this, $name);
+                break;
+
+            case 'line':
+                $tag = new Line($this, $name);
+                break;
+
+            case 'polyline':
+                $tag = new Polyline($this, $name);
+                break;
+
+            case 'polygon':
+                $tag = new Polygon($this, $name);
+                break;
+
+            case 'lineargradient':
+                $tag = new LinearGradient($this, $name);
+                break;
+
+            case 'radialgradient':
+                $tag = new LinearGradient($this, $name);
+                break;
+
+            case 'stop':
+                $tag = new Stop($this, $name);
+                break;
+
+            case 'style':
+                $tag = new StyleTag($this, $name);
+                break;
+
+            case 'a':
+                $tag = new Anchor($this, $name);
+                break;
+
+            case 'g':
+                $tag = new Group($this, $name);
+                break;
+
+            case 'symbol':
+                $this->enterDefs();
+                $tag = new Symbol($this, $name);
+                break;
+    
+            case 'clippath':
+                $tag = new ClipPath($this, $name);
+                break;
+
+            case 'use':
+                $tag = new UseTag($this, $name);
+                break;
+
+            case 'text':
+                $tag = new Text($this, $name);
+                break;
+
+            case 'desc':
+                return;
+        }
+
+        if ($tag) {
+            if (isset($attributes["id"])) {
+                $this->defs[$attributes["id"]] = $tag;
+            }
+            else {
+                /** @var AbstractTag $top */
+                $top = end($this->stack);
+                if ($top && $top != $tag) {
+                    $top->children[] = $tag;
+                }
+            }
+
+            $this->stack[] = $tag;
+
+            $tag->handle($attributes);
+        }
+    }
+
+    function _charData($parser, $data)
+    {
+        $stack_top = end($this->stack);
+
+        if ($stack_top instanceof Text || $stack_top instanceof StyleTag) {
+            $stack_top->appendText($data);
+        }
+    }
+
+    function _tagEnd($parser, $name)
+    {
+        /** @var AbstractTag $tag */
+        $tag = null;
+        switch (strtolower($name)) {
+            case 'defs':
+                $this->exitDefs();
+                return;
+
+            case 'symbol':
+                $this->exitDefs();
+                $tag = array_pop($this->stack);
+                break;
+    
+            case 'svg':
+            case 'path':
+            case 'rect':
+            case 'circle':
+            case 'ellipse':
+            case 'image':
+            case 'line':
+            case 'polyline':
+            case 'polygon':
+            case 'radialgradient':
+            case 'lineargradient':
+            case 'stop':
+            case 'style':
+            case 'text':
+            case 'g':
+            case 'clippath':
+            case 'use':
+            case 'a':
+                $tag = array_pop($this->stack);
+                break;
+        }
+
+        if ((!$this->inDefs && $tag) || $tag instanceof StyleTag) {
+            $tag->handleEnd();
+        }
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Gradient/Stop.php

@@ -0,0 +1,15 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Gradient;
+
+class Stop
+{
+    public $offset;
+    public $color;
+    public $opacity = 1.0;
+}

vendor/dompdf/php-svg-lib/src/Svg/Style.php

@@ -0,0 +1,564 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg;
+
+use Svg\Tag\AbstractTag;
+
+class Style
+{
+    const TYPE_COLOR = 1;
+    const TYPE_LENGTH = 2;
+    const TYPE_NAME = 3;
+    const TYPE_ANGLE = 4;
+    const TYPE_NUMBER = 5;
+
+    private $_document;
+    private $_parentStyle;
+
+    public $color;
+    public $opacity;
+    public $display;
+
+    public $fill;
+    public $fillOpacity;
+    public $fillRule;
+
+    public $stroke;
+    public $strokeOpacity;
+    public $strokeLinecap;
+    public $strokeLinejoin;
+    public $strokeMiterlimit;
+    public $strokeWidth;
+    public $strokeDasharray;
+    public $strokeDashoffset;
+
+    public $fontFamily = 'serif';
+    public $fontSize = 12;
+    public $fontWeight = 'normal';
+    public $fontStyle = 'normal';
+    public $textAnchor = 'start';
+
+    public function __construct($document = null) {
+        if ($document !== null) {
+            $this->_document = $document;
+        }
+    }
+
+    protected function getStyleMap()
+    {
+        return array(
+            'color'             => array('color', self::TYPE_COLOR),
+            'opacity'           => array('opacity', self::TYPE_NUMBER),
+            'display'           => array('display', self::TYPE_NAME),
+
+            'fill'              => array('fill', self::TYPE_COLOR),
+            'fill-opacity'      => array('fillOpacity', self::TYPE_NUMBER),
+            'fill-rule'         => array('fillRule', self::TYPE_NAME),
+
+            'stroke'            => array('stroke', self::TYPE_COLOR),
+            'stroke-dasharray'  => array('strokeDasharray', self::TYPE_NAME),
+            'stroke-dashoffset' => array('strokeDashoffset', self::TYPE_NUMBER),
+            'stroke-linecap'    => array('strokeLinecap', self::TYPE_NAME),
+            'stroke-linejoin'   => array('strokeLinejoin', self::TYPE_NAME),
+            'stroke-miterlimit' => array('strokeMiterlimit', self::TYPE_NUMBER),
+            'stroke-opacity'    => array('strokeOpacity', self::TYPE_NUMBER),
+            'stroke-width'      => array('strokeWidth', self::TYPE_NUMBER),
+
+            'font-family'       => array('fontFamily', self::TYPE_NAME),
+            'font-size'         => array('fontSize', self::TYPE_NUMBER),
+            'font-weight'       => array('fontWeight', self::TYPE_NAME),
+            'font-style'        => array('fontStyle', self::TYPE_NAME),
+            'text-anchor'       => array('textAnchor', self::TYPE_NAME),
+        );
+    }
+
+    /**
+     * @param $attributes
+     *
+     * @return Style
+     */
+    public function fromAttributes($attributes)
+    {
+        $this->fillStyles($attributes);
+
+        if (isset($attributes["style"])) {
+            $styles = self::parseCssStyle($attributes["style"]);
+            $this->fillStyles($styles);
+        }
+    }
+
+    public function inherit(AbstractTag $tag) {
+        $group = $tag->getParentGroup();
+        if ($group) {
+            $parent_style = $group->getStyle();
+            $this->_parentStyle = $parent_style;
+            foreach ($parent_style as $_key => $_value) {
+                if ($_value !== null) {
+                    $this->$_key = $_value;
+                }
+            }
+        }
+    }
+
+    public function fromStyleSheets(AbstractTag $tag, $attributes) {
+        $class = isset($attributes["class"]) ? preg_split('/\s+/', trim($attributes["class"])) : null;
+
+        $stylesheets = $tag->getDocument()->getStyleSheets();
+
+        $styles = array();
+
+        foreach ($stylesheets as $_sc) {
+
+            /** @var \Sabberworm\CSS\RuleSet\DeclarationBlock $_decl */
+            foreach ($_sc->getAllDeclarationBlocks() as $_decl) {
+
+                /** @var \Sabberworm\CSS\Property\Selector $_selector */
+                foreach ($_decl->getSelectors() as $_selector) {
+                    $_selector = $_selector->getSelector();
+
+                    // Match class name
+                    if ($class !== null) {
+                        foreach ($class as $_class) {
+                            if ($_selector === ".$_class") {
+                                /** @var \Sabberworm\CSS\Rule\Rule $_rule */
+                                foreach ($_decl->getRules() as $_rule) {
+                                    $styles[$_rule->getRule()] = $_rule->getValue() . "";
+                                }
+
+                                break 2;
+                            }
+                        }
+                    }
+
+                    // Match tag name
+                    if ($_selector === $tag->tagName) {
+                        /** @var \Sabberworm\CSS\Rule\Rule $_rule */
+                        foreach ($_decl->getRules() as $_rule) {
+                            $styles[$_rule->getRule()] = $_rule->getValue() . "";
+                        }
+
+                        break;
+                    }
+                }
+            }
+        }
+
+        $this->fillStyles($styles);
+    }
+
+    protected function fillStyles($styles)
+    {
+        $style_map = $this->getStyleMap();
+        foreach ($style_map as $from => $spec) {
+            if (isset($styles[$from])) {
+                list($to, $type) = $spec;
+                $value = null;
+                switch ($type) {
+                    case self::TYPE_COLOR:
+                        $value = self::parseColor($styles[$from]);
+                        if ($value === "currentcolor") {
+                            if ($type === "color") {
+                                $value = $this->_parentStyle->color;
+                            } else {
+                                $value = $this->color;
+                            }
+                        }
+                        if (is_array($value) && $value[3] !== 1.0 && array_key_exists("{$from}-opacity", $style_map) === true) {
+                            $styles["{$from}-opacity"] = $value[3];
+                        }
+                        break;
+
+                    case self::TYPE_NUMBER:
+                        $value = ($styles[$from] === null) ? null : (float)$styles[$from];
+                        break;
+
+                    default:
+                        $value = $styles[$from];
+                }
+
+                if ($from === "font-family") {
+                    $scheme = \strtolower(parse_url($value, PHP_URL_SCHEME) ?: "");
+                    if (
+                        $scheme === "phar" || \strtolower(\substr($value, 0, 7)) === "phar://"
+                        || ($this->_document !== null && $this->_document->allowExternalReferences === false && $scheme !== "data")
+                    ) {
+                        continue;
+                    }
+                }
+
+                if ($value !== null) {
+                    $this->$to = $value;
+                }
+            }
+        }
+    }
+
+    static function parseColor($color)
+    {
+        $color = strtolower(trim($color));
+
+        $parts = preg_split('/[^,]\s+/', $color, 2);
+
+        if (count($parts) == 2) {
+            $color = $parts[1];
+        } else {
+            $color = $parts[0];
+        }
+
+        if ($color === "none") {
+            return "none";
+        }
+
+        if ($color === "currentcolor") {
+            return "currentcolor";
+        }
+
+        if ($color === "transparent") {
+            return [0.0, 0.0, 0.0, 0.0];
+        }
+
+        // SVG color name
+        if (isset(self::$colorNames[$color])) {
+            return self::parseHexColor(self::$colorNames[$color]);
+        }
+
+        // Hex color
+        if ($color[0] === "#") {
+            return self::parseHexColor($color);
+        }
+
+        // RGB color
+        if (strpos($color, "rgb") !== false) {
+            return self::getQuad($color);
+        }
+
+        // HSL color
+        if (strpos($color, "hsl") !== false) {
+            $quad = self::getQuad($color, true);
+
+            if ($quad == null) {
+                return null;
+            }
+
+            list($h, $s, $l, $a) = $quad;
+
+            $r = $l;
+            $g = $l;
+            $b = $l;
+            $v = ($l <= 0.5) ? ($l * (1.0 + $s)) : ($l + $s - $l * $s);
+            if ($v > 0) {
+                $m = $l + $l - $v;
+                $sv = ($v - $m) / $v;
+                $h *= 6.0;
+                $sextant = floor($h);
+                $fract = $h - $sextant;
+                $vsf = $v * $sv * $fract;
+                $mid1 = $m + $vsf;
+                $mid2 = $v - $vsf;
+
+                switch ($sextant) {
+                    case 0:
+                        $r = $v;
+                        $g = $mid1;
+                        $b = $m;
+                        break;
+                    case 1:
+                        $r = $mid2;
+                        $g = $v;
+                        $b = $m;
+                        break;
+                    case 2:
+                        $r = $m;
+                        $g = $v;
+                        $b = $mid1;
+                        break;
+                    case 3:
+                        $r = $m;
+                        $g = $mid2;
+                        $b = $v;
+                        break;
+                    case 4:
+                        $r = $mid1;
+                        $g = $m;
+                        $b = $v;
+                        break;
+                    case 5:
+                        $r = $v;
+                        $g = $m;
+                        $b = $mid2;
+                        break;
+                }
+            }
+            $a = $a * 255;
+
+            return array(
+                $r * 255.0,
+                $g * 255.0,
+                $b * 255.0,
+                $a
+            );
+        }
+
+        // Gradient
+        if (strpos($color, "url(#") !== false) {
+            $i = strpos($color, "(");
+            $j = strpos($color, ")");
+
+            // Bad url format
+            if ($i === false || $j === false) {
+                return null;
+            }
+
+            //FIXME: gradients not supported?
+            return null; // trim(substr($color, $i + 1, $j - $i - 1));
+        }
+
+        return null;
+    }
+
+    static function getQuad($color, $percent = false) {
+        $i = strpos($color, "(");
+        $j = strpos($color, ")");
+
+        // Bad color value
+        if ($i === false || $j === false) {
+            return null;
+        }
+
+        $quad = preg_split("/\\s*[,\\/]\\s*/", trim(substr($color, $i + 1, $j - $i - 1)));
+        if (!isset($quad[3])) {
+            $quad[3] = "1";
+        }
+
+        if (count($quad) != 3 && count($quad) != 4) {
+            return null;
+        }
+
+        foreach (array_keys($quad) as $c) {
+            $quad[$c] = trim($quad[$c]);
+
+            if ($percent) {
+                if ($quad[$c][strlen($quad[$c]) - 1] === "%") {
+                    $quad[$c] = floatval($quad[$c]) / 100;
+                } else {
+                    $quad[$c] = floatval($quad[$c]) / 255;
+                }
+            } else {
+                if ($quad[$c][strlen($quad[$c]) - 1] === "%") {
+                    $quad[$c] = floatval($quad[$c]) * 2.55;
+                } else {
+                    $quad[$c] = floatval($quad[$c]);
+                }
+            }
+        }
+
+        return $quad;
+    }
+
+    static function parseHexColor($hex)
+    {
+        $c = array(0.0, 0.0, 0.0, 1.0);
+
+        // #FFFFFF
+        if (isset($hex[6])) {
+            $c[0] = hexdec(substr($hex, 1, 2));
+            $c[1] = hexdec(substr($hex, 3, 2));
+            $c[2] = hexdec(substr($hex, 5, 2));
+
+            if (isset($hex[7])) {
+                $alpha = substr($hex, 7, 2);
+                if (ctype_xdigit($alpha)) {
+                    $c[3] = round(hexdec($alpha)/255, 2);
+                }
+            }
+        } else {
+            $c[0] = hexdec($hex[1] . $hex[1]);
+            $c[1] = hexdec($hex[2] . $hex[2]);
+            $c[2] = hexdec($hex[3] . $hex[3]);
+
+            if (isset($hex[4])) {
+                if (ctype_xdigit($hex[4])) {
+                    $c[3] = round(hexdec($hex[4] . $hex[4])/255, 2);
+                }
+            }
+        }
+
+        return $c;
+    }
+
+    /**
+     * Simple CSS parser
+     *
+     * @param $style
+     *
+     * @return array
+     */
+    static function parseCssStyle($style)
+    {
+        $matches = array();
+        preg_match_all("/([a-z-]+)\\s*:\\s*([^;$]+)/si", $style, $matches, PREG_SET_ORDER);
+
+        $styles = array();
+        foreach ($matches as $match) {
+            $styles[$match[1]] = $match[2];
+        }
+
+        return $styles;
+    }
+
+    static $colorNames = array(
+        'antiquewhite'         => '#FAEBD7',
+        'aqua'                 => '#00FFFF',
+        'aquamarine'           => '#7FFFD4',
+        'beige'                => '#F5F5DC',
+        'black'                => '#000000',
+        'blue'                 => '#0000FF',
+        'brown'                => '#A52A2A',
+        'cadetblue'            => '#5F9EA0',
+        'chocolate'            => '#D2691E',
+        'cornflowerblue'       => '#6495ED',
+        'crimson'              => '#DC143C',
+        'darkblue'             => '#00008B',
+        'darkgoldenrod'        => '#B8860B',
+        'darkgreen'            => '#006400',
+        'darkmagenta'          => '#8B008B',
+        'darkorange'           => '#FF8C00',
+        'darkred'              => '#8B0000',
+        'darkseagreen'         => '#8FBC8F',
+        'darkslategray'        => '#2F4F4F',
+        'darkviolet'           => '#9400D3',
+        'deepskyblue'          => '#00BFFF',
+        'dodgerblue'           => '#1E90FF',
+        'firebrick'            => '#B22222',
+        'forestgreen'          => '#228B22',
+        'fuchsia'              => '#FF00FF',
+        'gainsboro'            => '#DCDCDC',
+        'gold'                 => '#FFD700',
+        'gray'                 => '#808080',
+        'green'                => '#008000',
+        'greenyellow'          => '#ADFF2F',
+        'hotpink'              => '#FF69B4',
+        'indigo'               => '#4B0082',
+        'khaki'                => '#F0E68C',
+        'lavenderblush'        => '#FFF0F5',
+        'lemonchiffon'         => '#FFFACD',
+        'lightcoral'           => '#F08080',
+        'lightgoldenrodyellow' => '#FAFAD2',
+        'lightgreen'           => '#90EE90',
+        'lightsalmon'          => '#FFA07A',
+        'lightskyblue'         => '#87CEFA',
+        'lightslategray'       => '#778899',
+        'lightyellow'          => '#FFFFE0',
+        'lime'                 => '#00FF00',
+        'limegreen'            => '#32CD32',
+        'magenta'              => '#FF00FF',
+        'maroon'               => '#800000',
+        'mediumaquamarine'     => '#66CDAA',
+        'mediumorchid'         => '#BA55D3',
+        'mediumseagreen'       => '#3CB371',
+        'mediumspringgreen'    => '#00FA9A',
+        'mediumvioletred'      => '#C71585',
+        'midnightblue'         => '#191970',
+        'mintcream'            => '#F5FFFA',
+        'moccasin'             => '#FFE4B5',
+        'navy'                 => '#000080',
+        'olive'                => '#808000',
+        'orange'               => '#FFA500',
+        'orchid'               => '#DA70D6',
+        'palegreen'            => '#98FB98',
+        'palevioletred'        => '#D87093',
+        'peachpuff'            => '#FFDAB9',
+        'pink'                 => '#FFC0CB',
+        'powderblue'           => '#B0E0E6',
+        'purple'               => '#800080',
+        'red'                  => '#FF0000',
+        'royalblue'            => '#4169E1',
+        'salmon'               => '#FA8072',
+        'seagreen'             => '#2E8B57',
+        'sienna'               => '#A0522D',
+        'silver'               => '#C0C0C0',
+        'skyblue'              => '#87CEEB',
+        'slategray'            => '#708090',
+        'springgreen'          => '#00FF7F',
+        'steelblue'            => '#4682B4',
+        'tan'                  => '#D2B48C',
+        'teal'                 => '#008080',
+        'thistle'              => '#D8BFD8',
+        'turquoise'            => '#40E0D0',
+        'violetred'            => '#D02090',
+        'white'                => '#FFFFFF',
+        'yellow'               => '#FFFF00',
+        'aliceblue'            => '#f0f8ff',
+        'azure'                => '#f0ffff',
+        'bisque'               => '#ffe4c4',
+        'blanchedalmond'       => '#ffebcd',
+        'blueviolet'           => '#8a2be2',
+        'burlywood'            => '#deb887',
+        'chartreuse'           => '#7fff00',
+        'coral'                => '#ff7f50',
+        'cornsilk'             => '#fff8dc',
+        'cyan'                 => '#00ffff',
+        'darkcyan'             => '#008b8b',
+        'darkgray'             => '#a9a9a9',
+        'darkgrey'             => '#a9a9a9',
+        'darkkhaki'            => '#bdb76b',
+        'darkolivegreen'       => '#556b2f',
+        'darkorchid'           => '#9932cc',
+        'darksalmon'           => '#e9967a',
+        'darkslateblue'        => '#483d8b',
+        'darkslategrey'        => '#2f4f4f',
+        'darkturquoise'        => '#00ced1',
+        'deeppink'             => '#ff1493',
+        'dimgray'              => '#696969',
+        'dimgrey'              => '#696969',
+        'floralwhite'          => '#fffaf0',
+        'ghostwhite'           => '#f8f8ff',
+        'goldenrod'            => '#daa520',
+        'grey'                 => '#808080',
+        'honeydew'             => '#f0fff0',
+        'indianred'            => '#cd5c5c',
+        'ivory'                => '#fffff0',
+        'lavender'             => '#e6e6fa',
+        'lawngreen'            => '#7cfc00',
+        'lightblue'            => '#add8e6',
+        'lightcyan'            => '#e0ffff',
+        'lightgray'            => '#d3d3d3',
+        'lightgrey'            => '#d3d3d3',
+        'lightpink'            => '#ffb6c1',
+        'lightseagreen'        => '#20b2aa',
+        'lightslategrey'       => '#778899',
+        'lightsteelblue'       => '#b0c4de',
+        'linen'                => '#faf0e6',
+        'mediumblue'           => '#0000cd',
+        'mediumpurple'         => '#9370db',
+        'mediumslateblue'      => '#7b68ee',
+        'mediumturquoise'      => '#48d1cc',
+        'mistyrose'            => '#ffe4e1',
+        'navajowhite'          => '#ffdead',
+        'oldlace'              => '#fdf5e6',
+        'olivedrab'            => '#6b8e23',
+        'orangered'            => '#ff4500',
+        'palegoldenrod'        => '#eee8aa',
+        'paleturquoise'        => '#afeeee',
+        'papayawhip'           => '#ffefd5',
+        'peru'                 => '#cd853f',
+        'plum'                 => '#dda0dd',
+        'rosybrown'            => '#bc8f8f',
+        'saddlebrown'          => '#8b4513',
+        'sandybrown'           => '#f4a460',
+        'seashell'             => '#fff5ee',
+        'slateblue'            => '#6a5acd',
+        'slategrey'            => '#708090',
+        'snow'                 => '#fffafa',
+        'tomato'               => '#ff6347',
+        'violet'               => '#ee82ee',
+        'wheat'                => '#f5deb3',
+        'whitesmoke'           => '#f5f5f5',
+        'yellowgreen'          => '#9acd32',
+    );
+}

vendor/dompdf/php-svg-lib/src/Svg/Surface/SurfaceCpdf.php

@@ -0,0 +1,494 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Surface;
+
+use Svg\Document;
+use Svg\Style;
+
+class SurfaceCpdf implements SurfaceInterface
+{
+    const DEBUG = false;
+
+    /** @var \Svg\Surface\CPdf */
+    private $canvas;
+
+    private $width;
+    private $height;
+
+    /** @var Style */
+    private $style;
+
+    public function __construct(Document $doc, $canvas = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $dimensions = $doc->getDimensions();
+        $w = $dimensions["width"];
+        $h = $dimensions["height"];
+
+        if (!$canvas) {
+            $canvas = new \Svg\Surface\CPdf(array(0, 0, $w, $h));
+            $refl = new \ReflectionClass($canvas);
+            $canvas->fontcache = realpath(dirname($refl->getFileName()) . "/../../fonts/")."/";
+        }
+
+        // Flip PDF coordinate system so that the origin is in
+        // the top left rather than the bottom left
+        $canvas->transform(array(
+            1,  0,
+            0, -1,
+            0, $h
+        ));
+
+        $this->width  = $w;
+        $this->height = $h;
+
+        $this->canvas = $canvas;
+    }
+
+    function out()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        return $this->canvas->output();
+    }
+
+    public function save()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->save();
+    }
+
+    public function restore()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->restore();
+    }
+
+    public function scale($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $this->transform($x, 0, 0, $y, 0, 0);
+    }
+
+    public function rotate($angle)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $a = deg2rad($angle);
+        $cos_a = cos($a);
+        $sin_a = sin($a);
+
+        $this->transform(
+            $cos_a,                         $sin_a,
+            -$sin_a,                         $cos_a,
+            0, 0
+        );
+    }
+
+    public function translate($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $this->transform(
+            1,  0,
+            0,  1,
+            $x, $y
+        );
+    }
+
+    public function transform($a, $b, $c, $d, $e, $f)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $this->canvas->transform(array($a, $b, $c, $d, $e, $f));
+    }
+
+    public function beginPath()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        // TODO: Implement beginPath() method.
+    }
+
+    public function closePath()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->closePath();
+    }
+
+    public function fillStroke(bool $close = false)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->fillStroke($close);
+    }
+
+    public function clip()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->clip();
+    }
+
+    public function fillText($text, $x, $y, $maxWidth = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->addText($x, $y, $this->style->fontSize, $text);
+    }
+
+    public function strokeText($text, $x, $y, $maxWidth = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->addText($x, $y, $this->style->fontSize, $text);
+    }
+
+    public function drawImage($image, $sx, $sy, $sw = null, $sh = null, $dx = null, $dy = null, $dw = null, $dh = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        if (strpos($image, "data:") === 0) {
+            $parts = explode(',', $image, 2);
+
+            $data = $parts[1];
+            $base64 = false;
+
+            $token = strtok($parts[0], ';');
+            while ($token !== false) {
+                if ($token == 'base64') {
+                    $base64 = true;
+                }
+
+                $token = strtok(';');
+            }
+
+            if ($base64) {
+                $data = base64_decode($data);
+            }
+        }
+        else {
+            $data = file_get_contents($image);
+        }
+
+        $image = tempnam(sys_get_temp_dir(), "svg");
+        file_put_contents($image, $data);
+
+        $img = $this->image($image, $sx, $sy, $sw, $sh, "normal");
+
+
+        unlink($image);
+    }
+
+    public static function getimagesize($filename)
+    {
+        static $cache = array();
+
+        if (isset($cache[$filename])) {
+            return $cache[$filename];
+        }
+
+        list($width, $height, $type) = getimagesize($filename);
+
+        if ($width == null || $height == null) {
+            $data = file_get_contents($filename, null, null, 0, 26);
+
+            if (substr($data, 0, 2) === "BM") {
+                $meta = unpack('vtype/Vfilesize/Vreserved/Voffset/Vheadersize/Vwidth/Vheight', $data);
+                $width = (int)$meta['width'];
+                $height = (int)$meta['height'];
+                $type = IMAGETYPE_BMP;
+            }
+        }
+
+        return $cache[$filename] = array($width, $height, $type);
+    }
+
+    function image($img, $x, $y, $w, $h, $resolution = "normal")
+    {
+        list($width, $height, $type) = $this->getimagesize($img);
+
+        switch ($type) {
+            case IMAGETYPE_JPEG:
+                $this->canvas->addJpegFromFile($img, $x, $y - $h, $w, $h);
+                break;
+
+            case IMAGETYPE_GIF:
+            case IMAGETYPE_BMP:
+                // @todo use cache for BMP and GIF
+                $img = $this->_convert_gif_bmp_to_png($img, $type);
+
+            case IMAGETYPE_PNG:
+                $this->canvas->addPngFromFile($img, $x, $y - $h, $w, $h);
+                break;
+
+            default:
+        }
+    }
+
+    public function lineTo($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->lineTo($x, $y);
+    }
+
+    public function moveTo($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->moveTo($x, $y);
+    }
+
+    public function quadraticCurveTo($cpx, $cpy, $x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        // FIXME not accurate
+        $this->canvas->quadTo($cpx, $cpy, $x, $y);
+    }
+
+    public function bezierCurveTo($cp1x, $cp1y, $cp2x, $cp2y, $x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->curveTo($cp1x, $cp1y, $cp2x, $cp2y, $x, $y);
+    }
+
+    public function arcTo($x1, $y1, $x2, $y2, $radius)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+    }
+
+    public function arc($x, $y, $radius, $startAngle, $endAngle, $anticlockwise = false)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->ellipse($x, $y, $radius, $radius, 0, 8, $startAngle, $endAngle, false, false, false, true);
+    }
+
+    public function circle($x, $y, $radius)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->ellipse($x, $y, $radius, $radius, 0, 8, 0, 360, true, false, false, false);
+    }
+
+    public function ellipse($x, $y, $radiusX, $radiusY, $rotation, $startAngle, $endAngle, $anticlockwise)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->ellipse($x, $y, $radiusX, $radiusY, 0, 8, 0, 360, false, false, false, false);
+    }
+
+    public function fillRect($x, $y, $w, $h)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->rect($x, $y, $w, $h);
+        $this->fill();
+    }
+
+    public function rect($x, $y, $w, $h, $rx = 0, $ry = 0)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $canvas = $this->canvas;
+
+        if ($rx <= 0.000001/* && $ry <= 0.000001*/) {
+            $canvas->rect($x, $y, $w, $h);
+
+            return;
+        }
+
+        $rx = min($rx, $w / 2);
+        $rx = min($rx, $h / 2);
+
+        /* Define a path for a rectangle with corners rounded by a given radius.
+         * Start from the lower left corner and proceed counterclockwise.
+         */
+        $this->moveTo($x + $rx, $y);
+
+        /* Start of the arc segment in the lower right corner */
+        $this->lineTo($x + $w - $rx, $y);
+
+        /* Arc segment in the lower right corner */
+        $this->arc($x + $w - $rx, $y + $rx, $rx, 270, 360);
+
+        /* Start of the arc segment in the upper right corner */
+        $this->lineTo($x + $w, $y + $h - $rx );
+
+        /* Arc segment in the upper right corner */
+        $this->arc($x + $w - $rx, $y + $h - $rx, $rx, 0, 90);
+
+        /* Start of the arc segment in the upper left corner */
+        $this->lineTo($x + $rx, $y + $h);
+
+        /* Arc segment in the upper left corner */
+        $this->arc($x + $rx, $y + $h - $rx, $rx, 90, 180);
+
+        /* Start of the arc segment in the lower left corner */
+        $this->lineTo($x , $y + $rx);
+
+        /* Arc segment in the lower left corner */
+        $this->arc($x + $rx, $y + $rx, $rx, 180, 270);
+    }
+
+    public function fill()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->fill();
+    }
+
+    public function strokeRect($x, $y, $w, $h)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->rect($x, $y, $w, $h);
+        $this->stroke();
+    }
+
+    public function stroke(bool $close = false)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->stroke($close);
+    }
+
+    public function endPath()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->endPath();
+    }
+
+    public function measureText($text)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $style = $this->getStyle();
+        $this->setFont($style->fontFamily, $style->fontStyle, $style->fontWeight);
+
+        return $this->canvas->getTextWidth($this->getStyle()->fontSize, $text);
+    }
+
+    public function getStyle()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        return $this->style;
+    }
+
+    public function setStyle(Style $style)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $this->style = $style;
+        $canvas = $this->canvas;
+
+        if (is_array($style->stroke) && $stroke = $style->stroke) {
+            $canvas->setStrokeColor(array((float)$stroke[0]/255, (float)$stroke[1]/255, (float)$stroke[2]/255), true);
+        }
+
+        if (is_array($style->fill) && $fill = $style->fill) {
+            $canvas->setColor(array((float)$fill[0]/255, (float)$fill[1]/255, (float)$fill[2]/255), true);
+        }
+
+        if ($fillRule = strtolower($style->fillRule)) {
+            $canvas->setFillRule($fillRule);
+        }
+
+        $opacity = $style->opacity;
+        if ($opacity !== null && $opacity < 1.0) {
+            $canvas->setLineTransparency("Normal", $opacity);
+            $canvas->currentLineTransparency = null;
+
+            $canvas->setFillTransparency("Normal", $opacity);
+            $canvas->currentFillTransparency = null;
+        }
+        else {
+            $fillOpacity = $style->fillOpacity;
+            if ($fillOpacity !== null && $fillOpacity < 1.0) {
+                $canvas->setFillTransparency("Normal", $fillOpacity);
+                $canvas->currentFillTransparency = null;
+            }
+
+            $strokeOpacity = $style->strokeOpacity;
+            if ($strokeOpacity !== null && $strokeOpacity < 1.0) {
+                $canvas->setLineTransparency("Normal", $strokeOpacity);
+                $canvas->currentLineTransparency = null;
+            }
+        }
+
+        $dashArray = null;
+        if ($style->strokeDasharray) {
+            $dashArray = preg_split('/\s*,\s*/', $style->strokeDasharray);
+        }
+
+
+        $phase=0;
+        if ($style->strokeDashoffset) {
+           $phase = $style->strokeDashoffset;
+        }
+
+
+        $canvas->setLineStyle(
+            $style->strokeWidth,
+            $style->strokeLinecap,
+            $style->strokeLinejoin,
+            $dashArray,
+            $phase
+        );
+
+        $this->setFont($style->fontFamily, $style->fontStyle, $style->fontWeight);
+    }
+
+    public function setFont($family, $style, $weight)
+    {
+        $map = [
+            "serif"      => "times",
+            "sans-serif" => "helvetica",
+            "fantasy"    => "symbol",
+            "cursive"    => "times",
+            "monospace"  => "courier"
+        ];
+
+        $styleMap = [
+            "courier" => [
+                ""   => "Courier",
+                "b"  => "Courier-Bold",
+                "i"  => "Courier-Oblique",
+                "bi" => "Courier-BoldOblique",
+            ],
+            "helvetica" => [
+                ""   => "Helvetica",
+                "b"  => "Helvetica-Bold",
+                "i"  => "Helvetica-Oblique",
+                "bi" => "Helvetica-BoldOblique",
+            ],
+            "symbol" => [
+                "" => "Symbol"
+            ],
+            "times" => [
+                ""   => "Times-Roman",
+                "b"  => "Times-Bold",
+                "i"  => "Times-Italic",
+                "bi" => "Times-BoldItalic",
+            ],
+        ];
+
+        $family_lc = strtolower($family);
+        if (isset($map[$family_lc])) {
+            $family = $map[$family_lc];
+        }
+
+        if (isset($styleMap[$family])) {
+            $key = "";
+
+            $weight = strtolower($weight);
+            if ($weight === "bold" || $weight === "bolder" || (is_numeric($weight) && $weight >= 600)) {
+                $key .= "b";
+            }
+
+            $style = strtolower($style);
+            if ($style === "italic" || $style === "oblique") {
+                $key .= "i";
+            }
+
+            if (isset($styleMap[$family][$key])) {
+                $family = $styleMap[$family][$key];
+            }
+        }
+
+        $this->canvas->selectFont("$family.afm");
+    }
+}

vendor/dompdf/php-svg-lib/src/Svg/Surface/SurfaceInterface.php

@@ -0,0 +1,89 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Surface;
+
+use Svg\Style;
+
+/**
+ * Interface Surface, like CanvasRenderingContext2D
+ *
+ * @package Svg
+ */
+interface SurfaceInterface
+{
+    public function save();
+
+    public function restore();
+
+    // transformations (default transform is the identity matrix)
+    public function scale($x, $y);
+
+    public function rotate($angle);
+
+    public function translate($x, $y);
+
+    public function transform($a, $b, $c, $d, $e, $f);
+
+    // path ends
+    public function beginPath();
+
+    public function closePath();
+
+    public function fill();
+
+    public function stroke(bool $close = false);
+
+    public function endPath();
+
+    public function fillStroke(bool $close = false);
+
+    public function clip();
+
+    // text (see also the CanvasDrawingStyles interface)
+    public function fillText($text, $x, $y, $maxWidth = null);
+
+    public function strokeText($text, $x, $y, $maxWidth = null);
+
+    public function measureText($text);
+
+    // drawing images
+    public function drawImage($image, $sx, $sy, $sw = null, $sh = null, $dx = null, $dy = null, $dw = null, $dh = null);
+
+    // paths
+    public function lineTo($x, $y);
+
+    public function moveTo($x, $y);
+
+    public function quadraticCurveTo($cpx, $cpy, $x, $y);
+
+    public function bezierCurveTo($cp1x, $cp1y, $cp2x, $cp2y, $x, $y);
+
+    public function arcTo($x1, $y1, $x2, $y2, $radius);
+
+    public function circle($x, $y, $radius);
+
+    public function arc($x, $y, $radius, $startAngle, $endAngle, $anticlockwise = false);
+
+    public function ellipse($x, $y, $radiusX, $radiusY, $rotation, $startAngle, $endAngle, $anticlockwise);
+
+    // Rectangle
+    public function rect($x, $y, $w, $h, $rx = 0, $ry = 0);
+
+    public function fillRect($x, $y, $w, $h);
+
+    public function strokeRect($x, $y, $w, $h);
+
+    public function setStyle(Style $style);
+
+    /**
+     * @return Style
+     */
+    public function getStyle();
+
+    public function setFont($family, $style, $weight);
+}

vendor/dompdf/php-svg-lib/src/Svg/Surface/SurfacePDFLib.php

@@ -0,0 +1,429 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Surface;
+
+use Svg\Style;
+use Svg\Document;
+
+class SurfacePDFLib implements SurfaceInterface
+{
+    const DEBUG = false;
+
+    private $canvas;
+
+    private $width;
+    private $height;
+
+    /** @var Style */
+    private $style;
+
+    public function __construct(Document $doc, $canvas = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $dimensions = $doc->getDimensions();
+        $w = $dimensions["width"];
+        $h = $dimensions["height"];
+
+        if (!$canvas) {
+            $canvas = new \PDFlib();
+
+            /* all strings are expected as utf8 */
+            $canvas->set_option("stringformat=utf8");
+            $canvas->set_option("errorpolicy=return");
+
+            /*  open new PDF file; insert a file name to create the PDF on disk */
+            if ($canvas->begin_document("", "") == 0) {
+                die("Error: " . $canvas->get_errmsg());
+            }
+            $canvas->set_info("Creator", "PDFlib starter sample");
+            $canvas->set_info("Title", "starter_graphics");
+
+            $canvas->begin_page_ext($w, $h, "");
+        }
+
+        // Flip PDF coordinate system so that the origin is in
+        // the top left rather than the bottom left
+        $canvas->setmatrix(
+            1, 0,
+            0, -1,
+            0, $h
+        );
+
+        $this->width  = $w;
+        $this->height = $h;
+
+        $this->canvas = $canvas;
+    }
+
+    function out()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $this->canvas->end_page_ext("");
+        $this->canvas->end_document("");
+
+        return $this->canvas->get_buffer();
+    }
+
+    public function save()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->save();
+    }
+
+    public function restore()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->restore();
+    }
+
+    public function scale($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->scale($x, $y);
+    }
+
+    public function rotate($angle)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->rotate($angle);
+    }
+
+    public function translate($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->translate($x, $y);
+    }
+
+    public function transform($a, $b, $c, $d, $e, $f)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->concat($a, $b, $c, $d, $e, $f);
+    }
+
+    public function beginPath()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        // TODO: Implement beginPath() method.
+    }
+
+    public function closePath()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->closepath();
+    }
+
+    public function fillStroke(bool $close = false)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        if ($close) {
+            $this->canvas->closepath_fill_stroke();
+        } else {
+            $this->canvas->fill_stroke();
+        }
+    }
+
+    public function clip()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->clip();
+    }
+
+    public function fillText($text, $x, $y, $maxWidth = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->set_text_pos($x, $y);
+        $this->canvas->show($text);
+    }
+
+    public function strokeText($text, $x, $y, $maxWidth = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        // TODO: Implement drawImage() method.
+    }
+
+    public function drawImage($image, $sx, $sy, $sw = null, $sh = null, $dx = null, $dy = null, $dw = null, $dh = null)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        if (strpos($image, "data:") === 0) {
+            $data = substr($image, strpos($image, ";") + 1);
+            if (strpos($data, "base64") === 0) {
+                $data = base64_decode(substr($data, 7));
+            }
+        }
+        else {
+            $data = file_get_contents($image);
+        }
+
+        $image = tempnam(sys_get_temp_dir(), "svg");
+        file_put_contents($image, $data);
+
+        $img = $this->canvas->load_image("auto", $image, "");
+
+        $sy = $sy - $sh;
+        $this->canvas->fit_image($img, $sx, $sy, 'boxsize={' . "$sw $sh" . '} fitmethod=entire');
+
+        unlink($image);
+    }
+
+    public function lineTo($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->lineto($x, $y);
+    }
+
+    public function moveTo($x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->moveto($x, $y);
+    }
+
+    public function quadraticCurveTo($cpx, $cpy, $x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        // FIXME not accurate
+        $this->canvas->curveTo($cpx, $cpy, $cpx, $cpy, $x, $y);
+    }
+
+    public function bezierCurveTo($cp1x, $cp1y, $cp2x, $cp2y, $x, $y)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->curveto($cp1x, $cp1y, $cp2x, $cp2y, $x, $y);
+    }
+
+    public function arcTo($x1, $y1, $x2, $y2, $radius)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+    }
+
+    public function arc($x, $y, $radius, $startAngle, $endAngle, $anticlockwise = false)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->arc($x, $y, $radius, $startAngle, $endAngle);
+    }
+
+    public function circle($x, $y, $radius)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->circle($x, $y, $radius);
+    }
+
+    public function ellipse($x, $y, $radiusX, $radiusY, $rotation, $startAngle, $endAngle, $anticlockwise)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->ellipse($x, $y, $radiusX, $radiusY);
+    }
+
+    public function fillRect($x, $y, $w, $h)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->rect($x, $y, $w, $h);
+        $this->fill();
+    }
+
+    public function rect($x, $y, $w, $h, $rx = 0, $ry = 0)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $canvas = $this->canvas;
+
+        if ($rx <= 0.000001/* && $ry <= 0.000001*/) {
+            $canvas->rect($x, $y, $w, $h);
+
+            return;
+        }
+
+        /* Define a path for a rectangle with corners rounded by a given radius.
+         * Start from the lower left corner and proceed counterclockwise.
+         */
+        $canvas->moveto($x + $rx, $y);
+
+        /* Start of the arc segment in the lower right corner */
+        $canvas->lineto($x + $w - $rx, $y);
+
+        /* Arc segment in the lower right corner */
+        $canvas->arc($x + $w - $rx, $y + $rx, $rx, 270, 360);
+
+        /* Start of the arc segment in the upper right corner */
+        $canvas->lineto($x + $w, $y + $h - $rx );
+
+        /* Arc segment in the upper right corner */
+        $canvas->arc($x + $w - $rx, $y + $h - $rx, $rx, 0, 90);
+
+        /* Start of the arc segment in the upper left corner */
+        $canvas->lineto($x + $rx, $y + $h);
+
+        /* Arc segment in the upper left corner */
+        $canvas->arc($x + $rx, $y + $h - $rx, $rx, 90, 180);
+
+        /* Start of the arc segment in the lower left corner */
+        $canvas->lineto($x , $y + $rx);
+
+        /* Arc segment in the lower left corner */
+        $canvas->arc($x + $rx, $y + $rx, $rx, 180, 270);
+    }
+
+    public function fill()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->fill();
+    }
+
+    public function strokeRect($x, $y, $w, $h)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->rect($x, $y, $w, $h);
+        $this->stroke();
+    }
+
+    public function stroke(bool $close = false)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        if ($close) {
+            $this->canvas->closepath_stroke();
+        } else {
+            $this->canvas->stroke();
+        }
+    }
+
+    public function endPath()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $this->canvas->endPath();
+    }
+
+    public function measureText($text)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        $style = $this->getStyle();
+        $font = $this->getFont($style->fontFamily, $style->fontStyle);
+
+        return $this->canvas->stringwidth($text, $font, $this->getStyle()->fontSize);
+    }
+
+    public function getStyle()
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+        return $this->style;
+    }
+
+    public function setStyle(Style $style)
+    {
+        if (self::DEBUG) echo __FUNCTION__ . "\n";
+
+        $this->style = $style;
+        $canvas = $this->canvas;
+
+        if (is_array($style->stroke) && $stroke = $style->stroke) {
+            $canvas->setcolor(
+                "stroke",
+                "rgb",
+                $stroke[0] / 255,
+                $stroke[1] / 255,
+                $stroke[2] / 255,
+                null
+            );
+        }
+
+        if (is_array($style->fill) && $fill = $style->fill) {
+            $canvas->setcolor(
+                "fill",
+                "rgb",
+                $fill[0] / 255,
+                $fill[1] / 255,
+                $fill[2] / 255,
+                null
+            );
+        }
+
+        if ($fillRule = strtolower($style->fillRule)) {
+            $map = array(
+                "nonzero" => "winding",
+                "evenodd" => "evenodd",
+            );
+
+            if (isset($map[$fillRule])) {
+                $fillRule = $map[$fillRule];
+
+                $canvas->set_parameter("fillrule", $fillRule);
+            }
+        }
+
+        $opts = array();
+        if ($style->strokeWidth > 0.000001) {
+            $opts[] = "linewidth=$style->strokeWidth";
+        }
+
+        if (in_array($style->strokeLinecap, array("butt", "round", "projecting"))) {
+            $opts[] = "linecap=$style->strokeLinecap";
+        }
+
+        if (in_array($style->strokeLinejoin, array("miter", "round", "bevel"))) {
+            $opts[] = "linejoin=$style->strokeLinejoin";
+        }
+
+        $canvas->set_graphics_option(implode(" ", $opts));
+
+        $opts = array();
+        $opacity = $style->opacity;
+        if ($opacity !== null && $opacity < 1.0) {
+            $opts[] = "opacityfill=$opacity";
+            $opts[] = "opacitystroke=$opacity";
+        }
+        else {
+            $fillOpacity = $style->fillOpacity;
+            if ($fillOpacity !== null && $fillOpacity < 1.0) {
+                $opts[] = "opacityfill=$fillOpacity";
+            }
+
+            $strokeOpacity = $style->strokeOpacity;
+            if ($strokeOpacity !== null && $strokeOpacity < 1.0) {
+                $opts[] = "opacitystroke=$strokeOpacity";
+            }
+        }
+
+        if (count($opts)) {
+            $gs = $canvas->create_gstate(implode(" ", $opts));
+            $canvas->set_gstate($gs);
+        }
+
+        $font = $this->getFont($style->fontFamily, $style->fontStyle);
+        if ($font) {
+            $canvas->setfont($font, $style->fontSize);
+        }
+    }
+
+    private function getFont($family, $style)
+    {
+        $map = array(
+            "serif"      => "Times",
+            "sans-serif" => "Helvetica",
+            "fantasy"    => "Symbol",
+            "cursive"    => "Times",
+            "monospace"  => "Courier",
+
+            "arial"      => "Helvetica",
+            "verdana"    => "Helvetica",
+        );
+
+        $family = strtolower($family);
+        if (isset($map[$family])) {
+            $family = $map[$family];
+        }
+
+        return $this->canvas->load_font($family, "unicode", "fontstyle=$style");
+    }
+
+    public function setFont($family, $style, $weight)
+    {
+        // TODO: Implement setFont() method.
+    }
+}

vendor/dompdf/php-svg-lib/src/Svg/Tag/AbstractTag.php

@@ -0,0 +1,326 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\CssLength;
+use Svg\Document;
+use Svg\Style;
+
+abstract class AbstractTag
+{
+    /** @var Document */
+    protected $document;
+
+    public $tagName;
+
+    /** @var Style */
+    protected $style;
+
+    protected $attributes = array();
+
+    protected $hasShape = true;
+
+    /** @var self[] */
+    protected $children = array();
+
+    public function __construct(Document $document, $tagName)
+    {
+        $this->document = $document;
+        $this->tagName = $tagName;
+    }
+
+    public function getDocument(){
+        return $this->document;
+    }
+
+    /**
+     * @return Group|null
+     */
+    public function getParentGroup() {
+        $stack = $this->getDocument()->getStack();
+        for ($i = count($stack)-2; $i >= 0; $i--) {
+            $tag = $stack[$i];
+
+            if ($tag instanceof Group || $tag instanceof Document) {
+                return $tag;
+            }
+        }
+
+        return null;
+    }
+
+    public function handle($attributes)
+    {
+        $this->attributes = $attributes;
+
+        if (!$this->getDocument()->inDefs || $this instanceof StyleTag) {
+            $this->before($attributes);
+            $this->start($attributes);
+        }
+    }
+
+    public function handleEnd()
+    {
+        if (!$this->getDocument()->inDefs || $this instanceof StyleTag) {
+            $this->end();
+            $this->after();
+        }
+    }
+
+    protected function before($attributes)
+    {
+    }
+
+    protected function start($attributes)
+    {
+    }
+
+    protected function end()
+    {
+    }
+
+    protected function after()
+    {
+    }
+
+    public function getAttributes()
+    {
+        return $this->attributes;
+    }
+
+    protected function setStyle(Style $style)
+    {
+        $this->style = $style;
+
+        if ($style->display === "none") {
+            $this->hasShape = false;
+        }
+    }
+
+    /**
+     * @return Style
+     */
+    public function getStyle()
+    {
+        return $this->style;
+    }
+
+    /**
+     * Make a style object from the tag and its attributes
+     *
+     * @param array $attributes
+     *
+     * @return Style
+     */
+    protected function makeStyle($attributes) {
+        $style = new Style($this->document);
+        $style->inherit($this);
+        $style->fromStyleSheets($this, $attributes);
+        $style->fromAttributes($attributes);
+
+        return $style;
+    }
+
+    protected function applyTransform($attributes)
+    {
+
+        if (isset($attributes["transform"])) {
+            $surface = $this->document->getSurface();
+
+            $transform = $attributes["transform"];
+
+            $matches = array();
+            preg_match_all(
+                '/(matrix|translate|scale|rotate|skew|skewX|skewY)\((.*?)\)/is',
+                $transform,
+                $matches,
+                PREG_SET_ORDER
+            );
+
+            $transformations = array();
+            foreach ($matches as $match) {
+                $arguments = preg_split('/[ ,]+/', $match[2]);
+                array_unshift($arguments, $match[1]);
+                $transformations[] = $arguments;
+            }
+
+            foreach ($transformations as $t) {
+                switch ($t[0]) {
+                    case "matrix":
+                        $surface->transform($t[1], $t[2], $t[3], $t[4], $t[5], $t[6]);
+                        break;
+
+                    case "translate":
+                        $surface->translate($t[1], isset($t[2]) ? $t[2] : 0);
+                        break;
+
+                    case "scale":
+                        $surface->scale($t[1], isset($t[2]) ? $t[2] : $t[1]);
+                        break;
+
+                    case "rotate":
+                        if (isset($t[2])) {
+                            $t[3] = isset($t[3]) ? $t[3] : 0;
+                            $surface->translate($t[2], $t[3]);
+                            $surface->rotate($t[1]);
+                            $surface->translate(-$t[2], -$t[3]);
+                        } else {
+                            $surface->rotate($t[1]);
+                        }
+                        break;
+
+                    case "skewX":
+                        $tan_x = tan(deg2rad($t[1]));
+                        $surface->transform(1, 0, $tan_x, 1, 0, 0);
+                        break;
+
+                    case "skewY":
+                        $tan_y = tan(deg2rad($t[1]));
+                        $surface->transform(1, $tan_y, 0, 1, 0, 0);
+                        break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Apply a viewBox transform to the element
+     *
+     * @param array $attributes
+     */
+    protected function applyViewbox($attributes) {
+        if (!isset($attributes["viewbox"])) {
+            return;
+        }
+
+        $surface = $this->document->getSurface();
+        $viewBox = preg_split('/[\s,]+/is', trim($attributes['viewbox']));
+        if (count($viewBox) != 4) {
+            return;
+        }
+
+        // Computing the equivalent transform of an SVG viewport
+        // https://svgwg.org/svg2-draft/coords.html#ComputingAViewportsTransform
+
+        // 1. Let vb-x, vb-y, vb-width, vb-height be the min-x, min-y, width and height values of the viewBox attribute respectively.
+        [$vbX, $vbY, $vbWidth, $vbHeight] = $viewBox;
+
+        if ($vbWidth < 0 || $vbHeight < 0) {
+            return;
+        }
+
+        // correct solution is to not render, for now scaling to 0 below
+        //if ($vbWidth == 0 || $vbHeight == 0) {
+        //}
+
+        // 2. Let e-x, e-y, e-width, e-height be the position and size of the element respectively.
+        $eX = $attributes["x"] ?? 0;
+        $eY = $attributes["y"] ?? 0;
+        $eWidth = $attributes["width"] ?? $this->document->getWidth();
+        $eHeight = $attributes["height"] ?? $this->document->getHeight();
+
+        // 3. Let align be the align value of preserveAspectRatio, or 'xMidYMid' if preserveAspectRatio is not defined.
+        $preserveAspectRatio = explode(" ", $attributes["preserveAspectRatio"] ?? "xMidYMid meet");
+        $align = $preserveAspectRatio[0];
+
+        // 4. Let meetOrSlice be the meetOrSlice value of preserveAspectRatio, or 'meet' if preserveAspectRatio is not defined or if meetOrSlice is missing from this value.
+        $meetOrSlice = $meetOrSlice ?? "meet";
+
+        // 5. Initialize scale-x to e-width/vb-width.
+        $scaleX = $vbWidth == 0 ? 0 : ($eWidth / $vbWidth);
+
+        // 6. Initialize scale-y to e-height/vb-height.
+        $scaleY = $vbHeight == 0 ? 0 : ($eHeight / $vbHeight);
+
+        // 7. If align is not 'none' and meetOrSlice is 'meet', set the larger of scale-x and scale-y to the smaller.
+        if ($align !== "none" && $meetOrSlice === "meet") {
+            $scaleX = min($scaleX, $scaleY);
+            $scaleY = min($scaleX, $scaleY);
+        }
+
+        // 8. Otherwise, if align is not 'none' and meetOrSlice is 'slice', set the smaller of scale-x and scale-y to the larger.
+        elseif ($align !== "none" && $meetOrSlice === "slice") {
+            $scaleX = max($scaleX, $scaleY);
+            $scaleY = max($scaleX, $scaleY);
+        }
+
+        // 9. Initialize translate-x to e-x - (vb-x * scale-x).
+        $translateX = $eX - ($vbX * $scaleX);
+
+        // 10. Initialize translate-y to e-y - (vb-y * scale-y)
+        $translateY = $eY - ($vbY * $scaleY);
+
+        // 11. If align contains 'xMid', add (e-width - vb-width * scale-x) / 2 to translate-x.
+        if (strpos($align, "xMid") !== false) {
+            $translateX += ($eWidth - $vbWidth * $scaleX) / 2;
+        }
+
+        // 12. If align contains 'xMax', add (e-width - vb-width * scale-x) to translate-x.
+        if (strpos($align, "xMax") !== false) {
+            $translateX += ($eWidth - $vbWidth * $scaleX);
+        }
+
+        // 13. If align contains 'yMid', add (e-height - vb-height * scale-y) / 2 to translate-y.
+        if (strpos($align, "yMid") !== false) {
+            $translateX += ($eHeight - $vbHeight * $scaleY) / 2;
+        }
+
+        // 14. If align contains 'yMax', add (e-height - vb-height * scale-y) to translate-y.
+        if (strpos($align, "yMid") !== false) {
+            $translateX += ($eHeight - $vbHeight * $scaleY);
+        }
+
+        $surface->translate($translateX, $translateY);
+        $surface->scale($scaleX, $scaleY);
+    }
+
+    /**
+     * Convert the given size for the context of this current tag.
+     * Takes a pixel-based reference, which is usually specific to the context of the size,
+     * but the actual reference size will be decided based upon the unit used.
+     *
+     * @param string $size
+     * @param float $pxReference
+     *
+     * @return float
+     */
+    protected function convertSize(string $size, float $pxReference): float
+    {
+        $length = new CssLength($size);
+        $reference = $pxReference;
+        $defaultFontSize = 12;
+
+        switch ($length->getUnit()) {
+            case "em":
+                $reference = $this->style->fontSize ?? $defaultFontSize;
+                break;
+            case "rem":
+                $reference = $this->document->style->fontSize ?? $defaultFontSize;
+                break;
+            case "ex":
+            case "ch":
+                $emRef = $this->style->fontSize ?? $defaultFontSize;
+                $reference = $emRef * 0.5;
+                break;
+            case "vw":
+                $reference = $this->getDocument()->getWidth();
+                break;
+            case "vh":
+                $reference = $this->getDocument()->getHeight();
+                break;
+            case "vmin":
+                $reference = min($this->getDocument()->getHeight(), $this->getDocument()->getWidth());
+                break;
+            case "vmax":
+                $reference = max($this->getDocument()->getHeight(), $this->getDocument()->getWidth());
+                break;
+        }
+
+        return (new CssLength($size))->toPixels($reference);
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Anchor.php

@@ -0,0 +1,13 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+class Anchor extends Group
+{
+
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Circle.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Circle extends Shape
+{
+    protected $cx = 0;
+    protected $cy = 0;
+    protected $r;
+
+    public function start($attributes)
+    {
+        if (isset($attributes['cx'])) {
+            $width = $this->document->getWidth();
+            $this->cx = $this->convertSize($attributes['cx'], $width);
+        }
+        if (isset($attributes['cy'])) {
+            $height = $this->document->getHeight();
+            $this->cy = $this->convertSize($attributes['cy'], $height);
+        }
+        if (isset($attributes['r'])) {
+            $diagonal = $this->document->getDiagonal();
+            $this->r = $this->convertSize($attributes['r'], $diagonal);
+        }
+
+        $this->document->getSurface()->circle($this->cx, $this->cy, $this->r);
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/ClipPath.php

@@ -0,0 +1,32 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class ClipPath extends AbstractTag
+{
+    protected function before($attributes)
+    {
+        $surface = $this->document->getSurface();
+
+        $surface->save();
+
+        $style = $this->makeStyle($attributes);
+
+        $this->setStyle($style);
+        $surface->setStyle($style);
+
+        $this->applyTransform($attributes);
+    }
+
+    protected function after()
+    {
+        $this->document->getSurface()->restore();
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Ellipse.php

@@ -0,0 +1,41 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Ellipse extends Shape
+{
+    protected $cx = 0;
+    protected $cy = 0;
+    protected $rx = 0;
+    protected $ry = 0;
+
+    public function start($attributes)
+    {
+        parent::start($attributes);
+
+        $width = $this->document->getWidth();
+        $height = $this->document->getHeight();
+
+        if (isset($attributes['cx'])) {
+            $this->cx = $this->convertSize($attributes['cx'], $width);
+        }
+        if (isset($attributes['cy'])) {
+            $this->cy = $this->convertSize($attributes['cy'], $height);
+        }
+        if (isset($attributes['rx'])) {
+            $this->rx = $this->convertSize($attributes['rx'], $width);
+        }
+        if (isset($attributes['ry'])) {
+            $this->ry = $this->convertSize($attributes['ry'], $height);
+        }
+
+        $this->document->getSurface()->ellipse($this->cx, $this->cy, $this->rx, $this->ry, 0, 0, 360, false);
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Group.php

@@ -0,0 +1,32 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Group extends AbstractTag
+{
+    protected function before($attributes)
+    {
+        $surface = $this->document->getSurface();
+
+        $surface->save();
+
+        $style = $this->makeStyle($attributes);
+
+        $this->setStyle($style);
+        $surface->setStyle($style);
+
+        $this->applyTransform($attributes);
+    }
+
+    protected function after()
+    {
+        $this->document->getSurface()->restore();
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Image.php

@@ -0,0 +1,75 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Image extends AbstractTag
+{
+    protected $x = 0;
+    protected $y = 0;
+    protected $width = 0;
+    protected $height = 0;
+    protected $href = null;
+
+    protected function before($attributes)
+    {
+        parent::before($attributes);
+
+        $surface = $this->document->getSurface();
+        $surface->save();
+
+        $this->applyTransform($attributes);
+    }
+
+    public function start($attributes)
+    {
+        $height = $this->document->getHeight();
+        $width = $this->document->getWidth();
+        $this->y = $height;
+
+        if (isset($attributes['x'])) {
+            $this->x = $this->convertSize($attributes['x'], $width);
+        }
+        if (isset($attributes['y'])) {
+            $this->y = $height - $this->convertSize($attributes['y'], $height);
+        }
+
+        if (isset($attributes['width'])) {
+            $this->width = $this->convertSize($attributes['width'], $width);
+        }
+        if (isset($attributes['height'])) {
+            $this->height = $this->convertSize($attributes['height'], $height);
+        }
+
+        if (isset($attributes['xlink:href'])) {
+            $this->href = $attributes['xlink:href'];
+        }
+
+        if (isset($attributes['href'])) {
+            $this->href = $attributes['href'];
+        }
+
+        $this->document->getSurface()->transform(1, 0, 0, -1, 0, $height);
+
+        $scheme = \strtolower(parse_url($this->href, PHP_URL_SCHEME) ?: "");
+        if (
+            $scheme === "phar" || \strtolower(\substr($this->href, 0, 7)) === "phar://"
+            || ($this->document->allowExternalReferences === false && $scheme !== "data")
+        ) {
+            return;
+        }
+
+        $this->document->getSurface()->drawImage($this->href, $this->x, $this->y, $this->width, $this->height);
+    }
+
+    protected function after()
+    {
+        $this->document->getSurface()->restore();
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Line.php

@@ -0,0 +1,42 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Line extends Shape
+{
+    protected $x1 = 0;
+    protected $y1 = 0;
+
+    protected $x2 = 0;
+    protected $y2 = 0;
+
+    public function start($attributes)
+    {
+        $height = $this->document->getHeight();
+        $width = $this->document->getWidth();
+
+        if (isset($attributes['x1'])) {
+            $this->x1 = $this->convertSize($attributes['x1'], $width);
+        }
+        if (isset($attributes['y1'])) {
+            $this->y1 = $this->convertSize($attributes['y1'], $height);
+        }
+        if (isset($attributes['x2'])) {
+            $this->x2 = $this->convertSize($attributes['x2'], $width);
+        }
+        if (isset($attributes['y2'])) {
+            $this->y2 = $this->convertSize($attributes['y2'], $height);
+        }
+
+        $surface = $this->document->getSurface();
+        $surface->moveTo($this->x1, $this->y1);
+        $surface->lineTo($this->x2, $this->y2);
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/LinearGradient.php

@@ -0,0 +1,82 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+
+use Svg\Gradient;
+use Svg\Style;
+
+class LinearGradient extends AbstractTag
+{
+    protected $x1;
+    protected $y1;
+    protected $x2;
+    protected $y2;
+
+    /** @var Gradient\Stop[] */
+    protected $stops = array();
+
+    public function start($attributes)
+    {
+        parent::start($attributes);
+
+        if (isset($attributes['x1'])) {
+            $this->x1 = $attributes['x1'];
+        }
+        if (isset($attributes['y1'])) {
+            $this->y1 = $attributes['y1'];
+        }
+        if (isset($attributes['x2'])) {
+            $this->x2 = $attributes['x2'];
+        }
+        if (isset($attributes['y2'])) {
+            $this->y2 = $attributes['y2'];
+        }
+    }
+
+    public function getStops() {
+        if (empty($this->stops)) {
+            foreach ($this->children as $_child) {
+                if ($_child->tagName != "stop") {
+                    continue;
+                }
+
+                $_stop = new Gradient\Stop();
+                $_attributes = $_child->attributes;
+
+                // Style
+                if (isset($_attributes["style"])) {
+                    $_style = Style::parseCssStyle($_attributes["style"]);
+
+                    if (isset($_style["stop-color"])) {
+                        $_stop->color = Style::parseColor($_style["stop-color"]);
+                    }
+
+                    if (isset($_style["stop-opacity"])) {
+                        $_stop->opacity = max(0, min(1.0, $_style["stop-opacity"]));
+                    }
+                }
+
+                // Attributes
+                if (isset($_attributes["offset"])) {
+                    $_stop->offset = $_attributes["offset"];
+                }
+                if (isset($_attributes["stop-color"])) {
+                    $_stop->color = Style::parseColor($_attributes["stop-color"]);
+                }
+                if (isset($_attributes["stop-opacity"])) {
+                    $_stop->opacity = max(0, min(1.0, $_attributes["stop-opacity"]));
+                }
+
+                $this->stops[] = $_stop;
+            }
+        }
+
+        return $this->stops;
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Path.php

@@ -0,0 +1,580 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Surface\SurfaceInterface;
+
+class Path extends Shape
+{
+    // kindly borrowed from fabric.util.parsePath.
+    /* @see https://github.com/fabricjs/fabric.js/blob/master/src/util/path.js#L664 */
+    const NUMBER_PATTERN = '([-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?)\s*';
+    const COMMA_PATTERN = '(?:\s+,?\s*|,\s*)?';
+    const FLAG_PATTERN = '([01])';
+    const ARC_REGEXP = '/'
+        . self::NUMBER_PATTERN
+        . self::COMMA_PATTERN
+        . self::NUMBER_PATTERN
+        . self::COMMA_PATTERN
+        . self::NUMBER_PATTERN
+        . self::COMMA_PATTERN
+        . self::FLAG_PATTERN
+        . self::COMMA_PATTERN
+        . self::FLAG_PATTERN
+        . self::COMMA_PATTERN
+        . self::NUMBER_PATTERN
+        . self::COMMA_PATTERN
+        . self::NUMBER_PATTERN
+        . '/';
+
+    static $commandLengths = array(
+        'm' => 2,
+        'l' => 2,
+        'h' => 1,
+        'v' => 1,
+        'c' => 6,
+        's' => 4,
+        'q' => 4,
+        't' => 2,
+        'a' => 7,
+    );
+
+    static $repeatedCommands = array(
+        'm' => 'l',
+        'M' => 'L',
+    );
+
+    public static function parse(string $commandSequence): array
+    {
+        $commands = array();
+        preg_match_all('/([MZLHVCSQTAmzlhvcsqta])([eE ,\-.\d]+)*/', $commandSequence, $commands, PREG_SET_ORDER);
+        
+        $path = array();
+        foreach ($commands as $c) {
+            if (count($c) == 3) {
+                $commandLower = strtolower($c[1]);
+
+                // arcs have special flags that apparently don't require spaces.
+                if ($commandLower === 'a' && preg_match_all(static::ARC_REGEXP, $c[2], $matches, PREG_PATTERN_ORDER)) {
+                    $numberOfMatches = count($matches[0]);
+                    for ($k = 0; $k < $numberOfMatches; ++$k) {
+                        $path[] = [
+                            $c[1],
+                            $matches[1][$k],
+                            $matches[2][$k],
+                            $matches[3][$k],
+                            $matches[4][$k],
+                            $matches[5][$k],
+                            $matches[6][$k],
+                            $matches[7][$k],
+                        ];
+                    }
+                    continue;
+                }
+
+                $arguments = array();
+                preg_match_all('/([-+]?((\d+\.\d+)|((\d+)|(\.\d+)))(?:e[-+]?\d+)?)/i', $c[2], $arguments, PREG_PATTERN_ORDER);
+                $item = $arguments[0];
+
+                if (
+                    isset(self::$commandLengths[$commandLower]) &&
+                    ($commandLength = self::$commandLengths[$commandLower]) &&
+                    count($item) > $commandLength
+                ) {
+                    $repeatedCommand = isset(self::$repeatedCommands[$c[1]]) ? self::$repeatedCommands[$c[1]] : $c[1];
+                    $command = $c[1];
+
+                    for ($k = 0, $klen = count($item); $k < $klen; $k += $commandLength) {
+                        $_item = array_slice($item, $k, $k + $commandLength);
+                        array_unshift($_item, $command);
+                        $path[] = $_item;
+
+                        $command = $repeatedCommand;
+                    }
+                } else {
+                    array_unshift($item, $c[1]);
+                    $path[] = $item;
+                }
+
+            } else {
+                $item = array($c[1]);
+
+                $path[] = $item;
+            }
+        }
+
+        return $path;
+    }
+
+    public function start($attributes)
+    {
+        if (!isset($attributes['d'])) {
+            $this->hasShape = false;
+
+            return;
+        }
+
+        $path = static::parse($attributes['d']);
+        $surface = $this->document->getSurface();
+
+        // From https://github.com/kangax/fabric.js/blob/master/src/shapes/path.class.js
+        $current = null; // current instruction
+        $previous = null;
+        $subpathStartX = 0;
+        $subpathStartY = 0;
+        $x = 0; // current x
+        $y = 0; // current y
+        $controlX = 0; // current control point x
+        $controlY = 0; // current control point y
+        $tempX = null;
+        $tempY = null;
+        $tempControlX = null;
+        $tempControlY = null;
+        $l = 0; //-((this.width / 2) + $this.pathOffset.x),
+        $t = 0; //-((this.height / 2) + $this.pathOffset.y),
+
+        foreach ($path as $current) {
+            switch ($current[0]) { // first letter
+                case 'l': // lineto, relative
+                    $x += $current[1];
+                    $y += $current[2];
+                    $surface->lineTo($x + $l, $y + $t);
+                    break;
+
+                case 'L': // lineto, absolute
+                    $x = $current[1];
+                    $y = $current[2];
+                    $surface->lineTo($x + $l, $y + $t);
+                    break;
+
+                case 'h': // horizontal lineto, relative
+                    $x += $current[1];
+                    $surface->lineTo($x + $l, $y + $t);
+                    break;
+
+                case 'H': // horizontal lineto, absolute
+                    $x = $current[1];
+                    $surface->lineTo($x + $l, $y + $t);
+                    break;
+
+                case 'v': // vertical lineto, relative
+                    $y += $current[1];
+                    $surface->lineTo($x + $l, $y + $t);
+                    break;
+
+                case 'V': // verical lineto, absolute
+                    $y = $current[1];
+                    $surface->lineTo($x + $l, $y + $t);
+                    break;
+
+                case 'm': // moveTo, relative
+                    $x += $current[1];
+                    $y += $current[2];
+                    $subpathStartX = $x;
+                    $subpathStartY = $y;
+                    $surface->moveTo($x + $l, $y + $t);
+                    break;
+
+                case 'M': // moveTo, absolute
+                    $x = $current[1];
+                    $y = $current[2];
+                    $subpathStartX = $x;
+                    $subpathStartY = $y;
+                    $surface->moveTo($x + $l, $y + $t);
+                    break;
+
+                case 'c': // bezierCurveTo, relative
+                    $tempX = $x + $current[5];
+                    $tempY = $y + $current[6];
+                    $controlX = $x + $current[3];
+                    $controlY = $y + $current[4];
+                    $surface->bezierCurveTo(
+                        $x + $current[1] + $l, // x1
+                        $y + $current[2] + $t, // y1
+                        $controlX + $l, // x2
+                        $controlY + $t, // y2
+                        $tempX + $l,
+                        $tempY + $t
+                    );
+                    $x = $tempX;
+                    $y = $tempY;
+                    break;
+
+                case 'C': // bezierCurveTo, absolute
+                    $x = $current[5];
+                    $y = $current[6];
+                    $controlX = $current[3];
+                    $controlY = $current[4];
+                    $surface->bezierCurveTo(
+                        $current[1] + $l,
+                        $current[2] + $t,
+                        $controlX + $l,
+                        $controlY + $t,
+                        $x + $l,
+                        $y + $t
+                    );
+                    break;
+
+                case 's': // shorthand cubic bezierCurveTo, relative
+
+                    // transform to absolute x,y
+                    $tempX = $x + $current[3];
+                    $tempY = $y + $current[4];
+
+                    if (!preg_match('/[CcSs]/', $previous[0])) {
+                        // If there is no previous command or if the previous command was not a C, c, S, or s,
+                        // the control point is coincident with the current point
+                        $controlX = $x;
+                        $controlY = $y;
+                    } else {
+                        // calculate reflection of previous control points
+                        $controlX = 2 * $x - $controlX;
+                        $controlY = 2 * $y - $controlY;
+                    }
+
+                    $surface->bezierCurveTo(
+                        $controlX + $l,
+                        $controlY + $t,
+                        $x + $current[1] + $l,
+                        $y + $current[2] + $t,
+                        $tempX + $l,
+                        $tempY + $t
+                    );
+                    // set control point to 2nd one of this command
+                    // "... the first control point is assumed to be
+                    // the reflection of the second control point on
+                    // the previous command relative to the current point."
+                    $controlX = $x + $current[1];
+                    $controlY = $y + $current[2];
+
+                    $x = $tempX;
+                    $y = $tempY;
+                    break;
+
+                case 'S': // shorthand cubic bezierCurveTo, absolute
+                    $tempX = $current[3];
+                    $tempY = $current[4];
+
+                    if (!preg_match('/[CcSs]/', $previous[0])) {
+                        // If there is no previous command or if the previous command was not a C, c, S, or s,
+                        // the control point is coincident with the current point
+                        $controlX = $x;
+                        $controlY = $y;
+                    } else {
+                        // calculate reflection of previous control points
+                        $controlX = 2 * $x - $controlX;
+                        $controlY = 2 * $y - $controlY;
+                    }
+
+                    $surface->bezierCurveTo(
+                        $controlX + $l,
+                        $controlY + $t,
+                        $current[1] + $l,
+                        $current[2] + $t,
+                        $tempX + $l,
+                        $tempY + $t
+                    );
+                    $x = $tempX;
+                    $y = $tempY;
+
+                    // set control point to 2nd one of this command
+                    // "... the first control point is assumed to be
+                    // the reflection of the second control point on
+                    // the previous command relative to the current point."
+                    $controlX = $current[1];
+                    $controlY = $current[2];
+
+                    break;
+
+                case 'q': // quadraticCurveTo, relative
+                    // transform to absolute x,y
+                    $tempX = $x + $current[3];
+                    $tempY = $y + $current[4];
+
+                    $controlX = $x + $current[1];
+                    $controlY = $y + $current[2];
+
+                    $surface->quadraticCurveTo(
+                        $controlX + $l,
+                        $controlY + $t,
+                        $tempX + $l,
+                        $tempY + $t
+                    );
+                    $x = $tempX;
+                    $y = $tempY;
+                    break;
+
+                case 'Q': // quadraticCurveTo, absolute
+                    $tempX = $current[3];
+                    $tempY = $current[4];
+
+                    $surface->quadraticCurveTo(
+                        $current[1] + $l,
+                        $current[2] + $t,
+                        $tempX + $l,
+                        $tempY + $t
+                    );
+                    $x = $tempX;
+                    $y = $tempY;
+                    $controlX = $current[1];
+                    $controlY = $current[2];
+                    break;
+
+                case 't': // shorthand quadraticCurveTo, relative
+
+                    // transform to absolute x,y
+                    $tempX = $x + $current[1];
+                    $tempY = $y + $current[2];
+
+                    // calculate reflection of previous control points
+                    if (preg_match('/[QqT]/', $previous[0])) {
+                        $controlX = 2 * $x - $controlX;
+                        $controlY = 2 * $y - $controlY;
+                    } elseif ($previous[0] === 't') {
+                        $controlX = 2 * $x - $tempControlX;
+                        $controlY = 2 * $y - $tempControlY;
+                    } else {
+                        $controlX = $x;
+                        $controlY = $y;
+                    }
+
+                    $tempControlX = $controlX;
+                    $tempControlY = $controlY;
+
+                    $surface->quadraticCurveTo(
+                        $controlX + $l,
+                        $controlY + $t,
+                        $tempX + $l,
+                        $tempY + $t
+                    );
+                    $x = $tempX;
+                    $y = $tempY;
+                    break;
+
+                case 'T':
+                    $tempX = $current[1];
+                    $tempY = $current[2];
+
+                    // calculate reflection of previous control points
+                    if (preg_match('/[QqTt]/', $previous[0])) {
+                        $controlX = 2 * $x - $controlX;
+                        $controlY = 2 * $y - $controlY;
+                    } else {
+                        $controlX = $x;
+                        $controlY = $y;
+                    }
+
+                    $surface->quadraticCurveTo(
+                        $controlX + $l,
+                        $controlY + $t,
+                        $tempX + $l,
+                        $tempY + $t
+                    );
+                    $x = $tempX;
+                    $y = $tempY;
+                    break;
+
+                case 'a':
+                    $this->drawArc(
+                        $surface,
+                        $x + $l,
+                        $y + $t,
+                        array(
+                            $current[1],
+                            $current[2],
+                            $current[3],
+                            $current[4],
+                            $current[5],
+                            $current[6] + $x + $l,
+                            $current[7] + $y + $t
+                        )
+                    );
+                    $x += $current[6];
+                    $y += $current[7];
+                    break;
+
+                case 'A':
+                    // TODO: optimize this
+                    $this->drawArc(
+                        $surface,
+                        $x + $l,
+                        $y + $t,
+                        array(
+                            $current[1],
+                            $current[2],
+                            $current[3],
+                            $current[4],
+                            $current[5],
+                            $current[6] + $l,
+                            $current[7] + $t
+                        )
+                    );
+                    $x = $current[6];
+                    $y = $current[7];
+                    break;
+
+                case 'z':
+                case 'Z':
+                    $x = $subpathStartX;
+                    $y = $subpathStartY;
+                    $surface->closePath();
+                    break;
+            }
+            $previous = $current;
+        }
+    }
+
+    function drawArc(SurfaceInterface $surface, $fx, $fy, $coords)
+    {
+        $rx = $coords[0];
+        $ry = $coords[1];
+        $rot = $coords[2];
+        $large = $coords[3];
+        $sweep = $coords[4];
+        $tx = $coords[5];
+        $ty = $coords[6];
+        $segs = array(
+            array(),
+            array(),
+            array(),
+            array(),
+        );
+
+        $toX = $tx - $fx;
+        $toY = $ty - $fy;
+
+        if ((float)($toX + $toY) === 0.0) {
+            return;
+        }
+
+        if ((float)abs($rx) == 0.0 || (float)abs($ry) === 0.0) {
+            $surface->lineTo($tx, $ty);
+            return;
+        }
+
+        $segsNorm = $this->arcToSegments($toX, $toY, $rx, $ry, $large, $sweep, $rot);
+
+        for ($i = 0, $len = count($segsNorm); $i < $len; $i++) {
+            $segs[$i][0] = $segsNorm[$i][0] + $fx;
+            $segs[$i][1] = $segsNorm[$i][1] + $fy;
+            $segs[$i][2] = $segsNorm[$i][2] + $fx;
+            $segs[$i][3] = $segsNorm[$i][3] + $fy;
+            $segs[$i][4] = $segsNorm[$i][4] + $fx;
+            $segs[$i][5] = $segsNorm[$i][5] + $fy;
+
+            call_user_func_array(array($surface, "bezierCurveTo"), $segs[$i]);
+        }
+    }
+
+    function arcToSegments($toX, $toY, $rx, $ry, $large, $sweep, $rotateX)
+    {
+        $th = $rotateX * M_PI / 180;
+        $sinTh = sin($th);
+        $cosTh = cos($th);
+        $fromX = 0;
+        $fromY = 0;
+
+        $rx = abs($rx);
+        $ry = abs($ry);
+
+        $px = -$cosTh * $toX * 0.5 - $sinTh * $toY * 0.5;
+        $py = -$cosTh * $toY * 0.5 + $sinTh * $toX * 0.5;
+        $rx2 = $rx * $rx;
+        $ry2 = $ry * $ry;
+        $py2 = $py * $py;
+        $px2 = $px * $px;
+        $pl = $rx2 * $ry2 - $rx2 * $py2 - $ry2 * $px2;
+        $root = 0;
+
+        if ($pl < 0) {
+            $s = sqrt(1 - $pl / ($rx2 * $ry2));
+            $rx *= $s;
+            $ry *= $s;
+        } else {
+            $root = ($large == $sweep ? -1.0 : 1.0) * sqrt($pl / ($rx2 * $py2 + $ry2 * $px2));
+        }
+
+        $cx = $root * $rx * $py / $ry;
+        $cy = -$root * $ry * $px / $rx;
+        $cx1 = $cosTh * $cx - $sinTh * $cy + $toX * 0.5;
+        $cy1 = $sinTh * $cx + $cosTh * $cy + $toY * 0.5;
+        $mTheta = $this->calcVectorAngle(1, 0, ($px - $cx) / $rx, ($py - $cy) / $ry);
+        $dtheta = $this->calcVectorAngle(($px - $cx) / $rx, ($py - $cy) / $ry, (-$px - $cx) / $rx, (-$py - $cy) / $ry);
+
+        if ($sweep == 0 && $dtheta > 0) {
+            $dtheta -= 2 * M_PI;
+        } else {
+            if ($sweep == 1 && $dtheta < 0) {
+                $dtheta += 2 * M_PI;
+            }
+        }
+
+        // $Convert $into $cubic $bezier $segments <= 90deg
+        $segments = ceil(abs($dtheta / M_PI * 2));
+        $result = array();
+        $mDelta = $dtheta / $segments;
+        $mT = 8 / 3 * sin($mDelta / 4) * sin($mDelta / 4) / sin($mDelta / 2);
+        $th3 = $mTheta + $mDelta;
+
+        for ($i = 0; $i < $segments; $i++) {
+            $result[$i] = $this->segmentToBezier(
+                $mTheta,
+                $th3,
+                $cosTh,
+                $sinTh,
+                $rx,
+                $ry,
+                $cx1,
+                $cy1,
+                $mT,
+                $fromX,
+                $fromY
+            );
+            $fromX = $result[$i][4];
+            $fromY = $result[$i][5];
+            $mTheta = $th3;
+            $th3 += $mDelta;
+        }
+
+        return $result;
+    }
+
+    function segmentToBezier($th2, $th3, $cosTh, $sinTh, $rx, $ry, $cx1, $cy1, $mT, $fromX, $fromY)
+    {
+        $costh2 = cos($th2);
+        $sinth2 = sin($th2);
+        $costh3 = cos($th3);
+        $sinth3 = sin($th3);
+        $toX = $cosTh * $rx * $costh3 - $sinTh * $ry * $sinth3 + $cx1;
+        $toY = $sinTh * $rx * $costh3 + $cosTh * $ry * $sinth3 + $cy1;
+        $cp1X = $fromX + $mT * (-$cosTh * $rx * $sinth2 - $sinTh * $ry * $costh2);
+        $cp1Y = $fromY + $mT * (-$sinTh * $rx * $sinth2 + $cosTh * $ry * $costh2);
+        $cp2X = $toX + $mT * ($cosTh * $rx * $sinth3 + $sinTh * $ry * $costh3);
+        $cp2Y = $toY + $mT * ($sinTh * $rx * $sinth3 - $cosTh * $ry * $costh3);
+
+        return array(
+            $cp1X,
+            $cp1Y,
+            $cp2X,
+            $cp2Y,
+            $toX,
+            $toY
+        );
+    }
+
+    function calcVectorAngle($ux, $uy, $vx, $vy)
+    {
+        $ta = atan2($uy, $ux);
+        $tb = atan2($vy, $vx);
+        if ($tb >= $ta) {
+            return $tb - $ta;
+        } else {
+            return 2 * M_PI - ($ta - $tb);
+        }
+    }
+}

vendor/dompdf/php-svg-lib/src/Svg/Tag/Polygon.php

@@ -0,0 +1,41 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+class Polygon extends Shape
+{
+    public function start($attributes)
+    {
+        $tmp = array();
+        preg_match_all('/([\-]*[0-9\.]+)/', $attributes['points'], $tmp, PREG_PATTERN_ORDER);
+
+        $points = $tmp[0];
+        $count = count($points);
+
+        if ($count < 4) {
+            // nothing to draw
+            return;
+        }
+
+        $surface = $this->document->getSurface();
+        list($x, $y) = $points;
+        $surface->moveTo($x, $y);
+
+        for ($i = 2; $i < $count; $i += 2) {
+            if ($i + 1 === $count) {
+                // invalid trailing point
+                continue;
+            }
+            $x = $points[$i];
+            $y = $points[$i + 1];
+            $surface->lineTo($x, $y);
+        }
+
+        $surface->closePath();
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Polyline.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+class Polyline extends Shape
+{
+    public function start($attributes)
+    {
+        $tmp = array();
+        preg_match_all('/([\-]*[0-9\.]+)/', $attributes['points'], $tmp, PREG_PATTERN_ORDER);
+
+        $points = $tmp[0];
+        $count = count($points);
+
+        if ($count < 4) {
+            // nothing to draw
+            return;
+        }
+
+        $surface = $this->document->getSurface();
+        list($x, $y) = $points;
+        $surface->moveTo($x, $y);
+
+        for ($i = 2; $i < $count; $i += 2) {
+            if ($i + 1 === $count) {
+                // invalid trailing point
+                continue;
+            }
+            $x = $points[$i];
+            $y = $points[$i + 1];
+            $surface->lineTo($x, $y);
+        }
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/RadialGradient.php

@@ -0,0 +1,16 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+class RadialGradient extends AbstractTag
+{
+    public function start($attributes)
+    {
+
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Rect.php

@@ -0,0 +1,49 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Rect extends Shape
+{
+    protected $x = 0;
+    protected $y = 0;
+    protected $width = 0;
+    protected $height = 0;
+    protected $rx = 0;
+    protected $ry = 0;
+
+    public function start($attributes)
+    {
+        $width = $this->document->getWidth();
+        $height = $this->document->getHeight();
+
+        if (isset($attributes['x'])) {
+            $this->x = $this->convertSize($attributes['x'], $width);
+        }
+        if (isset($attributes['y'])) {
+            $this->y = $this->convertSize($attributes['y'], $height);
+        }
+
+        if (isset($attributes['width'])) {
+            $this->width = $this->convertSize($attributes['width'], $width);
+        }
+        if (isset($attributes['height'])) {
+            $this->height = $this->convertSize($attributes['height'], $height);
+        }
+
+        if (isset($attributes['rx'])) {
+            $this->rx = $attributes['rx'];
+        }
+        if (isset($attributes['ry'])) {
+            $this->ry = $attributes['ry'];
+        }
+
+        $this->document->getSurface()->rect($this->x, $this->y, $this->width, $this->height, $this->rx, $this->ry);
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Shape.php

@@ -0,0 +1,62 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Shape extends AbstractTag
+{
+    protected function before($attributes)
+    {
+        $surface = $this->document->getSurface();
+
+        $surface->save();
+
+        $style = $this->makeStyle($attributes);
+
+        $this->setStyle($style);
+        $surface->setStyle($style);
+
+        $this->applyTransform($attributes);
+    }
+
+    protected function after()
+    {
+        $surface = $this->document->getSurface();
+
+        if ($this->hasShape) {
+            $style = $surface->getStyle();
+
+            $fill   = $style->fill   && is_array($style->fill);
+            $stroke = $style->stroke && is_array($style->stroke);
+
+            if ($fill) {
+                if ($stroke) {
+                    $surface->fillStroke(false);
+                } else {
+//                    if (is_string($style->fill)) {
+//                        /** @var LinearGradient|RadialGradient $gradient */
+//                        $gradient = $this->getDocument()->getDef($style->fill);
+//
+//                        var_dump($gradient->getStops());
+//                    }
+
+                    $surface->fill();
+                }
+            }
+            elseif ($stroke) {
+                $surface->stroke(false);
+            }
+            else {
+                $surface->endPath();
+            }
+        }
+
+        $surface->restore();
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Stop.php

@@ -0,0 +1,16 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+class Stop extends AbstractTag
+{
+    public function start($attributes)
+    {
+
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/StyleTag.php

@@ -0,0 +1,26 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Sabberworm\CSS;
+
+class StyleTag extends AbstractTag
+{
+    protected $text = "";
+
+    public function end()
+    {
+        $parser = new CSS\Parser($this->text);
+        $this->document->appendStyleSheet($parser->parse());
+    }
+
+    public function appendText($text)
+    {
+        $this->text .= $text;
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/Symbol.php

@@ -0,0 +1,33 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Symbol extends AbstractTag
+{
+    protected function before($attributes)
+    {
+        $surface = $this->document->getSurface();
+
+        $surface->save();
+
+        $style = $this->makeStyle($attributes);
+
+        $this->setStyle($style);
+        $surface->setStyle($style);
+
+        $this->applyViewbox($attributes);
+        $this->applyTransform($attributes);
+    }
+
+    protected function after()
+    {
+        $this->document->getSurface()->restore();
+    }
+}

vendor/dompdf/php-svg-lib/src/Svg/Tag/Text.php

@@ -0,0 +1,71 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+use Svg\Style;
+
+class Text extends Shape
+{
+    protected $x = 0;
+    protected $y = 0;
+    protected $text = "";
+
+    public function start($attributes)
+    {
+        $height = $this->document->getHeight();
+        $this->y = $height;
+
+        if (isset($attributes['x'])) {
+            $width = $this->document->getWidth();
+            $this->x = $this->convertSize($attributes['x'], $width);
+        }
+        if (isset($attributes['y'])) {
+            $this->y = $height - $this->convertSize($attributes['y'], $height);
+        }
+
+        $this->document->getSurface()->transform(1, 0, 0, -1, 0, $height);
+    }
+
+    public function end()
+    {
+        $surface = $this->document->getSurface();
+        $x = $this->x;
+        $y = $this->y;
+        $style = $surface->getStyle();
+        $surface->setFont($style->fontFamily, $style->fontStyle, $style->fontWeight);
+
+        switch ($style->textAnchor) {
+            case "middle":
+                $width = $surface->measureText($this->text);
+                $x -= $width / 2;
+                break;
+
+            case "end":
+                $width = $surface->measureText($this->text);
+                $x -= $width;
+                break;
+        }
+
+        $surface->fillText($this->getText(), $x, $y);
+    }
+
+    protected function after()
+    {
+        $this->document->getSurface()->restore();
+    }
+
+    public function appendText($text)
+    {
+        $this->text .= $text;
+    }
+
+    public function getText()
+    {
+        return trim($this->text);
+    }
+} 

vendor/dompdf/php-svg-lib/src/Svg/Tag/UseTag.php

@@ -0,0 +1,131 @@
+<?php
+/**
+ * @package php-svg-lib
+ * @link    http://github.com/dompdf/php-svg-lib
+ * @license GNU LGPLv3+ http://www.gnu.org/copyleft/lesser.html
+ */
+
+namespace Svg\Tag;
+
+class UseTag extends AbstractTag
+{
+    protected $x = 0;
+    protected $y = 0;
+    protected $width;
+    protected $height;
+    protected $instances = 0;
+
+    /** @var AbstractTag */
+    protected $reference;
+
+    protected function before($attributes)
+    {
+        $this->instances++;
+        if ($this->instances > 1) {
+            //TODO: log circular reference error state
+            return;
+        }
+
+        if (isset($attributes['x'])) {
+            $this->x = $attributes['x'];
+        }
+        if (isset($attributes['y'])) {
+            $this->y = $attributes['y'];
+        }
+
+        if (isset($attributes['width'])) {
+            $this->width = $attributes['width'];
+        }
+        if (isset($attributes['height'])) {
+            $this->height = $attributes['height'];
+        }
+
+        parent::before($attributes);
+
+        $document = $this->getDocument();
+
+        $link = $attributes["href"] ?? $attributes["xlink:href"];
+        $this->reference = $document->getDef($link);
+
+        $surface = $document->getSurface();
+        $surface->save();
+
+        $surface->translate($this->x, $this->y);
+    }
+
+    protected function after() {
+        if ($this->instances > 0) {
+            return;
+        }
+        parent::after();
+        $this->getDocument()->getSurface()->restore();
+    }
+
+    public function handle($attributes)
+    {
+        if ($this->instances > 1) {
+            //TODO: log circular reference error state
+            return;
+        }
+
+        parent::handle($attributes);
+
+        if (!$this->reference) {
+            return;
+        }
+
+        $originalAttributes = array_merge($this->reference->attributes);
+        $originalStyle = $this->reference->getStyle();
+        $mergedAttributes = $this->reference->attributes;
+        $attributesToNotMerge = ['x', 'y', 'width', 'height', 'href', 'xlink:href', 'id', 'style'];
+        foreach ($attributes as $attrKey => $attrVal) {
+            if (!in_array($attrKey, $attributesToNotMerge) && !isset($mergedAttributes[$attrKey])) {
+                $mergedAttributes[$attrKey] = $attrVal;
+            }
+        }
+        $mergedAttributes['style'] = ($attributes['style'] ?? '') . ';' . ($mergedAttributes['style'] ?? '');
+
+        $this->_handle($this->reference, $mergedAttributes);
+
+        $this->reference->attributes = $originalAttributes;
+        if ($originalStyle !== null) {
+            $this->reference->setStyle($originalStyle);
+        }
+    }
+
+    public function handleEnd()
+    {
+        $this->instances--;
+        if ($this->instances > 0) {
+            return;
+        }
+
+        if ($this->reference) {
+            $this->_handleEnd($this->reference);
+        }
+
+        parent::handleEnd();
+    }
+
+    private function _handle($tag, $attributes) {
+        $tag->handle($attributes);
+        foreach ($tag->children as $child) {
+            $originalAttributes = array_merge($child->attributes);
+            $originalStyle = $child->getStyle();
+            $mergedAttributes = $child->attributes;
+            $mergedAttributes['style'] = ($attributes['style'] ?? '') . ';' . ($mergedAttributes['style'] ?? '');
+            $this->_handle($child, $mergedAttributes);
+            $child->attributes = $originalAttributes;
+            if ($originalStyle !== null) {
+                $child->setStyle($originalStyle);
+            }
+        }
+    }
+
+    private function _handleEnd($tag) {
+        foreach ($tag->children as $child) {
+            $this->_handleEnd($child);
+        }
+        $tag->handleEnd();
+    }
+}