diff --git a/CHANGELOG-GRAVITYPDF.md b/CHANGELOG-GRAVITYPDF.md
index a1853f3db..7061d1944 100644
--- a/CHANGELOG-GRAVITYPDF.md
+++ b/CHANGELOG-GRAVITYPDF.md
@@ -37,6 +37,10 @@ Read this section before upgrading from upstream mPDF. Each entry says what chan
   * A property declared twice in one block is read at its last place, so `border-top-color: green; border: 1px solid blue; border-top-color: red` draws a red top.
 * **Dependencies changed.** `ext-json` is now required and `symfony/polyfill-intl-normalizer` is a new dependency. `myclabs/deep-copy` is no longer used. [#13] [#329]
 * **`outline-width` and `outline-color` no longer stroke the text.** mPDF read them as `text-outline-width` and `text-outline-color`, but in CSS they belong to the line around the box, which mPDF does not draw. `outline-width` on its own also raised an undefined-key warning. Write `text-outline-width` and `text-outline-color`, or `text-outline`, to keep stroking the text. [#578]
+* **CSS rules apply by specificity, then in the order they are written**, as in a browser. mPDF applied them in a fixed order of selector groups, so `div p` beat `#id`, `p.c` beat `#i`, `body p` beat `.lead`, the rule from the nearest ancestor beat a heavier descendant rule, and classes applied in alphabetical order. Now the more specific selector wins each of those, and of `.a { } .b { } .a { }` the second `.a` wins. Set `'cssMode' => \Mpdf\CssMode::LEGACY` to parse and apply CSS as mPDF v7 did. [#535] [#631]
+  * Each element takes, in order: the values it inherits; the built-in defaults and the rules of the default stylesheet (`defaultCssFile`), which any author rule beats; HTML attributes such as `<hr color>`, `width` and `vspace`, as author rules of no specificity; the stylesheets; then `style=""`.
+  * Class and id names still match whatever their case.
+  * An author's `a { }` rule now reaches the links of the table of contents and the index too. Style `a.mpdf_toc_a` and `a.mpdf_index_link` to keep them plain.
 
 New features
 ------------
@@ -120,6 +124,7 @@ Performance
 * **Image metadata.** JPEG and PNG metadata is read from the file's structure instead of by scanning the whole file, and PNG chunks are read from a chunk index. [#47] [#48]
 * **GD memory.** GD asks for less memory when it re-encodes an image. [#49]
 * **nth-child rules in tables.** Each row and cell looks up the nth-child rules the stylesheet uses by their keys, instead of running a regex over every rule. A 2,000-cell table under 1,000 rules is written in about 540 ms instead of 745 ms. Class combinations are built only up to the most classes one compound selector names, not one whole selector. [#526] [#580]
+* **Selector matching.** A chain of descendant combinators stops trying ancestors once none left can match, instead of trying every combination of them, and a general sibling combinator skips a tag the parent has no child of and looks from the first sibling. `.x div div div div div p` is matched on a path 50 deep in well under a millisecond instead of 4 seconds, and `h2 ~ p` against 5,000 paragraphs after an `<h2>` in 20 ms instead of 5 seconds. [#535] [#631]
 
 Bugfixes
 --------
@@ -132,6 +137,7 @@ Bugfixes
 * `@page { size: landscape }`, or a page box wider than it is tall, left the first page portrait, and `size: portrait` left a landscape document landscape. The first page now turns. A page box and percentage margins are measured on the turned sheet, so `size: 250mm 150mm` on A4 is no longer cut to 210 mm wide. [#552] [#562]
 * `page-break-before: auto` or `avoid` on a block inside another block closed the outer block and opened it again, so its border was drawn around each part. `page-break-after: auto` or `avoid` on a table started a new page. [#552] [#569]
 * `page-break-before` on a table was ignored. On a top-level table, `always`, `left` and `right` now start it on a new page, inside the blocks around it. [#552] [#622]
+* A table with a `font-size` and a row with `text-rotate` threw a `TypeError` on PHP 8, and raised a warning before it. A cell whose font size was already in force saved its text with an empty size. [#632] [#631]
 * `background-size: cover` scaled by the wrong ratio when the image came out shorter than the area. [mpdf/mpdf#833] [#22]
 * Only double-quoted attributes were read. Single-quoted, unquoted and bare attributes are now read as well. [mpdf/mpdf#2030] [#24]
 * A shadow colour written without spaces, such as `rgba(255,0,0,0.5)`, fell back to grey. Whitespace in shadows is now parsed as CSS writes it too. [#25]
@@ -777,6 +783,7 @@ These changes do not change output.
 [#527]: https://github.com/GravityPDF/mpdf/issues/527
 [#528]: https://github.com/GravityPDF/mpdf/issues/528
 [#533]: https://github.com/GravityPDF/mpdf/issues/533
+[#535]: https://github.com/GravityPDF/mpdf/issues/535
 [#538]: https://github.com/GravityPDF/mpdf/issues/538
 [#549]: https://github.com/GravityPDF/mpdf/pull/549
 [#552]: https://github.com/GravityPDF/mpdf/issues/552
@@ -820,3 +827,5 @@ These changes do not change output.
 [#627]: https://github.com/GravityPDF/mpdf/pull/627
 [#628]: https://github.com/GravityPDF/mpdf/pull/628
 [#629]: https://github.com/GravityPDF/mpdf/pull/629
+[#631]: https://github.com/GravityPDF/mpdf/pull/631
+[#632]: https://github.com/GravityPDF/mpdf/issues/632
diff --git a/src/Config/ConfigVariables.php b/src/Config/ConfigVariables.php
index e60298d85..82f32cf1f 100644
--- a/src/Config/ConfigVariables.php
+++ b/src/Config/ConfigVariables.php
@@ -2,6 +2,7 @@
 
 namespace Mpdf\Config;
 
+use Mpdf\CssMode;
 use Mpdf\Css\DefaultCss;
 use Mpdf\Language\LanguageToFont;
 use Mpdf\Language\LanguageToFontRegistry;
@@ -269,6 +270,9 @@ public function __construct()
 			// screen, print, or any other CSS @media type (except "all")
 			'CSSselectMedia' => 'print',
 
+			// How CSS is parsed and applied: CssMode::STANDARD as a browser does, CssMode::LEGACY as mPDF v7 did
+			'cssMode' => CssMode::STANDARD,
+
 			// PAGE HEADERS & FOOTERS
 			'forcePortraitHeaders' => false,
 
diff --git a/src/Css/CssMerger.php b/src/Css/CssMerger.php
index 8e5959dcc..867c079d6 100644
--- a/src/Css/CssMerger.php
+++ b/src/Css/CssMerger.php
@@ -3,6 +3,7 @@
 namespace Mpdf\Css;
 
 use Mpdf\Color\ColorConverter;
+use Mpdf\CssMode;
 use Mpdf\CssManager;
 use Mpdf\Exception\InvalidArgumentException;
 use Mpdf\Mpdf;
@@ -112,6 +113,10 @@ public function merge($inherit, $tag, $attr)
 
 		$attr = is_array($attr) ? $attr : [];
 
+		if ($this->mpdf->cssMode === CssMode::STANDARD) {
+			return $this->mergeInCascadeOrder($inherit, $tag, $attr);
+		}
+
 		$classes = [];
 		if (isset($attr['CLASS'])) {
 			// filter out classes that don't have any CSS applied, which reduces likelyhood of O(2^N) memory issue
@@ -140,18 +145,104 @@ public function merge($inherit, $tag, $attr)
 
 		$this->mergeTableCascadingCss($inherit, $tag, $attr, $classes);
 		$this->mergeBlockCascadingCss($inherit, $tag, $attr, $classes);
+		$this->mergeInheritedBlockProperties($inherit, $tag);
 		$this->mergeInlineAttributes($tag, $attr);
 		$this->mergeDefaultCss($tag);
 		$this->mergeTableSpecificCss($tag, $attr);
 		$this->mergeStylesheetSelectors($tag, $attr, $classes, $languageCode);
 		$this->mergeTagSpecificSelectors($tag, $attr, $classes, $languageCode);
 		$this->mergeDescendantSelectors($inherit, $tag, $attr, $classes, $languageCode);
-		$this->mergeCompiledRules($tag, $attr);
+		// The rules only the matcher reads, such as div > p, h1 + p and li:first-child, go after the descendant rules
+		$this->mergeMatchingRules($this->cssManager->getRules(), $tag, $attr['ID'], $this->classesOf($attr), [$this->mpdf, 'getStyledElementPath']);
+		$this->mergeInlineStyle($tag, $attr);
+
+		return $this->cssProperties;
+	}
+
+	/**
+	 * Merges an element's CSS as standard mode orders it, in layers, each over the one before: the inherited
+	 * values, the built-in defaults and the default stylesheet's rules, the presentational attributes as author rules
+	 * of zero specificity, the author rules, and the inline style. The rules of each stylesheet apply by specificity,
+	 * then in the order they were written.
+	 *
+	 * @param string $inherit Inheritance context (BLOCK, INLINE, TABLE, TOPTABLE)
+	 * @param string $tag HTML tag name
+	 * @param array $attr HTML attributes, as the tag handler was given them
+	 * @return array Merged CSS properties array
+	 */
+	private function mergeInCascadeOrder($inherit, $tag, array $attr)
+	{
+		// Found once, when a rule set first has a rule filed under the element. previewBlockCss() looks at an element
+		// that is not being written, so it is put in the innermost open element, and nothing is recorded
+		$mpdf = $this->mpdf;
+		$sideEffects = $this->sideEffects;
+		$elements = false;
+		$path = function () use ($mpdf, $sideEffects, $tag, $attr, &$elements) {
+			if ($elements === false) {
+				$elements = $sideEffects ? $mpdf->getStyledElementPath() : $mpdf->getOpenElementPathFor($tag, $attr);
+			}
+
+			return $elements;
+		};
+
+		if (isset($attr['LANG'])) {
+			$attr['LANG'] = strtolower($attr['LANG']);
+		}
+
+		$id = isset($attr['ID']) ? $attr['ID'] : '';
+		$classes = $this->classesOf($attr);
+
+		$this->mergeInheritedBlockProperties($inherit, $tag);
+
+		$this->mergeDefaultCss($tag);
+		$this->mergeMatchingRules($this->cssManager->getDefaultRules(), $tag, $id, $classes, $path);
+
+		$this->mergeInlineAttributes($tag, $attr);
+		$this->mergeTableSpecificCss($tag, $attr);
+
+		if ($tag === 'BODY') {
+			// Merged outside the document's elements, and written to by Mpdf::SetDefaultBodyCSS() and the like
+			$body = isset($this->cssManager->CSS['BODY']) ? $this->cssManager->CSS['BODY'] : [];
+			$this->setMergedCss($body, false);
+		} else {
+			$this->mergeMatchingRules($this->cssManager->getRules(), $tag, $id, $classes, $path);
+		}
+
 		$this->mergeInlineStyle($tag, $attr);
 
 		return $this->cssProperties;
 	}
 
+	/**
+	 * Merges the declarations of the rules in a rule set that an element matches, in the order they apply: by
+	 * specificity, then by their position in the stylesheets. Each rule that reaches a table cell draws its borders
+	 * over those of its neighbours
+	 *
+	 * @param RuleSet $rules
+	 * @param string $tag HTML tag name, uppercased
+	 * @param string $id Uppercased, or empty for none
+	 * @param string[] $classes Uppercased
+	 * @param callable $path Gives the open elements from the document down to the element, or null for none
+	 * @return void
+	 */
+	private function mergeMatchingRules(RuleSet $rules, $tag, $id, array $classes, callable $path)
+	{
+		$dominance = $tag === 'TD' || $tag === 'TH' ? 9 : false;
+
+		foreach ($rules->matchingDeclarations($tag, $id, $classes, $path) as $properties) {
+			$this->setMergedCss($properties, false, $dominance);
+		}
+	}
+
+	/**
+	 * @param array $attr HTML attributes, with CLASS uppercased
+	 * @return string[] The element's classes
+	 */
+	private function classesOf(array $attr)
+	{
+		return isset($attr['CLASS']) ? preg_split('/\s+/', $attr['CLASS'], -1, PREG_SPLIT_NO_EMPTY) : [];
+	}
+
 	/**
 	 * Preview block-level CSS without creating the block.
 	 *
@@ -231,7 +322,8 @@ protected function mergeTableCascadingCss($inherit, $tag, $attr, $classes)
 	/**
 	 * Merge block cascading CSS.
 	 *
-	 * Handles inheritance and cascading of CSS properties for block elements.
+	 * Lifts the descendant rules that go through a block element into its level of the block stack, for the elements
+	 * inside it.
 	 *
 	 * @param string $inherit Inheritance type (TOPTABLE, TABLE, BLOCK)
 	 * @param string $tag HTML tag name
@@ -283,6 +375,23 @@ protected function mergeBlockCascadingCss($inherit, $tag, $attr, $classes)
 			$this->mpdf->blk[$this->mpdf->blklvl] = $currentBlock;
 			$this->mpdf->markStyledElementAsLevel();
 		}
+	}
+
+	/**
+	 * Merge the properties a block inherits from the block it is opened in.
+	 *
+	 * @param string $inherit Inheritance type (TOPTABLE, TABLE, BLOCK)
+	 * @param string $tag HTML tag name
+	 * @return void
+	 */
+	protected function mergeInheritedBlockProperties($inherit, $tag)
+	{
+		if ($inherit !== 'BLOCK') {
+			return;
+		}
+
+		$previousBlockLevel = $this->getBlockLevel();
+		$previousBlock = isset($this->mpdf->blk[$previousBlockLevel]) ? $this->mpdf->blk[$previousBlockLevel] : [];
 
 		// Block properties which are inherited
 		if (!empty($previousBlock['margin_collapse'])) {
@@ -836,27 +945,6 @@ private function idClassKeys($tag, $id, $classes)
 		return $keys;
 	}
 
-	/**
-	 * Apply the rules whose selector only the matcher reads, such as div > p, h1 + p and li:first-child, matched
-	 * against the element and the open elements around it. They go with the descendant rules, after them, in the
-	 * order of their specificity and then of their position in the stylesheets.
-	 *
-	 * @param string $tag HTML tag name, uppercased
-	 * @param array $attr HTML attributes, with ID and CLASS uppercased and ID empty for none
-	 * @return void
-	 */
-	protected function mergeCompiledRules($tag, $attr)
-	{
-		$classes = isset($attr['CLASS']) ? preg_split('/\s+/', $attr['CLASS'], -1, PREG_SPLIT_NO_EMPTY) : [];
-		$path = [$this->mpdf, 'getStyledElementPath'];
-
-		$dominance = $tag === 'TD' || $tag === 'TH' ? 9 : false;
-
-		foreach ($this->cssManager->getRules()->matchingDeclarations($tag, $attr['ID'], $classes, $path) as $properties) {
-			$this->setMergedCss($properties, false, $dominance);
-		}
-	}
-
 	/**
 	 * Merge CSS properties into target array.
 	 *
diff --git a/src/Css/CssParser.php b/src/Css/CssParser.php
index 56b117e96..0044752a6 100644
--- a/src/Css/CssParser.php
+++ b/src/Css/CssParser.php
@@ -4,6 +4,7 @@
 
 use Mpdf\Utils\Arrays;
 use Mpdf\Utils\Path;
+use Mpdf\CssMode;
 use Mpdf\Mpdf;
 use Mpdf\Cache;
 use Mpdf\SizeConverter;
@@ -222,7 +223,8 @@ public function getCascadeCss()
 
 	/**
 	 * The rules of the last CSS parsed for the matcher: those whose selector the legacy parser cannot read, and the
-	 * descendant and :lang() rules it stores, which the matcher applies where the legacy engine cannot match them
+	 * descendant and :lang() rules it stores, which the matcher applies where the legacy engine cannot match them.
+	 * In standard mode, every rule it read
 	 *
 	 * @return array[] Each [compiled selector, declarations, whether the legacy parser stores it too], in the order
 	 *                 they were written
@@ -313,9 +315,22 @@ private function processCssSelector($written, $classProperties)
 			return;
 		}
 
+		$tag = $level === 1 ? $this->selectorParser->parseSimpleSelector($tags) : null;
+		$simple = $tag !== null && $this->isLegacySelector([$tag]);
+
+		if ($this->mpdf->cssMode === CssMode::STANDARD) {
+			$this->compileRule($written, $classProperties);
+
+			// Simple rules are still stored by key, for what reads CssManager::$CSS directly: BODY, and SVG's classes
+			if ($simple) {
+				$this->storeSimpleRule($tag, $classProperties);
+			}
+
+			return;
+		}
+
 		if ($level === 1) {
-			$tag = $this->selectorParser->parseSimpleSelector($tags);
-			if (!$this->isLegacySelector($tag === null ? [] : [$tag])) {
+			if (!$simple) {
 				$this->compileRule($written, $classProperties);
 				return;
 			}
@@ -325,13 +340,7 @@ private function processCssSelector($written, $classProperties)
 				$this->compileRule($written, $classProperties, true);
 			}
 
-			if (isset($this->css[$tag])) {
-				$this->css[$tag] = Arrays::uniqueRecursiveMerge($this->css[$tag], $classProperties);
-			} else {
-				$this->css[$tag] = $classProperties;
-			}
-
-			$this->indexStoredKey($tag);
+			$this->storeSimpleRule($tag, $classProperties);
 
 			return;
 		}
@@ -355,6 +364,24 @@ private function processCssSelector($written, $classProperties)
 		$this->compileRule($written, $classProperties, true);
 	}
 
+	/**
+	 * Stores a rule whose selector is one compound the legacy parser reads, under its key
+	 *
+	 * @param string $key A key SelectorParser::parseSimpleSelector() made, e.g. P or CLASS>>A
+	 * @param array $classProperties
+	 * @return void
+	 */
+	private function storeSimpleRule($key, array $classProperties)
+	{
+		if (isset($this->css[$key])) {
+			$this->css[$key] = Arrays::uniqueRecursiveMerge($this->css[$key], $classProperties);
+		} else {
+			$this->css[$key] = $classProperties;
+		}
+
+		$this->indexStoredKey($key);
+	}
+
 	/**
 	 * Record what the merger needs to know about the key of one compound selector of a stored rule: how many classes
 	 * it names, and its nth-child formula.
@@ -410,8 +437,7 @@ private function compileRule($selector, array $classProperties, $legacy = false)
 
 		$compiled = $this->selectorCompiler->compile($selector);
 
-		// The universal selector changes which elements existing documents style, so it waits for #530 and the
-		// standard cascade option
+		// The universal selector changes which elements existing documents style, so it waits for #530
 		if ($compiled !== null && !$compiled['universal']) {
 			$this->compiledRules[] = [$compiled, $classProperties, $legacy];
 		}
diff --git a/src/Css/SelectorMatcher.php b/src/Css/SelectorMatcher.php
index 88d63ff9b..1c1945e1a 100644
--- a/src/Css/SelectorMatcher.php
+++ b/src/Css/SelectorMatcher.php
@@ -13,6 +13,15 @@
 class SelectorMatcher
 {
 
+	/** The selector matches */
+	const MATCHES = 0;
+
+	/** It fails for this element, and may match another */
+	const FAILS_HERE = 1;
+
+	/** It fails for this element and for any other whose ancestors are all among this one's */
+	const FAILS_FOR_ANCESTORS = 2;
+
 	/**
 	 * Whether a selector matches the last element of a path
 	 *
@@ -28,13 +37,18 @@ public function matches(array $selector, array $path, $legacyView = false)
 	{
 		$depth = count($path) - 1;
 
-		return $this->matchesFrom($selector, count($selector['compounds']) - 1, $path, $depth - 1, $path[$depth]['nthChild'] - 1, $legacyView);
+		return $this->matchesFrom($selector, count($selector['compounds']) - 1, $path, $depth - 1, $path[$depth]['nthChild'] - 1, $legacyView) === self::MATCHES;
 	}
 
 	/**
 	 * Whether a compound matches an element, and the compounds to its left match the elements its combinators lead to.
-	 * A descendant or general sibling combinator tries each ancestor or earlier sibling in turn, nearest first, so a
-	 * compound further left that fails on the nearest one is tried again on the next
+	 * A descendant combinator tries each ancestor in turn, nearest first, and a general sibling combinator each earlier
+	 * sibling, from the first, so a compound further left that fails on one is tried again on the next.
+	 *
+	 * A failure says how far it reaches, so that the tries stop once none left can match: when the compounds to the
+	 * left of a descendant combinator have failed at every ancestor, they fail at every ancestor of those ancestors
+	 * too, and at their siblings. Without this, a chain of descendant combinators is tried along every combination of
+	 * ancestors on a deep path.
 	 *
 	 * @param array $selector A selector SelectorCompiler::compile() compiled
 	 * @param int $compound Which of its compounds to match, from the left
@@ -44,44 +58,63 @@ public function matches(array $selector, array $path, $legacyView = false)
 	 *                   has closed, it is the open element at the next depth
 	 * @param bool $legacyView Whether to match as the legacy engine does, as matches() takes it
 	 *
-	 * @return bool
+	 * @return int self::MATCHES, or how far the failure reaches: self::FAILS_HERE or self::FAILS_FOR_ANCESTORS
 	 */
 	private function matchesFrom(array $selector, $compound, array $path, $parent, $index, $legacyView)
 	{
 		if (!$this->matchesCompound($selector['compounds'][$compound], $path, $parent, $index, $legacyView)) {
-			return false;
+			return self::FAILS_HERE;
 		}
 
 		if ($compound === 0) {
-			return true;
+			return self::MATCHES;
 		}
 
 		$compound--;
 		switch ($selector['combinators'][$compound]) {
 			case '>':
-				return $parent >= 0 && $this->matchesFrom($selector, $compound, $path, $parent - 1, $path[$parent]['nthChild'] - 1, $legacyView);
+				if ($parent < 0) {
+					return self::FAILS_FOR_ANCESTORS;
+				}
+
+				return $this->matchesFrom($selector, $compound, $path, $parent - 1, $path[$parent]['nthChild'] - 1, $legacyView);
 
 			case ' ':
 				for ($depth = $parent; $depth >= 0; $depth--) {
-					if ((!$legacyView || $path[$depth]['level'])
-						&& $this->matchesFrom($selector, $compound, $path, $depth - 1, $path[$depth]['nthChild'] - 1, $legacyView)) {
-						return true;
+					if ($legacyView && !$path[$depth]['level']) {
+						continue;
+					}
+
+					$result = $this->matchesFrom($selector, $compound, $path, $depth - 1, $path[$depth]['nthChild'] - 1, $legacyView);
+					if ($result !== self::FAILS_HERE) {
+						return $result;
 					}
 				}
 
-				return false;
+				return self::FAILS_FOR_ANCESTORS;
 
 			case '+':
-				return $parent >= 0 && $index > 0 && $this->matchesFrom($selector, $compound, $path, $parent, $index - 1, $legacyView);
+				if ($parent < 0 || $index === 0) {
+					return self::FAILS_HERE;
+				}
+
+				return $this->matchesFrom($selector, $compound, $path, $parent, $index - 1, $legacyView);
 
 			default:
-				for ($sibling = $index - 1; $parent >= 0 && $sibling >= 0; $sibling--) {
-					if ($this->matchesFrom($selector, $compound, $path, $parent, $sibling, $legacyView)) {
-						return true;
+				// None of the siblings before it has the tag, if the parent has had no child with it
+				$tag = $selector['compounds'][$compound]['tag'];
+				if ($parent < 0 || ($tag !== null && !isset($path[$parent]['childTypes'][$tag]))) {
+					return self::FAILS_HERE;
+				}
+
+				for ($sibling = 0; $sibling < $index; $sibling++) {
+					$result = $this->matchesFrom($selector, $compound, $path, $parent, $sibling, $legacyView);
+					if ($result !== self::FAILS_HERE) {
+						return $result;
 					}
 				}
 
-				return false;
+				return self::FAILS_HERE;
 		}
 	}
 
@@ -152,7 +185,7 @@ private function matchesPseudoClass(array $pseudo, array $element, array $path,
 	{
 		if ($pseudo[0] === 'is' || $pseudo[0] === 'not') {
 			foreach ($pseudo[1] as $selector) {
-				if ($this->matchesFrom($selector, count($selector['compounds']) - 1, $path, $parent, $index, $legacyView)) {
+				if ($this->matchesFrom($selector, count($selector['compounds']) - 1, $path, $parent, $index, $legacyView) === self::MATCHES) {
 					return $pseudo[0] === 'is';
 				}
 			}
diff --git a/src/CssManager.php b/src/CssManager.php
index 7ce392545..ebc3870bb 100644
--- a/src/CssManager.php
+++ b/src/CssManager.php
@@ -92,6 +92,11 @@ class CssManager
 	 */
 	private $rules;
 
+	/**
+	 * @var RuleSet The rules of the default stylesheet, compiled for the matcher
+	 */
+	private $defaultRules;
+
 	/**
 	 * CssManager constructor.
 	 *
@@ -107,6 +112,7 @@ public function __construct(CssParser $cssParser, CssMerger $cssMerger)
 		$this->cssMerger = $cssMerger;
 		$this->cssMerger->setCssManager($this);
 		$this->rules = new RuleSet();
+		$this->defaultRules = new RuleSet();
 	}
 
 	/**
@@ -120,6 +126,30 @@ public function __construct(CssParser $cssParser, CssMerger $cssMerger)
 	 * @return string HTML with CSS content removed
 	 */
 	public function readCss($html)
+	{
+		return $this->read($html, $this->rules);
+	}
+
+	/**
+	 * Read the default stylesheet, Mpdf::$defaultCssFile. Its rules count as the built-in stylesheet's, which standard
+	 * mode applies with the built-in defaults, below every rule of the document's own stylesheets
+	 *
+	 * @param string $css The stylesheet, without a <style> tag around it
+	 * @return void
+	 */
+	public function readDefaultCss($css)
+	{
+		$this->read('<style> ' . $css . ' </style>', $this->defaultRules);
+	}
+
+	/**
+	 * Parse the CSS in HTML content into the stores readCss() describes, and file its compiled rules in a rule set
+	 *
+	 * @param string $html
+	 * @param RuleSet $rules
+	 * @return string HTML with CSS content removed
+	 */
+	private function read($html, RuleSet $rules)
 	{
 		if (!is_array($this->cascadeCSS)) {
 			$this->cascadeCSS = [];
@@ -131,7 +161,7 @@ public function readCss($html)
 		$this->cascadeCSS = Arrays::uniqueRecursiveMerge($this->cascadeCSS, $this->cssParser->getCascadeCss());
 
 		foreach ($this->cssParser->getCompiledRules() as $rule) {
-			$this->rules->add($rule[0], $rule[1], $rule[2]);
+			$rules->add($rule[0], $rule[1], $rule[2]);
 		}
 
 		return $html;
@@ -147,6 +177,16 @@ public function getRules()
 		return $this->rules;
 	}
 
+	/**
+	 * The rules of the default stylesheet, compiled for the matcher
+	 *
+	 * @return RuleSet
+	 */
+	public function getDefaultRules()
+	{
+		return $this->defaultRules;
+	}
+
 	/**
 	 * Parse inline CSS style attribute.
 	 *
diff --git a/src/CssMode.php b/src/CssMode.php
new file mode 100644
index 000000000..90caa092f
--- /dev/null
+++ b/src/CssMode.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Mpdf;
+
+/**
+ * The values of the cssMode configuration option, which says how mPDF parses and applies CSS
+ */
+final class CssMode
+{
+
+	/**
+	 * Applies CSS as a browser does: by specificity and then source order, with the newer selectors and behaviour.
+	 * The default
+	 */
+	const STANDARD = 'standard';
+
+	/**
+	 * Parses and applies CSS as mPDF v7 did
+	 */
+	const LEGACY = 'legacy';
+}
diff --git a/src/Mpdf.php b/src/Mpdf.php
index afc90160e..a0aa9ec49 100644
--- a/src/Mpdf.php
+++ b/src/Mpdf.php
@@ -234,6 +234,11 @@ class Mpdf implements \Psr\Log\LoggerAwareInterface
 	var $useSubstitutions;
 	var $CSSselectMedia;
 
+	/**
+	 * @var string A CssMode constant. See ConfigVariables
+	 */
+	var $cssMode;
+
 	var $forcePortraitHeaders;
 	var $forcePortraitMargins;
 	var $displayDefaultOrientation;
@@ -1171,6 +1176,10 @@ public function __construct(array $config = [], $container = null)
 		$originalConfig = $config;
 		$config = $this->initConfig($originalConfig);
 
+		if (!in_array($this->cssMode, [CssMode::STANDARD, CssMode::LEGACY], true)) {
+			throw new \Mpdf\MpdfException(sprintf('cssMode (%s) is not valid. (Use: %s or %s)', $this->cssMode, CssMode::STANDARD, CssMode::LEGACY));
+		}
+
 		if ($this->isPdfx4() && version_compare($this->pdf_version, '1.6', '<')) {
 			$this->pdf_version = '1.6';
 		}
@@ -1590,7 +1599,7 @@ public function __construct(array $config = [], $container = null)
 
 		if (file_exists($this->defaultCssFile)) {
 			$css = file_get_contents($this->defaultCssFile);
-			$this->cssManager->ReadCSS('<style> ' . $css . ' </style>');
+			$this->cssManager->readDefaultCss($css);
 		} else {
 			throw new \Mpdf\MpdfException(sprintf('Unable to read default CSS file "%s"', $this->defaultCssFile));
 		}
@@ -5167,13 +5176,14 @@ function SetFont($family, $style = '', $size = 0, $write = true, $forcewrite = f
 
 	function SetFontSize($size, $write = true)
 	{
-		// Set font size in points
+		// Set font size in points. Recorded even when it is already in force: Reset() empties it after setting the
+		// size, and the text saved for a table cell carries it
+		$this->currentfontsize = $size;
 		if ($this->FontSizePt == $size) {
 			return;
 		}
 		$this->FontSizePt = $size;
 		$this->FontSize = $size / Mpdf::SCALE;
-		$this->currentfontsize = $size;
 		if ($write) {
 			$fontout = (sprintf('BT /F%d %.3F Tf ET', $this->CurrentFont['i'], $this->FontSizePt));
 			// Edited mPDF 3.0
diff --git a/src/TracksOpenElements.php b/src/TracksOpenElements.php
index 12641fbe6..433093c41 100644
--- a/src/TracksOpenElements.php
+++ b/src/TracksOpenElements.php
@@ -142,20 +142,11 @@ public function getStyledElementPath()
 			return null;
 		}
 
-		$path = $this->styledElement['path'];
-		$tag = $this->styledElement['tag'];
-		if ($tag === null) {
-			return $path;
-		}
-
-		$parent = count($path) - 1;
-		if (self::impliesTbody($tag, $path[$parent])) {
-			$path[] = $this->newChildFrame($path[$parent], 'TBODY', []);
-			$parent++;
+		if ($this->styledElement['tag'] === null) {
+			return $this->styledElement['path'];
 		}
-		$path[] = $this->newChildFrame($path[$parent], $tag, $this->styledElement['attr']);
 
-		return $path;
+		return $this->withChildFrame($this->styledElement['path'], $this->styledElement['tag'], $this->styledElement['attr']);
 	}
 
 	/**
@@ -179,6 +170,43 @@ public function getStyledElementNthChild()
 		return self::impliesTbody($this->styledElement['tag'], $parent) ? 1 : count($parent['children']) + 1;
 	}
 
+	/**
+	 * The path an element would have if it were opened now, in the innermost open element, after the children that
+	 * element has so far. Nothing is recorded, so CssMerger::previewBlockCss() can match the selectors against it
+	 * without changing the stack
+	 *
+	 * @param string $tag Uppercased
+	 * @param string[] $attr
+	 *
+	 * @return array[] The open elements from the document down to it, with the element's own frame last
+	 */
+	public function getOpenElementPathFor($tag, array $attr)
+	{
+		return $this->withChildFrame($this->openElements, $tag, $attr);
+	}
+
+	/**
+	 * A path with a frame added for an element opened in its last element, after the children that element has so
+	 * far, and put under the tbody the stack gives a row written straight into a table
+	 *
+	 * @param array[] $path Open elements, outermost first
+	 * @param string $tag
+	 * @param string[] $attr
+	 *
+	 * @return array[]
+	 */
+	private function withChildFrame(array $path, $tag, array $attr)
+	{
+		$parent = count($path) - 1;
+		if (self::impliesTbody($tag, $path[$parent])) {
+			$path[] = $this->newChildFrame($path[$parent], 'TBODY', []);
+			$parent++;
+		}
+		$path[] = $this->newChildFrame($path[$parent], $tag, $attr);
+
+		return $path;
+	}
+
 	/**
 	 * Notes that the element whose CSS is being merged opens a level of the descendant rules the legacy parser
 	 * stores, as a block, a table and a table part do. CssMerger calls it when it lifts those rules at the element.
diff --git a/tests/Mpdf/CascadeContextTest.php b/tests/Mpdf/CascadeContextTest.php
new file mode 100644
index 000000000..04cbd19f0
--- /dev/null
+++ b/tests/Mpdf/CascadeContextTest.php
@@ -0,0 +1,226 @@
+<?php
+
+namespace Mpdf;
+
+use Yoast\PHPUnitPolyfills\TestCases\TestCase;
+
+/**
+ * The standard cascade orders competing rules by specificity and then position wherever the element is: a block, an
+ * inline element or a table cell, in a header or footer, in a positioned block, in a block laid out twice because
+ * it is kept together, and after a forced page break inside a block.
+ */
+class CascadeContextTest extends TestCase
+{
+
+	use DrawnStyles;
+
+	const RED = '1.000 0.000 0.000 rg';
+	const BLUE = '0.000 0.000 1.000 rg';
+	const GREEN = '0.000 0.502 0.000 rg';
+
+	/**
+	 * Each subject is drawn in the colour the rules that win leave it in: the element the heavier or later rule
+	 * matches, and a near miss that only the other rule matches
+	 *
+	 * @dataProvider casesInContexts
+	 *
+	 * @param string $context
+	 * @param string $css With {T} for the subjects' tag and {A} for their ancestors'
+	 * @param array[] $groups As cases() gives them
+	 */
+	public function testTheWinningRuleStylesTheElement($context, $css, array $groups)
+	{
+		$expected = [];
+		foreach ($groups as $group) {
+			foreach ($group[1] as $text => $subject) {
+				$expected[$text] = $subject[1];
+			}
+		}
+
+		$this->assertDrawnInColours($expected, $this->drawnColours($this->document($context, $css, $groups), ['cssMode' => CssMode::STANDARD]));
+	}
+
+	/**
+	 * Every case in every context
+	 *
+	 * @return array[]
+	 */
+	public function casesInContexts()
+	{
+		$data = [];
+		foreach (['block', 'inline', 'table cell', 'header', 'footer', 'positioned block', 'kept block', 'forced page break'] as $context) {
+			foreach ($this->cases() as $name => $case) {
+				$data[$context . ': ' . $name] = [$context, $case[0], $case[1]];
+			}
+		}
+
+		return $data;
+	}
+
+	/**
+	 * Rules that compete, with the elements they are matched against
+	 *
+	 * @return array[] Each [css, groups]: a group is [the attributes of the subjects' ancestors, outermost first, and
+	 *                 for each subject keyed by its text, its attributes and the colour it should be drawn in]
+	 */
+	private function cases()
+	{
+		return [
+			'an id beats a tag with a class' => [
+				'#i { color: #008000; } {T}.c { color: #f00; }',
+				[[[], ['with the id' => ['id="i" class="c"', self::GREEN], 'without it' => ['class="c"', self::RED]]]],
+			],
+			'an id beats a descendant rule' => [
+				'#i { color: #008000; } {A} {T} { color: #f00; }',
+				[[[''], ['with the id' => ['id="i"', self::GREEN], 'without it' => ['', self::RED]]]],
+			],
+			'a class beats a rule naming body' => [
+				'body {T} { color: #f00; } .c { color: #008000; }',
+				[[[], ['with the class' => ['class="c"', self::GREEN], 'without it' => ['', self::RED]]]],
+			],
+			'two classes beat a tag with a class' => [
+				'{T}.c { color: #f00; } .c.d { color: #008000; }',
+				[[[], ['with both' => ['class="c d"', self::GREEN], 'with one' => ['class="c"', self::RED]]]],
+			],
+			'a class ancestor beats two nearer tag ancestors' => [
+				'.c {T} { color: #008000; } {A} {A} {T} { color: #f00; }',
+				[
+					[['class="c"', ''], ['under the class' => ['', self::GREEN]]],
+					[['', ''], ['under plain ancestors' => ['', self::RED]]],
+				],
+			],
+			'an id ancestor beats two nearer tag ancestors' => [
+				'#o {T} { color: #008000; } {A} {A} {T} { color: #f00; }',
+				[
+					[['id="o"', ''], ['under the id' => ['', self::GREEN]]],
+					[['', ''], ['under plain ancestors' => ['', self::RED]]],
+				],
+			],
+			'classes apply in the order they are written' => [
+				'.b { color: #008000; } .a { color: #f00; }',
+				[[[], ['a then b' => ['class="a b"', self::RED], 'b then a' => ['class="b a"', self::RED], 'b alone' => ['class="b"', self::GREEN]]]],
+			],
+			'a selector written twice takes each of its places' => [
+				'.a { color: #f00; } .b { color: #008000; } .a { color: #00f; }',
+				[[[], ['a and b' => ['class="a b"', self::BLUE], 'b alone' => ['class="b"', self::GREEN]]]],
+			],
+			'a structural pseudo-class counts as a class' => [
+				'{T}:first-child { color: #008000; } .c { color: #f00; }',
+				[[[''], ['first child' => ['class="c"', self::GREEN], 'second child' => ['class="c"', self::RED]]]],
+			],
+			'an id beats an attribute selector' => [
+				'[data-x] { color: #f00; } #i { color: #008000; }',
+				[[[], ['with the id' => ['id="i" data-x="1"', self::GREEN], 'attribute alone' => ['data-x="1"', self::RED]]]],
+			],
+			':where() counts nothing' => [
+				':where(#o) {T} { color: #f00; } {A}.k {T} { color: #008000; }',
+				[
+					[['id="o" class="k"'], ['under both' => ['', self::GREEN]]],
+					[['id="o"'], ['under the id alone' => ['', self::RED]]],
+				],
+			],
+			'the inline style beats an id' => [
+				'#i { color: #f00; }',
+				[[[], ['styled inline' => ['id="i" style="color: #008000"', self::GREEN], 'id alone' => ['id="i"', self::RED]]]],
+			],
+		];
+	}
+
+	/**
+	 * @param string $context
+	 *
+	 * @return string[] The tag of the subjects in a context, and of their ancestors
+	 */
+	private function tags($context)
+	{
+		if ($context === 'inline') {
+			return ['em', 'span'];
+		}
+
+		return [$context === 'table cell' ? 'td' : 'p', 'div'];
+	}
+
+	/**
+	 * A document with each group of subjects, in their ancestors, in a context, under a stylesheet naming the tags the
+	 * context gives them
+	 *
+	 * @param string $context
+	 * @param string $css With {T} for the subjects' tag and {A} for their ancestors'
+	 * @param array[] $groups As cases() gives them
+	 *
+	 * @return string
+	 */
+	private function document($context, $css, array $groups)
+	{
+		list($subject, $ancestor) = $this->tags($context);
+
+		$style = '<style>' . str_replace(['{T}', '{A}'], [$subject, $ancestor], $css) . '</style>';
+		$html = '';
+		foreach ($groups as $group) {
+			$inner = '';
+			foreach ($group[1] as $text => $attributes) {
+				$inner .= '<' . $subject . ' ' . $attributes[0] . '>' . $text . '</' . $subject . '> ';
+			}
+
+			if ($context === 'table cell') {
+				$inner = '<table><tr>' . $inner . '</tr></table>';
+			}
+
+			foreach (array_reverse($group[0]) as $attributes) {
+				$inner = '<' . $ancestor . ' ' . $attributes . '>' . $inner . '</' . $ancestor . '>';
+			}
+
+			$html .= $context === 'inline' ? '<p>' . $inner . '</p>' : $inner;
+		}
+
+		switch ($context) {
+			case 'header':
+				return $style . '<htmlpageheader name="h">' . $html . '</htmlpageheader><sethtmlpageheader name="h" value="on" show-this-page="1" /><p>body</p>';
+
+			case 'footer':
+				return $style . '<htmlpagefooter name="f">' . $html . '</htmlpagefooter><sethtmlpagefooter name="f" value="on" /><p>body</p>';
+
+			case 'positioned block':
+				return $style . '<div style="position: absolute; top: 60mm; left: 20mm; width: 150mm;">' . $html . '</div>';
+
+			case 'kept block':
+				// Too little of the first page is left for the block, which is laid out again on the second
+				return $style . str_repeat('<p>filler</p>', 44) . '<div style="page-break-inside: avoid"><p>kept</p>' . $html . '</div>';
+
+			case 'forced page break':
+				return $style . '<div class="w"><p>before the break</p><pagebreak />' . $html . '</div>';
+
+			default:
+				return $style . $html;
+		}
+	}
+
+	/**
+	 * The kept-block context does lay its block out twice: it starts on the first page, runs over, and is laid out
+	 * again from the top of the second
+	 */
+	public function testTheKeptBlockMovesToTheNextPage()
+	{
+		$mpdf = $this->drawDocument($this->document('kept block', '.c { color: #f00; }', [[[''], ['kept subject' => ['class="c"'], 'second' => [''], 'third' => ['']]]]), ['cssMode' => CssMode::STANDARD]);
+		$pages = $this->keyedByText($mpdf, array_map(function ($box) {
+			return $box[0];
+		}, $mpdf->drawnBoxes));
+
+		$this->assertSame(2, $pages['kept']);
+		$this->assertSame(2, $pages['kept subject']);
+	}
+
+	/**
+	 * A rule naming the block a forced page break closes and opens again reaches what follows the break inside it,
+	 * over a lighter rule, and not what is outside it
+	 */
+	public function testARuleThroughABlockOpenedAgainAfterAForcedPageBreak()
+	{
+		$colours = $this->drawnColours('<style>.w p { color: #008000; } div p { color: #f00; }</style>'
+			. '<div class="w"><p>before</p><pagebreak /><div><p>after the break</p></div></div><div><p>outside</p></div>', ['cssMode' => CssMode::STANDARD]);
+
+		$this->assertSame(self::GREEN, $colours['before']);
+		$this->assertSame(self::GREEN, $colours['after the break']);
+		$this->assertSame(self::RED, $colours['outside']);
+	}
+}
diff --git a/tests/Mpdf/CascadeOrderTest.php b/tests/Mpdf/CascadeOrderTest.php
new file mode 100644
index 000000000..07ef29ed3
--- /dev/null
+++ b/tests/Mpdf/CascadeOrderTest.php
@@ -0,0 +1,369 @@
+<?php
+
+namespace Mpdf;
+
+use Yoast\PHPUnitPolyfills\TestCases\TestCase;
+
+/**
+ * The order the rules that set the same property of an element are applied in, under each value of cssMode. The
+ * legacy cascade applies them in a fixed order of selector groups; the standard cascade by specificity, then by the
+ * order they are written in, as a browser does.
+ */
+class CascadeOrderTest extends TestCase
+{
+
+	use DrawnStyles;
+	use PageStreams;
+
+	const RED = '1.000 0.000 0.000 rg';
+	const BLUE = '0.000 0.000 1.000 rg';
+	const GREEN = '0.000 0.502 0.000 rg';
+	const BLACK = '0.000 g';
+
+	/**
+	 * Each piece of text named is drawn in the colour the cascade leaves it in
+	 *
+	 * @dataProvider precedence
+	 *
+	 * @param string $cascade legacy or standard
+	 * @param string $css
+	 * @param string $html
+	 * @param array<string, string> $expected Pieces of text and the colour each should be drawn in
+	 */
+	public function testAppliesTheRulesInTheCascadesOrder($cascade, $css, $html, array $expected)
+	{
+		$this->assertDrawnInColours($expected, $this->drawnColours('<style>' . $css . '</style>' . $html, ['cssMode' => $cascade]));
+	}
+
+	/**
+	 * Each row of precedence() once for each cascade, with that cascade's colours
+	 *
+	 * @return array[]
+	 */
+	public function precedence()
+	{
+		$cases = [];
+		foreach ($this->precedenceTable() as $name => $row) {
+			list($css, $html, $legacy, $standard) = $row;
+			$cases[$name . ' (legacy)'] = [CssMode::LEGACY, $css, $html, $legacy];
+			$cases[$name . ' (standard)'] = [CssMode::STANDARD, $css, $html, $standard];
+		}
+
+		return $cases;
+	}
+
+	/**
+	 * Rules that compete for an element's colour, a document for them, and the colours its text is drawn in by the
+	 * legacy cascade, as measured, and by the standard cascade, as the Selectors and Cascade specifications give them
+	 *
+	 * @return array[] Each [css, html, legacy colours, standard colours]
+	 */
+	private function precedenceTable()
+	{
+		return [
+			'an id beats a tag with a class' => [
+				'#i { color: #008000; } p.c { color: #f00; }',
+				'<p id="i" class="c">id</p><p class="c">no id</p>',
+				['id' => self::RED, 'no id' => self::RED],
+				['id' => self::GREEN, 'no id' => self::RED],
+			],
+			'an id beats a descendant rule' => [
+				'#i { color: #008000; } div p { color: #f00; }',
+				'<div><p id="i">id</p><p>no id</p></div>',
+				['id' => self::RED, 'no id' => self::RED],
+				['id' => self::GREEN, 'no id' => self::RED],
+			],
+			'a class beats a descendant rule of tags' => [
+				'.c { color: #008000; } div p { color: #f00; }',
+				'<div><p class="c">class</p><p>no class</p></div>',
+				['class' => self::RED, 'no class' => self::RED],
+				['class' => self::GREEN, 'no class' => self::RED],
+			],
+			'a class beats body p, as CMS stylesheets write it' => [
+				'body p { color: #f00; } .c { color: #008000; }',
+				'<p class="c">class</p><p>no class</p>',
+				['class' => self::RED, 'no class' => self::RED],
+				['class' => self::GREEN, 'no class' => self::RED],
+			],
+			'two classes beat a tag with a class' => [
+				'p.c { color: #f00; } .c.d { color: #008000; }',
+				'<p class="c d">both</p><p class="c">one</p>',
+				['both' => self::RED, 'one' => self::RED],
+				['both' => self::GREEN, 'one' => self::RED],
+			],
+			'a heavier descendant rule beats one lifted from a nearer ancestor' => [
+				'.c p { color: #008000; } div div p { color: #f00; }',
+				'<div class="c"><div><p>classed ancestor</p></div></div><div><div><p>plain ancestors</p></div></div>',
+				['classed ancestor' => self::RED, 'plain ancestors' => self::RED],
+				['classed ancestor' => self::GREEN, 'plain ancestors' => self::RED],
+			],
+			'an id ancestor beats nearer tag ancestors' => [
+				'#o p { color: #008000; } div div p { color: #f00; }',
+				'<div id="o"><div><p>id ancestor</p></div></div><div><div><p>plain ancestors</p></div></div>',
+				['id ancestor' => self::RED, 'plain ancestors' => self::RED],
+				['id ancestor' => self::GREEN, 'plain ancestors' => self::RED],
+			],
+			'classes apply in the order they are written, not alphabetically' => [
+				'.b { color: #008000; } .a { color: #f00; }',
+				'<p class="a b">a b</p><p class="b a">b a</p><p class="b">b only</p>',
+				['a b' => self::GREEN, 'b a' => self::GREEN, 'b only' => self::GREEN],
+				['a b' => self::RED, 'b a' => self::RED, 'b only' => self::GREEN],
+			],
+			'a selector written twice takes each of its places' => [
+				'.a { color: #f00; } .b { color: #008000; } .a { color: #00f; }',
+				'<p class="a b">a b</p><p class="b">b only</p>',
+				['a b' => self::GREEN, 'b only' => self::GREEN],
+				['a b' => self::BLUE, 'b only' => self::GREEN],
+			],
+			'a later stylesheet wins at the same specificity' => [
+				'.b { color: #008000; } </style><style> .a { color: #f00; }',
+				'<p class="a b">both</p>',
+				['both' => self::GREEN],
+				['both' => self::RED],
+			],
+			'an id with a class beats a tag with an id' => [
+				'#i.c { color: #008000; } p#i { color: #f00; }',
+				'<p id="i" class="c">both</p><p id="i">id only</p>',
+				['both' => self::GREEN, 'id only' => self::RED],
+				['both' => self::GREEN, 'id only' => self::RED],
+			],
+			'an id beats a child rule' => [
+				'#inner { color: #008000; } div > p { color: #f00; }',
+				'<div><p id="inner">id</p><p>no id</p></div>',
+				['id' => self::RED, 'no id' => self::RED],
+				['id' => self::GREEN, 'no id' => self::RED],
+			],
+			'an id beats an attribute selector' => [
+				'[data-x] { color: #f00; } #i { color: #008000; }',
+				'<p id="i" data-x="1">both</p><p data-x="1">attribute only</p>',
+				['both' => self::RED, 'attribute only' => self::RED],
+				['both' => self::GREEN, 'attribute only' => self::RED],
+			],
+			':not() counts its argument, so the later rule wins' => [
+				'p:not(.x) { color: #008000; } p.y { color: #f00; }',
+				'<p class="y">y</p><p>neither</p>',
+				['y' => self::GREEN, 'neither' => self::GREEN],
+				['y' => self::RED, 'neither' => self::GREEN],
+			],
+			':where() counts nothing' => [
+				':where(#o) p { color: #f00; } div p { color: #008000; }',
+				'<div id="o"><p>inside</p></div>',
+				['inside' => self::RED],
+				['inside' => self::GREEN],
+			],
+			'the inline style beats an id' => [
+				'#i { color: #f00; }',
+				'<p id="i" style="color: #008000">inline</p><p id="i">rule</p>',
+				['inline' => self::GREEN, 'rule' => self::RED],
+				['inline' => self::GREEN, 'rule' => self::RED],
+			],
+			'class names match whatever their case' => [
+				'.Foo { color: #008000; }',
+				'<p class="foo">lower</p><p class="FOO">upper</p>',
+				['lower' => self::GREEN, 'upper' => self::GREEN],
+				['lower' => self::GREEN, 'upper' => self::GREEN],
+			],
+		];
+	}
+
+	/**
+	 * A stylesheet in a later WriteHTML() call comes after those before it, as a later <style> block does
+	 */
+	public function testAStylesheetWrittenLaterComesLater()
+	{
+		$mpdf = $this->drawDocument('<style>.b { color: #008000; }</style>', ['cssMode' => CssMode::STANDARD]);
+		$mpdf->WriteHTML('<style>.a { color: #f00; }</style><p class="a b">both</p>');
+
+		$this->assertSame(self::RED, $mpdf->drawnColours[0]);
+	}
+
+	/**
+	 * The default stylesheet counts as the built-in stylesheet under the standard cascade, so an author's rule beats
+	 * it whatever the specificity: `ul { margin-bottom }` reaches a nested list over the default
+	 * `ul ul { margin-bottom: 0 }`. The legacy cascade applies the descendant rule last
+	 *
+	 * @dataProvider cascades
+	 *
+	 * @param string $cascade
+	 * @param bool $authorWins
+	 */
+	public function testAnAuthorRuleBeatsTheDefaultStylesheet($cascade, $authorWins)
+	{
+		$mpdf = $this->drawDocument('<style>ul { margin: 0 0 20mm 0; }</style><ul><li>outer<ul><li>inner</li></ul></li><li>next</li></ul>', ['cssMode' => $cascade]);
+		$y = $this->keyedByText($mpdf, $mpdf->drawnY);
+
+		$this->assertEqualsWithDelta($authorWins ? 20 : 0, $y['next'] - $y['inner'] - ($y['inner'] - $y['outer']), 0.5);
+	}
+
+	/**
+	 * Each cascade, and whether an author's rule beats a more specific rule of the default stylesheet under it
+	 *
+	 * @return array[]
+	 */
+	public function cascades()
+	{
+		return [
+			CssMode::LEGACY => [CssMode::LEGACY, false],
+			CssMode::STANDARD => [CssMode::STANDARD, true],
+		];
+	}
+
+	/**
+	 * A presentational attribute is an author rule of no specificity under the standard cascade: it beats the built-in
+	 * defaults, as `<hr color>` over the grey of an hr, and loses to any stylesheet rule. The legacy cascade applies the
+	 * attributes before the defaults
+	 *
+	 * @dataProvider attributes
+	 *
+	 * @param string $cascade
+	 * @param string $html
+	 * @param string $expected The stroke colour the rule is drawn in
+	 */
+	public function testAPresentationalAttributeComesAfterTheDefaults($cascade, $html, $expected)
+	{
+		$page = $this->pages($this->render($html, ['cssMode' => $cascade]))[0];
+
+		$this->assertStringContainsString($expected, $page);
+	}
+
+	/**
+	 * Each cascade with an hr coloured by its attribute, with and without a stylesheet rule for it
+	 *
+	 * @return array[]
+	 */
+	public function attributes()
+	{
+		$grey = '0.533 0.533 0.533 RG';
+		$red = '1.000 0.000 0.000 RG';
+		$blue = '0.000 0.000 1.000 RG';
+
+		return [
+			'legacy: the default beats the attribute' => [CssMode::LEGACY, '<hr color="#ff0000" />', $grey],
+			'legacy: a rule beats the attribute' => [CssMode::LEGACY, '<style>hr { color: #00f; }</style><hr color="#ff0000" />', $blue],
+			'standard: the attribute beats the default' => [CssMode::STANDARD, '<hr color="#ff0000" />', $red],
+			'standard: a rule beats the attribute' => [CssMode::STANDARD, '<style>hr { color: #00f; }</style><hr color="#ff0000" />', $blue],
+		];
+	}
+
+	/**
+	 * `<img vspace>` beats the default margin of an image under the standard cascade, and moves what follows down
+	 */
+	public function testVspaceBeatsTheDefaultMarginOfAnImage()
+	{
+		$html = '<img src="' . __DIR__ . '/../data/img/tiger.jpg" width="20" vspace="30" /><p>after</p>';
+		$legacy = $this->drawDocument($html, ['cssMode' => CssMode::LEGACY]);
+		$standard = $this->drawDocument($html, ['cssMode' => CssMode::STANDARD]);
+
+		$this->assertEqualsWithDelta(2 * 30 * 25.4 / 96, $standard->drawnY[0] - $legacy->drawnY[0], 0.1);
+	}
+
+	/**
+	 * What Mpdf::SetDefaultBodyCSS() writes styles the document under the standard cascade too
+	 */
+	public function testTheBodyTakesWhatTheApiWritesForIt()
+	{
+		$mpdf = new TextRecordingMpdf(['mode' => 'c', 'cssMode' => CssMode::STANDARD]);
+		$mpdf->SetDefaultBodyCSS('color', '#008000');
+		$mpdf->WriteHTML('<p>body text</p>');
+
+		$this->assertSame(self::GREEN, $mpdf->drawnColours[0]);
+	}
+
+	/**
+	 * A stylesheet rule for body sets the document's font size under the standard cascade, and a rule naming body as
+	 * a parent reaches its children
+	 */
+	public function testBodyRulesStyleTheDocument()
+	{
+		$mpdf = $this->drawDocument('<style>body { font-size: 20pt; } body > p.c { color: #008000; }</style><p>plain</p><p class="c">classed</p>', ['cssMode' => CssMode::STANDARD]);
+		$sizes = $this->keyedByText($mpdf, $mpdf->drawnFontSize);
+		$colours = $this->keyedByText($mpdf, $mpdf->drawnColours);
+
+		$this->assertEquals(20, $sizes['plain']);
+		$this->assertSame(self::BLACK, $colours['plain']);
+		$this->assertSame(self::GREEN, $colours['classed']);
+	}
+
+	/**
+	 * The default stylesheet still applies under the standard cascade where no author rule competes: its `ul ul`
+	 * takes the margins off a nested list
+	 */
+	public function testTheDefaultStylesheetApplies()
+	{
+		$html = '<ul><li>outer<ul><li>inner</li></ul></li><li>next</li></ul>';
+		$legacy = $this->drawDocument($html, ['cssMode' => CssMode::LEGACY]);
+		$standard = $this->drawDocument($html, ['cssMode' => CssMode::STANDARD]);
+
+		$this->assertSame($legacy->drawnY, $standard->drawnY);
+	}
+
+	/**
+	 * A class rule still styles the text of an SVG under the standard cascade, whose classes are looked up in
+	 * CssManager::$CSS
+	 */
+	public function testSvgTextFindsItsClassRules()
+	{
+		$svg = '<svg xmlns="http://www.w3.org/2000/svg" width="60" height="20"><text class="t" x="0" y="15">Hi</text></svg>';
+		$html = '<style>.t { fill: #00ff00; }</style><img src="data:image/svg+xml;base64,' . base64_encode($svg) . '" />';
+
+		$this->assertStringContainsString('0.000 1.000 0.000 rg', $this->render($html, ['cssMode' => CssMode::STANDARD, 'svgClasses' => true]));
+	}
+
+	/**
+	 * @page rules set the page's margins under the standard cascade, as they do under the legacy one
+	 */
+	public function testPageRulesStillApply()
+	{
+		$mpdf = $this->drawDocument('<style>@page { margin-left: 50mm; }</style><p>text</p>', ['cssMode' => CssMode::STANDARD]);
+
+		$this->assertEqualsWithDelta(50, $mpdf->drawnBoxes[0][1], 0.01);
+	}
+
+	/**
+	 * A document whose rules never compete for a property is drawn the same by both cascades: its tables' collapsed
+	 * borders take the cell rules' dominance, and its lists, headings, links and inline styles the same values
+	 *
+	 * @dataProvider uncontestedDocuments
+	 *
+	 * @param string $html
+	 */
+	public function testADocumentWhoseRulesDoNotCompeteIsDrawnAlike($html)
+	{
+		$legacy = $this->pages($this->render($html, ['cssMode' => CssMode::LEGACY]));
+		$standard = $this->pages($this->render($html, ['cssMode' => CssMode::STANDARD]));
+
+		$this->assertSame($legacy, $standard);
+	}
+
+	/**
+	 * Documents in which no two rules set the same property of an element
+	 *
+	 * @return array[]
+	 */
+	public function uncontestedDocuments()
+	{
+		return [
+			'collapsed borders of cells, rows and the table' => ['<style>table { border-collapse: collapse; border: 1mm solid #00f; } td { border: 0.5mm solid #f00; } td.x { border-top: 2mm solid #0a0; }</style>'
+				. '<table><tr><td>a</td><td class="x">b</td></tr><tr><td class="x">c</td><td style="border-bottom: 1.5mm dotted #000">d</td></tr></table>'],
+			'a border from a cell rule against one as wide from the border attribute, which the rule wins' => ['<style>td.x { border: 0.264583mm solid #f00; }</style>'
+				. '<table border="1" style="border-collapse: collapse"><tr><td>a</td><td class="x">b</td><td>c</td></tr></table>'],
+			'separate borders and padding' => ['<style>table { border-spacing: 2mm; } td { border: 0.3mm solid #000; padding: 3mm; } th { background-color: #eee; }</style>'
+				. '<table cellpadding="4"><tr><th>h</th></tr><tr><td>a</td></tr></table>'],
+			'headings, lists and links' => ['<style>h2 { color: #800; } li { font-style: italic; } a { text-decoration: none; }</style>'
+				. '<h2>Title</h2><ol><li>one</li><li>two <a href="https://example.com/">link</a></li></ol>'],
+			'descendant rules and inline styles' => ['<style>.box p { margin: 5mm; } .box { border: 0.3mm solid #000; }</style>'
+				. '<div class="box"><p>boxed</p><p style="color: #00f">inline</p></div>'],
+		];
+	}
+
+	/**
+	 * Any value but legacy and standard is refused when the document is made
+	 */
+	public function testRefusesAnUnknownCascade()
+	{
+		$this->expectException(MpdfException::class);
+		$this->expectExceptionMessage('cssMode (browser) is not valid. (Use: standard or legacy)');
+
+		new Mpdf(['cssMode' => 'browser']);
+	}
+}
diff --git a/tests/Mpdf/Css/CssMergerTest.php b/tests/Mpdf/Css/CssMergerTest.php
index 9047d32b9..e12fc64fb 100644
--- a/tests/Mpdf/Css/CssMergerTest.php
+++ b/tests/Mpdf/Css/CssMergerTest.php
@@ -20,13 +20,10 @@ protected function set_up()
 	{
 		parent::set_up();
 
-		$this->mpdf = new Mpdf();
+		// The merges below read the legacy cascade's keys and trees
+		$this->mpdf = new Mpdf(['cssMode' => \Mpdf\CssMode::LEGACY]);
 
-		// Get CssManager (private property of Mpdf, but we can reflect it)
-		$reflection = new \ReflectionClass($this->mpdf);
-		$property   = $reflection->getProperty('cssManager');
-		$property->setAccessible(true);
-		$this->cssManager = $property->getValue($this->mpdf);
+		$this->cssManager = $this->cssManagerOf($this->mpdf);
 
 		// Get CssMerger (private property of CssManager)
 		$reflection = new \ReflectionClass($this->cssManager);
@@ -37,6 +34,22 @@ protected function set_up()
 		$this->mpdf->AddPage();
 	}
 
+	/**
+	 * A document's CssManager, which it keeps private
+	 *
+	 * @param Mpdf $mpdf
+	 *
+	 * @return CssManager
+	 */
+	private function cssManagerOf(Mpdf $mpdf)
+	{
+		$reflection = new \ReflectionClass($mpdf);
+		$property = $reflection->getProperty('cssManager');
+		$property->setAccessible(true);
+
+		return $property->getValue($mpdf);
+	}
+
 	protected function tear_down()
 	{
 		unset($this->mpdf, $this->cssManager, $this->cssMerger);
@@ -567,4 +580,28 @@ public function testMergeWithComplexSelectors()
 
 		$this->assertEquals('green', $result['COLOR']);
 	}
+
+	/**
+	 * Under the standard cascade, previewBlockCss() matches the stylesheet against the open elements with the block
+	 * in the innermost one, as a merge there would, and leaves the open elements and the block stack as they were
+	 */
+	public function testPreviewsABlockUnderTheStandardCascadeWithoutSideEffects()
+	{
+		$mpdf = new Mpdf(['cssMode' => \Mpdf\CssMode::STANDARD]);
+		$mpdf->WriteHTML('<style>.box > p { color: red; } p.lead { margin-top: 5mm; }</style><div class="box">', \Mpdf\HTMLParserMode::DEFAULT_MODE, true, false);
+
+		$cssManager = $this->cssManagerOf($mpdf);
+
+		$elements = $mpdf->getOpenElements();
+		$blocks = $mpdf->blk;
+		$level = $mpdf->blklvl;
+
+		$preview = $cssManager->previewBlockCss('P', ['CLASS' => 'LEAD']);
+
+		$this->assertSame('red', $preview['COLOR']);
+		$this->assertSame('5mm', $preview['MARGIN-TOP']);
+		$this->assertSame($elements, $mpdf->getOpenElements());
+		$this->assertSame($blocks, $mpdf->blk);
+		$this->assertSame($level, $mpdf->blklvl);
+	}
 }
diff --git a/tests/Mpdf/Css/CssParserTest.php b/tests/Mpdf/Css/CssParserTest.php
index bb258534c..b62f9665a 100644
--- a/tests/Mpdf/Css/CssParserTest.php
+++ b/tests/Mpdf/Css/CssParserTest.php
@@ -24,7 +24,8 @@ protected function set_up()
 		parent::set_up();
 
 		$logger = new NullLogger();
-		$this->mpdf = new Mpdf();
+		// The legacy cascade stores rules by key and in the descendant tree as well as compiling them
+		$this->mpdf = new Mpdf(['cssMode' => \Mpdf\CssMode::LEGACY]);
 		$this->mpdf->setLogger($logger);
 
 		$assetFetcher = $this->getMockBuilder(AssetFetcher::class)
@@ -339,4 +340,25 @@ public function testStartsANewListOfCompiledRulesForEachParse()
 		$this->assertCount(1, $rules);
 		$this->assertSame(['+'], $rules[0][0]['combinators']);
 	}
+
+	/**
+	 * Under the standard cascade every rule is compiled, in the order it is written, the matcher applying all of
+	 * them. The simple ones the legacy parser reads are still stored by key, for what reads CssManager::$CSS directly,
+	 * but no descendant rule goes into the legacy tree
+	 */
+	public function testCompilesEveryRuleUnderTheStandardCascade()
+	{
+		$this->mpdf->cssMode = \Mpdf\CssMode::STANDARD;
+		$this->parser->parse('<style>p { color: red; } .a, div .b { color: green; } li:first-child { color: blue; } @page { margin-left: 1cm; }</style>');
+
+		$rules = $this->parser->getCompiledRules();
+		$this->assertCount(4, $rules);
+		$this->assertSame(
+			[['COLOR' => 'red'], ['COLOR' => 'green'], ['COLOR' => 'green'], ['COLOR' => 'blue']],
+			array_column($rules, 1)
+		);
+		$this->assertSame([false, false, false, false], array_column($rules, 2));
+		$this->assertSame(['P', 'CLASS>>A', '@PAGE'], array_keys($this->parser->getCss()));
+		$this->assertSame([], $this->parser->getCascadeCss());
+	}
 }
diff --git a/tests/Mpdf/Css/SelectorMatcherTest.php b/tests/Mpdf/Css/SelectorMatcherTest.php
index 9d448194f..4d74409a6 100644
--- a/tests/Mpdf/Css/SelectorMatcherTest.php
+++ b/tests/Mpdf/Css/SelectorMatcherTest.php
@@ -280,6 +280,92 @@ public function legacyLanguages()
 		];
 	}
 
+	/**
+	 * A failure left of a combinator stops the tries only where no other ancestor or sibling could match: a child
+	 * combinator that fails at the nearest ancestor is tried at the next one, and an adjacent or general sibling
+	 * combinator that fails at the first sibling at the next one
+	 *
+	 * @dataProvider retriedSelectors
+	 *
+	 * @param string $selector
+	 * @param bool $expected Whether it matches the paragraph in `<section><article><div><article>` that follows an
+	 *                       `<h2>`, an `<h1>`, an `<h2>` and a `<ul>`
+	 */
+	public function testTriesTheNextAncestorOrSiblingAfterAFailure($selector, $expected)
+	{
+		$path = [
+			$this->frame('', 1, 1, [], []),
+			$this->frame('SECTION', 1, 1, [], []),
+			$this->frame('ARTICLE', 1, 1, [], []),
+			$this->frame('DIV', 1, 1, [], []),
+			$this->frame('ARTICLE', 1, 1, [], [['H2'], ['H1'], ['H2'], ['UL']]),
+			$this->frame('P', 5, 1, [], []),
+		];
+
+		$this->assertSame($expected, $this->matcher->matches($this->compiler->compile($selector), $path));
+	}
+
+	/**
+	 * A selector whose left part fails where it is first tried, and whether it matches in the end
+	 *
+	 * @return array[]
+	 */
+	public function retriedSelectors()
+	{
+		return [
+			'a child of a further ancestor' => ['section > article p', true],
+			'a child of no ancestor' => ['div > section p', false],
+			'the second of two siblings is adjacent to the one it needs' => ['h1 + h2 ~ p', true],
+			'no sibling is adjacent to the one it needs' => ['ul + h2 ~ p', false],
+			'the second of two siblings follows the one it needs' => ['h1 ~ h2 ~ p', true],
+			'no sibling follows the one it needs' => ['ul ~ h1 ~ p', false],
+			'a sibling tag the parent has no child of' => ['h3 ~ p', false],
+			'an ancestor chain that fails everywhere' => ['p article section div p', false],
+		];
+	}
+
+	/**
+	 * A chain of descendant combinators whose leftmost compound names the nearest ancestor fails without trying every
+	 * combination of ancestors. On a path 50 deep, `.x div div div div div p` has nearly two million of them
+	 */
+	public function testGivesUpOnADescendantChainOnceNoAncestorCanMatch()
+	{
+		$path = [$this->frame('', 1, 1, [], [])];
+		for ($depth = 1; $depth < 50; $depth++) {
+			$path[] = $this->frame('DIV', 1, 1, $depth === 49 ? ['CLASS' => 'X'] : [], []);
+		}
+		$path[] = $this->frame('P', 1, 1, [], []);
+
+		$start = microtime(true);
+		$this->assertFalse($this->matcher->matches($this->compiler->compile('.x div div div div div p'), $path));
+		$this->assertTrue($this->matcher->matches($this->compiler->compile('div div div div div.x p'), $path));
+		$this->assertLessThan(1, microtime(true) - $start);
+	}
+
+	/**
+	 * A general sibling combinator finds a sibling at the start of a long run of them, and skips a tag its parent has
+	 * no child of, without walking back through every sibling for each element. Matching each of 5,000 paragraphs
+	 * after an `<h2>` walks 12.5 million siblings that way
+	 */
+	public function testFindsAnEarlierSiblingWithoutWalkingThroughEachOne()
+	{
+		$children = [['H2']];
+		for ($i = 0; $i < 5000; $i++) {
+			$children[] = ['P'];
+		}
+		$parent = $this->frame('', 1, 1, [], $children);
+		$heading = $this->compiler->compile('h2 ~ p');
+		$missing = $this->compiler->compile('h3 ~ p');
+
+		$start = microtime(true);
+		for ($i = 1; $i <= 5000; $i++) {
+			$path = [$parent, $this->frame('P', $i + 1, $i, [], [])];
+			$this->assertTrue($this->matcher->matches($heading, $path));
+			$this->assertFalse($this->matcher->matches($missing, $path));
+		}
+		$this->assertLessThan(1, microtime(true) - $start);
+	}
+
 	/**
 	 * The open elements the selectors are matched against: `<li class="x">`, the second item of a `<ul>` that follows
 	 * an `<h2>` and a `<p>` in `<div id="main" class="card">`, which follows an `<h1>`, a `<p class="a">` and a `<p>` in
diff --git a/tests/Mpdf/CssManagerTest.php b/tests/Mpdf/CssManagerTest.php
index ecc771b3f..13ea9f102 100644
--- a/tests/Mpdf/CssManagerTest.php
+++ b/tests/Mpdf/CssManagerTest.php
@@ -19,7 +19,8 @@ protected function set_up()
 		$this->tempDir = sys_get_temp_dir() . '/mpdf_test_' . uniqid();
 		mkdir($this->tempDir);
 
-		$this->mpdf = new Mpdf(['tempDir' => $this->tempDir]);
+		// The merges below read the legacy cascade's keys and trees
+		$this->mpdf = new Mpdf(['tempDir' => $this->tempDir, 'cssMode' => CssMode::LEGACY]);
 		$this->mpdf->setBasePath($this->tempDir);
 
 		// Use reflection to access private cssManager property
@@ -903,4 +904,35 @@ public function testKeepsTheCompiledRulesOfEveryStylesheetRead()
 		$this->assertSame(['COLOR' => 'red'], $rules->rule($candidates[0])[1]);
 		$this->assertSame(['COLOR' => 'green'], $rules->rule($candidates[1])[1]);
 	}
+
+	/**
+	 * The default stylesheet's rules are kept apart from the document's, and a document's stylesheet never adds to them
+	 */
+	public function testKeepsTheDefaultStylesheetsRulesApart()
+	{
+		$default = $this->cssManager->getDefaultRules()->candidates('UL', '', []);
+
+		$this->cssManager->readDefaultCss('ul > ul { margin-top: 0; }');
+		$this->cssManager->readCss('<style>body > ul { color: red; } ul > li { color: blue; }</style>');
+
+		$defaultRules = array_values(array_diff($this->cssManager->getDefaultRules()->candidates('UL', '', []), $default));
+		$documentRules = $this->cssManager->getRules()->candidates('UL', '', []);
+		$this->assertCount(1, $defaultRules);
+		$this->assertCount(1, $documentRules);
+		$this->assertSame(['MARGIN-TOP' => '0'], $this->cssManager->getDefaultRules()->rule($defaultRules[0])[1]);
+		$this->assertSame(['COLOR' => 'red'], $this->cssManager->getRules()->rule($documentRules[0])[1]);
+		$this->assertSame([], $this->cssManager->getDefaultRules()->candidates('LI', '', []));
+	}
+
+	/**
+	 * The default stylesheet is read into the same stores a document's stylesheet is, for what reads them directly
+	 */
+	public function testReadsTheDefaultStylesheetIntoTheSharedStores()
+	{
+		$this->cssManager->readDefaultCss('.note { color: red; } div p { margin: 0; } @page { margin-left: 1cm; }');
+
+		$this->assertSame('red', $this->cssManager->CSS['CLASS>>NOTE']['COLOR']);
+		$this->assertArrayHasKey('@PAGE', $this->cssManager->CSS);
+		$this->assertArrayHasKey('P', $this->cssManager->cascadeCSS['DIV']);
+	}
 }
diff --git a/tests/Mpdf/DescendantLangSelectorTest.php b/tests/Mpdf/DescendantLangSelectorTest.php
index c5ba3cf0d..7c27d9c75 100644
--- a/tests/Mpdf/DescendantLangSelectorTest.php
+++ b/tests/Mpdf/DescendantLangSelectorTest.php
@@ -9,7 +9,7 @@
  * in block content and in tables.
  *
  * A regional language such as fr-CA falls back to the rule for its short code, fr, when no rule names it in full,
- * as the simple lang rules do.
+ * as the simple lang rules do. That is how the legacy cascade matches them, and these run under it.
  */
 class DescendantLangSelectorTest extends TestCase
 {
@@ -31,7 +31,7 @@ class DescendantLangSelectorTest extends TestCase
 	 */
 	public function testTheRuleColoursTheText($css, $html, $expected)
 	{
-		$colours = $this->textColours('<style>' . $css . '</style>' . $html);
+		$colours = $this->textColours('<style>' . $css . '</style>' . $html, ['cssMode' => CssMode::LEGACY]);
 
 		$this->assertArrayHasKey('text', $colours);
 		$this->assertSame($expected, $colours['text']);
diff --git a/tests/Mpdf/DrawnStyles.php b/tests/Mpdf/DrawnStyles.php
index bc117adc3..18b94c879 100644
--- a/tests/Mpdf/DrawnStyles.php
+++ b/tests/Mpdf/DrawnStyles.php
@@ -40,6 +40,20 @@ private function drawnColours($html, array $config = [])
 		return $this->keyedByText($mpdf, $mpdf->drawnColours);
 	}
 
+	/**
+	 * Each piece of text named is drawn, in the colour given for it
+	 *
+	 * @param array<string, string> $expected Pieces of text and the operator that should set each one's colour
+	 * @param array<string, string> $colours What was drawn, as drawnColours() gives it
+	 */
+	private function assertDrawnInColours(array $expected, array $colours)
+	{
+		foreach ($expected as $text => $colour) {
+			$this->assertArrayHasKey($text, $colours, sprintf('"%s" is not drawn', $text));
+			$this->assertSame($colour, $colours[$text], sprintf('"%s" is drawn in the wrong colour', $text));
+		}
+	}
+
 	/**
 	 * Keys what was recorded of each piece of text a document drew by the text itself, so a test can look a piece up
 	 * by what it says
diff --git a/tests/Mpdf/InlineAncestorSelectorTest.php b/tests/Mpdf/InlineAncestorSelectorTest.php
index 7abfeedab..b3315c4ff 100644
--- a/tests/Mpdf/InlineAncestorSelectorTest.php
+++ b/tests/Mpdf/InlineAncestorSelectorTest.php
@@ -117,7 +117,7 @@ public function selectors()
 	 */
 	public function testLeavesToTheLegacyEngineWhatItMatches($css, $html, $expected)
 	{
-		$colours = $this->drawnColours('<style>' . $css . '</style>' . $html);
+		$colours = $this->drawnColours('<style>' . $css . '</style>' . $html, ['cssMode' => CssMode::LEGACY]);
 
 		$this->assertSame($expected, $colours['text']);
 	}
@@ -166,7 +166,8 @@ public function legacyMatches()
 	public function testAppliesRulesMatchedThroughAnInlineAncestorAfterTheLegacyOnes()
 	{
 		$colours = $this->drawnColours(
-			'<style>.y b { color: #00f; } .x b { color: #f00; }</style><p class="x"><span class="y"><b>text</b></span></p>'
+			'<style>.y b { color: #00f; } .x b { color: #f00; }</style><p class="x"><span class="y"><b>text</b></span></p>',
+			['cssMode' => CssMode::LEGACY]
 		);
 
 		$this->assertSame(self::BLUE, $colours['text']);
diff --git a/tests/Mpdf/PageStreams.php b/tests/Mpdf/PageStreams.php
index a70ef2640..2daf8fd58 100644
--- a/tests/Mpdf/PageStreams.php
+++ b/tests/Mpdf/PageStreams.php
@@ -263,12 +263,13 @@ private function clipAndPlacement($stream)
 	 *
 	 * @param string $html
 	 * @param int $page Counted from 0
+	 * @param array $config
 	 *
 	 * @return array[]
 	 */
-	private function imagePlacements($html, $page = 0)
+	private function imagePlacements($html, $page = 0, $config = [])
 	{
-		$pages = $this->pages($this->render($html));
+		$pages = $this->pages($this->render($html, $config));
 		$this->assertArrayHasKey($page, $pages);
 		preg_match_all('/([-\d.]+) 0 0 ([-\d.]+) ([-\d.]+) [-\d.]+ cm \/I\d+ Do/', $pages[$page], $matches, PREG_SET_ORDER);
 
@@ -281,12 +282,13 @@ private function imagePlacements($html, $page = 0)
 	 * The width of the only image on the first page, in millimetres
 	 *
 	 * @param string $html
+	 * @param array $config
 	 *
 	 * @return float
 	 */
-	private function drawnWidth($html)
+	private function drawnWidth($html, $config = [])
 	{
-		$placements = $this->imagePlacements($html);
+		$placements = $this->imagePlacements($html, 0, $config);
 		$this->assertCount(1, $placements);
 
 		return $placements[0]['w'];
@@ -296,12 +298,13 @@ private function drawnWidth($html)
 	 * The fill colour each piece of text on the first page is drawn in, keyed by that text
 	 *
 	 * @param string $html
+	 * @param array $config
 	 *
 	 * @return string[]
 	 */
-	private function textColours($html)
+	private function textColours($html, $config = [])
 	{
-		$pages = $this->pages($this->render($html));
+		$pages = $this->pages($this->render($html, $config));
 		preg_match_all('/q ([\d. ]+ (?:rg|g)) .*?\((.*?)\) Tj/', $pages[0], $drawn, PREG_SET_ORDER);
 
 		$colours = [];
diff --git a/tests/Mpdf/PositionedBlockSelectorStandardCascadeTest.php b/tests/Mpdf/PositionedBlockSelectorStandardCascadeTest.php
new file mode 100644
index 000000000..73479720d
--- /dev/null
+++ b/tests/Mpdf/PositionedBlockSelectorStandardCascadeTest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Mpdf;
+
+/**
+ * Stylesheet rules that name a positioned block reach the content inside it under the standard cascade too
+ */
+class PositionedBlockSelectorStandardCascadeTest extends PositionedBlockSelectorTest
+{
+
+	/**
+	 * The standard cascade
+	 *
+	 * @return array
+	 */
+	protected function config()
+	{
+		return ['cssMode' => CssMode::STANDARD];
+	}
+}
diff --git a/tests/Mpdf/PositionedBlockSelectorTest.php b/tests/Mpdf/PositionedBlockSelectorTest.php
index c0f002f1a..59be3c153 100644
--- a/tests/Mpdf/PositionedBlockSelectorTest.php
+++ b/tests/Mpdf/PositionedBlockSelectorTest.php
@@ -20,6 +20,17 @@ class PositionedBlockSelectorTest extends TestCase
 	const BLUE = '0.000 0.000 1.000 rg';
 	const BLACK = '0.000 g';
 
+	/**
+	 * The configuration the documents are written with: the legacy cascade. A subclass runs the tests under the
+	 * standard one
+	 *
+	 * @return array
+	 */
+	protected function config()
+	{
+		return ['cssMode' => CssMode::LEGACY];
+	}
+
 	/**
 	 * A descendant rule naming the block's class reaches a paragraph and a table cell inside it
 	 */
@@ -31,7 +42,7 @@ public function testClassDescendantRulesReachTheContentOfAnAbsoluteBlock()
 			.box { color: #0000ff; }
 			</style>
 			<div class="box"><p>flow p</p><table><tr><td>flow td</td></tr></table></div>
-			<div class="box" style="position: absolute; top: 100mm; left: 20mm; width: 100mm;"><p>abs p</p><table><tr><td>abs td</td></tr></table><span>abs span</span></div>');
+			<div class="box" style="position: absolute; top: 100mm; left: 20mm; width: 100mm;"><p>abs p</p><table><tr><td>abs td</td></tr></table><span>abs span</span></div>', $this->config());
 
 		$this->assertSame(self::GREEN, $colours['flow p']);
 		$this->assertSame(self::RED, $colours['flow td']);
@@ -46,7 +57,7 @@ public function testClassDescendantRulesReachTheContentOfAnAbsoluteBlock()
 	public function testIdDescendantRulesReachTheContentOfAFixedBlock()
 	{
 		$colours = $this->textColours('<style>#side p { color: #ff0000; }</style>
-			<div id="side" style="position: fixed; top: 10mm; left: 20mm; width: 100mm;"><p>fixed p</p></div>');
+			<div id="side" style="position: fixed; top: 10mm; left: 20mm; width: 100mm;"><p>fixed p</p></div>', $this->config());
 
 		$this->assertSame(self::RED, $colours['fixed p']);
 	}
@@ -57,7 +68,7 @@ public function testIdDescendantRulesReachTheContentOfAFixedBlock()
 	public function testTheContentIsAChildOfTheBlockItself()
 	{
 		$colours = $this->textColours('<style>.box div p { color: #ff0000; }</style>
-			<div class="box" style="position: absolute; top: 100mm; left: 20mm; width: 100mm;"><p>direct p</p><div><p>nested p</p></div></div>');
+			<div class="box" style="position: absolute; top: 100mm; left: 20mm; width: 100mm;"><p>direct p</p><div><p>nested p</p></div></div>', $this->config());
 
 		$this->assertSame(self::BLACK, $colours['direct p']);
 		$this->assertSame(self::RED, $colours['nested p']);
@@ -70,7 +81,7 @@ public function testTheRulesOfOneBlockDoNotReachTheNext()
 	{
 		$colours = $this->textColours('<style>.box p { color: #00aa00; }</style>
 			<div class="box" style="position: absolute; top: 20mm; left: 20mm; width: 100mm;"><p>boxed p</p></div>
-			<div style="position: absolute; top: 100mm; left: 20mm; width: 100mm;"><p>plain p</p></div>');
+			<div style="position: absolute; top: 100mm; left: 20mm; width: 100mm;"><p>plain p</p></div>', $this->config());
 
 		$this->assertSame(self::GREEN, $colours['boxed p']);
 		$this->assertSame(self::BLACK, $colours['plain p']);
diff --git a/tests/Mpdf/RotatedCellFontSizeTest.php b/tests/Mpdf/RotatedCellFontSizeTest.php
new file mode 100644
index 000000000..1e0664d6e
--- /dev/null
+++ b/tests/Mpdf/RotatedCellFontSizeTest.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace Mpdf;
+
+use Yoast\PHPUnitPolyfills\TestCases\TestCase;
+
+/**
+ * Rotated text in a table cell whose font size is the one already in force, such as the size the table sets, is
+ * measured and drawn at that size (#632)
+ */
+class RotatedCellFontSizeTest extends TestCase
+{
+
+	use PageStreams;
+
+	/**
+	 * The rotated text is drawn at the table's size, set by an attribute or by a rule
+	 *
+	 * @dataProvider tables
+	 *
+	 * @param string $html
+	 */
+	public function testDrawsRotatedTextAtTheTablesFontSize($html)
+	{
+		preg_match_all('/([\d.]+) Tf ET(?:(?!Tf ET).)*?\(Rotated\) Tj/s', $this->pages($this->render($html))[0], $sizes);
+
+		$this->assertSame(['9.000'], $sizes[1]);
+	}
+
+	/**
+	 * Tables that set a font size, with a rotated cell
+	 *
+	 * @return array[]
+	 */
+	public function tables()
+	{
+		return [
+			'the size in the table\'s style' => ['<table style="font-size: 9pt"><tr style="text-rotate: 45"><td>Rotated</td></tr></table>'],
+			'the size in a rule for the table' => ['<style>table { font-size: 9pt; }</style><table><tr><td>Plain</td></tr><tr style="text-rotate: 90"><td>Rotated</td></tr></table>'],
+		];
+	}
+}
diff --git a/tests/Mpdf/StructuralSelectorTest.php b/tests/Mpdf/StructuralSelectorTest.php
index de717a4eb..6d463d949 100644
--- a/tests/Mpdf/StructuralSelectorTest.php
+++ b/tests/Mpdf/StructuralSelectorTest.php
@@ -268,7 +268,7 @@ public function selectors()
 	 */
 	public function testAppliesMatchedRulesBySpecificityThenPosition($css, $html, $expected)
 	{
-		$colours = $this->drawnColours('<style>' . $css . '</style>' . $html);
+		$colours = $this->drawnColours('<style>' . $css . '</style>' . $html, ['cssMode' => CssMode::LEGACY]);
 
 		$this->assertSame($expected, $colours['text']);
 	}
diff --git a/tests/Mpdf/StyledElementPathTest.php b/tests/Mpdf/StyledElementPathTest.php
index f9a6e2903..8223dc418 100644
--- a/tests/Mpdf/StyledElementPathTest.php
+++ b/tests/Mpdf/StyledElementPathTest.php
@@ -6,7 +6,8 @@
 
 /**
  * The open elements the CSS merger matches compiled rules against, for each element it styles: the element opened
- * by a start tag, a block opened again after a forced page break, a positioned block and the content written in it
+ * by a start tag, a block opened again after a forced page break, a positioned block and the content written in it.
+ * These run under the legacy cascade, which asks for the path only when a compiled rule is filed under the element
  */
 class StyledElementPathTest extends TestCase
 {
@@ -22,7 +23,7 @@ class StyledElementPathTest extends TestCase
 	 */
 	public function testGivesThePathToTheElementBeingStyled($html, array $expected)
 	{
-		$mpdf = new StyledPathRecordingMpdf(['mode' => 'c']);
+		$mpdf = new StyledPathRecordingMpdf(['mode' => 'c', 'cssMode' => CssMode::LEGACY]);
 		$mpdf->WriteHTML($html);
 
 		$this->assertSame($expected, $mpdf->styledPaths);
@@ -38,7 +39,7 @@ public function testGivesThePathToTheElementBeingStyled($html, array $expected)
 	 */
 	public function testGivesThePositionTheElementHasOnItsPath($html)
 	{
-		$mpdf = new StyledPathRecordingMpdf(['mode' => 'c']);
+		$mpdf = new StyledPathRecordingMpdf(['mode' => 'c', 'cssMode' => CssMode::LEGACY]);
 		$mpdf->WriteHTML($html . '<style>tr > td, tbody > tr { font-weight: bold; }</style>'
 			. '<table><tr><td>a</td><td>b</td></tr></table><table><tbody><tr><td>c</td></tr></tbody><tr><td>d</td></tr></table>');
 
@@ -85,7 +86,7 @@ public function documents()
 	 */
 	public function testLetsGoOfTheElementOnceItsStartTagIsRead()
 	{
-		$mpdf = new StyledPathRecordingMpdf(['mode' => 'c']);
+		$mpdf = new StyledPathRecordingMpdf(['mode' => 'c', 'cssMode' => CssMode::LEGACY]);
 		$mpdf->WriteHTML('<style>div > p { color: red; }</style><div><p>a</p><p>b</p></div>');
 
 		$this->assertNull($mpdf->getStyledElementPath());
@@ -96,7 +97,7 @@ public function testLetsGoOfTheElementOnceItsStartTagIsRead()
 	 */
 	public function testGivesNoPathForASpanWrappedAroundARunOfAnotherScript()
 	{
-		$mpdf = new StyledPathRecordingMpdf(['mode' => '', 'autoScriptToLang' => true]);
+		$mpdf = new StyledPathRecordingMpdf(['mode' => '', 'autoScriptToLang' => true, 'cssMode' => CssMode::LEGACY]);
 		$mpdf->WriteHTML('<style>p > span { color: red; }</style><p>abc שלום <span>def</span></p>');
 
 		$this->assertSame([null, '>P>SPAN'], $mpdf->styledPaths);
diff --git a/tests/Mpdf/TableCellDescendantSelectorStandardCascadeTest.php b/tests/Mpdf/TableCellDescendantSelectorStandardCascadeTest.php
new file mode 100644
index 000000000..34e121328
--- /dev/null
+++ b/tests/Mpdf/TableCellDescendantSelectorStandardCascadeTest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Mpdf;
+
+/**
+ * A descendant rule naming a table, row or cell reaches the content of the cell under the standard cascade too
+ */
+class TableCellDescendantSelectorStandardCascadeTest extends TableCellDescendantSelectorTest
+{
+
+	/**
+	 * The standard cascade
+	 *
+	 * @return array
+	 */
+	protected function config()
+	{
+		return ['cssMode' => CssMode::STANDARD];
+	}
+}
diff --git a/tests/Mpdf/TableCellDescendantSelectorTest.php b/tests/Mpdf/TableCellDescendantSelectorTest.php
index 0aa9f7899..826034917 100644
--- a/tests/Mpdf/TableCellDescendantSelectorTest.php
+++ b/tests/Mpdf/TableCellDescendantSelectorTest.php
@@ -12,6 +12,17 @@ class TableCellDescendantSelectorTest extends \Yoast\PHPUnitPolyfills\TestCases\
 
 	const RED = '1.000 0.000 0.000 rg';
 
+	/**
+	 * The configuration the documents are written with: the legacy cascade. A subclass runs the tests under the
+	 * standard one
+	 *
+	 * @return array
+	 */
+	protected function config()
+	{
+		return ['cssMode' => CssMode::LEGACY];
+	}
+
 	/**
 	 * A table of one cell holding the given content, in a div, under the given stylesheet
 	 *
@@ -60,7 +71,7 @@ public static function matchingRules()
 	 */
 	public function testARuleReachesAPictureInTheCell($selector, $content)
 	{
-		$this->assertEqualsWithDelta(20, $this->drawnWidth($this->table($selector . ' { max-width: 20mm; }', $content)), 0.01);
+		$this->assertEqualsWithDelta(20, $this->drawnWidth($this->table($selector . ' { max-width: 20mm; }', $content), $this->config()), 0.01);
 	}
 
 	/**
@@ -68,7 +79,7 @@ public function testARuleReachesAPictureInTheCell($selector, $content)
 	 */
 	public function testARuleForAnotherCellDoesNotMatch()
 	{
-		$width = $this->drawnWidth($this->table('td.other img { max-width: 20mm; }', self::image()));
+		$width = $this->drawnWidth($this->table('td.other img { max-width: 20mm; }', self::image()), $this->config());
 
 		$this->assertEqualsWithDelta(292 * 25.4 / 96, $width, 0.01);
 	}
@@ -94,7 +105,7 @@ public static function textRules()
 	 */
 	public function testARuleReachesTextInTheCell($selector, $content)
 	{
-		$colours = $this->textColours($this->table($selector . ' { color: #ff0000; }', $content));
+		$colours = $this->textColours($this->table($selector . ' { color: #ff0000; }', $content), $this->config());
 
 		$this->assertSame(self::RED, $colours['red']);
 	}
diff --git a/tests/Snapshots/DescendantLangSelectorSnapshotTest.php b/tests/Snapshots/DescendantLangSelectorSnapshotTest.php
index ce036484e..456728ef3 100644
--- a/tests/Snapshots/DescendantLangSelectorSnapshotTest.php
+++ b/tests/Snapshots/DescendantLangSelectorSnapshotTest.php
@@ -4,7 +4,8 @@
 
 /**
  * Descendant rules whose last part names a language, such as `div :lang(fr)`, `div [lang=fr]` and `div p:lang(fr)`,
- * in block content, inline content and tables, and a regional language falling back to the rule for its short code.
+ * in block content, inline content and tables, and a regional language falling back to the rule for its short code,
+ * under the legacy cascade.
  *
  * @group snapshot
  */
@@ -107,7 +108,8 @@ public function generatePdf()
 		<?php
 		$html = ob_get_clean();
 
-		$this->mpdf = $this->createMpdf();
+		// A regional language named in full winning over its short code, whatever the order, is the legacy cascade's
+		$this->mpdf = $this->createMpdf(['cssMode' => \Mpdf\CssMode::LEGACY]);
 
 		$this->mpdf->WriteHTML($html);
 	}
diff --git a/tests/Snapshots/FrameworkCascadeLegacySnapshotTest.php b/tests/Snapshots/FrameworkCascadeLegacySnapshotTest.php
new file mode 100644
index 000000000..15e72f501
--- /dev/null
+++ b/tests/Snapshots/FrameworkCascadeLegacySnapshotTest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * The framework stylesheet under the legacy cascade
+ *
+ * @group snapshot
+ */
+class FrameworkCascadeLegacySnapshotTest extends FrameworkCascadeSnapshot
+{
+
+	/**
+	 * @return string
+	 */
+	protected function cascade()
+	{
+		return \Mpdf\CssMode::LEGACY;
+	}
+
+}
diff --git a/tests/Snapshots/FrameworkCascadeSnapshot.php b/tests/Snapshots/FrameworkCascadeSnapshot.php
new file mode 100644
index 000000000..44fad39e0
--- /dev/null
+++ b/tests/Snapshots/FrameworkCascadeSnapshot.php
@@ -0,0 +1,120 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * A page styled the way a CSS framework and a theme style one: components, utility classes, ids, and descendant and
+ * child rules that compete for the same elements on specificity and source order. Written under each value of
+ * cssMode, with captions saying what each cascade draws.
+ *
+ * @group snapshot
+ */
+abstract class FrameworkCascadeSnapshot extends Snapshot
+{
+
+	/**
+	 * @return string legacy or standard
+	 */
+	abstract protected function cascade();
+
+	/**
+	 * The fixture's name
+	 *
+	 * @return string
+	 */
+	public function getId()
+	{
+		return 'framework-cascade-' . $this->cascade();
+	}
+
+	/**
+	 * The components, each under a caption saying what the standard and the legacy cascade draw
+	 */
+	public function generatePdf()
+	{
+		ob_start();
+		?>
+		<style>
+			/* Base */
+			body { font-family: sans-serif; font-size: 9pt; color: #212529; }
+			h1 { font-size: 15pt; margin: 0 0 1mm 0; }
+			h2 { font-size: 10pt; margin: 4mm 0 1mm 0; color: #000000; }
+			p.caption { font-size: 7.5pt; color: #6c757d; margin: 0 0 1.5mm 0; }
+			article p { font-size: 9pt; color: #343a40; margin: 1mm 0; }
+
+			/* Components */
+			.navbar { background-color: #212529; padding: 2mm 3mm; }
+			.navbar > .container a { color: #adb5bd; text-decoration: none; }
+			#brand { color: #ffc107; font-weight: bold; }
+
+			.card { border: 0.3mm solid #ced4da; padding: 2mm 3mm; margin-bottom: 2mm; }
+			.card h5 { font-size: 11pt; color: #212529; margin: 0 0 1mm 0; }
+			h5.card-title { color: #0d6efd; }
+			.lead { font-size: 12pt; color: #6c757d; }
+
+			.nav .nav-link { color: #0d6efd; }
+			#sidebar a { color: #6f42c1; font-weight: bold; }
+
+			.list-group { margin: 0; padding: 0; list-style-type: none; }
+			.list-group-item { padding: 1mm 2mm; border: 0.2mm solid #dee2e6; color: #212529; background-color: #ffffff; }
+			.list-group .list-group-item { background-color: #f8f9fa; }
+			.list-group-item.active { color: #ffffff; background-color: #0d6efd; }
+
+			table.table { border-collapse: collapse; width: 100%; }
+			.table td, .table th { padding: 1mm 2mm; border-bottom: 0.2mm solid #dee2e6; text-align: left; }
+			.table-striped tr:nth-child(odd) td { background-color: #f2f2f2; }
+			.title { color: #0d6efd; font-weight: bold; }
+
+			/* Utilities, last as frameworks write them */
+			td.text-end, th.text-end { text-align: right; }
+			.muted { color: #adb5bd; }
+		</style>
+
+		<h1>A framework's stylesheet</h1>
+		<p class="caption">Written with cssMode set to <?php echo $this->cascade(); ?>.</p>
+
+		<h2>Navbar</h2>
+		<p class="caption">#brand against .navbar &gt; .container a. Standard: "Brand" is yellow and bold, the id beating the child rule. Legacy: "Brand" is grey like the other links, though still bold, because a rule only the matcher reads is applied after the id.</p>
+		<div class="navbar"><div class="container"><a id="brand" href="#top">Brand</a> <a href="#home">Home</a> <a href="#docs">Docs</a></div></div>
+
+		<h2>Card</h2>
+		<p class="caption">h5.card-title against .card h5, as heavy and written later. Standard: the title is blue. Legacy: it is black, the descendant rule coming last.</p>
+		<p class="caption">.lead against article p. Standard: the lead paragraph is large and grey, a class outweighing two tags. Legacy: it is the size and colour of the paragraph after it.</p>
+		<div class="card">
+			<h5 class="card-title">Card title</h5>
+			<article><p class="lead">A lead paragraph, set larger than the text after it.</p><p>The body text of the card.</p></article>
+		</div>
+
+		<h2>Sidebar navigation</h2>
+		<p class="caption">#sidebar a against .nav .nav-link. Standard: the links are purple and bold, an id ancestor outweighing two classes. Legacy: they are blue and bold, the rule lifted from the nearer .nav coming last.</p>
+		<div id="sidebar"><ul class="nav"><li><a class="nav-link" href="#one">First link</a></li><li><a class="nav-link" href="#two">Second link</a></li></ul></div>
+
+		<h2>List group</h2>
+		<p class="caption">.list-group-item.active against .list-group .list-group-item, as heavy and written later. Standard: the active item is white on blue. Legacy: it is white on light grey, the descendant rule's background coming last, so its text all but disappears.</p>
+		<ul class="list-group">
+			<li class="list-group-item">An item</li>
+			<li class="list-group-item active">The active item</li>
+			<li class="list-group-item">Another item</li>
+		</ul>
+
+		<h2>Table</h2>
+		<p class="caption">td.text-end against .table td, as heavy and written later. Standard: the amounts are right-aligned. Legacy: they are left-aligned, the descendant rule coming last. "Hosting", the third row counting the header, is striped grey in both.</p>
+		<table class="table table-striped">
+			<tr><th>Item</th><th class="text-end">Amount</th></tr>
+			<tr><td>Consulting</td><td class="text-end">1,200.00</td></tr>
+			<tr><td>Hosting</td><td class="text-end">300.00</td></tr>
+			<tr><td>Support</td><td class="text-end">150.00</td></tr>
+		</table>
+
+		<h2>Utilities and components</h2>
+		<p class="caption">.muted, written after .title. Standard: "Muted title" is light grey and bold. Legacy: it is blue and bold, classes applying in alphabetical order.</p>
+		<p class="title muted">Muted title</p>
+		<?php
+		$html = ob_get_clean();
+
+		$this->mpdf = $this->createMpdf(['cssMode' => $this->cascade()]);
+
+		$this->mpdf->WriteHTML($html);
+	}
+
+}
diff --git a/tests/Snapshots/FrameworkCascadeStandardSnapshotTest.php b/tests/Snapshots/FrameworkCascadeStandardSnapshotTest.php
new file mode 100644
index 000000000..fd8eb5b5f
--- /dev/null
+++ b/tests/Snapshots/FrameworkCascadeStandardSnapshotTest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * The framework stylesheet under the standard cascade
+ *
+ * @group snapshot
+ */
+class FrameworkCascadeStandardSnapshotTest extends FrameworkCascadeSnapshot
+{
+
+	/**
+	 * @return string
+	 */
+	protected function cascade()
+	{
+		return \Mpdf\CssMode::STANDARD;
+	}
+
+}
diff --git a/tests/Snapshots/StandardCascadeSnapshotTest.php b/tests/Snapshots/StandardCascadeSnapshotTest.php
new file mode 100644
index 000000000..281f44e41
--- /dev/null
+++ b/tests/Snapshots/StandardCascadeSnapshotTest.php
@@ -0,0 +1,123 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * The standard cascade: rules that compete for an element applied by specificity and then by the order they are
+ * written in, after the built-in defaults and the presentational attributes and before the inline style. Each case
+ * sets one rule against another. The rule that wins colours its text green; the red rule is the one the legacy
+ * cascade lets win, where the two differ.
+ *
+ * @group snapshot
+ */
+class StandardCascadeSnapshotTest extends Snapshot
+{
+
+	/**
+	 * The fixture's name
+	 *
+	 * @return string
+	 */
+	public function getId()
+	{
+		return 'standard-cascade';
+	}
+
+	/**
+	 * One competing pair of rules per case, under a caption saying what should be seen
+	 */
+	public function generatePdf()
+	{
+		ob_start();
+		?>
+		<style>
+			body { font-size: 9pt; }
+			h1 { font-size: 15pt; margin: 0 0 2mm 0; }
+			p.caption { margin: 3mm 0 1mm 0; font-size: 8pt; color: #606060; }
+			div.case { border: 0.2mm solid #999999; padding: 0.5mm 2mm; }
+			div.case p { margin: 0.5mm 0; }
+
+			#c1 { color: #0a7d32; }
+			p.c1 { color: #ff0000; }
+
+			#c2 { color: #0a7d32; }
+			div.c2 div p { color: #ff0000; }
+
+			body p.c3 { color: #ff0000; }
+			.c3.win { color: #0a7d32; }
+
+			.c4 p { color: #0a7d32; }
+			div div div p { color: #ff0000; }
+
+			.c5b { color: #ff0000; }
+			.c5a { color: #0a7d32; }
+
+			.c6a { color: #ff0000; }
+			.c6b { color: #ff0000; }
+			.c6a { color: #0a7d32; }
+
+			.c7b { color: #ff0000; }
+
+			:where(#c8) p { color: #ff0000; }
+			div.c8 p { color: #0a7d32; }
+
+			#c9 { color: #ff0000; }
+
+			ul.c10 { margin: 0 0 4mm 0; }
+
+			table.c12 { border-collapse: collapse; }
+			table.c12 tr td { border: 0.3mm solid #ff0000; padding: 1mm 3mm; }
+			td#win { border: 0.8mm solid #0a7d32; }
+		</style>
+		<style>
+			.c7a { color: #0a7d32; }
+		</style>
+
+		<h1>The standard cascade</h1>
+
+		<p class="caption">#id beats p.class: the line is green.</p>
+		<div class="case"><p id="c1" class="c1">An id against a tag with a class</p></div>
+
+		<p class="caption">#id beats div.class div p: the line is green.</p>
+		<div class="case c2"><div><p id="c2">An id against a descendant rule</p></div></div>
+
+		<p class="caption">.class.class beats body p.class: the line is green.</p>
+		<div class="case"><p class="c3 win">Two classes against body and a tag with a class</p></div>
+
+		<p class="caption">.class p beats div div div p, although the divs are nearer: the line is green.</p>
+		<div class="case c4"><div><div><p>A class ancestor against three tag ancestors</p></div></div></div>
+
+		<p class="caption">.c5a is written after .c5b, so it wins whichever order the classes are in: both lines are green.</p>
+		<div class="case"><p class="c5a c5b">Classes a then b</p><p class="c5b c5a">Classes b then a</p></div>
+
+		<p class="caption">.c6a, then .c6b, then .c6a again: the second .c6a comes last, and the line is green.</p>
+		<div class="case"><p class="c6a c6b">A selector written twice</p></div>
+
+		<p class="caption">A rule in a later style block beats one as heavy in an earlier block: the line is green.</p>
+		<div class="case"><p class="c7a c7b">A rule in a later stylesheet</p></div>
+
+		<p class="caption">:where() counts nothing, so div.class p beats :where(#id) p: the line is green.</p>
+		<div class="case c8" id="c8"><p>:where() against a class</p></div>
+
+		<p class="caption">The inline style beats #id: the line is green.</p>
+		<div class="case"><p id="c9" style="color: #0a7d32">Inline style against an id</p></div>
+
+		<p class="caption">ul.class beats the default stylesheet's ul ul, which counts as the built-in stylesheet's: the nested list keeps the 4mm gap below it, so "Outer two" is well below "Inner two".</p>
+		<div class="case">
+			<ul class="c10"><li>Outer one<ul class="c10"><li>Inner one</li><li>Inner two</li></ul></li><li>Outer two</li></ul>
+		</div>
+
+		<p class="caption">&lt;hr color&gt; beats the grey of the built-in defaults: the rule is green.</p>
+		<div class="case"><hr color="#0a7d32" /></div>
+
+		<p class="caption">td#id beats table.class tr td: the middle cell has a thick green border, drawn over its neighbours' thin red ones.</p>
+		<table class="c12"><tr><td>Left</td><td id="win">Middle</td><td>Right</td></tr></table>
+		<?php
+		$html = ob_get_clean();
+
+		$this->mpdf = $this->createMpdf(['cssMode' => \Mpdf\CssMode::STANDARD]);
+
+		$this->mpdf->WriteHTML($html);
+	}
+
+}
diff --git a/tests/data/snapshots/framework-cascade-legacy.pdf b/tests/data/snapshots/framework-cascade-legacy.pdf
new file mode 100644
index 000000000..6e54d92e3
Binary files /dev/null and b/tests/data/snapshots/framework-cascade-legacy.pdf differ
diff --git a/tests/data/snapshots/framework-cascade-standard.pdf b/tests/data/snapshots/framework-cascade-standard.pdf
new file mode 100644
index 000000000..805ab9454
Binary files /dev/null and b/tests/data/snapshots/framework-cascade-standard.pdf differ
diff --git a/tests/data/snapshots/page-break-avoid-content.pdf b/tests/data/snapshots/page-break-avoid-content.pdf
index 1b0b528fb..7497dc2a8 100644
Binary files a/tests/data/snapshots/page-break-avoid-content.pdf and b/tests/data/snapshots/page-break-avoid-content.pdf differ
diff --git a/tests/data/snapshots/page-break-avoid-floats.pdf b/tests/data/snapshots/page-break-avoid-floats.pdf
index e2adc0af1..7da0d3ee5 100644
Binary files a/tests/data/snapshots/page-break-avoid-floats.pdf and b/tests/data/snapshots/page-break-avoid-floats.pdf differ
diff --git a/tests/data/snapshots/positioned-html.pdf b/tests/data/snapshots/positioned-html.pdf
index 80b27020e..2343ab40c 100644
Binary files a/tests/data/snapshots/positioned-html.pdf and b/tests/data/snapshots/positioned-html.pdf differ
diff --git a/tests/data/snapshots/rtl.pdf b/tests/data/snapshots/rtl.pdf
index 40fe553b9..724d684aa 100644
Binary files a/tests/data/snapshots/rtl.pdf and b/tests/data/snapshots/rtl.pdf differ
diff --git a/tests/data/snapshots/standard-cascade.pdf b/tests/data/snapshots/standard-cascade.pdf
new file mode 100644
index 000000000..8f561bf9b
Binary files /dev/null and b/tests/data/snapshots/standard-cascade.pdf differ
diff --git a/tests/data/snapshots/table.pdf b/tests/data/snapshots/table.pdf
index 69a1fe048..93b183e04 100644
Binary files a/tests/data/snapshots/table.pdf and b/tests/data/snapshots/table.pdf differ
diff --git a/tests/data/snapshots/toc-and-index.pdf b/tests/data/snapshots/toc-and-index.pdf
index 1e8ad6242..d1762981c 100644
Binary files a/tests/data/snapshots/toc-and-index.pdf and b/tests/data/snapshots/toc-and-index.pdf differ