From 001e222f67a6963f5fdb3ecdd9f4bb924430b800 Mon Sep 17 00:00:00 2001
From: Pierre Goiffon <pierre.goiffon@combodo.com>
Date: Fri, 29 Apr 2022 14:40:27 +0200
Subject: [PATCH] =?UTF-8?q?:arrow=5Fup:=20N=C2=B04824=20Composer=20libs=20?=
 =?UTF-8?q?:=20update=20pelago/emogrifier?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 composer.json                                 |    2 +-
 composer.lock                                 |   50 +-
 lib/composer/autoload_classmap.php            |    4 +-
 lib/composer/autoload_static.php              |    4 +-
 lib/composer/installed.json                   |   50 +-
 lib/composer/installed.php                    |   10 +-
 lib/pelago/emogrifier/.gitignore              |   25 -
 lib/pelago/emogrifier/.travis.yml             |   65 -
 lib/pelago/emogrifier/CHANGELOG.md            |  225 ++-
 lib/pelago/emogrifier/CODE_OF_CONDUCT.md      |   77 -
 lib/pelago/emogrifier/README.md               |  428 +++--
 lib/pelago/emogrifier/composer.json           |   16 +-
 lib/pelago/emogrifier/config/php-cs-fixer.php |   93 -
 lib/pelago/emogrifier/config/phpmd.xml        |   49 -
 lib/pelago/emogrifier/phpcs.xml.dist          |  140 --
 lib/pelago/emogrifier/src/Emogrifier.php      |  822 ++++-----
 .../emogrifier/src/Emogrifier/CssInliner.php  | 1513 +++++++----------
 .../HtmlProcessor/AbstractHtmlProcessor.php   |  114 +-
 .../HtmlProcessor/CssToAttributeConverter.php |   32 +-
 .../HtmlProcessor/HtmlNormalizer.php          |    2 -
 .../Emogrifier/HtmlProcessor/HtmlPruner.php   |  143 ++
 .../Emogrifier/Utilities/ArrayIntersector.php |   56 +
 .../{ => Utilities}/CssConcatenator.php       |   10 +-
 23 files changed, 1886 insertions(+), 2044 deletions(-)
 delete mode 100644 lib/pelago/emogrifier/.gitignore
 delete mode 100644 lib/pelago/emogrifier/.travis.yml
 delete mode 100644 lib/pelago/emogrifier/CODE_OF_CONDUCT.md
 delete mode 100644 lib/pelago/emogrifier/config/php-cs-fixer.php
 delete mode 100644 lib/pelago/emogrifier/config/phpmd.xml
 delete mode 100644 lib/pelago/emogrifier/phpcs.xml.dist
 create mode 100644 lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlPruner.php
 create mode 100644 lib/pelago/emogrifier/src/Emogrifier/Utilities/ArrayIntersector.php
 rename lib/pelago/emogrifier/src/Emogrifier/{ => Utilities}/CssConcatenator.php (94%)

diff --git a/composer.json b/composer.json
index cd4dff996..e43adbe39 100644
--- a/composer.json
+++ b/composer.json
@@ -13,7 +13,7 @@
     "combodo/tcpdf": "~6.4.4",
     "nikic/php-parser": "~4.13.2",
     "pear/archive_tar": "~1.4.14",
-    "pelago/emogrifier": "2.1.0",
+    "pelago/emogrifier": "~3.1.0",
     "scssphp/scssphp": "1.0.6",
     "swiftmailer/swiftmailer": "5.4.12",
     "symfony/console": "~3.4.47",
diff --git a/composer.lock b/composer.lock
index 4531a89ae..3af6a5144 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "ebd8582859a03bc00f64b6155d36a387",
+    "content-hash": "92ecc4c90eca1b55654c99c1b1f8cc8e",
     "packages": [
         {
             "name": "combodo/tcpdf",
@@ -417,34 +417,34 @@
         },
         {
             "name": "pelago/emogrifier",
-            "version": "v2.1.0",
+            "version": "v3.1.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/MyIntervals/emogrifier.git",
-                "reference": "40c3d4f475d44ffc7265a760d1dd0e81f579f96f"
+                "reference": "f6a5c7d44612d86c3901c93f1592f5440e6b2cd8"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/MyIntervals/emogrifier/zipball/40c3d4f475d44ffc7265a760d1dd0e81f579f96f",
-                "reference": "40c3d4f475d44ffc7265a760d1dd0e81f579f96f",
+                "url": "https://api.github.com/repos/MyIntervals/emogrifier/zipball/f6a5c7d44612d86c3901c93f1592f5440e6b2cd8",
+                "reference": "f6a5c7d44612d86c3901c93f1592f5440e6b2cd8",
                 "shasum": ""
             },
             "require": {
                 "ext-dom": "*",
                 "ext-libxml": "*",
-                "php": "^5.5.0 || ~7.0.0 || ~7.1.0 || ~7.2.0 || ~7.3.0",
-                "symfony/css-selector": "^3.4.0 || ^4.0.0"
+                "php": "^5.6 || ~7.0 || ~7.1 || ~7.2 || ~7.3 || ~7.4",
+                "symfony/css-selector": "^2.8 || ^3.0 || ^4.0 || ^5.0"
             },
             "require-dev": {
-                "friendsofphp/php-cs-fixer": "^2.2.0",
-                "phpmd/phpmd": "^2.6.0",
-                "phpunit/phpunit": "^4.8.0",
-                "squizlabs/php_codesniffer": "^3.3.2"
+                "friendsofphp/php-cs-fixer": "^2.15.3",
+                "phpmd/phpmd": "^2.7.0",
+                "phpunit/phpunit": "^5.7.27",
+                "squizlabs/php_codesniffer": "^3.5.0"
             },
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "2.1.x-dev"
+                    "dev-master": "4.0.x-dev"
                 }
             },
             "autoload": {
@@ -457,16 +457,6 @@
                 "MIT"
             ],
             "authors": [
-                {
-                    "name": "John Reeve",
-                    "email": "jreeve@pelagodesign.com"
-                },
-                {
-                    "name": "Cameron Brooks"
-                },
-                {
-                    "name": "Jaime Prado"
-                },
                 {
                     "name": "Oliver Klee",
                     "email": "github@oliverklee.de"
@@ -475,9 +465,19 @@
                     "name": "Zoli Szabó",
                     "email": "zoli.szabo+github@gmail.com"
                 },
+                {
+                    "name": "John Reeve",
+                    "email": "jreeve@pelagodesign.com"
+                },
                 {
                     "name": "Jake Hotson",
                     "email": "jake@qzdesign.co.uk"
+                },
+                {
+                    "name": "Cameron Brooks"
+                },
+                {
+                    "name": "Jaime Prado"
                 }
             ],
             "description": "Converts CSS styles into inline style attributes in your HTML code",
@@ -487,7 +487,11 @@
                 "email",
                 "pre-processing"
             ],
-            "time": "2018-12-08T13:55:46+00:00"
+            "support": {
+                "issues": "https://github.com/MyIntervals/emogrifier/issues",
+                "source": "https://github.com/MyIntervals/emogrifier"
+            },
+            "time": "2019-12-26T19:37:31+00:00"
         },
         {
             "name": "psr/cache",
diff --git a/lib/composer/autoload_classmap.php b/lib/composer/autoload_classmap.php
index 6cc6fef1e..0e459993d 100644
--- a/lib/composer/autoload_classmap.php
+++ b/lib/composer/autoload_classmap.php
@@ -385,11 +385,13 @@ return array(
     'ParseyyStackEntry' => $baseDir . '/core/oql/build/PHP/Lempar.php',
     'ParseyyToken' => $baseDir . '/core/oql/build/PHP/Lempar.php',
     'Pelago\\Emogrifier' => $vendorDir . '/pelago/emogrifier/src/Emogrifier.php',
-    'Pelago\\Emogrifier\\CssConcatenator' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/CssConcatenator.php',
     'Pelago\\Emogrifier\\CssInliner' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/CssInliner.php',
     'Pelago\\Emogrifier\\HtmlProcessor\\AbstractHtmlProcessor' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/AbstractHtmlProcessor.php',
     'Pelago\\Emogrifier\\HtmlProcessor\\CssToAttributeConverter' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/CssToAttributeConverter.php',
     'Pelago\\Emogrifier\\HtmlProcessor\\HtmlNormalizer' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlNormalizer.php',
+    'Pelago\\Emogrifier\\HtmlProcessor\\HtmlPruner' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlPruner.php',
+    'Pelago\\Emogrifier\\Utilities\\ArrayIntersector' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/Utilities/ArrayIntersector.php',
+    'Pelago\\Emogrifier\\Utilities\\CssConcatenator' => $vendorDir . '/pelago/emogrifier/src/Emogrifier/Utilities/CssConcatenator.php',
     'PhpParser\\Builder' => $vendorDir . '/nikic/php-parser/lib/PhpParser/Builder.php',
     'PhpParser\\BuilderFactory' => $vendorDir . '/nikic/php-parser/lib/PhpParser/BuilderFactory.php',
     'PhpParser\\BuilderHelpers' => $vendorDir . '/nikic/php-parser/lib/PhpParser/BuilderHelpers.php',
diff --git a/lib/composer/autoload_static.php b/lib/composer/autoload_static.php
index 642367c39..b80d41b55 100644
--- a/lib/composer/autoload_static.php
+++ b/lib/composer/autoload_static.php
@@ -615,11 +615,13 @@ class ComposerStaticInit0018331147de7601e7552f7da8e3bb8b
         'ParseyyStackEntry' => __DIR__ . '/../..' . '/core/oql/build/PHP/Lempar.php',
         'ParseyyToken' => __DIR__ . '/../..' . '/core/oql/build/PHP/Lempar.php',
         'Pelago\\Emogrifier' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier.php',
-        'Pelago\\Emogrifier\\CssConcatenator' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/CssConcatenator.php',
         'Pelago\\Emogrifier\\CssInliner' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/CssInliner.php',
         'Pelago\\Emogrifier\\HtmlProcessor\\AbstractHtmlProcessor' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/AbstractHtmlProcessor.php',
         'Pelago\\Emogrifier\\HtmlProcessor\\CssToAttributeConverter' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/CssToAttributeConverter.php',
         'Pelago\\Emogrifier\\HtmlProcessor\\HtmlNormalizer' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlNormalizer.php',
+        'Pelago\\Emogrifier\\HtmlProcessor\\HtmlPruner' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlPruner.php',
+        'Pelago\\Emogrifier\\Utilities\\ArrayIntersector' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/Utilities/ArrayIntersector.php',
+        'Pelago\\Emogrifier\\Utilities\\CssConcatenator' => __DIR__ . '/..' . '/pelago/emogrifier/src/Emogrifier/Utilities/CssConcatenator.php',
         'PhpParser\\Builder' => __DIR__ . '/..' . '/nikic/php-parser/lib/PhpParser/Builder.php',
         'PhpParser\\BuilderFactory' => __DIR__ . '/..' . '/nikic/php-parser/lib/PhpParser/BuilderFactory.php',
         'PhpParser\\BuilderHelpers' => __DIR__ . '/..' . '/nikic/php-parser/lib/PhpParser/BuilderHelpers.php',
diff --git a/lib/composer/installed.json b/lib/composer/installed.json
index 4ada053c3..290313c8b 100644
--- a/lib/composer/installed.json
+++ b/lib/composer/installed.json
@@ -432,36 +432,36 @@
         },
         {
             "name": "pelago/emogrifier",
-            "version": "v2.1.0",
-            "version_normalized": "2.1.0.0",
+            "version": "v3.1.0",
+            "version_normalized": "3.1.0.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/MyIntervals/emogrifier.git",
-                "reference": "40c3d4f475d44ffc7265a760d1dd0e81f579f96f"
+                "reference": "f6a5c7d44612d86c3901c93f1592f5440e6b2cd8"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/MyIntervals/emogrifier/zipball/40c3d4f475d44ffc7265a760d1dd0e81f579f96f",
-                "reference": "40c3d4f475d44ffc7265a760d1dd0e81f579f96f",
+                "url": "https://api.github.com/repos/MyIntervals/emogrifier/zipball/f6a5c7d44612d86c3901c93f1592f5440e6b2cd8",
+                "reference": "f6a5c7d44612d86c3901c93f1592f5440e6b2cd8",
                 "shasum": ""
             },
             "require": {
                 "ext-dom": "*",
                 "ext-libxml": "*",
-                "php": "^5.5.0 || ~7.0.0 || ~7.1.0 || ~7.2.0 || ~7.3.0",
-                "symfony/css-selector": "^3.4.0 || ^4.0.0"
+                "php": "^5.6 || ~7.0 || ~7.1 || ~7.2 || ~7.3 || ~7.4",
+                "symfony/css-selector": "^2.8 || ^3.0 || ^4.0 || ^5.0"
             },
             "require-dev": {
-                "friendsofphp/php-cs-fixer": "^2.2.0",
-                "phpmd/phpmd": "^2.6.0",
-                "phpunit/phpunit": "^4.8.0",
-                "squizlabs/php_codesniffer": "^3.3.2"
+                "friendsofphp/php-cs-fixer": "^2.15.3",
+                "phpmd/phpmd": "^2.7.0",
+                "phpunit/phpunit": "^5.7.27",
+                "squizlabs/php_codesniffer": "^3.5.0"
             },
-            "time": "2018-12-08T13:55:46+00:00",
+            "time": "2019-12-26T19:37:31+00:00",
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "2.1.x-dev"
+                    "dev-master": "4.0.x-dev"
                 }
             },
             "installation-source": "dist",
@@ -475,16 +475,6 @@
                 "MIT"
             ],
             "authors": [
-                {
-                    "name": "John Reeve",
-                    "email": "jreeve@pelagodesign.com"
-                },
-                {
-                    "name": "Cameron Brooks"
-                },
-                {
-                    "name": "Jaime Prado"
-                },
                 {
                     "name": "Oliver Klee",
                     "email": "github@oliverklee.de"
@@ -493,9 +483,19 @@
                     "name": "Zoli Szabó",
                     "email": "zoli.szabo+github@gmail.com"
                 },
+                {
+                    "name": "John Reeve",
+                    "email": "jreeve@pelagodesign.com"
+                },
                 {
                     "name": "Jake Hotson",
                     "email": "jake@qzdesign.co.uk"
+                },
+                {
+                    "name": "Cameron Brooks"
+                },
+                {
+                    "name": "Jaime Prado"
                 }
             ],
             "description": "Converts CSS styles into inline style attributes in your HTML code",
@@ -505,6 +505,10 @@
                 "email",
                 "pre-processing"
             ],
+            "support": {
+                "issues": "https://github.com/MyIntervals/emogrifier/issues",
+                "source": "https://github.com/MyIntervals/emogrifier"
+            },
             "install-path": "../pelago/emogrifier"
         },
         {
diff --git a/lib/composer/installed.php b/lib/composer/installed.php
index 53413b733..292559691 100644
--- a/lib/composer/installed.php
+++ b/lib/composer/installed.php
@@ -5,7 +5,7 @@
         'type' => 'project',
         'install_path' => __DIR__ . '/../../',
         'aliases' => array(),
-        'reference' => '14f18371ff806c027100f6a593ec09f93d76ccf7',
+        'reference' => '9ebd884f6e55363b145c271dfc1a9d64cae4d2db',
         'name' => '__root__',
         'dev' => true,
     ),
@@ -16,7 +16,7 @@
             'type' => 'project',
             'install_path' => __DIR__ . '/../../',
             'aliases' => array(),
-            'reference' => '14f18371ff806c027100f6a593ec09f93d76ccf7',
+            'reference' => '9ebd884f6e55363b145c271dfc1a9d64cae4d2db',
             'dev_requirement' => false,
         ),
         'combodo/tcpdf' => array(
@@ -83,12 +83,12 @@
             'dev_requirement' => false,
         ),
         'pelago/emogrifier' => array(
-            'pretty_version' => 'v2.1.0',
-            'version' => '2.1.0.0',
+            'pretty_version' => 'v3.1.0',
+            'version' => '3.1.0.0',
             'type' => 'library',
             'install_path' => __DIR__ . '/../pelago/emogrifier',
             'aliases' => array(),
-            'reference' => '40c3d4f475d44ffc7265a760d1dd0e81f579f96f',
+            'reference' => 'f6a5c7d44612d86c3901c93f1592f5440e6b2cd8',
             'dev_requirement' => false,
         ),
         'psr/cache' => array(
diff --git a/lib/pelago/emogrifier/.gitignore b/lib/pelago/emogrifier/.gitignore
deleted file mode 100644
index 8bfbb851e..000000000
--- a/lib/pelago/emogrifier/.gitignore
+++ /dev/null
@@ -1,25 +0,0 @@
-#########################
-# global ignore file
-########################
-# ignoring temporary files (left by e.g. vim)
-# ignoring by common IDE's used directories/files
-# dont ignore .rej and .orig as we want to see/clean files after conflict resolution
-#
-# for local exclude patterns please edit .git/info/exclude
-#
-*~
-*.bak
-*.idea
-*.project
-*.swp
-.buildpath
-.cache
-.project
-.session
-.settings
-.TemporaryItems
-.webprj
-nbproject
-/.php_cs.cache
-/vendor/
-composer.lock
diff --git a/lib/pelago/emogrifier/.travis.yml b/lib/pelago/emogrifier/.travis.yml
deleted file mode 100644
index f3a6c22ea..000000000
--- a/lib/pelago/emogrifier/.travis.yml
+++ /dev/null
@@ -1,65 +0,0 @@
-sudo: false
-
-language: php
-
-php:
-- 5.5
-- 5.6
-- 7.0
-- 7.1
-- 7.2
-- 7.3
-
-cache:
-  directories:
-  - vendor
-  - $HOME/.composer/cache
-
-env:
-  matrix:
-  - DEPENDENCIES_PREFERENCE="--prefer-lowest"
-  - DEPENDENCIES_PREFERENCE=""
-
-before_install:
-- phpenv config-rm xdebug.ini || echo "xdebug not available"
-
-install:
-- >
-  export IGNORE_PLATFORM_REQS="$(composer php:version |grep -q '^7.3' && printf -- --ignore-platform-reqs)";
-  echo;
-  echo "Updating the dependencies";
-  composer update $IGNORE_PLATFORM_REQS --with-dependencies $DEPENDENCIES_PREFERENCE;
-  composer show;
-
-script:
-- >
-  echo;
-  echo "Validating the composer.json";
-  composer validate --no-check-all --no-check-lock --strict;
-
-- >
-  echo;
-  echo "Linting all PHP files";
-  composer ci:php:lint;
-
-- >
-  echo;
-  echo "Running the unit tests";
-  composer ci:tests:unit;
-
-- >
-  echo;
-  echo "Running PHPMD";
-  composer ci:php:md;
-
-- >
-  echo;
-  function version_gte() { test "$(printf '%s\n' "$@" | sort -n -t. -r | head -n 1)" = "$1"; };
-  if version_gte $(composer php:version) 7; then
-    echo "Installing slevomat/coding-standard only for PHP 7.x";
-    composer require $IGNORE_PLATFORM_REQS --dev slevomat/coding-standard:^4.0 $DEPENDENCIES_PREFERENCE;
-    echo "Running PHP_CodeSniffer";
-    composer ci:php:sniff;
-  else
-    echo "Skipped PHP_CodeSniffer due to insufficient PHP version: $(composer php:version)";
-  fi;
diff --git a/lib/pelago/emogrifier/CHANGELOG.md b/lib/pelago/emogrifier/CHANGELOG.md
index 938e2b511..6ee477312 100644
--- a/lib/pelago/emogrifier/CHANGELOG.md
+++ b/lib/pelago/emogrifier/CHANGELOG.md
@@ -15,6 +15,200 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ### Fixed
 
+## 3.1.0
+
+### Added
+- Add support for PHP 7.4
+  ([#821](https://github.com/MyIntervals/emogrifier/pull/821),
+  [#829](https://github.com/MyIntervals/emogrifier/pull/829))
+
+### Changed
+- Upgrade to Symfony 5.0
+  ([#822](https://github.com/MyIntervals/emogrifier/pull/820)
+
+## 3.0.0
+
+### Added
+- Test and document excluding entire subtree with `addExcludedSelector()`
+  ([#347](https://github.com/MyIntervals/emogrifier/issues/347),
+  [#768](https://github.com/MyIntervals/emogrifier/pull/768))
+- Test that rules with `:optional` or `:required` are copied to the `<style>`
+  element ([#748](https://github.com/MyIntervals/emogrifier/issues/748),
+  [#765](https://github.com/MyIntervals/emogrifier/pull/765))
+- Test that rules with `:only-of-type` are copied to the `<style>` element
+  ([#748](https://github.com/MyIntervals/emogrifier/issues/748),
+  [#760](https://github.com/MyIntervals/emogrifier/pull/760))
+- Support `:last-of-type`
+  ([#748](https://github.com/MyIntervals/emogrifier/issues/748),
+  [#758](https://github.com/MyIntervals/emogrifier/pull/758))
+- Support `:first-of-type`
+  ([#748](https://github.com/MyIntervals/emogrifier/issues/748),
+  [#757](https://github.com/MyIntervals/emogrifier/pull/757))
+- Support `:empty`
+  ([#748](https://github.com/MyIntervals/emogrifier/issues/748),
+  [#756](https://github.com/MyIntervals/emogrifier/pull/756))
+- Test that rules with `:any-link` are copied to the `<style>` element
+  ([#748](https://github.com/MyIntervals/emogrifier/issues/748),
+  [#755](https://github.com/MyIntervals/emogrifier/pull/755))
+- Support and test `:only-child`
+  ([#747](https://github.com/MyIntervals/emogrifier/issues/747),
+  [#754](https://github.com/MyIntervals/emogrifier/pull/754))
+- Support and test `:nth-last-of-type`
+  ([#747](https://github.com/MyIntervals/emogrifier/issues/747),
+  [#751](https://github.com/MyIntervals/emogrifier/pull/751))
+- Support and test `:nth-last-child`
+  ([#747](https://github.com/MyIntervals/emogrifier/issues/747),
+  [#750](https://github.com/MyIntervals/emogrifier/pull/750))
+- Support and test general sibling combinator
+  ([#723](https://github.com/MyIntervals/emogrifier/issues/723),
+  [#745](https://github.com/MyIntervals/emogrifier/pull/745))
+- Test universal selector with combinators
+  ([#723](https://github.com/MyIntervals/emogrifier/issues/723),
+  [#743](https://github.com/MyIntervals/emogrifier/pull/743))
+- Preserve `display: none` elements with `-emogrifier-keep` class
+  ([#252](https://github.com/MyIntervals/emogrifier/issues/252),
+  [#737](https://github.com/MyIntervals/emogrifier/pull/737))
+- Preserve valid `@import` rules
+  ([#338](https://github.com/MyIntervals/emogrifier/issues/338),
+  [#334](https://github.com/MyIntervals/emogrifier/pull/334),
+  [#732](https://github.com/MyIntervals/emogrifier/pull/732),
+  [#735](https://github.com/MyIntervals/emogrifier/pull/735))
+- Add `HtmlPruner::removeRedundantClassesAfterCssInlined`
+  ([#380](https://github.com/MyIntervals/emogrifier/issues/380),
+  [#724](https://github.com/MyIntervals/emogrifier/pull/724))
+- Check on Travis that PHP-CS-Fixer will not change anything
+  [#727](https://github.com/MyIntervals/emogrifier/pull/727))
+- Support `:not(…)` as an entire selector
+  ([#469](https://github.com/MyIntervals/emogrifier/issues/469),
+  [#725](https://github.com/MyIntervals/emogrifier/pull/725))
+- Add `HtmlPruner::removeRedundantClasses`
+  ([#380](https://github.com/MyIntervals/emogrifier/issues/380),
+  [#708](https://github.com/MyIntervals/emogrifier/pull/708))
+- Support multiple attributes selectors
+  ([#385](https://github.com/MyIntervals/emogrifier/issues/385),
+  [#721](https://github.com/MyIntervals/emogrifier/pull/721))
+- Support `> :first-child` and `> :last-child` in selectors
+  ([#384](https://github.com/MyIntervals/emogrifier/issues/384),
+  [#720](https://github.com/MyIntervals/emogrifier/pull/720))
+- Add an `ArrayIntersector` class
+  ([#708](https://github.com/MyIntervals/emogrifier/pull/708),
+  [#710](https://github.com/MyIntervals/emogrifier/pull/710))
+- Add `CssInliner::getMatchingUninlinableSelectors`
+  ([#380](https://github.com/MyIntervals/emogrifier/issues/380),
+  [#707](https://github.com/MyIntervals/emogrifier/pull/707))
+- Add tests for `:nth-child` and `:nth-of-type`
+  ([#71](https://github.com/MyIntervals/emogrifier/issues/71),
+  [#698](https://github.com/MyIntervals/emogrifier/pull/698))
+
+### Changed
+- Relax the dependency on `symfony/css-selector`
+  ([#762](https://github.com/MyIntervals/emogrifier/pull/762))
+- Rename `HtmlPruner::removeInvisibleNodes` to
+  `HtmlPruner::removeElementsWithDisplayNone`
+  ([#717](https://github.com/MyIntervals/emogrifier/issues/717),
+  [#718](https://github.com/MyIntervals/emogrifier/pull/718))
+- Mark the utility classes as internal
+  ([#715](https://github.com/MyIntervals/emogrifier/pull/715))
+- Move utility classes to the `Pelago\Emogrifier\Utilities` namespace
+  ([#712](https://github.com/MyIntervals/emogrifier/pull/712))
+- Make the `$css` parameter of the `inlineCss` method optional
+  ([#700](https://github.com/MyIntervals/emogrifier/pull/700))
+- Update the development dependencies
+  ([#691](https://github.com/MyIntervals/emogrifier/pull/691))
+
+### Deprecated
+- Support for PHP 5.6 will be removed in Emogrifier 4.0.
+- Deprecate the `Emogrifier` class
+  ([#701](https://github.com/MyIntervals/emogrifier/pull/701))
+
+### Removed
+- Drop `enableCssToHtmlMapping` and `disableInvisibleNodeRemoval`
+  ([#692](https://github.com/MyIntervals/emogrifier/pull/692))
+- Drop support for PHP 5.5
+  ([#690](https://github.com/MyIntervals/emogrifier/pull/690))
+
+### Fixed
+- Fix PhpStorm code inspection warnings
+  ([#729](https://github.com/MyIntervals/emogrifier/issues/729),
+  [#770](https://github.com/MyIntervals/emogrifier/pull/770))
+- Uppercase type combined with class or ID in selector
+  ([#590](https://github.com/MyIntervals/emogrifier/issues/590),
+  [#769](https://github.com/MyIntervals/emogrifier/pull/769))
+- Dynamic pseudo-class combined with static one (rules copied to `<style>`
+  element, [#746](https://github.com/MyIntervals/emogrifier/pull/746))
+- Descendant attribute selectors (such as `html input[disabled]`)
+  ([#375](https://github.com/MyIntervals/emogrifier/pull/375),
+  [#709](https://github.com/MyIntervals/emogrifier/pull/709))
+- Attribute selectors with hyphen in attribute name
+  ([#284](https://github.com/MyIntervals/emogrifier/issues/284),
+  [#540](https://github.com/MyIntervals/emogrifier/pull/540),
+  [#704](https://github.com/MyIntervals/emogrifier/pull/702))
+- Attribute selectors with space, hyphen, colon, semicolon or (most) other
+  non-alphanumeric characters in attribute value
+  ([#284](https://github.com/MyIntervals/emogrifier/issues/284),
+  [#333](https://github.com/MyIntervals/emogrifier/issues/333),
+  [#550](https://github.com/MyIntervals/emogrifier/issues/550),
+  [#540](https://github.com/MyIntervals/emogrifier/pull/540),
+  [#704](https://github.com/MyIntervals/emogrifier/pull/702))
+- Don’t create empty `style` attributes for unparsable declarations
+  ([#259](https://github.com/MyIntervals/emogrifier/issues/259),
+  [#702](https://github.com/MyIntervals/emogrifier/pull/702))
+- Allow `:not(:behavioural-pseudo-class)` in selectors
+  ([#697](https://github.com/MyIntervals/emogrifier/pull/697),
+  [#703](https://github.com/MyIntervals/emogrifier/pull/703))
+
+## 2.2.0
+
+### Added
+- Add a `HtmlPruner` class
+  ([#679](https://github.com/MyIntervals/emogrifier/pull/679))
+- Add `AbstractHtmlProcessor::fromDomDocument`
+  ([#676](https://github.com/MyIntervals/emogrifier/pull/676))
+- Add `AbstractHtmlProcessor::fromHtml`
+  ([#675](https://github.com/MyIntervals/emogrifier/pull/675))
+
+### Changed
+- Make the closures static
+  ([#674](https://github.com/MyIntervals/emogrifier/pull/674))
+- Keep `<wbr>` elements by default with `CssInliner`
+  ([#665](https://github.com/MyIntervals/emogrifier/pull/665))
+- Make the `CssInliner` inherit `AbstractHtmlProcessor`
+  ([#660](https://github.com/MyIntervals/emogrifier/pull/660))
+- Separate `CssInliner::inlineCss` and the rendering
+  ([#654](https://github.com/MyIntervals/emogrifier/pull/654))
+
+### Removed
+- Drop the removal of unprocessable tags from `CssInliner`
+  ([#685](https://github.com/MyIntervals/emogrifier/pull/685))
+- Drop the removal of invisible nodes from `CssInliner`
+  ([#684](https://github.com/MyIntervals/emogrifier/pull/684))
+
+### Fixed
+- Remove opening `<body>` tag from `body` content when element has attribute(s)
+  ([#677](https://github.com/MyIntervals/emogrifier/issues/677),
+  [#683](https://github.com/MyIntervals/emogrifier/pull/683))
+- Keep development files out of the Composer packages
+  ([#678](https://github.com/MyIntervals/emogrifier/pull/678))
+- Call all static methods statically in `CssConcatenator`
+  ([#670](https://github.com/MyIntervals/emogrifier/pull/670))
+- Support all HTML5 self-closing tags, including `<embed>`, `<source>`,
+  `<track>` and `<wbr>`
+  ([#653](https://github.com/MyIntervals/emogrifier/pull/653))
+- Remove all "unprocessable" (e.g. `<wbr>`) tags
+  ([#650](https://github.com/MyIntervals/emogrifier/pull/650))
+- Correct translated xpath of `:nth-child` selector
+  ([#648](https://github.com/MyIntervals/emogrifier/pull/648))
+
+## 2.1.1
+
+### Changed
+- Add a test that a missing document type gets added
+  ([#641](https://github.com/MyIntervals/emogrifier/pull/641))
+
+### Fixed
+- Keep the `style` element the `head`
+  ([#642](https://github.com/MyIntervals/emogrifier/pull/642))
+
 ## 2.1.0
 
 ### Added
@@ -26,7 +220,7 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   ([#633](https://github.com/MyIntervals/emogrifier/pull/633))
 - Add a `getDomDocument()` method
   ([#630](https://github.com/MyIntervals/emogrifier/pull/630))
-- Add a Composer script for PHP CS Fixer 
+- Add a Composer script for PHP CS Fixer
   ([#607](https://github.com/MyIntervals/emogrifier/pull/607))
 - Copy matching rules with dynamic pseudo-classes or pseudo-elements in
   selectors to the style element
@@ -34,18 +228,18 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   [#562](https://github.com/MyIntervals/emogrifier/pull/562),
   [#567](https://github.com/MyIntervals/emogrifier/pull/567))
 - Add a CssToAttributeConverter
-  ([#546](https://github.com/jjriv/emogrifier/pull/546))
+  ([#546](https://github.com/MyIntervals/emogrifier/pull/546))
 - Expose the DOMDocument in AbstractHtmlProcessor
-  ([#520](https://github.com/jjriv/emogrifier/pull/520))
+  ([#520](https://github.com/MyIntervals/emogrifier/pull/520))
 - Add an HtmlNormalizer class
-  ([#513](https://github.com/jjriv/emogrifier/pull/513),
-  [#516](https://github.com/jjriv/emogrifier/pull/516))
+  ([#513](https://github.com/MyIntervals/emogrifier/pull/513),
+  [#516](https://github.com/MyIntervals/emogrifier/pull/516))
 - Add a CssInliner class
-  ([#514](https://github.com/jjriv/emogrifier/pull/514),
-  [#522](https://github.com/jjriv/emogrifier/pull/522))
+  ([#514](https://github.com/MyIntervals/emogrifier/pull/514),
+  [#522](https://github.com/MyIntervals/emogrifier/pull/522))
 - Composer scripts for the various CI build steps
 - Validate the composer.json on Travis
-  ([#476](https://github.com/jjriv/emogrifier/pull/476))
+  ([#476](https://github.com/MyIntervals/emogrifier/pull/476))
 
 ### Changed
 - Mark the work-in-progress classes as `@internal`
@@ -62,20 +256,20 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Add type hint checking to the code sniffs
   ([#566](https://github.com/MyIntervals/emogrifier/pull/566))
 - Check the code with PHPMD
-  ([#561](https://github.com/jjriv/emogrifier/pull/561))
+  ([#561](https://github.com/MyIntervals/emogrifier/pull/561))
 - Add the cyclomatic complexity to the checked code sniffs
-  ([#558](https://github.com/jjriv/emogrifier/pull/558))
+  ([#558](https://github.com/MyIntervals/emogrifier/pull/558))
 - Use the Symfony CSS selector component
-  ([#540](https://github.com/jjriv/emogrifier/pull/540))
+  ([#540](https://github.com/MyIntervals/emogrifier/pull/540))
 
 ### Deprecated
 - Support for PHP 5.5 will be removed in Emogrifier 3.0.
 - Support for PHP 5.6 will be removed in Emogrifier 4.0.
 - The removal of invisible nodes will be removed in Emogrifier 3.0.
-  ([#473](https://github.com/jjriv/emogrifier/pull/473))
+  ([#473](https://github.com/MyIntervals/emogrifier/pull/473))
 - Converting CSS styles to (non-CSS) HTML attributes will be removed
   in Emogrifier 3.0. Please use the new CssToAttributeConverter instead.
-  ([#474](https://github.com/jjriv/emogrifier/pull/474))
+  ([#474](https://github.com/MyIntervals/emogrifier/pull/474))
 - Emogrifier 3.x.y will be the last release that supports usage without
   Composer (i.e., you can still require the class file).
   Starting with version 4.0, Emogrifier will only work with Composer.
@@ -114,7 +308,8 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   ignored, [#507](https://github.com/MyIntervals/emogrifier/pull/507))
 - Allow attribute selectors in descendants
   ([#506](https://github.com/MyIntervals/emogrifier/pull/506),
-  [#381](https://github.com/MyIntervals/emogrifier/issues/381))
+  [#381](https://github.com/MyIntervals/emogrifier/issues/381),
+  [#443](https://github.com/MyIntervals/emogrifier/issues/443))
 - Allow adjacent sibling CSS selector combinator in minified CSS
   ([#505](https://github.com/MyIntervals/emogrifier/pull/505))
 - Allow CSS property values containing newlines
@@ -124,7 +319,7 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 ### Added
 - Support for CSS :not() selector
-  ([#431](https://github.com/jjriv/emogrifier/pull/431))
+  ([#431](https://github.com/MyIntervals/emogrifier/pull/431))
 - Automatically remove !important annotations from final inline style declarations
   ([#420](https://github.com/MyIntervals/emogrifier/pull/420))
 - Automatically move `<style>` block from `<head>` to `<body>`
diff --git a/lib/pelago/emogrifier/CODE_OF_CONDUCT.md b/lib/pelago/emogrifier/CODE_OF_CONDUCT.md
deleted file mode 100644
index c7bc5d9e3..000000000
--- a/lib/pelago/emogrifier/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,77 +0,0 @@
-# Contributor Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age,
-body size, disability, ethnicity, gender identity and expression, level of
-experience, nationality, personal appearance, race, religion, or sexual
-identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-  advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an
-appointed representative at an online or offline event. Representation of a
-project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at (emogrifier at myintervals dot com).
-All complaints will be reviewed and investigated and will result in a response
-that is deemed necessary and appropriate to the circumstances. The project team
-is obligated to maintain confidentiality with regard to the reporter of an
-incident. Further details of specific enforcement policies may be posted
-separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 1.4, available at
-[http://contributor-covenant.org/version/1/4/][version].
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/
diff --git a/lib/pelago/emogrifier/README.md b/lib/pelago/emogrifier/README.md
index eee5b79c4..0abe18b6e 100644
--- a/lib/pelago/emogrifier/README.md
+++ b/lib/pelago/emogrifier/README.md
@@ -30,11 +30,9 @@ into inline style attributes in your HTML code.
 - [How it works](#how-it-works)
 - [Installation](#installation)
 - [Usage](#usage)
-- [Options](#options)
-- [Installing with Composer](#installing-with-composer)
 - [Supported CSS selectors](#supported-css-selectors)
 - [Caveats](#caveats)
-- [Processing HTML](#processing-html)
+- [Steps to release a new version](#steps-to-release-a-new-version)
 - [Maintainers](#maintainers)
 
 ## How it Works
@@ -45,15 +43,212 @@ selectors.
 
 ## Installation
 
-For installing emogrifier, either add pelago/emogrifier to your
-project's composer.json, or you can use composer as below:
+For installing emogrifier, either add `pelago/emogrifier` to the `require`
+section in your project's `composer.json`, or you can use composer as below:
 
 ```bash
 composer require pelago/emogrifier
 ```
 
+See https://getcomposer.org/ for more information and documentation.
+
 ## Usage
 
+### Inlining Css
+
+The most basic way to use the `CssInliner` class is to create an instance with
+the original HTML, inline the external CSS, and then get back the resulting
+HTML:
+
+```php
+use Pelago\Emogrifier\CssInliner;
+
+…
+
+$visualHtml = CssInliner::fromHtml($html)->inlineCss($css)->render();
+```
+
+If there is no external CSS file and all CSS is located within `<style>`
+elements in the HTML, you can omit the `$css` parameter:
+
+```php
+$visualHtml = CssInliner::fromHtml($html)->inlineCss()->render();
+```
+
+If you would like to get back only the content of the `<body>` element instead of
+the complete HTML document, you can use the `renderBodyContent` method instead:
+
+```php
+$bodyContent = $visualHtml = CssInliner::fromHtml($html)->inlineCss()
+  ->renderBodyContent();
+```
+
+If you would like to modify the inlining process with any of the available
+[options](#options), you will need to call the corresponding methods
+before inlining the CSS. The code then would look like this:
+
+```php
+$visualHtml = CssInliner::fromHtml($html)->disableStyleBlocksParsing()
+  ->inlineCss($css)->render();
+```
+
+There are also some other HTML-processing classes available
+(all of which are subclasses of `AbstractHtmlProcessor`) which you can use
+to further change the HTML after inlining the CSS.
+(For more details on the classes, please have a look at the sections below.)
+`CssInliner` and all HTML-processing classes can share the same `DOMDocument`
+instance to work on:
+
+```php
+use Pelago\Emogrifier\CssInliner;
+use Pelago\Emogrifier\HtmlProcessor\CssToAttributeConverter;
+use Pelago\Emogrifier\HtmlProcessor\HtmlPruner;
+
+…
+
+$cssInliner = CssInliner::fromHtml($html)->inlineCss($css);
+$domDocument = $cssInliner->getDomDocument();
+HtmlPruner::fromDomDocument($domDocument)->removeElementsWithDisplayNone()
+  ->removeRedundantClassesAfterCssInlined($cssInliner);
+$finalHtml = CssToAttributeConverter::fromDomDocument($domDocument)
+  ->convertCssToVisualAttributes()->render();
+```
+
+### Normalizing and cleaning up HTML
+
+The `HtmlNormalizer` class normalizes the given HTML in the following ways:
+
+- add a document type (HTML5) if missing
+- disentangle incorrectly nested tags
+- add HEAD and BODY elements (if they are missing)
+- reformat the HTML
+
+The class can be used like this:
+
+```php
+use Pelago\Emogrifier\HtmlProcessor\HtmlNormalizer;
+
+…
+
+$cleanHtml = HtmlNormalizer::fromHtml($rawHtml)->render();
+```
+
+### Converting CSS styles to visual HTML attributes
+
+The `CssToAttributeConverter` converts a few style attributes values to visual
+HTML attributes. This allows to get at least a bit of visual styling for email
+clients that do not support CSS well. For example, `style="width: 100px"`
+will be converted to `width="100"`.
+
+The class can be used like this:
+
+```php
+use Pelago\Emogrifier\HtmlProcessor\CssToAttributeConverter;
+
+…
+
+$visualHtml = CssToAttributeConverter::fromHtml($rawHtml)
+  ->convertCssToVisualAttributes()->render();
+```
+
+You can also have the `CssToAttributeConverter` work on a `DOMDocument`:
+
+```php
+$visualHtml = CssToAttributeConverter::fromDomDocument($domDocument)
+  ->convertCssToVisualAttributes()->render();
+```
+
+### Removing redundant content and attributes from the HTML
+
+The `HtmlPruner` class can reduce the size of the HTML by removing elements with
+a `display: none` style declaration, and/or removing classes from `class`
+attributes that are not required.
+
+It can be used like this:
+
+```php
+use Pelago\Emogrifier\HtmlProcessor\HtmlPruner;
+
+…
+
+$prunedHtml = HtmlPruner::fromHtml($html)->removeElementsWithDisplayNone()
+  ->removeRedundantClasses($classesToKeep)->render();
+```
+
+The `removeRedundantClasses` method accepts a whitelist of names of classes that
+should be retained.  If this is a post-processing step after inlining CSS, you
+can alternatively use `removeRedundantClassesAfterCssInlined`, passing it the
+`CssInliner` instance that has inlined the CSS (and having the `HtmlPruner` work
+on the `DOMDocument`).  This will use information from the `CssInliner` to
+determine which classes are still required (namely, those used in uninlinable
+rules that have been copied to a `<style>` element):
+
+```php
+$prunedHtml = HtmlPruner::fromDomDocument($cssInliner->getDomDocument())
+  ->removeElementsWithDisplayNone()
+  ->removeRedundantClassesAfterCssInlined($cssInliner)->render();
+```
+
+The `removeElementsWithDisplayNone` method will not remove any elements which
+have the class `-emogrifier-keep`.  So if, for example, there are elements which
+by default have `display: none` but are revealed by an `@media` rule, or which
+are intended as a preheader, you can add that class to those elements.  The
+paragraph in this HTML snippet will not be removed even though it has
+`display: none` (which has presumably been applied by `CssInliner::inlineCss()`
+from a CSS rule `.preheader { display: none; }`):
+
+```html
+<p class="preheader -emogrifier-keep" style="display: none;">
+  Hello World!
+</p>
+```
+
+The `removeRedundantClassesAfterCssInlined` (or `removeRedundantClasses`)
+method, if invoked after `removeElementsWithDisplayNone`, will remove the
+`-emogrifier-keep` class.
+
+### Options
+
+There are several options that you can set on the `CssInliner` instance before
+calling the `inlineCss` method (or on the `Emogrifier` instance before calling
+the `emogrify` method):
+
+* `->disableStyleBlocksParsing()` - By default, `CssInliner` will grab
+  all `<style>` blocks in the HTML and will apply the CSS styles as inline
+  "style" attributes to the HTML. The `<style>` blocks will then be removed
+  from the HTML. If you want to disable this functionality so that `CssInliner`
+  leaves these `<style>` blocks in the HTML and does not parse them, you should
+  use this option. If you use this option, the contents of the `<style>` blocks
+  will _not_ be applied as inline styles and any CSS you want `CssInliner` to
+  use must be passed in as described in the [Usage section](#usage) above.
+* `->disableInlineStylesParsing()` - By default, `CssInliner`
+  preserves all of the "style" attributes on tags in the HTML you pass to it.
+  However if you want to discard all existing inline styles in the HTML before
+  the CSS is applied, you should use this option.
+* `->addAllowedMediaType(string $mediaName)` - By default, `CssInliner`
+  will keep only media types `all`, `screen` and `print`. If you want to keep
+  some others, you can use this method to define them.
+* `->removeAllowedMediaType(string $mediaName)` - You can use this
+  method to remove media types that Emogrifier keeps.
+* `->addExcludedSelector(string $selector)` - Keeps elements from
+  being affected by CSS inlining.  Note that only elements matching the supplied
+  selector(s) will be excluded from CSS inlining, not necessarily their
+  descendants.  If you wish to exclude an entire subtree, you should provide
+  selector(s) which will match all elements in the subtree, for example by using
+  the universal selector:
+  ```php
+  $cssInliner->addExcludedSelector('.message-preview');
+  $cssInliner->addExcludedSelector('.message-preview *');
+  ```
+
+### Using the legacy Emogrifier class
+
+In version 3.0.0, the `Emogrifier` class has been deprecated, and it will be
+removed for version 4.0.0. Please update your code to use the new
+`CssInliner` class instead.
+
+If you are still using the deprecated class, here is how to use it:
+
 First, you provide Emogrifier with the HTML and CSS you would like to merge.
 This can happen directly during instantiation:
 
@@ -92,74 +287,48 @@ the complete HTML document, you can use the `emogrifyBodyContent` instead:
 $bodyContent = $emogrifier->emogrifyBodyContent();
 ```
 
-## Options
+### Migrating from `Emogrifier` to `CssInliner`
 
-There are several options that you can set on the Emogrifier object before
-calling the `emogrify` method:
+#### Minimal example
 
-* `$emogrifier->disableStyleBlocksParsing()` - By default, Emogrifier will grab
-  all `<style>` blocks in the HTML and will apply the CSS styles as inline
-  "style" attributes to the HTML. The `<style>` blocks will then be removed
-  from the HTML. If you want to disable this functionality so that Emogrifier
-  leaves these `<style>` blocks in the HTML and does not parse them, you should
-  use this option. If you use this option, the contents of the `<style>` blocks
-  will _not_ be applied as inline styles and any CSS you want Emogrifier to
-  use must be passed in as described in the [Usage section](#usage) above.
-* `$emogrifier->disableInlineStylesParsing()` - By default, Emogrifier
-  preserves all of the "style" attributes on tags in the HTML you pass to it.
-  However if you want to discard all existing inline styles in the HTML before
-  the CSS is applied, you should use this option.
-* `$emogrifier->disableInvisibleNodeRemoval()` - By default, Emogrifier removes
-  elements from the DOM that have the style attribute `display: none;`.  If
-  you would like to keep invisible elements in the DOM, use this option.
-  Note: This option will be removed in Emogrifier 3.0. HTML tags with
-  `display: none;` then will always be retained.
-* `$emogrifier->addAllowedMediaType(string $mediaName)` - By default, Emogrifier
-  will keep only media types `all`, `screen` and `print`. If you want to keep
-  some others, you can use this method to define them.
-* `$emogrifier->removeAllowedMediaType(string $mediaName)` - You can use this
-  method to remove media types that Emogrifier keeps.
-* `$emogrifier->addExcludedSelector(string $selector)` - Keeps elements from
-  being affected by emogrification.
-* `$emogrifier->enableCssToHtmlMapping()` - Some email clients don't support CSS
-  well, even if inline and prefer HTML attributes. This function allows you to
-  put properties such as height, width, background color and font color in your
-  CSS while the transformed content will have all the available HTML
-  attributes set. This option will be removed in Emogrifier 3.0. Please use the
-  `CssToAttributeConverter` class instead.
+Old code using `Emogrifier`:
 
-## Installing with Composer
-
-Download the [`composer.phar`](https://getcomposer.org/composer.phar) locally
-or install [Composer](https://getcomposer.org/) globally:
-
-```bash
-curl -s https://getcomposer.org/installer | php
+```php
+$emogrifier = new Emogrifier($html);
+$html = $emogrifier->emogrify();
 ```
 
-Run the following command for a local installation:
+New code using `CssInliner`:
 
-```bash
-php composer.phar require pelago/emogrifier:^2.1.0
+```php
+$html = CssInliner::fromHtml($html)->inlineCss()->render();
 ```
 
-Or for a global installation, run the following command:
+NB: In this example, the old code removes elements with `display: none;`
+while the new code does not, as the default behaviors of the old and
+the new class differ in this regard.
 
-```bash
-composer require pelago/emogrifier:^2.1.0
+#### More complex example
+
+Old code using `Emogrifier`:
+
+```php
+$emogrifier = new Emogrifier($html, $css);
+$emogrifier->enableCssToHtmlMapping();
+
+$html = $emogrifier->emogrify();
 ```
 
-You can also add follow lines to your `composer.json` and run the
-`composer update` command:
+New code using `CssInliner` and family:
 
-```json
-"require": {
-  "pelago/emogrifier": "^2.1.0"
-}
+```php
+$domDocument = CssInliner::fromHtml($html)->inlineCss($css)->getDomDocument();
+
+HtmlPruner::fromDomDocument($domDocument)->removeElementsWithDisplayNone(),
+$html = CssToAttributeConverter::fromDomDocument($domDocument)
+  ->convertCssToVisualAttributes()->render();
 ```
 
-See https://getcomposer.org/ for more information and documentation.
-
 ## Supported CSS selectors
 
 Emogrifier currently supports the following
@@ -168,7 +337,8 @@ Emogrifier currently supports the following
  * [type](https://developer.mozilla.org/en-US/docs/Web/CSS/Type_selectors)
  * [class](https://developer.mozilla.org/en-US/docs/Web/CSS/Class_selectors)
  * [ID](https://developer.mozilla.org/en-US/docs/Web/CSS/ID_selectors)
- * [universal](https://developer.mozilla.org/en-US/docs/Web/CSS/Universal_selectors):
+ * [universal](https://developer.mozilla.org/en-US/docs/Web/CSS/Universal_selectors)
+   (partial support)
  * [attribute](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors):
     * presence
     * exact value match
@@ -178,42 +348,103 @@ Emogrifier currently supports the following
     * value with `$` (suffix match)
     * value with `*` (substring match)
  * [adjacent](https://developer.mozilla.org/en-US/docs/Web/CSS/Adjacent_sibling_selectors)
+ * [general sibling](https://developer.mozilla.org/en-US/docs/Web/CSS/General_sibling_combinator)
  * [child](https://developer.mozilla.org/en-US/docs/Web/CSS/Child_selectors)
  * [descendant](https://developer.mozilla.org/en-US/docs/Web/CSS/Descendant_selectors)
  * [pseudo-classes](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes):
+   * [empty](https://developer.mozilla.org/en-US/docs/Web/CSS/:empty)
    * [first-child](https://developer.mozilla.org/en-US/docs/Web/CSS/:first-child)
+   * [first-of-type](https://developer.mozilla.org/en-US/docs/Web/CSS/:first-of-type)
+     (with a type, e.g. `p:first-of-type` but not `*:first-of-type` which will
+     behave as `*:first-child`)
    * [last-child](https://developer.mozilla.org/en-US/docs/Web/CSS/:last-child)
+   * [last-of-type](https://developer.mozilla.org/en-US/docs/Web/CSS/:last-of-type)
+     (with a type)
    * [not()](https://developer.mozilla.org/en-US/docs/Web/CSS/:not)
+   * [nth-child()](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-child)
+   * [nth-last-child()](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-last-child)
+   * [nth-last-of-type()](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-last-of-type)
+     (with a type)
+   * [nth-of-type()](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-of-type)
+     (with a type)
+   * [only-child](https://developer.mozilla.org/en-US/docs/Web/CSS/:only-child)
 
 The following selectors are not implemented yet:
 
- * [universal](https://developer.mozilla.org/en-US/docs/Web/CSS/Universal_selectors)
+ * [universal](https://developer.mozilla.org/en-US/docs/Web/CSS/Universal_selectors):
+   * with
+     [child combinator](https://developer.mozilla.org/en-US/docs/Web/CSS/Child_combinator)
+   * as ancestor with 
+     [descendant combinator](https://developer.mozilla.org/en-US/docs/Web/CSS/Descendant_combinator)
+     (e.g. `p *` is supported but `* p` is not)
  * [case-insensitive attribute value](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors#case-insensitive)
- * [general sibling](https://developer.mozilla.org/en-US/docs/Web/CSS/General_sibling_selectors)
- * [pseudo-classes](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes)
-   (some of them will never be supported)
+ * static [pseudo-classes](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes):
+   * [first-of-type](https://developer.mozilla.org/en-US/docs/Web/CSS/:first-of-type)
+     without a type (will behave as `:first-child`)
+   * [last-of-type](https://developer.mozilla.org/en-US/docs/Web/CSS/:last-of-type)
+     without a type (will behave as `:last-child`)
+   * [nth-last-of-type()](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-last-of-type)
+     without a type (will behave as `:nth-last-child()`)
+   * [nth-of-type()](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-of-type)
+     without a type (will behave as `:nth-child()`)
+   * any pseudo-classes not listed above as supported – rules involving them
+     will nonetheless be preserved and copied to a `<style>` element in the 
+     HTML – including (but not necessarily limited to) the following:
+     * [any-link](https://developer.mozilla.org/en-US/docs/Web/CSS/:any-link)
+     * [only-of-type](https://developer.mozilla.org/en-US/docs/Web/CSS/:only-of-type)
+     * [optional](https://developer.mozilla.org/en-US/docs/Web/CSS/:optional)
+     * [required](https://developer.mozilla.org/en-US/docs/Web/CSS/:required)
+     
+Rules involving the following selectors cannot be applied as inline styles.
+They will, however, be preserved and copied to a `<style>` element in the HTML:
+     
+ * dynamic [pseudo-classes](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-classes)
+   (such as `:hover`)
  * [pseudo-elements](https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements)
+   (such as `::after`)
 
 ## Caveats
 
 * Emogrifier requires the HTML and the CSS to be UTF-8. Encodings like
   ISO8859-1 or ISO8859-15 are not supported.
-* Emogrifier now preserves all valuable @media queries. Media queries
-  can be very useful in responsive email design. See
+* Emogrifier preserves all valuable `@media` rules.  Media queries can be very
+  useful in responsive email design.  See
   [media query support](https://litmus.com/help/email-clients/media-query-support/).
+  However, in order for them to be effective, you may need to add `!important`
+  to some of the declarations within them so that they will override CSS styles
+  that have been inlined.  For example, with the following CSS, the `font-size`
+  declaration in the `@media` rule would not override the font size for `p`
+  elements from the preceding rule after that has been inlined as 
+  `<p style="font-size: 16px;">` in the HTML, without the `!important` directive
+  (even though `!important` would not be necessary if the CSS were not inlined):
+  ```css
+  p {
+    font-size: 16px;
+  }
+  @media (max-width: 640px) {
+    p {
+      font-size: 14px !important;
+    }
+  } 
+  ```
+* Emogrifier cannot inline CSS rules involving selectors with pseudo-elements
+  (such as `::after`) or dynamic pseudo-classes (such as `:hover`) – it is
+  impossible.  However, such rules will be preserved and copied to a `<style>`
+  element, as for `@media` rules.  The same caveat about the possible need for
+  the `!important` directive also applies with pseudo-classes.
 * Emogrifier will grab existing inline style attributes _and_ will
   grab `<style>` blocks from your HTML, but it will not grab CSS files
-  referenced in <link> elements. (The problem email clients are going to ignore
-  these tags anyway, so why leave them in your HTML?)
+  referenced in `<link>` elements or `@import` rules (though it will leave them
+  intact for email clients that support them).
 * Even with styles inline, certain CSS properties are ignored by certain email
   clients. For more information, refer to these resources:
     * [http://www.email-standards.org/](http://www.email-standards.org/)
     * [https://www.campaignmonitor.com/css/](https://www.campaignmonitor.com/css/)
     * [http://templates.mailchimp.com/resources/email-client-css-support/](http://templates.mailchimp.com/resources/email-client-css-support/)
-* All CSS attributes that apply to a node will be applied, even if they are
+* All CSS attributes that apply to an element will be applied, even if they are
   redundant. For example, if you define a font attribute _and_ a font-size
-  attribute, both attributes will be applied to that node (in other words, the
-  more specific attribute will not be combined into the more general
+  attribute, both attributes will be applied to that element (in other words,
+  the more specific attribute will not be combined into the more general
   attribute).
 * There's a good chance you might encounter problems if your HTML is not
   well-formed and valid (DOMDocument might complain). If you get problems like
@@ -223,53 +454,6 @@ The following selectors are not implemented yet:
 * Emogrifier automatically converts the provided (X)HTML into HTML5, i.e.,
   self-closing tags will lose their slash. To keep your HTML valid, it is
   recommended to use HTML5 instead of one of the XHTML variants.
-* Emogrifier only supports CSS1 level selectors and a few CSS2 level selectors
-  (but not all of them). It does not support pseudo selectors. (Emogrifier
-  works by converting CSS selectors to XPath selectors, and pseudo selectors
-  cannot be converted accurately).
-
-## Processing HTML
-
-The Emogrifier package also provides classes for (post-)processing the HTML
-generated by `emogrify` (and it also works on any other HTML).
-
-### Normalizing and cleaning up HTML
-
-The `HtmlNormalizer` class normalizes the given HTML in the following ways:
-
-- add a document type (HTML5) if missing
-- disentangle incorrectly nested tags
-- add HEAD and BODY elements (if they are missing)
-- reformat the HTML
-
-The class can be used like this:
-
-```php
-$normalizer = new \Pelago\Emogrifier\HtmlProcessor\HtmlNormalizer($rawHtml);
-$cleanHtml = $normalizer->render();
-```
-
-### Converting CSS styles to visual HTML attributes
-
-The `CssToAttributeConverter` converts a few style attributes values to visual
-HTML attributes. This allows to get at least a bit of visual styling for email
-clients that do not support CSS well. For example, `style="width: 100px"`
-will be converted to `width="100"`.
-
-The class can be used like this:
-
-```php
-$converter = new \Pelago\Emogrifier\HtmlProcessor\CssToAttributeConverter($rawHtml);
-$visualHtml = $converter->convertCssToVisualAttributes()->render();
-```
-
-### Technology preview of new classes
-
-Currently, a refactoring effort is underway, aiming towards replacing the
-grown-over-time `Emogrifier` class with the new `CssInliner` class and moving
-additional HTML processing into separate `CssProcessor` classes (which will
-inherit from `AbstractHtmlProcessor`). You can try the new classes, but be
-aware that the APIs of the new classes still are subject to change. 
 
 ## Steps to release a new version
 
@@ -277,11 +461,11 @@ aware that the APIs of the new classes still are subject to change.
    changes.
 1. In the [composer.json](composer.json), update the `branch-alias` entry to
    point to the release _after_ the upcoming release.
-1. In the [README.md](README.md), update the version numbers in the section
-   [Installing with Composer](#installing-with-composer).
-1. In the [CHANGELOG.md](CHANGELOG.md), set the version number and remove any
-   empty sections.
+1. In the [CHANGELOG.md](CHANGELOG.md), create a new section with subheadings
+   for changes _after_ the upcoming release, set the version number for the
+   upcoming release, and remove any empty sections.
 1. Have the pull request reviewed and merged.
+1. Tag the new release.
 1. In the [Releases tab](https://github.com/MyIntervals/emogrifier/releases),
    create a new release and copy the change log entries to the new release.
 1. Post about the new release on social media.
diff --git a/lib/pelago/emogrifier/composer.json b/lib/pelago/emogrifier/composer.json
index b2949f9bb..0ba7072b9 100644
--- a/lib/pelago/emogrifier/composer.json
+++ b/lib/pelago/emogrifier/composer.json
@@ -37,16 +37,16 @@
         "source": "https://github.com/MyIntervals/emogrifier"
     },
     "require": {
-        "php": "^5.5.0 || ~7.0.0 || ~7.1.0 || ~7.2.0 || ~7.3.0",
+        "php": "^5.6 || ~7.0 || ~7.1 || ~7.2 || ~7.3 || ~7.4",
         "ext-dom": "*",
         "ext-libxml": "*",
-        "symfony/css-selector": "^3.4.0 || ^4.0.0"
+        "symfony/css-selector": "^2.8 || ^3.0 || ^4.0 || ^5.0"
     },
     "require-dev": {
-        "friendsofphp/php-cs-fixer": "^2.2.0",
-        "squizlabs/php_codesniffer": "^3.3.2",
-        "phpmd/phpmd": "^2.6.0",
-        "phpunit/phpunit": "^4.8.0"
+        "friendsofphp/php-cs-fixer": "^2.15.3",
+        "squizlabs/php_codesniffer": "^3.5.0",
+        "phpmd/phpmd": "^2.7.0",
+        "phpunit/phpunit": "^5.7.27"
     },
     "autoload": {
         "psr-4": {
@@ -69,6 +69,7 @@
         "php:fix": "php-cs-fixer --config=config/php-cs-fixer.php fix config/ src/ tests/",
         "ci:php:lint": "find config src tests -name '*.php' -print0 | xargs -0 -n 1 -P 4 php -l",
         "ci:php:sniff": "phpcs config src tests",
+        "ci:php:fixer": "php-cs-fixer --config=config/php-cs-fixer.php fix --dry-run -v --show-progress=dots --diff-format=udiff config/ src/ tests/",
         "ci:php:md": "phpmd src text config/phpmd.xml",
         "ci:tests:unit": "phpunit tests/",
         "ci:tests": [
@@ -80,6 +81,7 @@
         "ci:static": [
             "@ci:php:lint",
             "@ci:php:sniff",
+            "@ci:php:fixer",
             "@ci:php:md"
         ],
         "ci": [
@@ -89,7 +91,7 @@
     },
     "extra": {
         "branch-alias": {
-            "dev-master": "2.1.x-dev"
+            "dev-master": "4.0.x-dev"
         }
     }
 }
diff --git a/lib/pelago/emogrifier/config/php-cs-fixer.php b/lib/pelago/emogrifier/config/php-cs-fixer.php
deleted file mode 100644
index 4e379ee7a..000000000
--- a/lib/pelago/emogrifier/config/php-cs-fixer.php
+++ /dev/null
@@ -1,93 +0,0 @@
-<?php
-
-if (PHP_SAPI !== 'cli') {
-    die('This script supports command line usage only. Please check your command.');
-}
-
-return \PhpCsFixer\Config::create()
-    ->setRiskyAllowed(true)
-    ->setRules(
-        [
-            // copied from the TYPO3 Core
-            '@PSR2' => true,
-            '@DoctrineAnnotation' => true,
-            'no_leading_import_slash' => true,
-            'no_trailing_comma_in_singleline_array' => true,
-            'no_singleline_whitespace_before_semicolons' => true,
-            'no_unused_imports' => true,
-            'concat_space' => ['spacing' => 'one'],
-            'no_whitespace_in_blank_line' => true,
-            'ordered_imports' => true,
-            'single_quote' => true,
-            'no_empty_statement' => true,
-            'no_extra_consecutive_blank_lines' => true,
-            'phpdoc_no_package' => true,
-            'phpdoc_scalar' => true,
-            'no_blank_lines_after_phpdoc' => true,
-            'array_syntax' => ['syntax' => 'short'],
-            'whitespace_after_comma_in_array' => true,
-            'function_typehint_space' => true,
-            'hash_to_slash_comment' => true,
-            'no_alias_functions' => true,
-            'lowercase_cast' => true,
-            'no_leading_namespace_whitespace' => true,
-            'native_function_casing' => true,
-            'no_short_bool_cast' => true,
-            'no_unneeded_control_parentheses' => true,
-            'phpdoc_trim' => true,
-            'no_superfluous_elseif' => true,
-            'no_useless_else' => true,
-            'phpdoc_types' => true,
-            'phpdoc_types_order' => ['null_adjustment' => 'always_last', 'sort_algorithm' => 'none'],
-            'return_type_declaration' => ['space_before' => 'none'],
-            'cast_spaces' => ['space' => 'none'],
-            'declare_equal_normalize' => ['space' => 'single'],
-            'dir_constant' => true,
-
-            // additional rules
-            'combine_consecutive_issets' => true,
-            'combine_consecutive_unsets' => true,
-            'compact_nullable_typehint' => true,
-            // PHP >= 7.0
-            // 'declare_strict_types' => true,
-            'elseif' => true,
-            'encoding' => true,
-            'escape_implicit_backslashes' => ['single_quoted' => true],
-            'is_null' => true,
-            'linebreak_after_opening_tag' => true,
-            'magic_constant_casing' => true,
-            'method_separation' => true,
-            'modernize_types_casting' => true,
-            // not yet, but maybe later to improve performance
-            // 'native_function_invocation' => true,
-            'new_with_braces' => true,
-            'no_blank_lines_after_class_opening' => true,
-            'no_empty_comment' => true,
-            'no_empty_phpdoc' => true,
-            'no_extra_blank_lines' => true,
-            'no_multiline_whitespace_before_semicolons' => true,
-            'no_php4_constructor' => true,
-            'no_short_echo_tag' => true,
-            'no_spaces_after_function_name' => true,
-            'no_spaces_inside_parenthesis' => true,
-            'no_unneeded_curly_braces' => true,
-            'no_useless_return' => true,
-            'no_whitespace_before_comma_in_array' => true,
-            'php_unit_construct' => true,
-            'php_unit_fqcn_annotation' => true,
-            'php_unit_set_up_tear_down_visibility' => true,
-            'phpdoc_add_missing_param_annotation' => true,
-            'phpdoc_indent' => true,
-            'phpdoc_separation' => true,
-            'semicolon_after_instruction' => true,
-            'short_scalar_cast' => true,
-            'space_after_semicolon' => true,
-            'standardize_not_equals' => true,
-            'psr4' => true,
-            'ternary_operator_spaces' => true,
-            // PHP >= 7.0
-            // 'ternary_to_null_coalescing' => true,
-            'trailing_comma_in_multiline_array' => true,
-            'unary_operator_spaces' => true,
-        ]
-    );
diff --git a/lib/pelago/emogrifier/config/phpmd.xml b/lib/pelago/emogrifier/config/phpmd.xml
deleted file mode 100644
index 569409b48..000000000
--- a/lib/pelago/emogrifier/config/phpmd.xml
+++ /dev/null
@@ -1,49 +0,0 @@
-<?xml version="1.0"?>
-<ruleset name="phpList">
-    <description>
-        PHPMD rules for Emogrifier
-    </description>
-
-    <!-- The commented-out rules will be enabled once the code does not generate any warnings anymore. -->
-
-    <rule ref="rulesets/cleancode.xml/BooleanArgumentFlag"/>
-    <rule ref="rulesets/cleancode.xml/StaticAccess"/>
-
-    <rule ref="rulesets/codesize.xml/CyclomaticComplexity"/>
-    <rule ref="rulesets/codesize.xml/NPathComplexity"/>
-    <rule ref="rulesets/codesize.xml/ExcessiveMethodLength"/>
-    <!--<rule ref="rulesets/codesize.xml/ExcessiveClassLength"/>-->
-    <!--<rule ref="rulesets/codesize.xml/ExcessiveParameterList"/>-->
-    <rule ref="rulesets/codesize.xml/ExcessivePublicCount"/>
-    <!--<rule ref="rulesets/codesize.xml/TooManyFields"/>-->
-    <!--<rule ref="rulesets/codesize.xml/TooManyMethods"/>-->
-    <!--<rule ref="rulesets/codesize.xml/TooManyPublicMethods"/>-->
-    <!--<rule ref="rulesets/codesize.xml/ExcessiveClassComplexity"/>-->
-
-    <rule ref="rulesets/controversial.xml/Superglobals"/>
-    <rule ref="rulesets/controversial.xml/CamelCaseClassName"/>
-    <rule ref="rulesets/controversial.xml/CamelCasePropertyName"/>
-    <rule ref="rulesets/controversial.xml/CamelCaseMethodName"/>
-    <rule ref="rulesets/controversial.xml/CamelCaseParameterName"/>
-    <rule ref="rulesets/controversial.xml/CamelCaseVariableName"/>
-
-    <rule ref="rulesets/design.xml/ExitExpression"/>
-    <rule ref="rulesets/design.xml/EvalExpression"/>
-    <rule ref="rulesets/design.xml/GotoStatement"/>
-    <rule ref="rulesets/design.xml/NumberOfChildren"/>
-    <rule ref="rulesets/design.xml/DepthOfInheritance"/>
-    <rule ref="rulesets/design.xml/CouplingBetweenObjects"/>
-    <rule ref="rulesets/design.xml/DevelopmentCodeFragment"/>
-
-    <!--<rule ref="rulesets/naming.xml/ShortVariable"/>-->
-    <!--<rule ref="rulesets/naming.xml/LongVariable"/>-->
-    <rule ref="rulesets/naming.xml/ShortMethodName"/>
-    <rule ref="rulesets/naming.xml/ConstructorWithNameAsEnclosingClass"/>
-    <rule ref="rulesets/naming.xml/ConstantNamingConventions"/>
-    <rule ref="rulesets/naming.xml/BooleanGetMethodName"/>
-
-    <rule ref="rulesets/unusedcode.xml/UnusedPrivateField"/>
-    <rule ref="rulesets/unusedcode.xml/UnusedLocalVariable"/>
-    <!--<rule ref="rulesets/unusedcode.xml/UnusedPrivateMethod"/>-->
-    <!--<rule ref="rulesets/unusedcode.xml/UnusedFormalParameter"/>-->
-</ruleset>
diff --git a/lib/pelago/emogrifier/phpcs.xml.dist b/lib/pelago/emogrifier/phpcs.xml.dist
deleted file mode 100644
index d87f19c9e..000000000
--- a/lib/pelago/emogrifier/phpcs.xml.dist
+++ /dev/null
@@ -1,140 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ruleset name="Coding Standard">
-    <description>
-        This standard requires PHP_CodeSniffer >= 3.2.0.
-    </description>
-
-    <config name="installed_paths" value="../../slevomat/coding-standard"/>
-
-    <!--The complete PSR-2 ruleset-->
-    <rule ref="PSR2"/>
-
-    <!-- Arrays -->
-    <rule ref="Generic.Arrays.DisallowLongArraySyntax"/>
-    <rule ref="Squiz.Arrays.ArrayBracketSpacing"/>
-    <rule ref="Squiz.Arrays.ArrayDeclaration.NoCommaAfterLast"/>
-
-    <!-- Classes -->
-    <rule ref="Generic.Classes.DuplicateClassName"/>
-    <rule ref="Squiz.Classes.ClassFileName"/>
-    <rule ref="Squiz.Classes.DuplicateProperty"/>
-    <rule ref="Squiz.Classes.LowercaseClassKeywords"/>
-    <rule ref="Squiz.Classes.SelfMemberReference"/>
-
-    <!-- Code analysis -->
-    <rule ref="Generic.CodeAnalysis.EmptyStatement"/>
-    <rule ref="Generic.CodeAnalysis.AssignmentInCondition"/>
-    <rule ref="Generic.CodeAnalysis.ForLoopShouldBeWhileLoop"/>
-    <rule ref="Generic.CodeAnalysis.ForLoopWithTestFunctionCall"/>
-    <rule ref="Generic.CodeAnalysis.JumbledIncrementer"/>
-    <rule ref="Generic.CodeAnalysis.UnconditionalIfStatement"/>
-    <rule ref="Generic.CodeAnalysis.UnnecessaryFinalModifier"/>
-    <rule ref="Generic.CodeAnalysis.UnusedFunctionParameter"/>
-    <rule ref="Generic.CodeAnalysis.UselessOverridingMethod"/>
-
-    <!-- Commenting -->
-    <rule ref="Generic.Commenting.Fixme"/>
-    <rule ref="Generic.Commenting.Todo"/>
-    <rule ref="PEAR.Commenting.InlineComment"/>
-    <rule ref="Squiz.Commenting.DocCommentAlignment"/>
-    <rule ref="Squiz.Commenting.EmptyCatchComment"/>
-    <rule ref="Squiz.Commenting.FunctionComment">
-        <!-- Allow PHP-5-compatible type hinting. -->
-        <exclude name="Squiz.Commenting.FunctionComment.ScalarTypeHintMissing"/>
-        <!-- Allow no comment for self-describing parameter and exception class names. -->
-        <exclude name="Squiz.Commenting.FunctionComment.MissingParamComment"/>
-        <exclude name="Squiz.Commenting.FunctionComment.EmptyThrows"/>
-        <!-- Allow "int" rather than "integer", etc., in PHPDoc. -->
-        <exclude name="Squiz.Commenting.FunctionComment.IncorrectParamVarName"/>
-        <exclude name="Squiz.Commenting.FunctionComment.InvalidReturn"/>
-        <!-- Allow "@return" to be omitted (for methods which do not return a value). -->
-        <exclude name="Squiz.Commenting.FunctionComment.MissingReturn"/>
-        <!-- Allow parameter type, name and comment not all vertically aligned. -->
-        <exclude name="Squiz.Commenting.FunctionComment.SpacingAfterParamType"/>
-        <exclude name="Squiz.Commenting.FunctionComment.SpacingAfterParamName"/>
-        <!-- Allow parameter and exception descriptions which are not full sentences. -->
-        <exclude name="Squiz.Commenting.FunctionComment.ParamCommentNotCapital"/>
-        <exclude name="Squiz.Commenting.FunctionComment.ParamCommentFullStop"/>
-        <exclude name="Squiz.Commenting.FunctionComment.ThrowsNotCapital"/>
-        <exclude name="Squiz.Commenting.FunctionComment.ThrowsNoFullStop"/>
-    </rule>
-    <rule ref="Squiz.Commenting.FunctionCommentThrowTag"/>
-    <rule ref="Squiz.Commenting.PostStatementComment"/>
-
-    <!-- Control structures -->
-    <rule ref="PEAR.ControlStructures.ControlSignature"/>
-
-    <!-- Debug -->
-    <rule ref="Generic.Debug.ClosureLinter"/>
-
-    <!-- Files -->
-    <rule ref="Generic.Files.OneClassPerFile"/>
-    <rule ref="Generic.Files.OneInterfacePerFile"/>
-    <rule ref="Generic.Files.OneObjectStructurePerFile"/>
-    <rule ref="Zend.Files.ClosingTag"/>
-
-    <!-- Formatting -->
-    <rule ref="Generic.Formatting.NoSpaceAfterCast"/>
-    <rule ref="PEAR.Formatting.MultiLineAssignment"/>
-
-    <!-- Functions -->
-    <rule ref="Generic.Functions.CallTimePassByReference"/>
-    <rule ref="SlevomatCodingStandard.Namespaces.FullyQualifiedGlobalFunctions"/>
-    <rule ref="Squiz.Functions.FunctionDuplicateArgument"/>
-    <rule ref="Squiz.Functions.GlobalFunction"/>
-
-    <!-- Metrics -->
-    <rule ref="Generic.Metrics.CyclomaticComplexity"/>
-    <rule ref="Generic.Metrics.NestingLevel"/>
-
-    <!-- Naming conventions -->
-    <rule ref="Generic.NamingConventions.ConstructorName"/>
-    <rule ref="PEAR.NamingConventions.ValidClassName"/>
-
-    <!-- Objects -->
-    <rule ref="Squiz.Objects.ObjectMemberComma"/>
-
-    <!-- Operators -->
-    <rule ref="Squiz.Operators.IncrementDecrementUsage"/>
-    <rule ref="Squiz.Operators.ValidLogicalOperators"/>
-
-    <!-- PHP -->
-    <rule ref="Generic.PHP.BacktickOperator"/>
-    <rule ref="Generic.PHP.CharacterBeforePHPOpeningTag"/>
-    <rule ref="Generic.PHP.DeprecatedFunctions"/>
-    <rule ref="Generic.PHP.DisallowAlternativePHPTags"/>
-    <rule ref="Generic.PHP.DisallowShortOpenTag"/>
-    <rule ref="Generic.PHP.DiscourageGoto"/>
-    <rule ref="Generic.PHP.ForbiddenFunctions"/>
-    <rule ref="Generic.PHP.NoSilencedErrors"/>
-    <rule ref="Squiz.PHP.CommentedOutCode">
-        <properties>
-            <property name="maxPercentage" value="70"/>
-        </properties>
-    </rule>
-    <rule ref="Squiz.PHP.DisallowMultipleAssignments"/>
-    <rule ref="Squiz.PHP.DisallowSizeFunctionsInLoops"/>
-    <rule ref="Squiz.PHP.DiscouragedFunctions"/>
-    <rule ref="Squiz.PHP.Eval"/>
-    <rule ref="Squiz.PHP.GlobalKeyword"/>
-    <rule ref="Squiz.PHP.Heredoc"/>
-    <rule ref="Squiz.PHP.InnerFunctions"/>
-    <rule ref="Squiz.PHP.LowercasePHPFunctions"/>
-    <rule ref="Squiz.PHP.NonExecutableCode"/>
-
-    <!-- Scope -->
-    <rule ref="Squiz.Scope.MemberVarScope"/>
-    <rule ref="Squiz.Scope.StaticThisUsage"/>
-
-    <!--Strings-->
-    <rule ref="Squiz.Strings.DoubleQuoteUsage"/>
-
-    <!-- Whitespace -->
-    <rule ref="PEAR.WhiteSpace.ObjectOperatorIndent"/>
-    <rule ref="PEAR.WhiteSpace.ScopeClosingBrace"/>
-    <rule ref="Squiz.WhiteSpace.CastSpacing"/>
-    <rule ref="Squiz.WhiteSpace.LogicalOperatorSpacing"/>
-    <rule ref="Squiz.WhiteSpace.OperatorSpacing"/>
-    <rule ref="Squiz.WhiteSpace.PropertyLabelSpacing"/>
-    <rule ref="Squiz.WhiteSpace.SemicolonSpacing"/>
-</ruleset>
\ No newline at end of file
diff --git a/lib/pelago/emogrifier/src/Emogrifier.php b/lib/pelago/emogrifier/src/Emogrifier.php
index 9f1c1a218..5f6c6c55c 100644
--- a/lib/pelago/emogrifier/src/Emogrifier.php
+++ b/lib/pelago/emogrifier/src/Emogrifier.php
@@ -2,11 +2,15 @@
 
 namespace Pelago;
 
+use Pelago\Emogrifier\Utilities\CssConcatenator;
+
 /**
  * This class provides functions for converting CSS styles into inline style attributes in your HTML code.
  *
  * For more information, please see the README.md file.
  *
+ * @deprecated Will be removed for version 4.0.0. Please use the CssInliner class instead.
+ *
  * @author Cameron Brooks
  * @author Jaime Prado
  * @author Oliver Klee <github@oliverklee.de>
@@ -73,7 +77,7 @@ class Emogrifier
      *
      * @var string
      */
-    const PSEUDO_CLASS_MATCHER = '\\S+\\-(?:child|type\\()|not\\([[:ascii:]]*\\)';
+    const PSEUDO_CLASS_MATCHER = '(?:first|last|nth)-child|nth-of-type|not\\([[:ascii:]]*\\)';
 
     /**
      * @var string
@@ -85,11 +89,25 @@ class Emogrifier
      */
     const DEFAULT_DOCUMENT_TYPE = '<!DOCTYPE html>';
 
+    /**
+     * @var string Regular expression part to match tag names that PHP's DOMDocument implementation is not aware are
+     *      self-closing. These are mostly HTML5 elements, but for completeness <command> (obsolete) and <keygen>
+     *      (deprecated) are also included.
+     *
+     * @see https://bugs.php.net/bug.php?id=73175
+     */
+    const PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER = '(?:command|embed|keygen|source|track|wbr)';
+
     /**
      * @var \DOMDocument
      */
     protected $domDocument = null;
 
+    /**
+     * @var \DOMXPath
+     */
+    protected $xPath = null;
+
     /**
      * @var string
      */
@@ -156,14 +174,6 @@ class Emogrifier
      */
     private $isStyleBlocksParsingEnabled = true;
 
-    /**
-     * Determines whether elements with the `display: none` property are
-     * removed from the DOM.
-     *
-     * @var bool
-     */
-    private $shouldRemoveInvisibleNodes = true;
-
     /**
      * For calculating selector precedence order.
      * Keys are a regular expression part to match before a CSS name.
@@ -216,42 +226,6 @@ class Emogrifier
         => '\\1[substring(@\\2, string-length(@\\2) - string-length("\\3") + 1) = "\\3"]',
     ];
 
-    /**
-     * Determines whether CSS styles that have an equivalent HTML attribute
-     * should be mapped and attached to those elements.
-     *
-     * @var bool
-     */
-    private $shouldMapCssToHtml = false;
-
-    /**
-     * This multi-level array contains simple mappings of CSS properties to
-     * HTML attributes. If a mapping only applies to certain HTML nodes or
-     * only for certain values, the mapping is an object with a whitelist
-     * of nodes and values.
-     *
-     * @var mixed[][]
-     */
-    private $cssToHtmlMap = [
-        'background-color' => [
-            'attribute' => 'bgcolor',
-        ],
-        'text-align' => [
-            'attribute' => 'align',
-            'nodes' => ['p', 'div', 'td'],
-            'values' => ['left', 'right', 'center', 'justify'],
-        ],
-        'float' => [
-            'attribute' => 'align',
-            'nodes' => ['table', 'img'],
-            'values' => ['left', 'right'],
-        ],
-        'border-spacing' => [
-            'attribute' => 'cellspacing',
-            'nodes' => ['table'],
-        ],
-    ];
-
     /**
      * Emogrifier will throw Exceptions when it encounters an error instead of silently ignoring them.
      *
@@ -321,7 +295,9 @@ class Emogrifier
      */
     protected function render()
     {
-        return $this->domDocument->saveHTML();
+        $htmlWithPossibleErroneousClosingTags = $this->domDocument->saveHTML();
+
+        return $this->removeSelfClosingTagsClosingTags($htmlWithPossibleErroneousClosingTags);
     }
 
     /**
@@ -331,9 +307,22 @@ class Emogrifier
      */
     protected function renderBodyContent()
     {
-        $bodyNodeHtml = $this->domDocument->saveHTML($this->getBodyElement());
+        $htmlWithPossibleErroneousClosingTags = $this->domDocument->saveHTML($this->getBodyElement());
+        $bodyNodeHtml = $this->removeSelfClosingTagsClosingTags($htmlWithPossibleErroneousClosingTags);
 
-        return \str_replace(['<body>', '</body>'], '', $bodyNodeHtml);
+        return \preg_replace('%</?+body(?:\\s[^>]*+)?+>%', '', $bodyNodeHtml);
+    }
+
+    /**
+     * Eliminates any invalid closing tags for void elements from the given HTML.
+     *
+     * @param string $html
+     *
+     * @return string
+     */
+    private function removeSelfClosingTagsClosingTags($html)
+    {
+        return \preg_replace('%</' . self::PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER . '>%', '', $html);
     }
 
     /**
@@ -348,6 +337,18 @@ class Emogrifier
         return $this->domDocument->getElementsByTagName('body')->item(0);
     }
 
+    /**
+     * Returns the HEAD element.
+     *
+     * This method assumes that there always is a HEAD element.
+     *
+     * @return \DOMElement
+     */
+    private function getHeadElement()
+    {
+        return $this->domDocument->getElementsByTagName('head')->item(0);
+    }
+
     /**
      * Applies $this->css to the given HTML and returns the HTML with the CSS
      * applied.
@@ -425,20 +426,19 @@ class Emogrifier
     private function createRawDomDocument($html)
     {
         $domDocument = new \DOMDocument();
-        $domDocument->encoding = 'UTF-8';
         $domDocument->strictErrorChecking = false;
         $domDocument->formatOutput = true;
         $libXmlState = \libxml_use_internal_errors(true);
         $domDocument->loadHTML($this->prepareHtmlForDomConversion($html));
         \libxml_clear_errors();
         \libxml_use_internal_errors($libXmlState);
-        $domDocument->normalizeDocument();
 
         $this->domDocument = $domDocument;
+        $this->xPath = new \DOMXPath($this->domDocument);
     }
 
     /**
-     * Returns the HTML with added document type and Content-Type meta tag if needed,
+     * Returns the HTML with added document type, Content-Type meta tag, and self-closing slashes, if needed,
      * ensuring that the HTML will be good for creating a DOM document from it.
      *
      * @param string $html
@@ -447,7 +447,8 @@ class Emogrifier
      */
     private function prepareHtmlForDomConversion($html)
     {
-        $htmlWithDocumentType = $this->ensureDocumentType($html);
+        $htmlWithSelfClosingSlashes = $this->ensurePhpUnrecognizedSelfClosingTagsAreXml($html);
+        $htmlWithDocumentType = $this->ensureDocumentType($htmlWithSelfClosingSlashes);
 
         return $this->addContentTypeMetaTag($htmlWithDocumentType);
     }
@@ -466,28 +467,31 @@ class Emogrifier
         $this->clearAllCaches();
         $this->purgeVisitedNodes();
 
-        $xPath = new \DOMXPath($this->domDocument);
         \set_error_handler([$this, 'handleXpathQueryWarnings'], E_WARNING);
         $this->removeUnprocessableTags();
-        $this->normalizeStyleAttributesOfAllNodes($xPath);
+        $this->normalizeStyleAttributesOfAllNodes();
 
         // grab any existing style blocks from the html and append them to the existing CSS
         // (these blocks should be appended so as to have precedence over conflicting styles in the existing CSS)
         $allCss = $this->css;
         if ($this->isStyleBlocksParsingEnabled) {
-            $allCss .= $this->getCssFromAllStyleNodes($xPath);
+            $allCss .= $this->getCssFromAllStyleNodes();
         }
 
-        $excludedNodes = $this->getNodesToExclude($xPath);
-        $cssRules = $this->parseCssRules($allCss);
-        foreach ($cssRules['inlineable'] as $cssRule) {
+        $cssWithoutComments = $this->removeCssComments($allCss);
+        list($cssWithoutCommentsCharsetOrImport, $cssImportRules)
+            = $this->extractImportAndCharsetRules($cssWithoutComments);
+
+        $excludedNodes = $this->getNodesToExclude();
+        $cssRules = $this->parseCssRules($cssWithoutCommentsCharsetOrImport);
+        foreach ($cssRules['inlinable'] as $cssRule) {
             // There's no real way to test "PHP Warning" output generated by the following XPath query unless PHPUnit
             // converts it to an exception. Unfortunately, this would only apply to tests and not work for production
             // executions, which can still flood logs/output unnecessarily. Instead, Emogrifier's error handler should
             // always throw an exception and it must be caught here and only rethrown if in debug mode.
             try {
                 // \DOMXPath::query will always return a DOMNodeList or throw an exception when errors are caught.
-                $nodesMatchingCssSelectors = $xPath->query($this->translateCssToXpath($cssRule['selector']));
+                $nodesMatchingCssSelectors = $this->xPath->query($this->translateCssToXpath($cssRule['selector']));
             } catch (\InvalidArgumentException $e) {
                 if ($this->debug) {
                     throw $e;
@@ -500,67 +504,30 @@ class Emogrifier
                 if (\in_array($node, $excludedNodes, true)) {
                     continue;
                 }
-                $this->copyInlineableCssToStyleAttribute($node, $cssRule);
+                $this->copyInlinableCssToStyleAttribute($node, $cssRule);
             }
         }
 
         if ($this->isInlineStyleAttributesParsingEnabled) {
             $this->fillStyleAttributesWithMergedStyles();
         }
-        $this->postProcess($xPath);
 
-        $this->removeImportantAnnotationFromAllInlineStyles($xPath);
+        $this->removeImportantAnnotationFromAllInlineStyles();
 
-        $this->copyUninlineableCssToStyleNode($xPath, $cssRules['uninlineable']);
+        $this->copyUninlinableCssToStyleNode($cssRules['uninlinable'], $cssImportRules);
 
         \restore_error_handler();
     }
 
-    /**
-     * Applies some optional post-processing to the HTML in the DOM document.
-     *
-     * @param \DOMXPath $xPath
-     *
-     * @return void
-     */
-    private function postProcess(\DOMXPath $xPath)
-    {
-        if ($this->shouldMapCssToHtml) {
-            $this->mapAllInlineStylesToHtmlAttributes($xPath);
-        }
-        if ($this->shouldRemoveInvisibleNodes) {
-            $this->removeInvisibleNodes($xPath);
-        }
-    }
-
-    /**
-     * Searches for all nodes with a style attribute, transforms the CSS found
-     * to HTML attributes and adds those attributes to each node.
-     *
-     * @param \DOMXPath $xPath
-     *
-     * @return void
-     */
-    private function mapAllInlineStylesToHtmlAttributes(\DOMXPath $xPath)
-    {
-        /** @var \DOMElement $node */
-        foreach ($this->getAllNodesWithStyleAttribute($xPath) as $node) {
-            $inlineStyleDeclarations = $this->parseCssDeclarationsBlock($node->getAttribute('style'));
-            $this->mapCssToHtmlAttributes($inlineStyleDeclarations, $node);
-        }
-    }
-
     /**
      * Searches for all nodes with a style attribute and removes the "!important" annotations out of
      * the inline style declarations, eventually by rearranging declarations.
      *
-     * @param \DOMXPath $xPath
-     *
      * @return void
      */
-    private function removeImportantAnnotationFromAllInlineStyles(\DOMXPath $xPath)
+    private function removeImportantAnnotationFromAllInlineStyles()
     {
-        foreach ($this->getAllNodesWithStyleAttribute($xPath) as $node) {
+        foreach ($this->getAllNodesWithStyleAttribute() as $node) {
             $this->removeImportantAnnotationFromNodeInlineStyle($node);
         }
     }
@@ -602,234 +569,25 @@ class Emogrifier
     /**
      * Returns a list with all DOM nodes that have a style attribute.
      *
-     * @param \DOMXPath $xPath
-     *
      * @return \DOMNodeList
      */
-    private function getAllNodesWithStyleAttribute(\DOMXPath $xPath)
+    private function getAllNodesWithStyleAttribute()
     {
-        return $xPath->query('//*[@style]');
-    }
-
-    /**
-     * Applies $styles to $node.
-     *
-     * This method maps CSS styles to HTML attributes and adds those to the
-     * node.
-     *
-     * @param string[] $styles the new CSS styles taken from the global styles to be applied to this node
-     * @param \DOMElement $node node to apply styles to
-     *
-     * @return void
-     */
-    private function mapCssToHtmlAttributes(array $styles, \DOMElement $node)
-    {
-        foreach ($styles as $property => $value) {
-            // Strip !important indicator
-            $value = \trim(\str_replace('!important', '', $value));
-            $this->mapCssToHtmlAttribute($property, $value, $node);
-        }
-    }
-
-    /**
-     * Tries to apply the CSS style to $node as an attribute.
-     *
-     * This method maps a CSS rule to HTML attributes and adds those to the node.
-     *
-     * @param string $property the name of the CSS property to map
-     * @param string $value the value of the style rule to map
-     * @param \DOMElement $node node to apply styles to
-     *
-     * @return void
-     */
-    private function mapCssToHtmlAttribute($property, $value, \DOMElement $node)
-    {
-        if (!$this->mapSimpleCssProperty($property, $value, $node)) {
-            $this->mapComplexCssProperty($property, $value, $node);
-        }
-    }
-
-    /**
-     * Looks up the CSS property in the mapping table and maps it if it matches the conditions.
-     *
-     * @param string $property the name of the CSS property to map
-     * @param string $value the value of the style rule to map
-     * @param \DOMElement $node node to apply styles to
-     *
-     * @return bool true if the property can be mapped using the simple mapping table
-     */
-    private function mapSimpleCssProperty($property, $value, \DOMElement $node)
-    {
-        if (!isset($this->cssToHtmlMap[$property])) {
-            return false;
-        }
-
-        $mapping = $this->cssToHtmlMap[$property];
-        $nodesMatch = !isset($mapping['nodes']) || \in_array($node->nodeName, $mapping['nodes'], true);
-        $valuesMatch = !isset($mapping['values']) || \in_array($value, $mapping['values'], true);
-        if (!$nodesMatch || !$valuesMatch) {
-            return false;
-        }
-
-        $node->setAttribute($mapping['attribute'], $value);
-
-        return true;
-    }
-
-    /**
-     * Maps CSS properties that need special transformation to an HTML attribute.
-     *
-     * @param string $property the name of the CSS property to map
-     * @param string $value the value of the style rule to map
-     * @param \DOMElement $node node to apply styles to
-     *
-     * @return void
-     */
-    private function mapComplexCssProperty($property, $value, \DOMElement $node)
-    {
-        switch ($property) {
-            case 'background':
-                $this->mapBackgroundProperty($node, $value);
-                break;
-            case 'width':
-                // intentional fall-through
-            case 'height':
-                $this->mapWidthOrHeightProperty($node, $value, $property);
-                break;
-            case 'margin':
-                $this->mapMarginProperty($node, $value);
-                break;
-            case 'border':
-                $this->mapBorderProperty($node, $value);
-                break;
-            default:
-        }
-    }
-
-    /**
-     * Maps the "background" CSS property to visual HTML attributes.
-     *
-     * @param \DOMElement $node node to apply styles to
-     * @param string $value the value of the style rule to map
-     *
-     * @return void
-     */
-    private function mapBackgroundProperty(\DOMElement $node, $value)
-    {
-        // parse out the color, if any
-        $styles = \explode(' ', $value);
-        $first = $styles[0];
-        if (!\is_numeric($first[0]) && \strpos($first, 'url') !== 0) {
-            // as this is not a position or image, assume it's a color
-            $node->setAttribute('bgcolor', $first);
-        }
-    }
-
-    /**
-     * Maps the "width" or "height" CSS properties to visual HTML attributes.
-     *
-     * @param \DOMElement $node node to apply styles to
-     * @param string $value the value of the style rule to map
-     * @param string $property the name of the CSS property to map
-     *
-     * @return void
-     */
-    private function mapWidthOrHeightProperty(\DOMElement $node, $value, $property)
-    {
-        // only parse values in px and %, but not values like "auto"
-        if (\preg_match('/^\\d+(px|%)$/', $value)) {
-            // Remove 'px'. This regex only conserves numbers and %.
-            $number = \preg_replace('/[^0-9.%]/', '', $value);
-            $node->setAttribute($property, $number);
-        }
-    }
-
-    /**
-     * Maps the "margin" CSS property to visual HTML attributes.
-     *
-     * @param \DOMElement $node node to apply styles to
-     * @param string $value the value of the style rule to map
-     *
-     * @return void
-     */
-    private function mapMarginProperty(\DOMElement $node, $value)
-    {
-        if (!$this->isTableOrImageNode($node)) {
-            return;
-        }
-
-        $margins = $this->parseCssShorthandValue($value);
-        if ($margins['left'] === 'auto' && $margins['right'] === 'auto') {
-            $node->setAttribute('align', 'center');
-        }
-    }
-
-    /**
-     * Maps the "border" CSS property to visual HTML attributes.
-     *
-     * @param \DOMElement $node node to apply styles to
-     * @param string $value the value of the style rule to map
-     *
-     * @return void
-     */
-    private function mapBorderProperty(\DOMElement $node, $value)
-    {
-        if (!$this->isTableOrImageNode($node)) {
-            return;
-        }
-
-        if ($value === 'none' || $value === '0') {
-            $node->setAttribute('border', '0');
-        }
-    }
-
-    /**
-     * Checks whether $node is a table or img element.
-     *
-     * @param \DOMElement $node
-     *
-     * @return bool
-     */
-    private function isTableOrImageNode(\DOMElement $node)
-    {
-        return $node->nodeName === 'table' || $node->nodeName === 'img';
-    }
-
-    /**
-     * Parses a shorthand CSS value and splits it into individual values
-     *
-     * @param string $value a string of CSS value with 1, 2, 3 or 4 sizes
-     *                      For example: padding: 0 auto;
-     *                      '0 auto' is split into top: 0, left: auto, bottom: 0,
-     *                      right: auto.
-     *
-     * @return string[] an array of values for top, right, bottom and left (using these as associative array keys)
-     */
-    private function parseCssShorthandValue($value)
-    {
-        $values = \preg_split('/\\s+/', $value);
-
-        $css = [];
-        $css['top'] = $values[0];
-        $css['right'] = (\count($values) > 1) ? $values[1] : $css['top'];
-        $css['bottom'] = (\count($values) > 2) ? $values[2] : $css['top'];
-        $css['left'] = (\count($values) > 3) ? $values[3] : $css['right'];
-
-        return $css;
+        return $this->xPath->query('//*[@style]');
     }
 
     /**
      * Extracts and parses the individual rules from a CSS string.
      *
-     * @param string $css a string of raw CSS code
+     * @param string $css a string of raw CSS code with comments removed
      *
-     * @return string[][][] A 2-entry array with the key "inlineable" containing rules which can be inlined as `style`
-     *         attributes and the key "uninlineable" containing rules which cannot.  Each value is an array of string
+     * @return string[][][] A 2-entry array with the key "inlinable" containing rules which can be inlined as `style`
+     *         attributes and the key "uninlinable" containing rules which cannot.  Each value is an array of string
      *         sub-arrays with the keys
      *         "media" (the media query string, e.g. "@media screen and (max-width: 480px)",
      *         or an empty string if not from a `@media` rule),
      *         "selector" (the CSS selector, e.g., "*" or "header h1"),
-     *         "hasUnmatchablePseudo" (true if that selector contains psuedo-elements or dynamic pseudo-classes
+     *         "hasUnmatchablePseudo" (true if that selector contains pseudo-elements or dynamic pseudo-classes
      *         such that the declarations cannot be applied inline),
      *         "declarationsBlock" (the semicolon-separated CSS declarations for that selector,
      *         e.g., "color: red; height: 4px;"),
@@ -838,12 +596,12 @@ class Emogrifier
     private function parseCssRules($css)
     {
         $cssKey = \md5($css);
-        if (!isset($this->caches[static::CACHE_KEY_CSS][$cssKey])) {
+        if (!isset($this->caches[self::CACHE_KEY_CSS][$cssKey])) {
             $matches = $this->getCssRuleMatches($css);
 
             $cssRules = [
-                'inlineable' => [],
-                'uninlineable' => [],
+                'inlinable' => [],
+                'uninlinable' => [],
             ];
             /** @var string[][] $matches */
             /** @var string[] $cssRule */
@@ -853,13 +611,12 @@ class Emogrifier
                     continue;
                 }
 
-                $selectors = \explode(',', $cssRule['selectors']);
-                foreach ($selectors as $selector) {
+                foreach (\explode(',', $cssRule['selectors']) as $selector) {
                     // don't process pseudo-elements and behavioral (dynamic) pseudo-classes;
                     // only allow structural pseudo-classes
                     $hasPseudoElement = \strpos($selector, '::') !== false;
                     $hasUnsupportedPseudoClass = (bool)\preg_match(
-                        '/:(?!' . static::PSEUDO_CLASS_MATCHER . ')[\\w\\-]/i',
+                        '/:(?!' . self::PSEUDO_CLASS_MATCHER . ')[\\w\\-]/i',
                         $selector
                     );
                     $hasUnmatchablePseudo = $hasPseudoElement || $hasUnsupportedPseudoClass;
@@ -872,23 +629,23 @@ class Emogrifier
                         // keep track of where it appears in the file, since order is important
                         'line' => $key,
                     ];
-                    $ruleType = ($cssRule['media'] === '' && !$hasUnmatchablePseudo) ? 'inlineable' : 'uninlineable';
+                    $ruleType = ($cssRule['media'] === '' && !$hasUnmatchablePseudo) ? 'inlinable' : 'uninlinable';
                     $cssRules[$ruleType][] = $parsedCssRule;
                 }
             }
 
-            \usort($cssRules['inlineable'], [$this, 'sortBySelectorPrecedence']);
+            \usort($cssRules['inlinable'], [$this, 'sortBySelectorPrecedence']);
 
-            $this->caches[static::CACHE_KEY_CSS][$cssKey] = $cssRules;
+            $this->caches[self::CACHE_KEY_CSS][$cssKey] = $cssRules;
         }
 
-        return $this->caches[static::CACHE_KEY_CSS][$cssKey];
+        return $this->caches[self::CACHE_KEY_CSS][$cssKey];
     }
 
     /**
      * Parses a string of CSS into the media query, selectors and declarations for each ruleset in order.
      *
-     * @param string $css
+     * @param string $css CSS with comments removed
      *
      * @return string[][] Array of string sub-arrays with the keys
      *         "media" (the media query string, e.g. "@media screen and (max-width: 480px)",
@@ -899,9 +656,9 @@ class Emogrifier
      */
     private function getCssRuleMatches($css)
     {
-        $ruleMatches = [];
-
         $splitCss = $this->splitCssAndMediaQuery($css);
+
+        $ruleMatches = [];
         foreach ($splitCss as $cssPart) {
             // process each part for selectors and definitions
             \preg_match_all('/(?:^|[\\s^{}]*)([^{]+){([^}]*)}/mi', $cssPart['css'], $matches, PREG_SET_ORDER);
@@ -939,31 +696,6 @@ class Emogrifier
         $this->isStyleBlocksParsingEnabled = false;
     }
 
-    /**
-     * Disables the removal of elements with `display: none` properties.
-     *
-     * @deprecated will be removed in Emogrifier 3.0
-     *
-     * @return void
-     */
-    public function disableInvisibleNodeRemoval()
-    {
-        $this->shouldRemoveInvisibleNodes = false;
-    }
-
-    /**
-     * Enables the attachment/override of HTML attributes for which a
-     * corresponding CSS property has been set.
-     *
-     * @deprecated will be removed in Emogrifier 3.0, use the CssToAttributeConverter instead
-     *
-     * @return void
-     */
-    public function enableCssToHtmlMapping()
-    {
-        $this->shouldMapCssToHtml = true;
-    }
-
     /**
      * Clears all caches.
      *
@@ -972,11 +704,11 @@ class Emogrifier
     private function clearAllCaches()
     {
         $this->caches = [
-            static::CACHE_KEY_CSS => [],
-            static::CACHE_KEY_SELECTOR => [],
-            static::CACHE_KEY_XPATH => [],
-            static::CACHE_KEY_CSS_DECLARATIONS_BLOCK => [],
-            static::CACHE_KEY_COMBINED_STYLES => [],
+            self::CACHE_KEY_CSS => [],
+            self::CACHE_KEY_SELECTOR => [],
+            self::CACHE_KEY_XPATH => [],
+            self::CACHE_KEY_CSS_DECLARATIONS_BLOCK => [],
+            self::CACHE_KEY_COMBINED_STYLES => [],
         ];
     }
 
@@ -1019,6 +751,7 @@ class Emogrifier
     {
         $key = \array_search($tagName, $this->unprocessableHtmlTags, true);
         if ($key !== false) {
+            /** @var int|string $key */
             unset($this->unprocessableHtmlTags[$key]);
         }
     }
@@ -1077,50 +810,18 @@ class Emogrifier
         }
     }
 
-    /**
-     * This removes styles from your email that contain display:none.
-     * We need to look for display:none, but we need to do a case-insensitive search. Since DOMDocument only
-     * supports XPath 1.0, lower-case() isn't available to us. We've thus far only set attributes to lowercase,
-     * not attribute values. Consequently, we need to translate() the letters that would be in 'NONE' ("NOE")
-     * to lowercase.
-     *
-     * @param \DOMXPath $xPath
-     *
-     * @return void
-     */
-    private function removeInvisibleNodes(\DOMXPath $xPath)
-    {
-        $nodesWithStyleDisplayNone = $xPath->query(
-            '//*[contains(translate(translate(@style," ",""),"NOE","noe"),"display:none")]'
-        );
-        if ($nodesWithStyleDisplayNone->length === 0) {
-            return;
-        }
-
-        // The checks on parentNode and is_callable below ensure that if we've deleted the parent node,
-        // we don't try to call removeChild on a nonexistent child node
-        /** @var \DOMNode $node */
-        foreach ($nodesWithStyleDisplayNone as $node) {
-            if ($node->parentNode && \is_callable([$node->parentNode, 'removeChild'])) {
-                $node->parentNode->removeChild($node);
-            }
-        }
-    }
-
     /**
      * Parses the document and normalizes all existing CSS attributes.
      * This changes 'DISPLAY: none' to 'display: none'.
      * We wouldn't have to do this if DOMXPath supported XPath 2.0.
      * Also stores a reference of nodes with existing inline styles so we don't overwrite them.
      *
-     * @param \DOMXPath $xPath
-     *
      * @return void
      */
-    private function normalizeStyleAttributesOfAllNodes(\DOMXPath $xPath)
+    private function normalizeStyleAttributesOfAllNodes()
     {
         /** @var \DOMElement $node */
-        foreach ($this->getAllNodesWithStyleAttribute($xPath) as $node) {
+        foreach ($this->getAllNodesWithStyleAttribute() as $node) {
             if ($this->isInlineStyleAttributesParsingEnabled) {
                 $this->normalizeStyleAttributes($node);
             }
@@ -1142,8 +843,8 @@ class Emogrifier
     private function normalizeStyleAttributes(\DOMElement $node)
     {
         $normalizedOriginalStyle = \preg_replace_callback(
-            '/[A-z\\-]+(?=\\:)/S',
-            function (array $m) {
+            '/-?+[_a-zA-Z][\\w\\-]*+(?=:)/S',
+            static function (array $m) {
                 return \strtolower($m[0]);
             },
             $node->getAttribute('style')
@@ -1194,8 +895,8 @@ class Emogrifier
     private function generateStyleStringFromDeclarationsArrays(array $oldStyles, array $newStyles)
     {
         $cacheKey = \serialize([$oldStyles, $newStyles]);
-        if (isset($this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey])) {
-            return $this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey];
+        if (isset($this->caches[self::CACHE_KEY_COMBINED_STYLES][$cacheKey])) {
+            return $this->caches[self::CACHE_KEY_COMBINED_STYLES][$cacheKey];
         }
 
         // Unset the overridden styles to preserve order, important if shorthand and individual properties are mixed
@@ -1205,7 +906,8 @@ class Emogrifier
             }
 
             $newAttributeValue = $newStyles[$attributeName];
-            if ($this->attributeValueIsImportant($attributeValue)
+            if (
+                $this->attributeValueIsImportant($attributeValue)
                 && !$this->attributeValueIsImportant($newAttributeValue)
             ) {
                 unset($newStyles[$attributeName]);
@@ -1222,7 +924,7 @@ class Emogrifier
         }
         $trimmedStyle = \rtrim($style);
 
-        $this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey] = $trimmedStyle;
+        $this->caches[self::CACHE_KEY_COMBINED_STYLES][$cacheKey] = $trimmedStyle;
 
         return $trimmedStyle;
     }
@@ -1261,8 +963,13 @@ class Emogrifier
      *
      * @return void
      */
-    private function copyInlineableCssToStyleAttribute(\DOMElement $node, array $cssRule)
+    private function copyInlinableCssToStyleAttribute(\DOMElement $node, array $cssRule)
     {
+        $newStyleDeclarations = $this->parseCssDeclarationsBlock($cssRule['declarationsBlock']);
+        if ($newStyleDeclarations === []) {
+            return;
+        }
+
         // if it has a style attribute, get it, process it, and append (overwrite) new stuff
         if ($node->hasAttribute('style')) {
             // break it up into an associative array
@@ -1270,7 +977,6 @@ class Emogrifier
         } else {
             $oldStyleDeclarations = [];
         }
-        $newStyleDeclarations = $this->parseCssDeclarationsBlock($cssRule['declarationsBlock']);
         $node->setAttribute(
             'style',
             $this->generateStyleStringFromDeclarationsArrays($oldStyleDeclarations, $newStyleDeclarations)
@@ -1278,46 +984,69 @@ class Emogrifier
     }
 
     /**
-     * Applies $cssRules to $this->domDocument, limited to the rules that actually apply to the document.
+     * Applies $cssRules to $this->domDocument, limited to the rules that actually apply to the document, by placing
+     * them as CSS in a `<style>` element.
      *
-     * @param \DOMXPath $xPath
-     * @param string[][] $cssRules The "uninlineable" array of CSS rules returned by `parseCssRules`
+     * @param string[][] $cssRules the "uninlinable" array of CSS rules returned by `parseCssRules`
+     * @param string $cssImportRules This may contain any `@import` rules that should precede the CSS placed in the
+     *        `<style>` element.  If there are no unlinlinable CSS rules to copy there, a `<style>` element will be
+     *        created containing just `$cssImportRules`.  `$cssImportRules` may be an empty string; if it is, and there
+     *        are no unlinlinable CSS rules, an empty `<style>` element will not be created.
      *
      * @return void
      */
-    private function copyUninlineableCssToStyleNode(\DOMXPath $xPath, array $cssRules)
+    private function copyUninlinableCssToStyleNode(array $cssRules, $cssImportRules)
     {
-        $cssRulesRelevantForDocument = \array_filter(
-            $cssRules,
-            function (array $cssRule) use ($xPath) {
-                $selector = $cssRule['selector'];
-                if ($cssRule['hasUnmatchablePseudo']) {
-                    $selector = $this->removeUnmatchablePseudoComponents($selector);
-                }
-                return $this->existsMatchForCssSelector($xPath, $selector);
+        $css = $cssImportRules;
+
+        $cssRulesRelevantForDocument = \array_filter($cssRules, [$this, 'existsMatchForSelectorInCssRule']);
+
+        // avoid including unneeded class dependency if there are no rules
+        if ($cssRulesRelevantForDocument !== []) {
+            // support use without autoload
+            if (!\class_exists(CssConcatenator::class)) {
+                require_once __DIR__ . '/Emogrifier/Utilities/CssConcatenator.php';
             }
-        );
 
-        if ($cssRulesRelevantForDocument === []) {
-            // avoid adding empty style element (or including unneeded class dependency)
-            return;
+            $cssConcatenator = new CssConcatenator();
+            foreach ($cssRulesRelevantForDocument as $cssRule) {
+                $cssConcatenator->append([$cssRule['selector']], $cssRule['declarationsBlock'], $cssRule['media']);
+            }
+
+            $css .= $cssConcatenator->getCss();
         }
 
-        // support use without autoload
-        if (!\class_exists('Pelago\\Emogrifier\\CssConcatenator')) {
-            require_once __DIR__ . '/Emogrifier/CssConcatenator.php';
+        // avoid adding empty style element
+        if ($css !== '') {
+            $this->addStyleElementToDocument($css);
         }
+    }
 
-        $cssConcatenator = new Emogrifier\CssConcatenator();
-        foreach ($cssRulesRelevantForDocument as $cssRule) {
-            $cssConcatenator->append([$cssRule['selector']], $cssRule['declarationsBlock'], $cssRule['media']);
+    /**
+     * Checks whether there is at least one matching element for the CSS selector contained in the `selector` element
+     * of the provided CSS rule.
+     *
+     * Any dynamic pseudo-classes will be assumed to apply. If the selector matches a pseudo-element,
+     * it will test for a match with its originating element.
+     *
+     * @param string[] $cssRule
+     *
+     * @return bool
+     *
+     * @throws \InvalidArgumentException
+     */
+    private function existsMatchForSelectorInCssRule(array $cssRule)
+    {
+        $selector = $cssRule['selector'];
+        if ($cssRule['hasUnmatchablePseudo']) {
+            $selector = $this->removeUnmatchablePseudoComponents($selector);
         }
-
-        $this->addStyleElementToDocument($cssConcatenator->getCss());
+        return $this->existsMatchForCssSelector($selector);
     }
 
     /**
      * Removes pseudo-elements and dynamic pseudo-classes from a CSS selector, replacing them with "*" if necessary.
+     * If such a pseudo-component is within the argument of `:not`, the entire `:not` component is removed or replaced.
      *
      * @param string $selector
      *
@@ -1326,30 +1055,61 @@ class Emogrifier
      */
     private function removeUnmatchablePseudoComponents($selector)
     {
-        $pseudoComponentMatcher = ':(?!' . static::PSEUDO_CLASS_MATCHER . '):?+[\\w\\-]++(?:\\([^\\)]*+\\))?+';
+        // The regex allows nested brackets via `(?2)`.
+        // A space is temporarily prepended because the callback can't determine if the match was at the very start.
+        $selectorWithoutNots = \ltrim(\preg_replace_callback(
+            '/(\\s?+):not(\\([^()]*+(?:(?2)[^()]*+)*+\\))/i',
+            [$this, 'replaceUnmatchableNotComponent'],
+            ' ' . $selector
+        ));
+
+        $pseudoComponentMatcher = ':(?!' . self::PSEUDO_CLASS_MATCHER . '):?+[\\w\\-]++(?:\\([^\\)]*+\\))?+';
         return \preg_replace(
             ['/(\\s|^)' . $pseudoComponentMatcher . '/i', '/' . $pseudoComponentMatcher . '/i'],
             ['$1*', ''],
-            $selector
+            $selectorWithoutNots
         );
     }
 
+    /**
+     * Helps `removeUnmatchablePseudoComponents()` replace or remove a selector `:not(...)` component if its argument
+     * contains pseudo-elements or dynamic pseudo-classes.
+     *
+     * @param string[] $matches array of elements matched by the regular expression
+     *
+     * @return string the full match if there were no unmatchable pseudo components within; otherwise, any preceding
+     *         whitespace followed by "*", or an empty string if there was no preceding whitespace
+     */
+    private function replaceUnmatchableNotComponent(array $matches)
+    {
+        list($notComponentWithAnyPrecedingWhitespace, $anyPrecedingWhitespace, $notArgumentInBrackets) = $matches;
+
+        $hasUnmatchablePseudo = \preg_match(
+            '/:(?!' . self::PSEUDO_CLASS_MATCHER . ')[\\w\\-:]/i',
+            $notArgumentInBrackets
+        );
+
+        if ($hasUnmatchablePseudo) {
+            return $anyPrecedingWhitespace !== '' ? $anyPrecedingWhitespace . '*' : '';
+        }
+        return $notComponentWithAnyPrecedingWhitespace;
+    }
+
     /**
      * Checks whether there is at least one matching element for $cssSelector.
      * When not in debug mode, it returns true also for invalid selectors (because they may be valid,
      * just not implemented/recognized yet by Emogrifier).
      *
-     * @param \DOMXPath $xPath
      * @param string $cssSelector
      *
      * @return bool
      *
      * @throws \InvalidArgumentException
      */
-    private function existsMatchForCssSelector(\DOMXPath $xPath, $cssSelector)
+    private function existsMatchForCssSelector($cssSelector)
     {
         try {
-            $nodesMatchingSelector = $xPath->query($this->translateCssToXpath($cssSelector));
+            $nodesMatchingSelector = $this->xPath->query($this->translateCssToXpath($cssSelector));
         } catch (\InvalidArgumentException $e) {
             if ($this->debug) {
                 throw $e;
@@ -1363,13 +1123,11 @@ class Emogrifier
     /**
      * Returns CSS content.
      *
-     * @param \DOMXPath $xPath
-     *
      * @return string
      */
-    private function getCssFromAllStyleNodes(\DOMXPath $xPath)
+    private function getCssFromAllStyleNodes()
     {
-        $styleNodes = $xPath->query('//style');
+        $styleNodes = $this->xPath->query('//style');
 
         if ($styleNodes === false) {
             return '';
@@ -1390,7 +1148,7 @@ class Emogrifier
      *
      * This method is protected to allow overriding.
      *
-     * @see https://github.com/jjriv/emogrifier/issues/103
+     * @see https://github.com/MyIntervals/emogrifier/issues/103
      *
      * @param string $css
      *
@@ -1403,14 +1161,16 @@ class Emogrifier
         $styleAttribute->value = 'text/css';
         $styleElement->appendChild($styleAttribute);
 
-        $bodyElement = $this->getBodyElement();
-        $bodyElement->appendChild($styleElement);
+        $headElement = $this->getHeadElement();
+        $headElement->appendChild($styleElement);
     }
 
     /**
      * Checks that $this->domDocument has a BODY element and adds it if it is missing.
      *
      * @return void
+     *
+     * @throws \UnexpectedValueException
      */
     private function ensureExistenceOfBodyElement()
     {
@@ -1419,11 +1179,63 @@ class Emogrifier
         }
 
         $htmlElement = $this->domDocument->getElementsByTagName('html')->item(0);
+        if ($htmlElement === null) {
+            throw new \UnexpectedValueException('There is no HTML element although there should be one.', 1569930874);
+        }
         $htmlElement->appendChild($this->domDocument->createElement('body'));
     }
 
     /**
-     * Splits input CSS code into an array of parts for different media querues, in order.
+     * Removes comments from the supplied CSS.
+     *
+     * @param string $css
+     *
+     * @return string CSS with the comments removed
+     */
+    private function removeCssComments($css)
+    {
+        return \preg_replace('%/\\*[^*]*+(?:\\*(?!/)[^*]*+)*+\\*/%', '', $css);
+    }
+
+    /**
+     * Extracts `@import` and `@charset` rules from the supplied CSS.  These rules must not be preceded by any other
+     * rules, or they will be ignored.  (From the CSS 2.1 specification: "CSS 2.1 user agents must ignore any '@import'
+     * rule that occurs inside a block or after any non-ignored statement other than an @charset or an @import rule."
+     * Note also that `@charset` is case sensitive whereas `@import` is not.)
+     *
+     * @param string $css CSS with comments removed
+     *
+     * @return string[] The first element is the CSS with the valid `@import` and `@charset` rules removed.  The second
+     * element contains a concatenation of the valid `@import` rules, each followed by whatever whitespace followed it
+     * in the original CSS (so that either unminified or minified formatting is preserved); if there were no `@import`
+     * rules, it will be an empty string.  The (valid) `@charset` rules are discarded.
+     */
+    private function extractImportAndCharsetRules($css)
+    {
+        $possiblyModifiedCss = $css;
+        $importRules = '';
+
+        while (
+            \preg_match(
+                '/^\\s*+(@((?i)import(?-i)|charset)\\s[^;]++;\\s*+)/',
+                $possiblyModifiedCss,
+                $matches
+            )
+        ) {
+            list($fullMatch, $atRuleAndFollowingWhitespace, $atRuleName) = $matches;
+
+            if (\strtolower($atRuleName) === 'import') {
+                $importRules .= $atRuleAndFollowingWhitespace;
+            }
+
+            $possiblyModifiedCss = \substr($possiblyModifiedCss, \strlen($fullMatch));
+        }
+
+        return [$possiblyModifiedCss, $importRules];
+    }
+
+    /**
+     * Splits input CSS code into an array of parts for different media queries, in order.
      * Each part is an array where:
      *
      * - key "css" will contain clean CSS code (for @media rules this will be the group rule body within "{...}")
@@ -1453,8 +1265,6 @@ class Emogrifier
      */
     private function splitCssAndMediaQuery($css)
     {
-        $cssWithoutComments = \preg_replace('/\\/\\*.*\\*\\//sU', '', $css);
-
         $mediaTypesExpression = '';
         if (!empty($this->allowedMediaTypes)) {
             $mediaTypesExpression = '|' . \implode('|', \array_keys($this->allowedMediaTypes));
@@ -1463,9 +1273,9 @@ class Emogrifier
         $mediaRuleBodyMatcher = '[^{]*+{(?:[^{}]*+{.*})?\\s*+}\\s*+';
 
         $cssSplitForAllowedMediaTypes = \preg_split(
-            '#(@media\\s++(?:only\\s++)?+(?:(?=[{\\(])' . $mediaTypesExpression . ')' . $mediaRuleBodyMatcher
+            '#(@media\\s++(?:only\\s++)?+(?:(?=[{(])' . $mediaTypesExpression . ')' . $mediaRuleBodyMatcher
             . ')#misU',
-            $cssWithoutComments,
+            $css,
             -1,
             PREG_SPLIT_DELIM_CAPTURE
         );
@@ -1506,11 +1316,14 @@ class Emogrifier
     private function removeUnprocessableTags()
     {
         foreach ($this->unprocessableHtmlTags as $tagName) {
-            $nodes = $this->domDocument->getElementsByTagName($tagName);
+            // Deleting nodes from a 'live' NodeList invalidates iteration on it, so a copy must be made to iterate.
+            $nodes = [];
+            foreach ($this->domDocument->getElementsByTagName($tagName) as $node) {
+                $nodes[] = $node;
+            }
             /** @var \DOMNode $node */
             foreach ($nodes as $node) {
-                $hasContent = $node->hasChildNodes() || $node->hasChildNodes();
-                if (!$hasContent) {
+                if (!$node->hasChildNodes()) {
                     $node->parentNode->removeChild($node);
                 }
             }
@@ -1531,12 +1344,14 @@ class Emogrifier
             return $html;
         }
 
-        return static::DEFAULT_DOCUMENT_TYPE . $html;
+        return self::DEFAULT_DOCUMENT_TYPE . $html;
     }
 
     /**
      * Adds a Content-Type meta tag for the charset.
      *
+     * This method also ensures that there is a HEAD element.
+     *
      * @param string $html
      *
      * @return string the HTML with the meta tag added
@@ -1554,20 +1369,37 @@ class Emogrifier
         $hasHtmlTag = \stripos($html, '<html') !== false;
 
         if ($hasHeadTag) {
-            $reworkedHtml = \preg_replace('/<head(.*?)>/i', '<head$1>' . static::CONTENT_TYPE_META_TAG, $html);
+            $reworkedHtml = \preg_replace('/<head(.*?)>/i', '<head$1>' . self::CONTENT_TYPE_META_TAG, $html);
         } elseif ($hasHtmlTag) {
             $reworkedHtml = \preg_replace(
                 '/<html(.*?)>/i',
-                '<html$1><head>' . static::CONTENT_TYPE_META_TAG . '</head>',
+                '<html$1><head>' . self::CONTENT_TYPE_META_TAG . '</head>',
                 $html
             );
         } else {
-            $reworkedHtml = static::CONTENT_TYPE_META_TAG . $html;
+            $reworkedHtml = self::CONTENT_TYPE_META_TAG . $html;
         }
 
         return $reworkedHtml;
     }
 
+    /**
+     * Makes sure that any self-closing tags not recognized as such by PHP's DOMDocument implementation have a
+     * self-closing slash.
+     *
+     * @param string $html
+     *
+     * @return string HTML with problematic tags converted.
+     */
+    private function ensurePhpUnrecognizedSelfClosingTagsAreXml($html)
+    {
+        return \preg_replace(
+            '%<' . self::PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER . '\\b[^>]*+(?<!/)(?=>)%',
+            '$0/',
+            $html
+        );
+    }
+
     /**
      * @param string[] $a
      * @param string[] $b
@@ -1594,7 +1426,7 @@ class Emogrifier
     private function getCssSelectorPrecedence($selector)
     {
         $selectorKey = \md5($selector);
-        if (!isset($this->caches[static::CACHE_KEY_SELECTOR][$selectorKey])) {
+        if (!isset($this->caches[self::CACHE_KEY_SELECTOR][$selectorKey])) {
             $precedence = 0;
             foreach ($this->selectorPrecedenceMatchers as $matcher => $value) {
                 if (\trim($selector) === '') {
@@ -1604,10 +1436,10 @@ class Emogrifier
                 $selector = \preg_replace('/' . $matcher . '\\w+/', '', $selector, -1, $number);
                 $precedence += ($value * $number);
             }
-            $this->caches[static::CACHE_KEY_SELECTOR][$selectorKey] = $precedence;
+            $this->caches[self::CACHE_KEY_SELECTOR][$selectorKey] = $precedence;
         }
 
-        return $this->caches[static::CACHE_KEY_SELECTOR][$selectorKey];
+        return $this->caches[self::CACHE_KEY_SELECTOR][$selectorKey];
     }
 
     /**
@@ -1624,15 +1456,15 @@ class Emogrifier
         $paddedSelector = ' ' . $cssSelector . ' ';
         $lowercasePaddedSelector = \preg_replace_callback(
             '/\\s+\\w+\\s+/',
-            function (array $matches) {
+            static function (array $matches) {
                 return \strtolower($matches[0]);
             },
             $paddedSelector
         );
         $trimmedLowercaseSelector = \trim($lowercasePaddedSelector);
         $xPathKey = \md5($trimmedLowercaseSelector);
-        if (isset($this->caches[static::CACHE_KEY_XPATH][$xPathKey])) {
-            return $this->caches[static::CACHE_KEY_SELECTOR][$xPathKey];
+        if (isset($this->caches[self::CACHE_KEY_XPATH][$xPathKey])) {
+            return $this->caches[self::CACHE_KEY_SELECTOR][$xPathKey];
         }
 
         $hasNotSelector = (bool)\preg_match(
@@ -1640,17 +1472,17 @@ class Emogrifier
             $trimmedLowercaseSelector,
             $matches
         );
-        if (!$hasNotSelector) {
-            $xPath = '//' . $this->translateCssToXpathPass($trimmedLowercaseSelector);
-        } else {
+        if ($hasNotSelector) {
             /** @var string[] $matches */
             list(, $partBeforeNot, $notContents) = $matches;
             $xPath = '//' . $this->translateCssToXpathPass($partBeforeNot) .
                 '[not(' . $this->translateCssToXpathPassInline($notContents) . ')]';
+        } else {
+            $xPath = '//' . $this->translateCssToXpathPass($trimmedLowercaseSelector);
         }
-        $this->caches[static::CACHE_KEY_SELECTOR][$xPathKey] = $xPath;
+        $this->caches[self::CACHE_KEY_SELECTOR][$xPathKey] = $xPath;
 
-        return $this->caches[static::CACHE_KEY_SELECTOR][$xPathKey];
+        return $this->caches[self::CACHE_KEY_SELECTOR][$xPathKey];
     }
 
     /**
@@ -1698,12 +1530,12 @@ class Emogrifier
     ) {
         $roughXpath = \preg_replace(\array_keys($this->xPathRules), $this->xPathRules, $trimmedLowercaseSelector);
         $xPathWithIdAttributeMatchers = \preg_replace_callback(
-            static::ID_ATTRIBUTE_MATCHER,
+            self::ID_ATTRIBUTE_MATCHER,
             [$this, 'matchIdAttributes'],
             $roughXpath
         );
         $xPathWithIdAttributeAndClassMatchers = \preg_replace_callback(
-            static::CLASS_ATTRIBUTE_MATCHER,
+            self::CLASS_ATTRIBUTE_MATCHER,
             $matchClassAttributesCallback,
             $xPathWithIdAttributeMatchers
         );
@@ -1751,10 +1583,8 @@ class Emogrifier
     private function matchClassAttributesInline(array $match)
     {
         return 'contains(concat(" ",@class," "),concat(" ","' .
-            \implode(
-                '"," "))][contains(concat(" ",@class," "),concat(" ","',
-                \explode('.', \substr($match[2], 1))
-            ) . '"," "))';
+            \str_replace('.', '"," "))][contains(concat(" ",@class," "),concat(" ","', \substr($match[2], 1)) .
+            '"," "))';
     }
 
     /**
@@ -1766,25 +1596,25 @@ class Emogrifier
     {
         $parseResult = $this->parseNth($match);
 
-        if (isset($parseResult[static::MULTIPLIER])) {
-            if ($parseResult[static::MULTIPLIER] < 0) {
-                $parseResult[static::MULTIPLIER] = \abs($parseResult[static::MULTIPLIER]);
+        if (isset($parseResult[self::MULTIPLIER])) {
+            if ($parseResult[self::MULTIPLIER] < 0) {
+                $parseResult[self::MULTIPLIER] = \abs($parseResult[self::MULTIPLIER]);
                 $xPathExpression = \sprintf(
-                    '*[(last() - position()) mod %1%u = %2$u]/static::%3$s',
-                    $parseResult[static::MULTIPLIER],
-                    $parseResult[static::INDEX],
+                    '*[(last() - position()) mod %1%u = %2$u]/self::%3$s',
+                    $parseResult[self::MULTIPLIER],
+                    $parseResult[self::INDEX],
                     $match[1]
                 );
             } else {
                 $xPathExpression = \sprintf(
-                    '*[position() mod %1$u = %2$u]/static::%3$s',
-                    $parseResult[static::MULTIPLIER],
-                    $parseResult[static::INDEX],
+                    '*[position() mod %1$u = %2$u]/self::%3$s',
+                    $parseResult[self::MULTIPLIER],
+                    $parseResult[self::INDEX],
                     $match[1]
                 );
             }
         } else {
-            $xPathExpression = \sprintf('*[%1$u]/static::%2$s', $parseResult[static::INDEX], $match[1]);
+            $xPathExpression = \sprintf('*[%1$u]/self::%2$s', $parseResult[self::INDEX], $match[1]);
         }
 
         return $xPathExpression;
@@ -1799,25 +1629,25 @@ class Emogrifier
     {
         $parseResult = $this->parseNth($match);
 
-        if (isset($parseResult[static::MULTIPLIER])) {
-            if ($parseResult[static::MULTIPLIER] < 0) {
-                $parseResult[static::MULTIPLIER] = \abs($parseResult[static::MULTIPLIER]);
+        if (isset($parseResult[self::MULTIPLIER])) {
+            if ($parseResult[self::MULTIPLIER] < 0) {
+                $parseResult[self::MULTIPLIER] = \abs($parseResult[self::MULTIPLIER]);
                 $xPathExpression = \sprintf(
                     '%1$s[(last() - position()) mod %2$u = %3$u]',
                     $match[1],
-                    $parseResult[static::MULTIPLIER],
-                    $parseResult[static::INDEX]
+                    $parseResult[self::MULTIPLIER],
+                    $parseResult[self::INDEX]
                 );
             } else {
                 $xPathExpression = \sprintf(
                     '%1$s[position() mod %2$u = %3$u]',
                     $match[1],
-                    $parseResult[static::MULTIPLIER],
-                    $parseResult[static::INDEX]
+                    $parseResult[self::MULTIPLIER],
+                    $parseResult[self::INDEX]
                 );
             }
         } else {
-            $xPathExpression = \sprintf('%1$s[%2$u]', $match[1], $parseResult[static::INDEX]);
+            $xPathExpression = \sprintf('%1$s[%2$u]', $match[1], $parseResult[self::INDEX]);
         }
 
         return $xPathExpression;
@@ -1833,12 +1663,12 @@ class Emogrifier
         if (\in_array(\strtolower($match[2]), ['even', 'odd'], true)) {
             // we have "even" or "odd"
             $index = \strtolower($match[2]) === 'even' ? 0 : 1;
-            return [static::MULTIPLIER => 2, static::INDEX => $index];
+            return [self::MULTIPLIER => 2, self::INDEX => $index];
         }
         if (\stripos($match[2], 'n') === false) {
             // if there is a multiplier
             $index = (int)\str_replace(' ', '', $match[2]);
-            return [static::INDEX => $index];
+            return [self::INDEX => $index];
         }
 
         if (isset($match[3])) {
@@ -1854,7 +1684,7 @@ class Emogrifier
         if ($multiplier === '') {
             $multiplier = 1;
         } elseif ($multiplier === '0') {
-            return [static::INDEX => $index];
+            return [self::INDEX => $index];
         } else {
             $multiplier = (int)$multiplier;
         }
@@ -1863,7 +1693,7 @@ class Emogrifier
             $index += \abs($multiplier);
         }
 
-        return [static::MULTIPLIER => $multiplier, static::INDEX => $index];
+        return [self::MULTIPLIER => $multiplier, self::INDEX => $index];
     }
 
     /**
@@ -1887,14 +1717,12 @@ class Emogrifier
      */
     private function parseCssDeclarationsBlock($cssDeclarationsBlock)
     {
-        if (isset($this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock])) {
-            return $this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock];
+        if (isset($this->caches[self::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock])) {
+            return $this->caches[self::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock];
         }
 
         $properties = [];
-        $declarations = \preg_split('/;(?!base64|charset)/', $cssDeclarationsBlock);
-
-        foreach ($declarations as $declaration) {
+        foreach (\preg_split('/;(?!base64|charset)/', $cssDeclarationsBlock) as $declaration) {
             $matches = [];
             if (!\preg_match('/^([A-Za-z\\-]+)\\s*:\\s*(.+)$/s', \trim($declaration), $matches)) {
                 continue;
@@ -1904,7 +1732,7 @@ class Emogrifier
             $propertyValue = $matches[2];
             $properties[$propertyName] = $propertyValue;
         }
-        $this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock] = $properties;
+        $this->caches[self::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock] = $properties;
 
         return $properties;
     }
@@ -1912,18 +1740,16 @@ class Emogrifier
     /**
      * Find the nodes that are not to be emogrified.
      *
-     * @param \DOMXPath $xPath
-     *
      * @return \DOMElement[]
      *
      * @throws \InvalidArgumentException
      */
-    private function getNodesToExclude(\DOMXPath $xPath)
+    private function getNodesToExclude()
     {
         $excludedNodes = [];
         foreach (\array_keys($this->excludedSelectors) as $selectorToExclude) {
             try {
-                $matchingNodes = $xPath->query($this->translateCssToXpath($selectorToExclude));
+                $matchingNodes = $this->xPath->query($this->translateCssToXpath($selectorToExclude));
             } catch (\InvalidArgumentException $e) {
                 if ($this->debug) {
                     throw $e;
diff --git a/lib/pelago/emogrifier/src/Emogrifier/CssInliner.php b/lib/pelago/emogrifier/src/Emogrifier/CssInliner.php
index 3ad06c4d8..681785aaf 100644
--- a/lib/pelago/emogrifier/src/Emogrifier/CssInliner.php
+++ b/lib/pelago/emogrifier/src/Emogrifier/CssInliner.php
@@ -2,6 +2,8 @@
 
 namespace Pelago\Emogrifier;
 
+use Pelago\Emogrifier\HtmlProcessor\AbstractHtmlProcessor;
+use Pelago\Emogrifier\Utilities\CssConcatenator;
 use Symfony\Component\CssSelector\CssSelectorConverter;
 use Symfony\Component\CssSelector\Exception\SyntaxErrorException;
 
@@ -12,8 +14,6 @@ use Symfony\Component\CssSelector\Exception\SyntaxErrorException;
  *
  * For more information, please see the README.md file.
  *
- * @internal This class currently is a new technology preview, and its API is still in flux. Don't use it in production.
- *
  * @author Cameron Brooks
  * @author Jaime Prado
  * @author Oliver Klee <github@oliverklee.de>
@@ -21,7 +21,7 @@ use Symfony\Component\CssSelector\Exception\SyntaxErrorException;
  * @author Sander Kruger <s.kruger@invessel.com>
  * @author Zoli Szabó <zoli.szabo+github@gmail.com>
  */
-class CssInliner
+class CssInliner extends AbstractHtmlProcessor
 {
     /**
      * @var int
@@ -51,38 +51,14 @@ class CssInliner
      *
      * @var string
      */
-    const PSEUDO_CLASS_MATCHER = '\\S+\\-(?:child|type\\()|not\\([[:ascii:]]*\\)';
-
-    /**
-     * @var string
-     */
-    const CONTENT_TYPE_META_TAG = '<meta http-equiv="Content-Type" content="text/html; charset=utf-8">';
-
-    /**
-     * @var string
-     */
-    const DEFAULT_DOCUMENT_TYPE = '<!DOCTYPE html>';
-
-    /**
-     * @var \DOMDocument
-     */
-    protected $domDocument = null;
-
-    /**
-     * @var string
-     */
-    private $css = '';
+    const PSEUDO_CLASS_MATCHER
+        = 'empty|(?:first|last|nth(?:-last)?+|only)-child|(?:first|last|nth(?:-last)?+)-of-type|not\\([[:ascii:]]*\\)';
 
     /**
      * @var bool[]
      */
     private $excludedSelectors = [];
 
-    /**
-     * @var string[]
-     */
-    private $unprocessableHtmlTags = ['wbr'];
-
     /**
      * @var bool[]
      */
@@ -138,14 +114,6 @@ class CssInliner
      */
     private $isStyleBlocksParsingEnabled = true;
 
-    /**
-     * Determines whether elements with the `display: none` property are
-     * removed from the DOM.
-     *
-     * @var bool
-     */
-    private $shouldRemoveInvisibleNodes = true;
-
     /**
      * For calculating selector precedence order.
      * Keys are a regular expression part to match before a CSS name.
@@ -162,6 +130,14 @@ class CssInliner
         '(?:(?<![="\':\\w\\-])|::)' => 1,
     ];
 
+    /**
+     * array of data describing CSS rules which apply to the document but cannot be inlined, in the format returned by
+     * `parseCssRules`
+     *
+     * @var string[][]
+     */
+    private $matchingUninlinableCssRules = null;
+
     /**
      * Emogrifier will throw Exceptions when it encounters an error instead of silently ignoring them.
      *
@@ -170,208 +146,38 @@ class CssInliner
     private $debug = false;
 
     /**
-     * @param string $unprocessedHtml raw HTML, must be UTF-encoded, must not be empty
+     * Inlines the given CSS into the existing HTML.
      *
-     * @throws \InvalidArgumentException if $unprocessedHtml is anything other than a non-empty string
-     */
-    public function __construct($unprocessedHtml)
-    {
-        if (!\is_string($unprocessedHtml)) {
-            throw new \InvalidArgumentException('The provided HTML must be a string.', 1540403176);
-        }
-        if ($unprocessedHtml === '') {
-            throw new \InvalidArgumentException('The provided HTML must not be empty.', 1540403181);
-        }
-
-        $this->cssSelectorConverter = new CssSelectorConverter();
-
-        $this->setHtml($unprocessedHtml);
-    }
-
-    /**
-     * Sets the HTML to process.
+     * @param string $css the CSS to inline, must be UTF-8-encoded
      *
-     * @param string $html the HTML to process, must be UTF-8-encoded
-     *
-     * @return void
-     */
-    private function setHtml($html)
-    {
-        $this->createUnifiedDomDocument($html);
-    }
-
-    /**
-     * Provides access to the internal DOMDocument representation of the HTML in its current state.
-     *
-     * @return \DOMDocument
-     */
-    public function getDomDocument()
-    {
-        return $this->domDocument;
-    }
-
-    /**
-     * Sets the CSS to merge with the HTML.
-     *
-     * @param string $css the CSS to merge, must be UTF-8-encoded
-     *
-     * @return void
-     */
-    public function setCss($css)
-    {
-        $this->css = $css;
-    }
-
-    /**
-     * Renders the normalized and processed HTML.
-     *
-     * @return string
-     */
-    public function render()
-    {
-        return $this->domDocument->saveHTML();
-    }
-
-    /**
-     * Renders the content of the BODY element of the normalized and processed HTML.
-     *
-     * @return string
-     */
-    public function renderBodyContent()
-    {
-        $bodyNodeHtml = $this->domDocument->saveHTML($this->getBodyElement());
-
-        return \str_replace(['<body>', '</body>'], '', $bodyNodeHtml);
-    }
-
-    /**
-     * Returns the BODY element.
-     *
-     * This method assumes that there always is a BODY element.
-     *
-     * @return \DOMElement
-     */
-    private function getBodyElement()
-    {
-        return $this->domDocument->getElementsByTagName('body')->item(0);
-    }
-
-    /**
-     * Applies $this->css to the given HTML and returns the HTML with the CSS
-     * applied.
-     *
-     * This method places the CSS inline.
-     *
-     * @return string
+     * @return self fluent interface
      *
      * @throws SyntaxErrorException
      */
-    public function emogrify()
-    {
-        $this->process();
-
-        return $this->render();
-    }
-
-    /**
-     * Applies $this->css to the given HTML and returns only the HTML content
-     * within the <body> tag.
-     *
-     * This method places the CSS inline.
-     *
-     * @return string
-     *
-     * @throws SyntaxErrorException
-     */
-    public function emogrifyBodyContent()
-    {
-        $this->process();
-
-        return $this->renderBodyContent();
-    }
-
-    /**
-     * Creates a DOM document from the given HTML and stores it in $this->domDocument.
-     *
-     * The DOM document will always have a BODY element and a document type.
-     *
-     * @param string $html
-     *
-     * @return void
-     */
-    private function createUnifiedDomDocument($html)
-    {
-        $this->createRawDomDocument($html);
-        $this->ensureExistenceOfBodyElement();
-    }
-
-    /**
-     * Creates a DOMDocument instance from the given HTML and stores it in $this->domDocument.
-     *
-     * @param string $html
-     *
-     * @return void
-     */
-    private function createRawDomDocument($html)
-    {
-        $domDocument = new \DOMDocument();
-        $domDocument->encoding = 'UTF-8';
-        $domDocument->strictErrorChecking = false;
-        $domDocument->formatOutput = true;
-        $libXmlState = \libxml_use_internal_errors(true);
-        $domDocument->loadHTML($this->prepareHtmlForDomConversion($html));
-        \libxml_clear_errors();
-        \libxml_use_internal_errors($libXmlState);
-        $domDocument->normalizeDocument();
-
-        $this->domDocument = $domDocument;
-    }
-
-    /**
-     * Returns the HTML with added document type and Content-Type meta tag if needed,
-     * ensuring that the HTML will be good for creating a DOM document from it.
-     *
-     * @param string $html
-     *
-     * @return string the unified HTML
-     */
-    private function prepareHtmlForDomConversion($html)
-    {
-        $htmlWithDocumentType = $this->ensureDocumentType($html);
-
-        return $this->addContentTypeMetaTag($htmlWithDocumentType);
-    }
-
-    /**
-     * Applies $this->css to $this->domDocument.
-     *
-     * This method places the CSS inline.
-     *
-     * @return void
-     *
-     * @throws SyntaxErrorException
-     */
-    protected function process()
+    public function inlineCss($css = '')
     {
         $this->clearAllCaches();
         $this->purgeVisitedNodes();
 
-        $xPath = new \DOMXPath($this->domDocument);
-        $this->removeUnprocessableTags();
-        $this->normalizeStyleAttributesOfAllNodes($xPath);
+        $this->normalizeStyleAttributesOfAllNodes();
 
-        // grab any existing style blocks from the html and append them to the existing CSS
+        $combinedCss = $css;
+        // grab any existing style blocks from the HTML and append them to the existing CSS
         // (these blocks should be appended so as to have precedence over conflicting styles in the existing CSS)
-        $allCss = $this->css;
         if ($this->isStyleBlocksParsingEnabled) {
-            $allCss .= $this->getCssFromAllStyleNodes($xPath);
+            $combinedCss .= $this->getCssFromAllStyleNodes();
         }
 
-        $excludedNodes = $this->getNodesToExclude($xPath);
-        $cssRules = $this->parseCssRules($allCss);
-        foreach ($cssRules['inlineable'] as $cssRule) {
+        $cssWithoutComments = $this->removeCssComments($combinedCss);
+        list($cssWithoutCommentsCharsetOrImport, $cssImportRules)
+            = $this->extractImportAndCharsetRules($cssWithoutComments);
+
+        $excludedNodes = $this->getNodesToExclude();
+        $cssRules = $this->parseCssRules($cssWithoutCommentsCharsetOrImport);
+        $cssSelectorConverter = $this->getCssSelectorConverter();
+        foreach ($cssRules['inlinable'] as $cssRule) {
             try {
-                $nodesMatchingCssSelectors = $xPath->query($this->cssSelectorConverter->toXPath($cssRule['selector']));
+                $nodesMatchingCssSelectors = $this->xPath->query($cssSelectorConverter->toXPath($cssRule['selector']));
             } catch (SyntaxErrorException $e) {
                 if ($this->debug) {
                     throw $e;
@@ -384,194 +190,20 @@ class CssInliner
                 if (\in_array($node, $excludedNodes, true)) {
                     continue;
                 }
-                $this->copyInlineableCssToStyleAttribute($node, $cssRule);
+                $this->copyInlinableCssToStyleAttribute($node, $cssRule);
             }
         }
 
         if ($this->isInlineStyleAttributesParsingEnabled) {
             $this->fillStyleAttributesWithMergedStyles();
         }
-        $this->postProcess($xPath);
 
-        $this->removeImportantAnnotationFromAllInlineStyles($xPath);
+        $this->removeImportantAnnotationFromAllInlineStyles();
 
-        $this->copyUninlineableCssToStyleNode($xPath, $cssRules['uninlineable']);
-    }
+        $this->determineMatchingUninlinableCssRules($cssRules['uninlinable']);
+        $this->copyUninlinableCssToStyleNode($cssImportRules);
 
-    /**
-     * Applies some optional post-processing to the HTML in the DOM document.
-     *
-     * @param \DOMXPath $xPath
-     *
-     * @return void
-     */
-    private function postProcess(\DOMXPath $xPath)
-    {
-        if ($this->shouldRemoveInvisibleNodes) {
-            $this->removeInvisibleNodes($xPath);
-        }
-    }
-
-    /**
-     * Searches for all nodes with a style attribute and removes the "!important" annotations out of
-     * the inline style declarations, eventually by rearranging declarations.
-     *
-     * @param \DOMXPath $xPath
-     *
-     * @return void
-     */
-    private function removeImportantAnnotationFromAllInlineStyles(\DOMXPath $xPath)
-    {
-        foreach ($this->getAllNodesWithStyleAttribute($xPath) as $node) {
-            $this->removeImportantAnnotationFromNodeInlineStyle($node);
-        }
-    }
-
-    /**
-     * Removes the "!important" annotations out of the inline style declarations,
-     * eventually by rearranging declarations.
-     * Rearranging needed when !important shorthand properties are followed by some of their
-     * not !important expanded-version properties.
-     * For example "font: 12px serif !important; font-size: 13px;" must be reordered
-     * to "font-size: 13px; font: 12px serif;" in order to remain correct.
-     *
-     * @param \DOMElement $node
-     *
-     * @return void
-     */
-    private function removeImportantAnnotationFromNodeInlineStyle(\DOMElement $node)
-    {
-        $inlineStyleDeclarations = $this->parseCssDeclarationsBlock($node->getAttribute('style'));
-        $regularStyleDeclarations = [];
-        $importantStyleDeclarations = [];
-        foreach ($inlineStyleDeclarations as $property => $value) {
-            if ($this->attributeValueIsImportant($value)) {
-                $importantStyleDeclarations[$property] = \trim(\str_replace('!important', '', $value));
-            } else {
-                $regularStyleDeclarations[$property] = $value;
-            }
-        }
-        $inlineStyleDeclarationsInNewOrder = \array_merge(
-            $regularStyleDeclarations,
-            $importantStyleDeclarations
-        );
-        $node->setAttribute(
-            'style',
-            $this->generateStyleStringFromSingleDeclarationsArray($inlineStyleDeclarationsInNewOrder)
-        );
-    }
-
-    /**
-     * Returns a list with all DOM nodes that have a style attribute.
-     *
-     * @param \DOMXPath $xPath
-     *
-     * @return \DOMNodeList
-     */
-    private function getAllNodesWithStyleAttribute(\DOMXPath $xPath)
-    {
-        return $xPath->query('//*[@style]');
-    }
-
-    /**
-     * Extracts and parses the individual rules from a CSS string.
-     *
-     * @param string $css a string of raw CSS code
-     *
-     * @return string[][][] A 2-entry array with the key "inlineable" containing rules which can be inlined as `style`
-     *         attributes and the key "uninlineable" containing rules which cannot.  Each value is an array of string
-     *         sub-arrays with the keys
-     *         "media" (the media query string, e.g. "@media screen and (max-width: 480px)",
-     *         or an empty string if not from a `@media` rule),
-     *         "selector" (the CSS selector, e.g., "*" or "header h1"),
-     *         "hasUnmatchablePseudo" (true if that selector contains psuedo-elements or dynamic pseudo-classes
-     *         such that the declarations cannot be applied inline),
-     *         "declarationsBlock" (the semicolon-separated CSS declarations for that selector,
-     *         e.g., "color: red; height: 4px;"),
-     *         and "line" (the line number e.g. 42)
-     */
-    private function parseCssRules($css)
-    {
-        $cssKey = \md5($css);
-        if (!isset($this->caches[static::CACHE_KEY_CSS][$cssKey])) {
-            $matches = $this->getCssRuleMatches($css);
-
-            $cssRules = [
-                'inlineable' => [],
-                'uninlineable' => [],
-            ];
-            /** @var string[][] $matches */
-            /** @var string[] $cssRule */
-            foreach ($matches as $key => $cssRule) {
-                $cssDeclaration = \trim($cssRule['declarations']);
-                if ($cssDeclaration === '') {
-                    continue;
-                }
-
-                $selectors = \explode(',', $cssRule['selectors']);
-                foreach ($selectors as $selector) {
-                    // don't process pseudo-elements and behavioral (dynamic) pseudo-classes;
-                    // only allow structural pseudo-classes
-                    $hasPseudoElement = \strpos($selector, '::') !== false;
-                    $hasUnsupportedPseudoClass = (bool)\preg_match(
-                        '/:(?!' . static::PSEUDO_CLASS_MATCHER . ')[\\w\\-]/i',
-                        $selector
-                    );
-                    $hasUnmatchablePseudo = $hasPseudoElement || $hasUnsupportedPseudoClass;
-
-                    $parsedCssRule = [
-                        'media' => $cssRule['media'],
-                        'selector' => \trim($selector),
-                        'hasUnmatchablePseudo' => $hasUnmatchablePseudo,
-                        'declarationsBlock' => $cssDeclaration,
-                        // keep track of where it appears in the file, since order is important
-                        'line' => $key,
-                    ];
-                    $ruleType = ($cssRule['media'] === '' && !$hasUnmatchablePseudo) ? 'inlineable' : 'uninlineable';
-                    $cssRules[$ruleType][] = $parsedCssRule;
-                }
-            }
-
-            \usort($cssRules['inlineable'], [$this, 'sortBySelectorPrecedence']);
-
-            $this->caches[static::CACHE_KEY_CSS][$cssKey] = $cssRules;
-        }
-
-        return $this->caches[static::CACHE_KEY_CSS][$cssKey];
-    }
-
-    /**
-     * Parses a string of CSS into the media query, selectors and declarations for each ruleset in order.
-     *
-     * @param string $css
-     *
-     * @return string[][] Array of string sub-arrays with the keys
-     *         "media" (the media query string, e.g. "@media screen and (max-width: 480px)",
-     *         or an empty string if not from an `@media` rule),
-     *         "selectors" (the CSS selector(s), e.g., "*" or "h1, h2"),
-     *         "declarations" (the semicolon-separated CSS declarations for that/those selector(s),
-     *         e.g., "color: red; height: 4px;"),
-     */
-    private function getCssRuleMatches($css)
-    {
-        $ruleMatches = [];
-
-        $splitCss = $this->splitCssAndMediaQuery($css);
-        foreach ($splitCss as $cssPart) {
-            // process each part for selectors and definitions
-            \preg_match_all('/(?:^|[\\s^{}]*)([^{]+){([^}]*)}/mi', $cssPart['css'], $matches, PREG_SET_ORDER);
-
-            /** @var string[][] $matches */
-            foreach ($matches as $cssRule) {
-                $ruleMatches[] = [
-                    'media' => $cssPart['media'],
-                    'selectors' => $cssRule[1],
-                    'declarations' => $cssRule[2],
-                ];
-            }
-        }
-
-        return $ruleMatches;
+        return $this;
     }
 
     /**
@@ -594,76 +226,6 @@ class CssInliner
         $this->isStyleBlocksParsingEnabled = false;
     }
 
-    /**
-     * Disables the removal of elements with `display: none` properties.
-     *
-     * @deprecated will be removed in Emogrifier 3.0
-     *
-     * @return void
-     */
-    public function disableInvisibleNodeRemoval()
-    {
-        $this->shouldRemoveInvisibleNodes = false;
-    }
-
-    /**
-     * Clears all caches.
-     *
-     * @return void
-     */
-    private function clearAllCaches()
-    {
-        $this->caches = [
-            static::CACHE_KEY_CSS => [],
-            static::CACHE_KEY_SELECTOR => [],
-            static::CACHE_KEY_CSS_DECLARATIONS_BLOCK => [],
-            static::CACHE_KEY_COMBINED_STYLES => [],
-        ];
-    }
-
-    /**
-     * Purges the visited nodes.
-     *
-     * @return void
-     */
-    private function purgeVisitedNodes()
-    {
-        $this->visitedNodes = [];
-        $this->styleAttributesForNodes = [];
-    }
-
-    /**
-     * Marks a tag for removal.
-     *
-     * There are some HTML tags that DOMDocument cannot process, and it will throw an error if it encounters them.
-     * In particular, DOMDocument will complain if you try to use HTML5 tags in an XHTML document.
-     *
-     * Note: The tags will not be removed if they have any content.
-     *
-     * @param string $tagName the tag name, e.g., "p"
-     *
-     * @return void
-     */
-    public function addUnprocessableHtmlTag($tagName)
-    {
-        $this->unprocessableHtmlTags[] = $tagName;
-    }
-
-    /**
-     * Drops a tag from the removal list.
-     *
-     * @param string $tagName the tag name, e.g., "p"
-     *
-     * @return void
-     */
-    public function removeUnprocessableHtmlTag($tagName)
-    {
-        $key = \array_search($tagName, $this->unprocessableHtmlTags, true);
-        if ($key !== false) {
-            unset($this->unprocessableHtmlTags[$key]);
-        }
-    }
-
     /**
      * Marks a media query type to keep.
      *
@@ -719,33 +281,60 @@ class CssInliner
     }
 
     /**
-     * This removes styles from your email that contain display:none.
-     * We need to look for display:none, but we need to do a case-insensitive search. Since DOMDocument only
-     * supports XPath 1.0, lower-case() isn't available to us. We've thus far only set attributes to lowercase,
-     * not attribute values. Consequently, we need to translate() the letters that would be in 'NONE' ("NOE")
-     * to lowercase.
+     * Sets the debug mode.
      *
-     * @param \DOMXPath $xPath
+     * @param bool $debug set to true to enable debug mode
      *
      * @return void
      */
-    private function removeInvisibleNodes(\DOMXPath $xPath)
+    public function setDebug($debug)
     {
-        $nodesWithStyleDisplayNone = $xPath->query(
-            '//*[contains(translate(translate(@style," ",""),"NOE","noe"),"display:none")]'
-        );
-        if ($nodesWithStyleDisplayNone->length === 0) {
-            return;
+        $this->debug = $debug;
+    }
+
+    /**
+     * Gets the array of selectors present in the CSS provided to `inlineCss()` for which the declarations could not be
+     * applied as inline styles, but which may affect elements in the HTML.  The relevant CSS will have been placed in a
+     * `<style>` element.  The selectors may include those used within `@media` rules or those involving dynamic
+     * pseudo-classes (such as `:hover`) or pseudo-elements (such as `::after`).
+     *
+     * @return string[]
+     *
+     * @throws \BadMethodCallException if `inlineCss` has not been called first
+     */
+    public function getMatchingUninlinableSelectors()
+    {
+        if ($this->matchingUninlinableCssRules === null) {
+            throw new \BadMethodCallException('inlineCss must be called first', 1568385221);
         }
 
-        // The checks on parentNode and is_callable below ensure that if we've deleted the parent node,
-        // we don't try to call removeChild on a nonexistent child node
-        /** @var \DOMNode $node */
-        foreach ($nodesWithStyleDisplayNone as $node) {
-            if ($node->parentNode && \is_callable([$node->parentNode, 'removeChild'])) {
-                $node->parentNode->removeChild($node);
-            }
-        }
+        return \array_column($this->matchingUninlinableCssRules, 'selector');
+    }
+
+    /**
+     * Clears all caches.
+     *
+     * @return void
+     */
+    private function clearAllCaches()
+    {
+        $this->caches = [
+            self::CACHE_KEY_CSS => [],
+            self::CACHE_KEY_SELECTOR => [],
+            self::CACHE_KEY_CSS_DECLARATIONS_BLOCK => [],
+            self::CACHE_KEY_COMBINED_STYLES => [],
+        ];
+    }
+
+    /**
+     * Purges the visited nodes.
+     *
+     * @return void
+     */
+    private function purgeVisitedNodes()
+    {
+        $this->visitedNodes = [];
+        $this->styleAttributesForNodes = [];
     }
 
     /**
@@ -754,14 +343,12 @@ class CssInliner
      * We wouldn't have to do this if DOMXPath supported XPath 2.0.
      * Also stores a reference of nodes with existing inline styles so we don't overwrite them.
      *
-     * @param \DOMXPath $xPath
-     *
      * @return void
      */
-    private function normalizeStyleAttributesOfAllNodes(\DOMXPath $xPath)
+    private function normalizeStyleAttributesOfAllNodes()
     {
         /** @var \DOMElement $node */
-        foreach ($this->getAllNodesWithStyleAttribute($xPath) as $node) {
+        foreach ($this->getAllNodesWithStyleAttribute() as $node) {
             if ($this->isInlineStyleAttributesParsingEnabled) {
                 $this->normalizeStyleAttributes($node);
             }
@@ -773,6 +360,16 @@ class CssInliner
         }
     }
 
+    /**
+     * Returns a list with all DOM nodes that have a style attribute.
+     *
+     * @return \DOMNodeList
+     */
+    private function getAllNodesWithStyleAttribute()
+    {
+        return $this->xPath->query('//*[@style]');
+    }
+
     /**
      * Normalizes the value of the "style" attribute and saves it.
      *
@@ -783,8 +380,8 @@ class CssInliner
     private function normalizeStyleAttributes(\DOMElement $node)
     {
         $normalizedOriginalStyle = \preg_replace_callback(
-            '/[A-z\\-]+(?=\\:)/S',
-            function (array $m) {
+            '/-?+[_a-zA-Z][\\w\\-]*+(?=:)/S',
+            static function (array $m) {
                 return \strtolower($m[0]);
             },
             $node->getAttribute('style')
@@ -802,211 +399,54 @@ class CssInliner
     }
 
     /**
-     * Merges styles from styles attributes and style nodes and applies them to the attribute nodes
+     * Parses a CSS declaration block into property name/value pairs.
      *
-     * @return void
+     * Example:
+     *
+     * The declaration block
+     *
+     *   "color: #000; font-weight: bold;"
+     *
+     * will be parsed into the following array:
+     *
+     *   "color" => "#000"
+     *   "font-weight" => "bold"
+     *
+     * @param string $cssDeclarationsBlock the CSS declarations block without the curly braces, may be empty
+     *
+     * @return string[]
+     *         the CSS declarations with the property names as array keys and the property values as array values
      */
-    private function fillStyleAttributesWithMergedStyles()
+    private function parseCssDeclarationsBlock($cssDeclarationsBlock)
     {
-        foreach ($this->styleAttributesForNodes as $nodePath => $styleAttributesForNode) {
-            $node = $this->visitedNodes[$nodePath];
-            $currentStyleAttributes = $this->parseCssDeclarationsBlock($node->getAttribute('style'));
-            $node->setAttribute(
-                'style',
-                $this->generateStyleStringFromDeclarationsArrays(
-                    $currentStyleAttributes,
-                    $styleAttributesForNode
-                )
-            );
-        }
-    }
-
-    /**
-     * This method merges old or existing name/value array with new name/value array
-     * and then generates a string of the combined style suitable for placing inline.
-     * This becomes the single point for CSS string generation allowing for consistent
-     * CSS output no matter where the CSS originally came from.
-     *
-     * @param string[] $oldStyles
-     * @param string[] $newStyles
-     *
-     * @return string
-     */
-    private function generateStyleStringFromDeclarationsArrays(array $oldStyles, array $newStyles)
-    {
-        $cacheKey = \serialize([$oldStyles, $newStyles]);
-        if (isset($this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey])) {
-            return $this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey];
+        if (isset($this->caches[self::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock])) {
+            return $this->caches[self::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock];
         }
 
-        // Unset the overridden styles to preserve order, important if shorthand and individual properties are mixed
-        foreach ($oldStyles as $attributeName => $attributeValue) {
-            if (!isset($newStyles[$attributeName])) {
+        $properties = [];
+        foreach (\preg_split('/;(?!base64|charset)/', $cssDeclarationsBlock) as $declaration) {
+            $matches = [];
+            if (!\preg_match('/^([A-Za-z\\-]+)\\s*:\\s*(.+)$/s', \trim($declaration), $matches)) {
                 continue;
             }
 
-            $newAttributeValue = $newStyles[$attributeName];
-            if ($this->attributeValueIsImportant($attributeValue)
-                && !$this->attributeValueIsImportant($newAttributeValue)
-            ) {
-                unset($newStyles[$attributeName]);
-            } else {
-                unset($oldStyles[$attributeName]);
-            }
+            $propertyName = \strtolower($matches[1]);
+            $propertyValue = $matches[2];
+            $properties[$propertyName] = $propertyValue;
         }
+        $this->caches[self::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock] = $properties;
 
-        $combinedStyles = \array_merge($oldStyles, $newStyles);
-
-        $style = '';
-        foreach ($combinedStyles as $attributeName => $attributeValue) {
-            $style .= \strtolower(\trim($attributeName)) . ': ' . \trim($attributeValue) . '; ';
-        }
-        $trimmedStyle = \rtrim($style);
-
-        $this->caches[static::CACHE_KEY_COMBINED_STYLES][$cacheKey] = $trimmedStyle;
-
-        return $trimmedStyle;
-    }
-
-    /**
-     * Generates a CSS style string suitable to be used inline from the $styleDeclarations property => value array.
-     *
-     * @param string[] $styleDeclarations
-     *
-     * @return string
-     */
-    private function generateStyleStringFromSingleDeclarationsArray(array $styleDeclarations)
-    {
-        return $this->generateStyleStringFromDeclarationsArrays([], $styleDeclarations);
-    }
-
-    /**
-     * Checks whether $attributeValue is marked as !important.
-     *
-     * @param string $attributeValue
-     *
-     * @return bool
-     */
-    private function attributeValueIsImportant($attributeValue)
-    {
-        return \strtolower(\substr(\trim($attributeValue), -10)) === '!important';
-    }
-
-    /**
-     * Applies $cssRules to $this->domDocument, limited to the rules that actually apply to the document.
-     *
-     * @param \DOMXPath $xPath
-     * @param string[][] $cssRules The "uninlineable" array of CSS rules returned by `parseCssRules`
-     *
-     * @return void
-     */
-    private function copyUninlineableCssToStyleNode(\DOMXPath $xPath, array $cssRules)
-    {
-        $cssRulesRelevantForDocument = \array_filter(
-            $cssRules,
-            function (array $cssRule) use ($xPath) {
-                $selector = $cssRule['selector'];
-                if ($cssRule['hasUnmatchablePseudo']) {
-                    $selector = $this->removeUnmatchablePseudoComponents($selector);
-                }
-                return $this->existsMatchForCssSelector($xPath, $selector);
-            }
-        );
-
-        if ($cssRulesRelevantForDocument === []) {
-            // avoid adding empty style element (or including unneeded class dependency)
-            return;
-        }
-
-        $cssConcatenator = new CssConcatenator();
-        foreach ($cssRulesRelevantForDocument as $cssRule) {
-            $cssConcatenator->append([$cssRule['selector']], $cssRule['declarationsBlock'], $cssRule['media']);
-        }
-
-        $this->addStyleElementToDocument($cssConcatenator->getCss());
-    }
-
-    /**
-     * Removes pseudo-elements and dynamic pseudo-classes from a CSS selector, replacing them with "*" if necessary.
-     *
-     * @param string $selector
-     *
-     * @return string Selector which will match the relevant DOM elements if the pseudo-classes are assumed to apply,
-     *                or in the case of pseudo-elements will match their originating element.
-     */
-    private function removeUnmatchablePseudoComponents($selector)
-    {
-        $pseudoComponentMatcher = ':(?!' . static::PSEUDO_CLASS_MATCHER . '):?+[\\w\\-]++(?:\\([^\\)]*+\\))?+';
-        return \preg_replace(
-            ['/(\\s|^)' . $pseudoComponentMatcher . '/i', '/' . $pseudoComponentMatcher . '/i'],
-            ['$1*', ''],
-            $selector
-        );
-    }
-
-    /**
-     * Copies $cssRule into the style attribute of $node.
-     *
-     * Note: This method does not check whether $cssRule matches $node.
-     *
-     * @param \DOMElement $node
-     * @param string[][] $cssRule
-     *
-     * @return void
-     */
-    private function copyInlineableCssToStyleAttribute(\DOMElement $node, array $cssRule)
-    {
-        // if it has a style attribute, get it, process it, and append (overwrite) new stuff
-        if ($node->hasAttribute('style')) {
-            // break it up into an associative array
-            $oldStyleDeclarations = $this->parseCssDeclarationsBlock($node->getAttribute('style'));
-        } else {
-            $oldStyleDeclarations = [];
-        }
-        $newStyleDeclarations = $this->parseCssDeclarationsBlock($cssRule['declarationsBlock']);
-        $node->setAttribute(
-            'style',
-            $this->generateStyleStringFromDeclarationsArrays($oldStyleDeclarations, $newStyleDeclarations)
-        );
-    }
-
-    /**
-     * Checks whether there is at least one matching element for $cssSelector.
-     * When not in debug mode, it returns true also for invalid selectors (because they may be valid,
-     * just not implemented/recognized yet by Emogrifier).
-     *
-     * @param \DOMXPath $xPath
-     * @param string $cssSelector
-     *
-     * @return bool
-     *
-     * @throws SyntaxErrorException
-     */
-    private function existsMatchForCssSelector(\DOMXPath $xPath, $cssSelector)
-    {
-        try {
-            $nodesMatchingSelector = $xPath->query($this->cssSelectorConverter->toXPath($cssSelector));
-        } catch (SyntaxErrorException $e) {
-            if ($this->debug) {
-                throw $e;
-            }
-            return true;
-        }
-
-        return $nodesMatchingSelector !== false && $nodesMatchingSelector->length !== 0;
+        return $properties;
     }
 
     /**
      * Returns CSS content.
      *
-     * @param \DOMXPath $xPath
-     *
      * @return string
      */
-    private function getCssFromAllStyleNodes(\DOMXPath $xPath)
+    private function getCssFromAllStyleNodes()
     {
-        $styleNodes = $xPath->query('//style');
-
+        $styleNodes = $this->xPath->query('//style');
         if ($styleNodes === false) {
             return '';
         }
@@ -1022,44 +462,241 @@ class CssInliner
     }
 
     /**
-     * Adds a style element with $css to $this->domDocument.
-     *
-     * This method is protected to allow overriding.
-     *
-     * @see https://github.com/jjriv/emogrifier/issues/103
+     * Removes comments from the supplied CSS.
      *
      * @param string $css
      *
-     * @return void
+     * @return string CSS with the comments removed
      */
-    protected function addStyleElementToDocument($css)
+    private function removeCssComments($css)
     {
-        $styleElement = $this->domDocument->createElement('style', $css);
-        $styleAttribute = $this->domDocument->createAttribute('type');
-        $styleAttribute->value = 'text/css';
-        $styleElement->appendChild($styleAttribute);
-
-        $bodyElement = $this->getBodyElement();
-        $bodyElement->appendChild($styleElement);
+        return \preg_replace('%/\\*[^*]*+(?:\\*(?!/)[^*]*+)*+\\*/%', '', $css);
     }
 
     /**
-     * Checks that $this->domDocument has a BODY element and adds it if it is missing.
+     * Extracts `@import` and `@charset` rules from the supplied CSS.  These rules must not be preceded by any other
+     * rules, or they will be ignored.  (From the CSS 2.1 specification: "CSS 2.1 user agents must ignore any '@import'
+     * rule that occurs inside a block or after any non-ignored statement other than an @charset or an @import rule."
+     * Note also that `@charset` is case sensitive whereas `@import` is not.)
      *
-     * @return void
+     * @param string $css CSS with comments removed
+     *
+     * @return string[] The first element is the CSS with the valid `@import` and `@charset` rules removed.  The second
+     * element contains a concatenation of the valid `@import` rules, each followed by whatever whitespace followed it
+     * in the original CSS (so that either unminified or minified formatting is preserved); if there were no `@import`
+     * rules, it will be an empty string.  The (valid) `@charset` rules are discarded.
      */
-    private function ensureExistenceOfBodyElement()
+    private function extractImportAndCharsetRules($css)
     {
-        if ($this->domDocument->getElementsByTagName('body')->item(0) !== null) {
-            return;
+        $possiblyModifiedCss = $css;
+        $importRules = '';
+
+        while (
+            \preg_match(
+                '/^\\s*+(@((?i)import(?-i)|charset)\\s[^;]++;\\s*+)/',
+                $possiblyModifiedCss,
+                $matches
+            )
+        ) {
+            list($fullMatch, $atRuleAndFollowingWhitespace, $atRuleName) = $matches;
+
+            if (\strtolower($atRuleName) === 'import') {
+                $importRules .= $atRuleAndFollowingWhitespace;
+            }
+
+            $possiblyModifiedCss = \substr($possiblyModifiedCss, \strlen($fullMatch));
         }
 
-        $htmlElement = $this->domDocument->getElementsByTagName('html')->item(0);
-        $htmlElement->appendChild($this->domDocument->createElement('body'));
+        return [$possiblyModifiedCss, $importRules];
     }
 
     /**
-     * Splits input CSS code into an array of parts for different media querues, in order.
+     * Find the nodes that are not to be emogrified.
+     *
+     * @return \DOMElement[]
+     *
+     * @throws SyntaxErrorException
+     */
+    private function getNodesToExclude()
+    {
+        $excludedNodes = [];
+        foreach (\array_keys($this->excludedSelectors) as $selectorToExclude) {
+            try {
+                $matchingNodes = $this->xPath->query($this->getCssSelectorConverter()->toXPath($selectorToExclude));
+            } catch (SyntaxErrorException $e) {
+                if ($this->debug) {
+                    throw $e;
+                }
+                continue;
+            }
+            foreach ($matchingNodes as $node) {
+                $excludedNodes[] = $node;
+            }
+        }
+
+        return $excludedNodes;
+    }
+
+    /**
+     * @return CssSelectorConverter
+     */
+    private function getCssSelectorConverter()
+    {
+        if ($this->cssSelectorConverter === null) {
+            $this->cssSelectorConverter = new CssSelectorConverter();
+        }
+
+        return $this->cssSelectorConverter;
+    }
+
+    /**
+     * Extracts and parses the individual rules from a CSS string.
+     *
+     * @param string $css a string of raw CSS code with comments removed
+     *
+     * @return string[][][] A 2-entry array with the key "inlinable" containing rules which can be inlined as `style`
+     *         attributes and the key "uninlinable" containing rules which cannot.  Each value is an array of string
+     *         sub-arrays with the keys
+     *         "media" (the media query string, e.g. "@media screen and (max-width: 480px)",
+     *         or an empty string if not from a `@media` rule),
+     *         "selector" (the CSS selector, e.g., "*" or "header h1"),
+     *         "hasUnmatchablePseudo" (true if that selector contains pseudo-elements or dynamic pseudo-classes
+     *         such that the declarations cannot be applied inline),
+     *         "declarationsBlock" (the semicolon-separated CSS declarations for that selector,
+     *         e.g., "color: red; height: 4px;"),
+     *         and "line" (the line number e.g. 42)
+     */
+    private function parseCssRules($css)
+    {
+        $cssKey = \md5($css);
+        if (isset($this->caches[self::CACHE_KEY_CSS][$cssKey])) {
+            return $this->caches[self::CACHE_KEY_CSS][$cssKey];
+        }
+
+        $matches = $this->getCssRuleMatches($css);
+
+        $cssRules = [
+            'inlinable' => [],
+            'uninlinable' => [],
+        ];
+        /** @var string[][] $matches */
+        /** @var string[] $cssRule */
+        foreach ($matches as $key => $cssRule) {
+            $cssDeclaration = \trim($cssRule['declarations']);
+            if ($cssDeclaration === '') {
+                continue;
+            }
+
+            foreach (\explode(',', $cssRule['selectors']) as $selector) {
+                // don't process pseudo-elements and behavioral (dynamic) pseudo-classes;
+                // only allow structural pseudo-classes
+                $hasPseudoElement = \strpos($selector, '::') !== false;
+                $hasUnsupportedPseudoClass = (bool)\preg_match(
+                    '/:(?!' . self::PSEUDO_CLASS_MATCHER . ')[\\w\\-]/i',
+                    $selector
+                );
+                $hasUnmatchablePseudo = $hasPseudoElement || $hasUnsupportedPseudoClass;
+
+                $parsedCssRule = [
+                    'media' => $cssRule['media'],
+                    'selector' => \trim($selector),
+                    'hasUnmatchablePseudo' => $hasUnmatchablePseudo,
+                    'declarationsBlock' => $cssDeclaration,
+                    // keep track of where it appears in the file, since order is important
+                    'line' => $key,
+                ];
+                $ruleType = ($cssRule['media'] === '' && !$hasUnmatchablePseudo) ? 'inlinable' : 'uninlinable';
+                $cssRules[$ruleType][] = $parsedCssRule;
+            }
+        }
+
+        \usort($cssRules['inlinable'], [$this, 'sortBySelectorPrecedence']);
+
+        $this->caches[self::CACHE_KEY_CSS][$cssKey] = $cssRules;
+
+        return $cssRules;
+    }
+
+    /**
+     * @param string[] $a
+     * @param string[] $b
+     *
+     * @return int
+     */
+    private function sortBySelectorPrecedence(array $a, array $b)
+    {
+        $precedenceA = $this->getCssSelectorPrecedence($a['selector']);
+        $precedenceB = $this->getCssSelectorPrecedence($b['selector']);
+
+        // We want these sorted in ascending order so selectors with lesser precedence get processed first and
+        // selectors with greater precedence get sorted last.
+        $precedenceForEquals = ($a['line'] < $b['line'] ? -1 : 1);
+        $precedenceForNotEquals = ($precedenceA < $precedenceB ? -1 : 1);
+        return ($precedenceA === $precedenceB) ? $precedenceForEquals : $precedenceForNotEquals;
+    }
+
+    /**
+     * @param string $selector
+     *
+     * @return int
+     */
+    private function getCssSelectorPrecedence($selector)
+    {
+        $selectorKey = \md5($selector);
+        if (isset($this->caches[self::CACHE_KEY_SELECTOR][$selectorKey])) {
+            return $this->caches[self::CACHE_KEY_SELECTOR][$selectorKey];
+        }
+
+        $precedence = 0;
+        foreach ($this->selectorPrecedenceMatchers as $matcher => $value) {
+            if (\trim($selector) === '') {
+                break;
+            }
+            $number = 0;
+            $selector = \preg_replace('/' . $matcher . '\\w+/', '', $selector, -1, $number);
+            $precedence += ($value * $number);
+        }
+        $this->caches[self::CACHE_KEY_SELECTOR][$selectorKey] = $precedence;
+
+        return $precedence;
+    }
+
+    /**
+     * Parses a string of CSS into the media query, selectors and declarations for each ruleset in order.
+     *
+     * @param string $css CSS with comments removed
+     *
+     * @return string[][] Array of string sub-arrays with the keys
+     *         "media" (the media query string, e.g. "@media screen and (max-width: 480px)",
+     *         or an empty string if not from an `@media` rule),
+     *         "selectors" (the CSS selector(s), e.g., "*" or "h1, h2"),
+     *         "declarations" (the semicolon-separated CSS declarations for that/those selector(s),
+     *         e.g., "color: red; height: 4px;"),
+     */
+    private function getCssRuleMatches($css)
+    {
+        $splitCss = $this->splitCssAndMediaQuery($css);
+
+        $ruleMatches = [];
+        foreach ($splitCss as $cssPart) {
+            // process each part for selectors and definitions
+            \preg_match_all('/(?:^|[\\s^{}]*)([^{]+){([^}]*)}/mi', $cssPart['css'], $matches, PREG_SET_ORDER);
+
+            /** @var string[][] $matches */
+            foreach ($matches as $cssRule) {
+                $ruleMatches[] = [
+                    'media' => $cssPart['media'],
+                    'selectors' => $cssRule[1],
+                    'declarations' => $cssRule[2],
+                ];
+            }
+        }
+
+        return $ruleMatches;
+    }
+
+    /**
+     * Splits input CSS code into an array of parts for different media queries, in order.
      * Each part is an array where:
      *
      * - key "css" will contain clean CSS code (for @media rules this will be the group rule body within "{...}")
@@ -1089,8 +726,6 @@ class CssInliner
      */
     private function splitCssAndMediaQuery($css)
     {
-        $cssWithoutComments = \preg_replace('/\\/\\*.*\\*\\//sU', '', $css);
-
         $mediaTypesExpression = '';
         if (!empty($this->allowedMediaTypes)) {
             $mediaTypesExpression = '|' . \implode('|', \array_keys($this->allowedMediaTypes));
@@ -1099,9 +734,9 @@ class CssInliner
         $mediaRuleBodyMatcher = '[^{]*+{(?:[^{}]*+{.*})?\\s*+}\\s*+';
 
         $cssSplitForAllowedMediaTypes = \preg_split(
-            '#(@media\\s++(?:only\\s++)?+(?:(?=[{\\(])' . $mediaTypesExpression . ')' . $mediaRuleBodyMatcher
+            '#(@media\\s++(?:only\\s++)?+(?:(?=[{(])' . $mediaTypesExpression . ')' . $mediaRuleBodyMatcher
             . ')#misU',
-            $cssWithoutComments,
+            $css,
             -1,
             PREG_SPLIT_DELIM_CAPTURE
         );
@@ -1135,198 +770,346 @@ class CssInliner
     }
 
     /**
-     * Removes empty unprocessable tags from the DOM document.
+     * Copies $cssRule into the style attribute of $node.
+     *
+     * Note: This method does not check whether $cssRule matches $node.
+     *
+     * @param \DOMElement $node
+     * @param string[][] $cssRule
      *
      * @return void
      */
-    private function removeUnprocessableTags()
+    private function copyInlinableCssToStyleAttribute(\DOMElement $node, array $cssRule)
     {
-        foreach ($this->unprocessableHtmlTags as $tagName) {
-            $nodes = $this->domDocument->getElementsByTagName($tagName);
-            /** @var \DOMNode $node */
-            foreach ($nodes as $node) {
-                $hasContent = $node->hasChildNodes() || $node->hasChildNodes();
-                if (!$hasContent) {
-                    $node->parentNode->removeChild($node);
-                }
-            }
-        }
-    }
-
-    /**
-     * Makes sure that the passed HTML has a document type.
-     *
-     * @param string $html
-     *
-     * @return string HTML with document type
-     */
-    private function ensureDocumentType($html)
-    {
-        $hasDocumentType = \stripos($html, '<!DOCTYPE') !== false;
-        if ($hasDocumentType) {
-            return $html;
+        $newStyleDeclarations = $this->parseCssDeclarationsBlock($cssRule['declarationsBlock']);
+        if ($newStyleDeclarations === []) {
+            return;
         }
 
-        return static::DEFAULT_DOCUMENT_TYPE . $html;
-    }
-
-    /**
-     * Adds a Content-Type meta tag for the charset.
-     *
-     * @param string $html
-     *
-     * @return string the HTML with the meta tag added
-     */
-    private function addContentTypeMetaTag($html)
-    {
-        $hasContentTypeMetaTag = \stripos($html, 'Content-Type') !== false;
-        if ($hasContentTypeMetaTag) {
-            return $html;
-        }
-
-        // We are trying to insert the meta tag to the right spot in the DOM.
-        // If we just prepended it to the HTML, we would lose attributes set to the HTML tag.
-        $hasHeadTag = \stripos($html, '<head') !== false;
-        $hasHtmlTag = \stripos($html, '<html') !== false;
-
-        if ($hasHeadTag) {
-            $reworkedHtml = \preg_replace('/<head(.*?)>/i', '<head$1>' . static::CONTENT_TYPE_META_TAG, $html);
-        } elseif ($hasHtmlTag) {
-            $reworkedHtml = \preg_replace(
-                '/<html(.*?)>/i',
-                '<html$1><head>' . static::CONTENT_TYPE_META_TAG . '</head>',
-                $html
-            );
+        // if it has a style attribute, get it, process it, and append (overwrite) new stuff
+        if ($node->hasAttribute('style')) {
+            // break it up into an associative array
+            $oldStyleDeclarations = $this->parseCssDeclarationsBlock($node->getAttribute('style'));
         } else {
-            $reworkedHtml = static::CONTENT_TYPE_META_TAG . $html;
+            $oldStyleDeclarations = [];
         }
-
-        return $reworkedHtml;
+        $node->setAttribute(
+            'style',
+            $this->generateStyleStringFromDeclarationsArrays($oldStyleDeclarations, $newStyleDeclarations)
+        );
     }
 
     /**
-     * @param string[] $a
-     * @param string[] $b
+     * This method merges old or existing name/value array with new name/value array
+     * and then generates a string of the combined style suitable for placing inline.
+     * This becomes the single point for CSS string generation allowing for consistent
+     * CSS output no matter where the CSS originally came from.
      *
-     * @return int
-     */
-    private function sortBySelectorPrecedence(array $a, array $b)
-    {
-        $precedenceA = $this->getCssSelectorPrecedence($a['selector']);
-        $precedenceB = $this->getCssSelectorPrecedence($b['selector']);
-
-        // We want these sorted in ascending order so selectors with lesser precedence get processed first and
-        // selectors with greater precedence get sorted last.
-        $precedenceForEquals = ($a['line'] < $b['line'] ? -1 : 1);
-        $precedenceForNotEquals = ($precedenceA < $precedenceB ? -1 : 1);
-        return ($precedenceA === $precedenceB) ? $precedenceForEquals : $precedenceForNotEquals;
-    }
-
-    /**
-     * @param string $selector
+     * @param string[] $oldStyles
+     * @param string[] $newStyles
      *
-     * @return int
+     * @return string
      */
-    private function getCssSelectorPrecedence($selector)
+    private function generateStyleStringFromDeclarationsArrays(array $oldStyles, array $newStyles)
     {
-        $selectorKey = \md5($selector);
-        if (!isset($this->caches[static::CACHE_KEY_SELECTOR][$selectorKey])) {
-            $precedence = 0;
-            foreach ($this->selectorPrecedenceMatchers as $matcher => $value) {
-                if (\trim($selector) === '') {
-                    break;
-                }
-                $number = 0;
-                $selector = \preg_replace('/' . $matcher . '\\w+/', '', $selector, -1, $number);
-                $precedence += ($value * $number);
-            }
-            $this->caches[static::CACHE_KEY_SELECTOR][$selectorKey] = $precedence;
+        $cacheKey = \serialize([$oldStyles, $newStyles]);
+        if (isset($this->caches[self::CACHE_KEY_COMBINED_STYLES][$cacheKey])) {
+            return $this->caches[self::CACHE_KEY_COMBINED_STYLES][$cacheKey];
         }
 
-        return $this->caches[static::CACHE_KEY_SELECTOR][$selectorKey];
-    }
-
-    /**
-     * Parses a CSS declaration block into property name/value pairs.
-     *
-     * Example:
-     *
-     * The declaration block
-     *
-     *   "color: #000; font-weight: bold;"
-     *
-     * will be parsed into the following array:
-     *
-     *   "color" => "#000"
-     *   "font-weight" => "bold"
-     *
-     * @param string $cssDeclarationsBlock the CSS declarations block without the curly braces, may be empty
-     *
-     * @return string[]
-     *         the CSS declarations with the property names as array keys and the property values as array values
-     */
-    private function parseCssDeclarationsBlock($cssDeclarationsBlock)
-    {
-        if (isset($this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock])) {
-            return $this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock];
-        }
-
-        $properties = [];
-        $declarations = \preg_split('/;(?!base64|charset)/', $cssDeclarationsBlock);
-
-        foreach ($declarations as $declaration) {
-            $matches = [];
-            if (!\preg_match('/^([A-Za-z\\-]+)\\s*:\\s*(.+)$/s', \trim($declaration), $matches)) {
+        // Unset the overridden styles to preserve order, important if shorthand and individual properties are mixed
+        foreach ($oldStyles as $attributeName => $attributeValue) {
+            if (!isset($newStyles[$attributeName])) {
                 continue;
             }
 
-            $propertyName = \strtolower($matches[1]);
-            $propertyValue = $matches[2];
-            $properties[$propertyName] = $propertyValue;
+            $newAttributeValue = $newStyles[$attributeName];
+            if (
+                $this->attributeValueIsImportant($attributeValue)
+                && !$this->attributeValueIsImportant($newAttributeValue)
+            ) {
+                unset($newStyles[$attributeName]);
+            } else {
+                unset($oldStyles[$attributeName]);
+            }
         }
-        $this->caches[static::CACHE_KEY_CSS_DECLARATIONS_BLOCK][$cssDeclarationsBlock] = $properties;
 
-        return $properties;
+        $combinedStyles = \array_merge($oldStyles, $newStyles);
+
+        $style = '';
+        foreach ($combinedStyles as $attributeName => $attributeValue) {
+            $style .= \strtolower(\trim($attributeName)) . ': ' . \trim($attributeValue) . '; ';
+        }
+        $trimmedStyle = \rtrim($style);
+
+        $this->caches[self::CACHE_KEY_COMBINED_STYLES][$cacheKey] = $trimmedStyle;
+
+        return $trimmedStyle;
     }
 
     /**
-     * Find the nodes that are not to be emogrified.
+     * Checks whether $attributeValue is marked as !important.
      *
-     * @param \DOMXPath $xPath
+     * @param string $attributeValue
      *
-     * @return \DOMElement[]
+     * @return bool
+     */
+    private function attributeValueIsImportant($attributeValue)
+    {
+        return \strtolower(\substr(\trim($attributeValue), -10)) === '!important';
+    }
+
+    /**
+     * Merges styles from styles attributes and style nodes and applies them to the attribute nodes
+     *
+     * @return void
+     */
+    private function fillStyleAttributesWithMergedStyles()
+    {
+        foreach ($this->styleAttributesForNodes as $nodePath => $styleAttributesForNode) {
+            $node = $this->visitedNodes[$nodePath];
+            $currentStyleAttributes = $this->parseCssDeclarationsBlock($node->getAttribute('style'));
+            $node->setAttribute(
+                'style',
+                $this->generateStyleStringFromDeclarationsArrays(
+                    $currentStyleAttributes,
+                    $styleAttributesForNode
+                )
+            );
+        }
+    }
+
+    /**
+     * Searches for all nodes with a style attribute and removes the "!important" annotations out of
+     * the inline style declarations, eventually by rearranging declarations.
+     *
+     * @return void
+     */
+    private function removeImportantAnnotationFromAllInlineStyles()
+    {
+        foreach ($this->getAllNodesWithStyleAttribute() as $node) {
+            $this->removeImportantAnnotationFromNodeInlineStyle($node);
+        }
+    }
+
+    /**
+     * Removes the "!important" annotations out of the inline style declarations,
+     * eventually by rearranging declarations.
+     * Rearranging needed when !important shorthand properties are followed by some of their
+     * not !important expanded-version properties.
+     * For example "font: 12px serif !important; font-size: 13px;" must be reordered
+     * to "font-size: 13px; font: 12px serif;" in order to remain correct.
+     *
+     * @param \DOMElement $node
+     *
+     * @return void
+     */
+    private function removeImportantAnnotationFromNodeInlineStyle(\DOMElement $node)
+    {
+        $inlineStyleDeclarations = $this->parseCssDeclarationsBlock($node->getAttribute('style'));
+        $regularStyleDeclarations = [];
+        $importantStyleDeclarations = [];
+        foreach ($inlineStyleDeclarations as $property => $value) {
+            if ($this->attributeValueIsImportant($value)) {
+                $importantStyleDeclarations[$property] = \trim(\str_replace('!important', '', $value));
+            } else {
+                $regularStyleDeclarations[$property] = $value;
+            }
+        }
+        $inlineStyleDeclarationsInNewOrder = \array_merge(
+            $regularStyleDeclarations,
+            $importantStyleDeclarations
+        );
+        $node->setAttribute(
+            'style',
+            $this->generateStyleStringFromSingleDeclarationsArray($inlineStyleDeclarationsInNewOrder)
+        );
+    }
+
+    /**
+     * Generates a CSS style string suitable to be used inline from the $styleDeclarations property => value array.
+     *
+     * @param string[] $styleDeclarations
+     *
+     * @return string
+     */
+    private function generateStyleStringFromSingleDeclarationsArray(array $styleDeclarations)
+    {
+        return $this->generateStyleStringFromDeclarationsArrays([], $styleDeclarations);
+    }
+
+    /**
+     * Determines which of `$cssRules` actually apply to `$this->domDocument`, and sets them in
+     * `$this->matchingUninlinableCssRules`.
+     *
+     * @param string[][] $cssRules the "uninlinable" array of CSS rules returned by `parseCssRules`
+     *
+     * @return void
+     */
+    private function determineMatchingUninlinableCssRules(array $cssRules)
+    {
+        $this->matchingUninlinableCssRules = \array_filter($cssRules, [$this, 'existsMatchForSelectorInCssRule']);
+    }
+
+    /**
+     * Checks whether there is at least one matching element for the CSS selector contained in the `selector` element
+     * of the provided CSS rule.
+     *
+     * Any dynamic pseudo-classes will be assumed to apply. If the selector matches a pseudo-element,
+     * it will test for a match with its originating element.
+     *
+     * @param string[] $cssRule
+     *
+     * @return bool
      *
      * @throws SyntaxErrorException
      */
-    private function getNodesToExclude(\DOMXPath $xPath)
+    private function existsMatchForSelectorInCssRule(array $cssRule)
     {
-        $excludedNodes = [];
-        foreach (\array_keys($this->excludedSelectors) as $selectorToExclude) {
-            try {
-                $matchingNodes = $xPath->query($this->cssSelectorConverter->toXPath($selectorToExclude));
-            } catch (SyntaxErrorException $e) {
-                if ($this->debug) {
-                    throw $e;
-                }
-                continue;
-            }
-            foreach ($matchingNodes as $node) {
-                $excludedNodes[] = $node;
-            }
+        $selector = $cssRule['selector'];
+        if ($cssRule['hasUnmatchablePseudo']) {
+            $selector = $this->removeUnmatchablePseudoComponents($selector);
         }
-
-        return $excludedNodes;
+        return $this->existsMatchForCssSelector($selector);
     }
 
     /**
-     * Sets the debug mode.
+     * Checks whether there is at least one matching element for $cssSelector.
+     * When not in debug mode, it returns true also for invalid selectors (because they may be valid,
+     * just not implemented/recognized yet by Emogrifier).
      *
-     * @param bool $debug set to true to enable debug mode
+     * @param string $cssSelector
+     *
+     * @return bool
+     *
+     * @throws SyntaxErrorException
+     */
+    private function existsMatchForCssSelector($cssSelector)
+    {
+        try {
+            $nodesMatchingSelector = $this->xPath->query($this->getCssSelectorConverter()->toXPath($cssSelector));
+        } catch (SyntaxErrorException $e) {
+            if ($this->debug) {
+                throw $e;
+            }
+            return true;
+        }
+
+        return $nodesMatchingSelector !== false && $nodesMatchingSelector->length !== 0;
+    }
+
+    /**
+     * Removes pseudo-elements and dynamic pseudo-classes from a CSS selector, replacing them with "*" if necessary.
+     * If such a pseudo-component is within the argument of `:not`, the entire `:not` component is removed or replaced.
+     *
+     * @param string $selector
+     *
+     * @return string Selector which will match the relevant DOM elements if the pseudo-classes are assumed to apply,
+     *                or in the case of pseudo-elements will match their originating element.
+     */
+    private function removeUnmatchablePseudoComponents($selector)
+    {
+        // The regex allows nested brackets via `(?2)`.
+        // A space is temporarily prepended because the callback can't determine if the match was at the very start.
+        $selectorWithoutNots = \ltrim(\preg_replace_callback(
+            '/(\\s?+):not(\\([^()]*+(?:(?2)[^()]*+)*+\\))/i',
+            [$this, 'replaceUnmatchableNotComponent'],
+            ' ' . $selector
+        ));
+
+        $pseudoComponentMatcher = ':(?!' . self::PSEUDO_CLASS_MATCHER . '):?+[\\w\\-]++(?:\\([^\\)]*+\\))?+';
+        return \preg_replace(
+            ['/(\\s|^)' . $pseudoComponentMatcher . '/i', '/' . $pseudoComponentMatcher . '/i'],
+            ['$1*', ''],
+            $selectorWithoutNots
+        );
+    }
+
+    /**
+     * Helps `removeUnmatchablePseudoComponents()` replace or remove a selector `:not(...)` component if its argument
+     * contains pseudo-elements or dynamic pseudo-classes.
+     *
+     * @param string[] $matches array of elements matched by the regular expression
+     *
+     * @return string the full match if there were no unmatchable pseudo components within; otherwise, any preceding
+     *         whitespace followed by "*", or an empty string if there was no preceding whitespace
+     */
+    private function replaceUnmatchableNotComponent(array $matches)
+    {
+        list($notComponentWithAnyPrecedingWhitespace, $anyPrecedingWhitespace, $notArgumentInBrackets) = $matches;
+
+        $hasUnmatchablePseudo = \preg_match(
+            '/:(?!' . self::PSEUDO_CLASS_MATCHER . ')[\\w\\-:]/i',
+            $notArgumentInBrackets
+        );
+
+        if ($hasUnmatchablePseudo) {
+            return $anyPrecedingWhitespace !== '' ? $anyPrecedingWhitespace . '*' : '';
+        }
+        return $notComponentWithAnyPrecedingWhitespace;
+    }
+
+    /**
+     * Applies `$this->matchingUninlinableCssRules` to `$this->domDocument` by placing them as CSS in a `<style>`
+     * element.
+     *
+     * @param string $cssImportRules This may contain any `@import` rules that should precede the CSS placed in the
+     *        `<style>` element.  If there are no unlinlinable CSS rules to copy there, a `<style>` element will be
+     *        created containing just `$cssImportRules`.  `$cssImportRules` may be an empty string; if it is, and there
+     *        are no unlinlinable CSS rules, an empty `<style>` element will not be created.
      *
      * @return void
      */
-    public function setDebug($debug)
+    private function copyUninlinableCssToStyleNode($cssImportRules)
     {
-        $this->debug = $debug;
+        $css = $cssImportRules;
+
+        // avoid including unneeded class dependency if there are no rules
+        if ($this->matchingUninlinableCssRules !== []) {
+            $cssConcatenator = new CssConcatenator();
+            foreach ($this->matchingUninlinableCssRules as $cssRule) {
+                $cssConcatenator->append([$cssRule['selector']], $cssRule['declarationsBlock'], $cssRule['media']);
+            }
+            $css .= $cssConcatenator->getCss();
+        }
+
+        // avoid adding empty style element
+        if ($css !== '') {
+            $this->addStyleElementToDocument($css);
+        }
+    }
+
+    /**
+     * Adds a style element with $css to $this->domDocument.
+     *
+     * This method is protected to allow overriding.
+     *
+     * @see https://github.com/MyIntervals/emogrifier/issues/103
+     *
+     * @param string $css
+     *
+     * @return void
+     */
+    protected function addStyleElementToDocument($css)
+    {
+        $styleElement = $this->domDocument->createElement('style', $css);
+        $styleAttribute = $this->domDocument->createAttribute('type');
+        $styleAttribute->value = 'text/css';
+        $styleElement->appendChild($styleAttribute);
+
+        $headElement = $this->getHeadElement();
+        $headElement->appendChild($styleElement);
+    }
+
+    /**
+     * Returns the HEAD element.
+     *
+     * This method assumes that there always is a HEAD element.
+     *
+     * @return \DOMElement
+     */
+    private function getHeadElement()
+    {
+        return $this->domDocument->getElementsByTagName('head')->item(0);
     }
 }
diff --git a/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/AbstractHtmlProcessor.php b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/AbstractHtmlProcessor.php
index cf767425c..589898d52 100644
--- a/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/AbstractHtmlProcessor.php
+++ b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/AbstractHtmlProcessor.php
@@ -7,8 +7,6 @@ namespace Pelago\Emogrifier\HtmlProcessor;
  *
  * The "vanilla" subclass is the HtmlNormalizer.
  *
- * @internal This class currently is a new technology preview, and its API is still in flux. Don't use it in production.
- *
  * @author Oliver Klee <github@oliverklee.de>
  */
 abstract class AbstractHtmlProcessor
@@ -23,17 +21,44 @@ abstract class AbstractHtmlProcessor
      */
     const CONTENT_TYPE_META_TAG = '<meta http-equiv="Content-Type" content="text/html; charset=utf-8">';
 
+    /**
+     * @var string Regular expression part to match tag names that PHP's DOMDocument implementation is not aware are
+     *      self-closing. These are mostly HTML5 elements, but for completeness <command> (obsolete) and <keygen>
+     *      (deprecated) are also included.
+     *
+     * @see https://bugs.php.net/bug.php?id=73175
+     */
+    const PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER = '(?:command|embed|keygen|source|track|wbr)';
+
     /**
      * @var \DOMDocument
      */
     protected $domDocument = null;
 
     /**
+     * @var \DOMXPath
+     */
+    protected $xPath = null;
+
+    /**
+     * The constructor.
+     *
+     * Please use ::fromHtml instead.
+     */
+    private function __construct()
+    {
+    }
+
+    /**
+     * Builds a new instance from the given HTML.
+     *
      * @param string $unprocessedHtml raw HTML, must be UTF-encoded, must not be empty
      *
+     * @return static
+     *
      * @throws \InvalidArgumentException if $unprocessedHtml is anything other than a non-empty string
      */
-    public function __construct($unprocessedHtml)
+    public static function fromHtml($unprocessedHtml)
     {
         if (!\is_string($unprocessedHtml)) {
             throw new \InvalidArgumentException('The provided HTML must be a string.', 1515459744);
@@ -42,7 +67,25 @@ abstract class AbstractHtmlProcessor
             throw new \InvalidArgumentException('The provided HTML must not be empty.', 1515763647);
         }
 
-        $this->setHtml($unprocessedHtml);
+        $instance = new static();
+        $instance->setHtml($unprocessedHtml);
+
+        return $instance;
+    }
+
+    /**
+     * Builds a new instance from the given DOM document.
+     *
+     * @param \DOMDocument $document a DOM document returned by getDomDocument() of another instance
+     *
+     * @return static
+     */
+    public static function fromDomDocument(\DOMDocument $document)
+    {
+        $instance = new static();
+        $instance->setDomDocument($document);
+
+        return $instance;
     }
 
     /**
@@ -67,6 +110,17 @@ abstract class AbstractHtmlProcessor
         return $this->domDocument;
     }
 
+    /**
+     * @param \DOMDocument $domDocument
+     *
+     * @return void
+     */
+    private function setDomDocument(\DOMDocument $domDocument)
+    {
+        $this->domDocument = $domDocument;
+        $this->xPath = new \DOMXPath($this->domDocument);
+    }
+
     /**
      * Renders the normalized and processed HTML.
      *
@@ -74,7 +128,9 @@ abstract class AbstractHtmlProcessor
      */
     public function render()
     {
-        return $this->domDocument->saveHTML();
+        $htmlWithPossibleErroneousClosingTags = $this->domDocument->saveHTML();
+
+        return $this->removeSelfClosingTagsClosingTags($htmlWithPossibleErroneousClosingTags);
     }
 
     /**
@@ -84,9 +140,22 @@ abstract class AbstractHtmlProcessor
      */
     public function renderBodyContent()
     {
-        $bodyNodeHtml = $this->domDocument->saveHTML($this->getBodyElement());
+        $htmlWithPossibleErroneousClosingTags = $this->domDocument->saveHTML($this->getBodyElement());
+        $bodyNodeHtml = $this->removeSelfClosingTagsClosingTags($htmlWithPossibleErroneousClosingTags);
 
-        return \str_replace(['<body>', '</body>'], '', $bodyNodeHtml);
+        return \preg_replace('%</?+body(?:\\s[^>]*+)?+>%', '', $bodyNodeHtml);
+    }
+
+    /**
+     * Eliminates any invalid closing tags for void elements from the given HTML.
+     *
+     * @param string $html
+     *
+     * @return string
+     */
+    private function removeSelfClosingTagsClosingTags($html)
+    {
+        return \preg_replace('%</' . static::PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER . '>%', '', $html);
     }
 
     /**
@@ -133,11 +202,11 @@ abstract class AbstractHtmlProcessor
         \libxml_clear_errors();
         \libxml_use_internal_errors($libXmlState);
 
-        $this->domDocument = $domDocument;
+        $this->setDomDocument($domDocument);
     }
 
     /**
-     * Returns the HTML with added document type and Content-Type meta tag if needed,
+     * Returns the HTML with added document type, Content-Type meta tag, and self-closing slashes, if needed,
      * ensuring that the HTML will be good for creating a DOM document from it.
      *
      * @param string $html
@@ -146,7 +215,8 @@ abstract class AbstractHtmlProcessor
      */
     private function prepareHtmlForDomConversion($html)
     {
-        $htmlWithDocumentType = $this->ensureDocumentType($html);
+        $htmlWithSelfClosingSlashes = $this->ensurePhpUnrecognizedSelfClosingTagsAreXml($html);
+        $htmlWithDocumentType = $this->ensureDocumentType($htmlWithSelfClosingSlashes);
 
         return $this->addContentTypeMetaTag($htmlWithDocumentType);
     }
@@ -171,6 +241,8 @@ abstract class AbstractHtmlProcessor
     /**
      * Adds a Content-Type meta tag for the charset.
      *
+     * This method also ensures that there is a HEAD element.
+     *
      * @param string $html
      *
      * @return string the HTML with the meta tag added
@@ -202,10 +274,29 @@ abstract class AbstractHtmlProcessor
         return $reworkedHtml;
     }
 
+    /**
+     * Makes sure that any self-closing tags not recognized as such by PHP's DOMDocument implementation have a
+     * self-closing slash.
+     *
+     * @param string $html
+     *
+     * @return string HTML with problematic tags converted.
+     */
+    private function ensurePhpUnrecognizedSelfClosingTagsAreXml($html)
+    {
+        return \preg_replace(
+            '%<' . static::PHP_UNRECOGNIZED_VOID_TAGNAME_MATCHER . '\\b[^>]*+(?<!/)(?=>)%',
+            '$0/',
+            $html
+        );
+    }
+
     /**
      * Checks that $this->domDocument has a BODY element and adds it if it is missing.
      *
      * @return void
+     *
+     * @throws \UnexpectedValueException
      */
     private function ensureExistenceOfBodyElement()
     {
@@ -214,6 +305,9 @@ abstract class AbstractHtmlProcessor
         }
 
         $htmlElement = $this->domDocument->getElementsByTagName('html')->item(0);
+        if ($htmlElement === null) {
+            throw new \UnexpectedValueException('There is no HTML element although there should be one.', 1569930853);
+        }
         $htmlElement->appendChild($this->domDocument->createElement('body'));
     }
 }
diff --git a/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/CssToAttributeConverter.php b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/CssToAttributeConverter.php
index 97a94b1c9..3ea7937db 100644
--- a/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/CssToAttributeConverter.php
+++ b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/CssToAttributeConverter.php
@@ -10,8 +10,6 @@ namespace Pelago\Emogrifier\HtmlProcessor;
  *
  * To trigger the conversion, call the convertCssToVisualAttributes method.
  *
- * @internal This class currently is a new technology preview, and its API is still in flux. Don't use it in production.
- *
  * @author Oliver Klee <github@oliverklee.de>
  */
 class CssToAttributeConverter extends AbstractHtmlProcessor
@@ -52,7 +50,7 @@ class CssToAttributeConverter extends AbstractHtmlProcessor
     /**
      * Maps the CSS from the style nodes to visual HTML attributes.
      *
-     * @return CssToAttributeConverter fluent interface
+     * @return self fluent interface
      */
     public function convertCssToVisualAttributes()
     {
@@ -72,9 +70,7 @@ class CssToAttributeConverter extends AbstractHtmlProcessor
      */
     private function getAllNodesWithStyleAttribute()
     {
-        $xPath = new \DOMXPath($this->domDocument);
-
-        return $xPath->query('//*[@style]');
+        return $this->xPath->query('//*[@style]');
     }
 
     /**
@@ -103,9 +99,7 @@ class CssToAttributeConverter extends AbstractHtmlProcessor
         }
 
         $properties = [];
-        $declarations = \preg_split('/;(?!base64|charset)/', $cssDeclarationsBlock);
-
-        foreach ($declarations as $declaration) {
+        foreach (\preg_split('/;(?!base64|charset)/', $cssDeclarationsBlock) as $declaration) {
             $matches = [];
             if (!\preg_match('/^([A-Za-z\\-]+)\\s*:\\s*(.+)$/s', \trim($declaration), $matches)) {
                 continue;
@@ -176,13 +170,12 @@ class CssToAttributeConverter extends AbstractHtmlProcessor
         $mapping = $this->cssToHtmlMap[$property];
         $nodesMatch = !isset($mapping['nodes']) || \in_array($node->nodeName, $mapping['nodes'], true);
         $valuesMatch = !isset($mapping['values']) || \in_array($value, $mapping['values'], true);
-        if (!$nodesMatch || !$valuesMatch) {
-            return false;
+        $canBeMapped = $nodesMatch && $valuesMatch;
+        if ($canBeMapped) {
+            $node->setAttribute($mapping['attribute'], $value);
         }
 
-        $node->setAttribute($mapping['attribute'], $value);
-
-        return true;
+        return $canBeMapped;
     }
 
     /**
@@ -224,12 +217,14 @@ class CssToAttributeConverter extends AbstractHtmlProcessor
     private function mapBackgroundProperty(\DOMElement $node, $value)
     {
         // parse out the color, if any
-        $styles = \explode(' ', $value);
+        $styles = \explode(' ', $value, 2);
         $first = $styles[0];
-        if (!\is_numeric($first[0]) && \strpos($first, 'url') !== 0) {
-            // as this is not a position or image, assume it's a color
-            $node->setAttribute('bgcolor', $first);
+        if (\is_numeric($first[0]) || \strncmp($first, 'url', 3) === 0) {
+            return;
         }
+
+        // as this is not a position or image, assume it's a color
+        $node->setAttribute('bgcolor', $first);
     }
 
     /**
@@ -307,6 +302,7 @@ class CssToAttributeConverter extends AbstractHtmlProcessor
      */
     private function parseCssShorthandValue($value)
     {
+        /** @var string[] $values */
         $values = \preg_split('/\\s+/', $value);
 
         $css = [];
diff --git a/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlNormalizer.php b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlNormalizer.php
index ad3abff37..1406a9ff8 100644
--- a/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlNormalizer.php
+++ b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlNormalizer.php
@@ -9,8 +9,6 @@ namespace Pelago\Emogrifier\HtmlProcessor;
  * - add HEAD and BODY elements (if they are missing)
  * - reformat the HTML
  *
- * @internal This class currently is a new technology preview, and its API is still in flux. Don't use it in production.
- *
  * @author Oliver Klee <github@oliverklee.de>
  */
 class HtmlNormalizer extends AbstractHtmlProcessor
diff --git a/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlPruner.php b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlPruner.php
new file mode 100644
index 000000000..59b8ef109
--- /dev/null
+++ b/lib/pelago/emogrifier/src/Emogrifier/HtmlProcessor/HtmlPruner.php
@@ -0,0 +1,143 @@
+<?php
+
+namespace Pelago\Emogrifier\HtmlProcessor;
+
+use Pelago\Emogrifier\CssInliner;
+use Pelago\Emogrifier\Utilities\ArrayIntersector;
+
+/**
+ * This class can remove things from HTML.
+ *
+ * @author Oliver Klee <github@oliverklee.de>
+ * @author Jake Hotson <jake.github@qzdesign.co.uk>
+ */
+class HtmlPruner extends AbstractHtmlProcessor
+{
+    /**
+     * We need to look for display:none, but we need to do a case-insensitive search. Since DOMDocument only
+     * supports XPath 1.0, lower-case() isn't available to us. We've thus far only set attributes to lowercase,
+     * not attribute values. Consequently, we need to translate() the letters that would be in 'NONE' ("NOE")
+     * to lowercase.
+     *
+     * @var string
+     */
+    const DISPLAY_NONE_MATCHER
+        = '//*[@style and contains(translate(translate(@style," ",""),"NOE","noe"),"display:none")'
+        . ' and not(@class and contains(concat(" ", normalize-space(@class), " "), " -emogrifier-keep "))]';
+
+    /**
+     * Removes elements that have a "display: none;" style.
+     *
+     * @return self fluent interface
+     */
+    public function removeElementsWithDisplayNone()
+    {
+        $elementsWithStyleDisplayNone = $this->xPath->query(self::DISPLAY_NONE_MATCHER);
+        if ($elementsWithStyleDisplayNone->length === 0) {
+            return $this;
+        }
+
+        /** @var \DOMNode $element */
+        foreach ($elementsWithStyleDisplayNone as $element) {
+            $parentNode = $element->parentNode;
+            if ($parentNode !== null) {
+                $parentNode->removeChild($element);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Removes classes that are no longer required (e.g. because there are no longer any CSS rules that reference them)
+     * from `class` attributes.
+     *
+     * Note that this does not inspect the CSS, but expects to be provided with a list of classes that are still in use.
+     *
+     * This method also has the (presumably beneficial) side-effect of minifying (removing superfluous whitespace from)
+     * `class` attributes.
+     *
+     * @param string[] $classesToKeep names of classes that should not be removed
+     *
+     * @return self fluent interface
+     */
+    public function removeRedundantClasses(array $classesToKeep = [])
+    {
+        $elementsWithClassAttribute = $this->xPath->query('//*[@class]');
+
+        if ($classesToKeep !== []) {
+            $this->removeClassesFromElements($elementsWithClassAttribute, $classesToKeep);
+        } else {
+            // Avoid unnecessary processing if there are no classes to keep.
+            $this->removeClassAttributeFromElements($elementsWithClassAttribute);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Removes classes from the `class` attribute of each element in `$elements`, except any in `$classesToKeep`,
+     * removing the `class` attribute itself if the resultant list is empty.
+     *
+     * @param \DOMNodeList $elements
+     * @param string[] $classesToKeep
+     *
+     * @return void
+     */
+    private function removeClassesFromElements(\DOMNodeList $elements, array $classesToKeep)
+    {
+        $classesToKeepIntersector = new ArrayIntersector($classesToKeep);
+
+        /** @var \DOMNode $element */
+        foreach ($elements as $element) {
+            $elementClasses = \preg_split('/\\s++/', \trim($element->getAttribute('class')));
+            $elementClassesToKeep = $classesToKeepIntersector->intersectWith($elementClasses);
+            if ($elementClassesToKeep !== []) {
+                $element->setAttribute('class', \implode(' ', $elementClassesToKeep));
+            } else {
+                $element->removeAttribute('class');
+            }
+        }
+    }
+
+    /**
+     * Removes the `class` attribute from each element in `$elements`.
+     *
+     * @param \DOMNodeList $elements
+     *
+     * @return void
+     */
+    private function removeClassAttributeFromElements(\DOMNodeList $elements)
+    {
+        /** @var \DOMNode $element */
+        foreach ($elements as $element) {
+            $element->removeAttribute('class');
+        }
+    }
+
+    /**
+     * After CSS has been inlined, there will likely be some classes in `class` attributes that are no longer referenced
+     * by any remaining (uninlinable) CSS.  This method removes such classes.
+     *
+     * Note that it does not inspect the remaining CSS, but uses information readily available from the `CssInliner`
+     * instance about the CSS rules that could not be inlined.
+     *
+     * @param CssInliner $cssInliner object instance that performed the CSS inlining
+     *
+     * @return self fluent interface
+     *
+     * @throws \BadMethodCallException if `inlineCss` has not first been called on `$cssInliner`
+     */
+    public function removeRedundantClassesAfterCssInlined(CssInliner $cssInliner)
+    {
+        $classesToKeepAsKeys = [];
+        foreach ($cssInliner->getMatchingUninlinableSelectors() as $selector) {
+            \preg_match_all('/\\.(-?+[_a-zA-Z][\\w\\-]*+)/', $selector, $matches);
+            $classesToKeepAsKeys += \array_fill_keys($matches[1], true);
+        }
+
+        $this->removeRedundantClasses(\array_keys($classesToKeepAsKeys));
+
+        return $this;
+    }
+}
diff --git a/lib/pelago/emogrifier/src/Emogrifier/Utilities/ArrayIntersector.php b/lib/pelago/emogrifier/src/Emogrifier/Utilities/ArrayIntersector.php
new file mode 100644
index 000000000..701ceb8df
--- /dev/null
+++ b/lib/pelago/emogrifier/src/Emogrifier/Utilities/ArrayIntersector.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Pelago\Emogrifier\Utilities;
+
+/**
+ * When computing many array intersections using the same array, it is more efficient to use `array_flip()` first and
+ * then `array_intersect_key()`, than `array_intersect()`.  See the discussion at
+ * {@link https://stackoverflow.com/questions/6329211/php-array-intersect-efficiency Stack Overflow} for more
+ * information.
+ *
+ * Of course, this is only possible if the arrays contain integer or string values, and either don't contain duplicates,
+ * or that fact that duplicates will be removed does not matter.
+ *
+ * This class takes care of the detail.
+ *
+ * @internal
+ *
+ * @author Jake Hotson <jake.github@qzdesign.co.uk>
+ */
+class ArrayIntersector
+{
+    /**
+     * the array with which the object was constructed, with all its keys exchanged with their associated values
+     *
+     * @var (int|string)[]
+     */
+    private $invertedArray;
+
+    /**
+     * Constructs the object with the array that will be reused for many intersection computations.
+     *
+     * @param (int|string)[] $array
+     */
+    public function __construct(array $array)
+    {
+        $this->invertedArray = \array_flip($array);
+    }
+
+    /**
+     * Computes the intersection of `$array` and the array with which this object was constructed.
+     *
+     * @param (int|string)[] $array
+     *
+     * @return (int|string)[] Returns an array containing all of the values in `$array` whose values exist in the array
+     *         with which this object was constructed.  Note that keys are preserved, order is maintained, but
+     *         duplicates are removed.
+     */
+    public function intersectWith(array $array)
+    {
+        $invertedArray = \array_flip($array);
+
+        $invertedIntersection = \array_intersect_key($invertedArray, $this->invertedArray);
+
+        return \array_flip($invertedIntersection);
+    }
+}
diff --git a/lib/pelago/emogrifier/src/Emogrifier/CssConcatenator.php b/lib/pelago/emogrifier/src/Emogrifier/Utilities/CssConcatenator.php
similarity index 94%
rename from lib/pelago/emogrifier/src/Emogrifier/CssConcatenator.php
rename to lib/pelago/emogrifier/src/Emogrifier/Utilities/CssConcatenator.php
index 3ebd33b95..8d75ee233 100644
--- a/lib/pelago/emogrifier/src/Emogrifier/CssConcatenator.php
+++ b/lib/pelago/emogrifier/src/Emogrifier/Utilities/CssConcatenator.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace Pelago\Emogrifier;
+namespace Pelago\Emogrifier\Utilities;
 
 /**
  * Facilitates building a CSS string by appending rule blocks one at a time, checking whether the media query,
@@ -33,6 +33,8 @@ namespace Pelago\Emogrifier;
  * `   }
  * ` }
  *
+ * @internal
+ *
  * @author Jake Hotson <jake.github@qzdesign.co.uk>
  */
 class CssConcatenator
@@ -72,7 +74,7 @@ class CssConcatenator
             $lastRuleBlock->selectorsAsKeys += $selectorsAsKeys;
         } else {
             $hasSameSelectorsAsLastRule = $lastRuleBlock !== false
-                && static::hasEquivalentSelectors($selectorsAsKeys, $lastRuleBlock->selectorsAsKeys);
+                && self::hasEquivalentSelectors($selectorsAsKeys, $lastRuleBlock->selectorsAsKeys);
             if ($hasSameSelectorsAsLastRule) {
                 $lastDeclarationsBlockWithoutSemicolon = \rtrim(\rtrim($lastRuleBlock->declarationsBlock), ';');
                 $lastRuleBlock->declarationsBlock = $lastDeclarationsBlockWithoutSemicolon . ';' . $declarationsBlock;
@@ -87,7 +89,7 @@ class CssConcatenator
      */
     public function getCss()
     {
-        return \implode('', \array_map([$this, 'getMediaRuleCss'], $this->mediaRules));
+        return \implode('', \array_map([self::class, 'getMediaRuleCss'], $this->mediaRules));
     }
 
     /**
@@ -133,7 +135,7 @@ class CssConcatenator
      */
     private static function getMediaRuleCss(\stdClass $mediaRule)
     {
-        $css = \implode('', \array_map([static::class, 'getRuleBlockCss'], $mediaRule->ruleBlocks));
+        $css = \implode('', \array_map([self::class, 'getRuleBlockCss'], $mediaRule->ruleBlocks));
         if ($mediaRule->media !== '') {
             $css = $mediaRule->media . '{' . $css . '}';
         }