<form method="POST">
    <h3>Editing: CssToInlineStyles.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace TijsVerkoyen\CssToInlineStyles;

use Symfony\Component\CssSelector\CssSelector;
use Symfony\Component\CssSelector\CssSelectorConverter;
use Symfony\Component\CssSelector\Exception\ExceptionInterface;
use TijsVerkoyen\CssToInlineStyles\Css\Processor;
use TijsVerkoyen\CssToInlineStyles\Css\Property\Processor as PropertyProcessor;
use TijsVerkoyen\CssToInlineStyles\Css\Rule\Processor as RuleProcessor;

class CssToInlineStyles
{
    private $cssConverter;

    public function __construct()
    {
        if (class_exists('Symfony\Component\CssSelector\CssSelectorConverter')) {
            $this-&gt;cssConverter = new CssSelectorConverter();
        }
    }

    /**
     * Will inline the $css into the given $html
     *
     * Remark: if the html contains &lt;style&gt;-tags those will be used, the rules
     * in $css will be appended.
     *
     * @param string $html
     * @param string $css
     *
     * @return string
     */
    public function convert($html, $css = null)
    {
        $document = $this-&gt;createDomDocumentFromHtml($html);
        $processor = new Processor();

        // get all styles from the style-tags
        $rules = $processor-&gt;getRules(
            $processor-&gt;getCssFromStyleTags($html)
        );

        if ($css !== null) {
            $rules = $processor-&gt;getRules($css, $rules);
        }

        $document = $this-&gt;inline($document, $rules);

        return $this-&gt;getHtmlFromDocument($document);
    }

    /**
     * Inline the given properties on an given DOMElement
     *
     * @param \DOMElement             $element
     * @param Css\Property\Property[] $properties
     *
     * @return \DOMElement
     */
    public function inlineCssOnElement(\DOMElement $element, array $properties)
    {
        if (empty($properties)) {
            return $element;
        }

        $cssProperties = array();
        $inlineProperties = array();

        foreach ($this-&gt;getInlineStyles($element) as $property) {
            $inlineProperties[$property-&gt;getName()] = $property;
        }

        foreach ($properties as $property) {
            if (!isset($inlineProperties[$property-&gt;getName()])) {
                $cssProperties[$property-&gt;getName()] = $property;
            }
        }

        $rules = array();
        foreach (array_merge($cssProperties, $inlineProperties) as $property) {
            $rules[] = $property-&gt;toString();
        }
        $element-&gt;setAttribute('style', implode(' ', $rules));

        return $element;
    }

    /**
     * Get the current inline styles for a given DOMElement
     *
     * @param \DOMElement $element
     *
     * @return Css\Property\Property[]
     */
    public function getInlineStyles(\DOMElement $element)
    {
        $processor = new PropertyProcessor();

        return $processor-&gt;convertArrayToObjects(
            $processor-&gt;splitIntoSeparateProperties(
                $element-&gt;getAttribute('style')
            )
        );
    }

    /**
     * @param string $html
     *
     * @return \DOMDocument
     */
    protected function createDomDocumentFromHtml($html)
    {
        $document = new \DOMDocument('1.0', 'UTF-8');
        $internalErrors = libxml_use_internal_errors(true);
        $document-&gt;loadHTML(mb_encode_numericentity($html, [0x80, 0x10FFFF, 0, 0x1FFFFF], 'UTF-8'));
        libxml_use_internal_errors($internalErrors);
        $document-&gt;formatOutput = true;

        return $document;
    }

    /**
     * @param \DOMDocument $document
     *
     * @return string
     */
    protected function getHtmlFromDocument(\DOMDocument $document)
    {
        // retrieve the document element
        // we do it this way to preserve the utf-8 encoding
        $htmlElement = $document-&gt;documentElement;
        $html = $document-&gt;saveHTML($htmlElement);
        $html = trim($html);

        // retrieve the doctype
        $document-&gt;removeChild($htmlElement);
        $doctype = $document-&gt;saveHTML();
        $doctype = trim($doctype);

        // if it is the html5 doctype convert it to lowercase
        if ($doctype === '&lt;!DOCTYPE html&gt;') {
            $doctype = strtolower($doctype);
        }

        return $doctype.&quot;\n&quot;.$html;
    }

    /**
     * @param \DOMDocument    $document
     * @param Css\Rule\Rule[] $rules
     *
     * @return \DOMDocument
     */
    protected function inline(\DOMDocument $document, array $rules)
    {
        if (empty($rules)) {
            return $document;
        }

        $propertyStorage = new \SplObjectStorage();

        $xPath = new \DOMXPath($document);

        usort($rules, array(RuleProcessor::class, 'sortOnSpecificity'));

        foreach ($rules as $rule) {
            try {
                if (null !== $this-&gt;cssConverter) {
                    $expression = $this-&gt;cssConverter-&gt;toXPath($rule-&gt;getSelector());
                } else {
                    // Compatibility layer for Symfony 2.7 and older
                    $expression = CssSelector::toXPath($rule-&gt;getSelector());
                }
            } catch (ExceptionInterface $e) {
                continue;
            }

            $elements = $xPath-&gt;query($expression);

            if ($elements === false) {
                continue;
            }

            foreach ($elements as $element) {
                $propertyStorage[$element] = $this-&gt;calculatePropertiesToBeApplied(
                    $rule-&gt;getProperties(),
                    $propertyStorage-&gt;contains($element) ? $propertyStorage[$element] : array()
                );
            }
        }

        foreach ($propertyStorage as $element) {
            $this-&gt;inlineCssOnElement($element, $propertyStorage[$element]);
        }

        return $document;
    }

    /**
     * Merge the CSS rules to determine the applied properties.
     *
     * @param Css\Property\Property[] $properties
     * @param Css\Property\Property[] $cssProperties existing applied properties indexed by name
     *
     * @return Css\Property\Property[] updated properties, indexed by name
     */
    private function calculatePropertiesToBeApplied(array $properties, array $cssProperties)
    {
        if (empty($properties)) {
            return $cssProperties;
        }

        foreach ($properties as $property) {
            if (isset($cssProperties[$property-&gt;getName()])) {
                $existingProperty = $cssProperties[$property-&gt;getName()];

                //skip check to overrule if existing property is important and current is not
                if ($existingProperty-&gt;isImportant() &amp;&amp; !$property-&gt;isImportant()) {
                    continue;
                }

                //overrule if current property is important and existing is not, else check specificity
                $overrule = !$existingProperty-&gt;isImportant() &amp;&amp; $property-&gt;isImportant();
                if (!$overrule) {
                    $overrule = $existingProperty-&gt;getOriginalSpecificity()-&gt;compareTo($property-&gt;getOriginalSpecificity()) &lt;= 0;
                }

                if ($overrule) {
                    unset($cssProperties[$property-&gt;getName()]);
                    $cssProperties[$property-&gt;getName()] = $property;
                }
            } else {
                $cssProperties[$property-&gt;getName()] = $property;
            }
        }

        return $cssProperties;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>