diff --git a/CHANGELOG-GRAVITYPDF.md b/CHANGELOG-GRAVITYPDF.md
index d4b40a2a9..1957334e4 100644
--- a/CHANGELOG-GRAVITYPDF.md
+++ b/CHANGELOG-GRAVITYPDF.md
@@ -74,6 +74,10 @@ Read this section before upgrading from upstream mPDF. Each entry says what chan
   * A block inside an underlined inline element, as in `<span style="text-decoration: underline">…<div>…</div>…</span>`, is underlined too, as is the text after it up to the element's end tag.
   * Floats, positioned blocks and inline blocks no longer take the decorations of the element they are in. Tables never did.
   * A child block no longer takes its parent's `vertical-align`, which is not inherited.
+* **Every element inherits its parent's computed values**, as in a browser, under the standard `cssMode`. The separate ways mPDF handed styles from a block to its children, from an inline element to a block in it, from a table to its cells and from a positioned block to its content each carried their own set of properties and values. They are replaced by one: each open element keeps the computed values of the inherited properties, and its children start from them. Set `'cssMode' => \Mpdf\CssMode::LEGACY` to keep the old output. [#547] [#683]
+  * A length given in `em`, `ex`, `ch` or `rem` is inherited as the length it came to, not as the unit read again at the child's size. `letter-spacing: 0.1em` on a 20pt block spaces the letters of a 10pt paragraph in it 2pt apart, not 1pt. `inherit` on a length that is not inherited, such as `padding-left: inherit`, takes it in the same way.
+  * The content of a positioned block draws `line-height: normal` as the rest of the document does. It used to be drawn at a fixed 1.33, which with DejaVu Sans or Times sets the lines a little further apart. To keep the old spacing, add `line-height: 1.33` to the positioned block.
+  * A bidirectional embedding, as in `<span dir="rtl">…<div>…</div>…</span>`, is opened again for the inline element's text after the block.
 
 New features
 ------------
@@ -278,7 +282,7 @@ Bugfixes
 ### Forms
 
 * A `<select>` with a bare `disabled` attribute was not disabled. [#429]
-* `font-size: larger` or `smaller` on an `<input>`, `<select>`, `<textarea>` or `<textcircle>` drew its text at 0pt, so it could not be seen. In the legacy CSS mode the value is now ignored and the element keeps the size around it; in the standard mode it is 1.2 times the document's size, or that divided by 1.2. [#545] [#647]
+* `font-size: larger` or `smaller` on an `<input>`, `<select>`, `<textarea>` or `<textcircle>` drew its text at 0pt, so it could not be seen. In the legacy CSS mode the value is now ignored and the element keeps the size around it; in the standard mode it is 1.2 times the size of the element it is in, or that divided by 1.2. [#545] [#647]
 * A button with no `name` raised warnings under `useActiveForms`. Unnamed buttons are now named `Submit_<n>`, `Reset_<n>` or `Button_<n>`. [#438]
 * Text wider than its field was cut off. It is now drawn in a smaller font, both on the page and in an active field's appearance. [#433] [#441]
 * A shaped value too long for its field is cut to the longest start that fits, and only between whole clusters. [#460] [#492]
@@ -938,3 +942,5 @@ These changes do not change output.
 [#654]: https://github.com/GravityPDF/mpdf/pull/654
 [#645]: https://github.com/GravityPDF/mpdf/issues/645
 [#678]: https://github.com/GravityPDF/mpdf/pull/678
+[#547]: https://github.com/GravityPDF/mpdf/issues/547
+[#683]: https://github.com/GravityPDF/mpdf/pull/683
diff --git a/src/Css/ComputedValues.php b/src/Css/ComputedValues.php
new file mode 100644
index 000000000..49242974e
--- /dev/null
+++ b/src/Css/ComputedValues.php
@@ -0,0 +1,295 @@
+<?php
+
+namespace Mpdf\Css;
+
+use Mpdf\Mpdf;
+use Mpdf\SizeConverter;
+
+/**
+ * An element's computed values, as each frame on the stack of open elements carries them under CssMode::STANDARD.
+ *
+ * An element starts from the computed values its parent's frame holds of the properties InheritedProperties names. The
+ * cascade and the CSS-wide keywords then give its own values, and compute() makes them computed values:
+ *
+ * - font-size is absolute: a percentage, em, ex, larger or smaller is taken of the parent's size, rem of html's, and a
+ *   keyword such as large of the document's default size;
+ * - font-weight is a number: bolder and lighter step from the parent's weight, as RelativeFontValues gives;
+ * - line-height stays a number or normal where it was given as one, and a length or percentage is made the absolute
+ *   length it stands for at the element's own font size;
+ * - every other length given in em, ex, ch or rem is made absolute at the element's own font size, so that a
+ *   descendant that inherits it, or takes it through inherit, gets the length and not the unit;
+ * - percentages other than those of font-size and line-height stay percentages, taken of whatever the element that
+ *   uses them is in.
+ *
+ * A property the frames do not hold has its initial value, which is the state an element is drawn in before its own
+ * CSS is applied. So the frames stay small, and an element that sets nothing hands on what it was handed.
+ *
+ * Custom properties and var() resolve at computed-value time, so they belong here once mPDF reads them (#595).
+ */
+final class ComputedValues
+{
+
+	/**
+	 * A length in a unit taken of a font size
+	 */
+	const FONT_RELATIVE_LENGTH = '/(?<![\w.#-])([-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[-+]?\d+)?)(em|ex|ch|rem)\b/i';
+
+	/**
+	 * A line-height of zero, in any unit or none, which is drawn as no height rather than as normal
+	 */
+	const ZERO_LINE_HEIGHT = '/^[0.]*0(?:[a-z]+|%)?$/i';
+
+	/**
+	 * Absolute units a font size may be given in, which are kept as they are written
+	 */
+	const ABSOLUTE_FONT_SIZE = '/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:mm|cm|q|in|pt|pc|px)$/i';
+
+	/**
+	 * Properties other than font-size and line-height whose lengths may be given in a unit taken of a font size
+	 */
+	const LENGTHS = [
+		'LETTER-SPACING' => true,
+		'WORD-SPACING' => true,
+		'TEXT-INDENT' => true,
+		'TEXT-SHADOW' => true,
+		'TEXT-OUTLINE-WIDTH' => true,
+		'PADDING-TOP' => true,
+		'PADDING-RIGHT' => true,
+		'PADDING-BOTTOM' => true,
+		'PADDING-LEFT' => true,
+		'MARGIN-TOP' => true,
+		'MARGIN-RIGHT' => true,
+		'MARGIN-BOTTOM' => true,
+		'MARGIN-LEFT' => true,
+		'BORDER-TOP' => true,
+		'BORDER-RIGHT' => true,
+		'BORDER-BOTTOM' => true,
+		'BORDER-LEFT' => true,
+		'BORDER-TOP-WIDTH' => true,
+		'BORDER-RIGHT-WIDTH' => true,
+		'BORDER-BOTTOM-WIDTH' => true,
+		'BORDER-LEFT-WIDTH' => true,
+		'BORDER-TOP-LEFT-RADIUS-H' => true,
+		'BORDER-TOP-LEFT-RADIUS-V' => true,
+		'BORDER-TOP-RIGHT-RADIUS-H' => true,
+		'BORDER-TOP-RIGHT-RADIUS-V' => true,
+		'BORDER-BOTTOM-LEFT-RADIUS-H' => true,
+		'BORDER-BOTTOM-LEFT-RADIUS-V' => true,
+		'BORDER-BOTTOM-RIGHT-RADIUS-H' => true,
+		'BORDER-BOTTOM-RIGHT-RADIUS-V' => true,
+		'BORDER-SPACING-H' => true,
+		'BORDER-SPACING-V' => true,
+		'BOX-SHADOW' => true,
+		'WIDTH' => true,
+		'HEIGHT' => true,
+		'MIN-WIDTH' => true,
+		'MAX-WIDTH' => true,
+		'MIN-HEIGHT' => true,
+		'MAX-HEIGHT' => true,
+		'TOP' => true,
+		'RIGHT' => true,
+		'BOTTOM' => true,
+		'LEFT' => true,
+	];
+
+	/**
+	 * @var Mpdf
+	 */
+	private $mpdf;
+
+	/**
+	 * @var SizeConverter
+	 */
+	private $sizeConverter;
+
+	/**
+	 * @var array|null The computed values inheritedFrom() was last given
+	 */
+	private $lastParent;
+
+	/**
+	 * @var array What inheritedFrom() gave for them
+	 */
+	private $lastInherited = [];
+
+	/**
+	 * @var array Absolute font sizes read so far, in mm, by how they are written, or null for one that is not a size
+	 */
+	private $sizes = [];
+
+	/**
+	 * @param Mpdf $mpdf
+	 * @param SizeConverter $sizeConverter
+	 */
+	public function __construct(Mpdf $mpdf, SizeConverter $sizeConverter)
+	{
+		$this->mpdf = $mpdf;
+		$this->sizeConverter = $sizeConverter;
+	}
+
+	/**
+	 * @param array $parent The computed values on the parent's frame
+	 *
+	 * @return array What an element inherits: the values of the inherited properties its parent's frame holds
+	 */
+	public function inheritedFrom(array $parent)
+	{
+		// Siblings are merged one after another, so the parent is usually the one seen last
+		if ($parent !== $this->lastParent) {
+			$this->lastParent = $parent;
+			$this->lastInherited = InheritedProperties::of($parent, InheritedProperties::names());
+		}
+
+		return $this->lastInherited;
+	}
+
+	/**
+	 * @param array $properties The element's properties once the cascade and the CSS-wide keywords have been applied,
+	 *                          over what it inherits
+	 * @param array $parent The computed values on the parent's frame
+	 * @param array|null $own The element's own declarations, keyed by property, or null when all of $properties are.
+	 *                        What it inherits is the parent's computed values already
+	 * @param float|null $medium The size, in pt, a keyword such as large is taken of, or null for the default font size
+	 *
+	 * @return array The element's computed values
+	 */
+	public function compute(array $properties, array $parent, $own = null, $medium = null)
+	{
+		if ($own === null) {
+			$own = $properties;
+		}
+
+		$font = $this->languageFont($properties);
+		if ($font !== null) {
+			$properties['FONT-FAMILY'] = $font;
+		}
+
+		$parentSize = $this->fontSize($parent, $this->mpdf->default_font_size / Mpdf::SCALE);
+		$fontSize = $parentSize;
+		if (isset($own['FONT-SIZE'], $properties['FONT-SIZE'])) {
+			$size = $this->computeFontSize($properties['FONT-SIZE'], $parentSize, $medium === null ? $this->mpdf->default_font_size : $medium);
+			// A value that is not a size, such as a form field's auto, is left for the element to read
+			if ($size !== null) {
+				$properties['FONT-SIZE'] = $size;
+			}
+			$fontSize = $this->fontSize($properties, $parentSize);
+		}
+		if (isset($own['FONT-WEIGHT'], $properties['FONT-WEIGHT'])) {
+			$parentWeight = isset($parent['FONT-WEIGHT']) ? $parent['FONT-WEIGHT'] : RelativeFontValues::NORMAL_WEIGHT;
+			$weight = RelativeFontValues::weight($properties['FONT-WEIGHT'], $parentWeight);
+			if ($weight !== null) {
+				$properties['FONT-WEIGHT'] = (string) $weight;
+			} elseif (isset($parent['FONT-WEIGHT'])) {
+				// A value that is not a weight leaves the parent's
+				$properties['FONT-WEIGHT'] = $parent['FONT-WEIGHT'];
+			} else {
+				unset($properties['FONT-WEIGHT']);
+			}
+		}
+
+		if (isset($own['LINE-HEIGHT'], $properties['LINE-HEIGHT'])) {
+			$properties['LINE-HEIGHT'] = $this->computeLineHeight($properties['LINE-HEIGHT'], $fontSize);
+		}
+
+		foreach (array_intersect_key($own, self::LENGTHS) as $property => $declared) {
+			$value = isset($properties[$property]) ? $properties[$property] : null;
+			if (is_string($value) && strpbrk($value, 'eEhH') !== false) {
+				$properties[$property] = $this->absoluteLengths($value, $fontSize);
+			}
+		}
+
+		return $properties;
+	}
+
+
+	/**
+	 * The font mPDF chooses for an element's language under autoLangToFont, which Mpdf::setCSS() draws the element in,
+	 * so that what the element holds is handed on
+	 *
+	 * @param array $properties
+	 *
+	 * @return string|null The font, or null where the language chooses none
+	 */
+	private function languageFont(array $properties)
+	{
+		return empty($properties['LANG']) ? null : $this->mpdf->fontForLanguage($properties['LANG']);
+	}
+
+	/**
+	 * @param array $computed Computed values, as compute() gives them
+	 * @param float $default In mm
+	 *
+	 * @return float The font size they give, in mm, or the default when they give none
+	 */
+	private function fontSize(array $computed, $default)
+	{
+		if (!isset($computed['FONT-SIZE'])) {
+			return $default;
+		}
+
+		// The same few sizes are read for every element
+		$size = $computed['FONT-SIZE'];
+		if (!array_key_exists($size, $this->sizes)) {
+			$this->sizes[$size] = preg_match(self::ABSOLUTE_FONT_SIZE, $size) ? $this->sizeConverter->convert($size) : null;
+		}
+
+		return $this->sizes[$size] === null ? $default : $this->sizes[$size];
+	}
+
+	/**
+	 * @param string $value
+	 * @param float $parentSize In mm
+	 * @param float $medium The size a keyword is taken of, in pt
+	 *
+	 * @return string|null The absolute size, or null for a value that is not a font size
+	 */
+	private function computeFontSize($value, $parentSize, $medium)
+	{
+		$value = trim($value);
+		if (preg_match(self::ABSOLUTE_FONT_SIZE, $value)) {
+			return $value;
+		}
+
+		$size = $this->sizeConverter->convertFontSize($value, $parentSize, $medium);
+
+		// Written so that it reads back as the same number
+		return $size === null ? null : var_export($size, true) . 'pt';
+	}
+
+	/**
+	 * @param string|float $value
+	 * @param float $fontSize The element's font size, in mm
+	 *
+	 * @return string|float A number or normal as given, or else the length it stands for, in mm
+	 */
+	private function computeLineHeight($value, $fontSize)
+	{
+		$value = trim($value);
+		if (preg_match(self::ZERO_LINE_HEIGHT, $value)) {
+			return '0mm';
+		}
+
+		if (preg_match('/^[0-9.,]*$/', $value) || strtoupper($value) === 'NORMAL' || $value === 'N') {
+			return $value;
+		}
+
+		$length = $this->sizeConverter->convert($value, $fontSize, $fontSize, true);
+
+		return $length ? $length . 'mm' : $value;
+	}
+
+	/**
+	 * @param string $value
+	 * @param float $fontSize In mm
+	 *
+	 * @return string The value with each length in a unit taken of a font size made absolute, in mm
+	 */
+	private function absoluteLengths($value, $fontSize)
+	{
+		$sizeConverter = $this->sizeConverter;
+
+		return preg_replace_callback(self::FONT_RELATIVE_LENGTH, function ($m) use ($sizeConverter, $fontSize) {
+			return $sizeConverter->convert($m[1] . $m[2], $fontSize, $fontSize) . 'mm';
+		}, $value);
+	}
+}
diff --git a/src/Css/CssMerger.php b/src/Css/CssMerger.php
index 54fb666f8..6dbacccaf 100644
--- a/src/Css/CssMerger.php
+++ b/src/Css/CssMerger.php
@@ -98,6 +98,16 @@ class CssMerger
 	 */
 	private $cssProperties = [];
 
+	/**
+	 * @var array Under the standard cascade, the computed values of the element merged last
+	 */
+	private $lastComputed = [];
+
+	/**
+	 * @var ComputedValues
+	 */
+	private $computedValues;
+
 	/**
 	 * @var \Mpdf\Css\BorderMerger
 	 */
@@ -128,7 +138,8 @@ public function __construct(
 		ColorConverter $colorConverter,
 		BorderMerger $borderMerger,
 		PresentationalHints $presentationalHints,
-		SizeConverter $sizeConverter
+		SizeConverter $sizeConverter,
+		ComputedValues $computedValues
 	) {
 		$this->mpdf = $mpdf;
 		$this->normalizeProperties = $normalizeProperties;
@@ -139,6 +150,7 @@ public function __construct(
 		$this->borderMerger = $borderMerger;
 		$this->presentationalHints = $presentationalHints;
 		$this->sizeConverter = $sizeConverter;
+		$this->computedValues = $computedValues;
 	}
 
 	/**
@@ -165,17 +177,16 @@ public function setCssManager(CssManager $cssManager)
 	 * @param string $inherit Inheritance context (BLOCK, INLINE, TABLE, TOPTABLE)
 	 * @param string $tag HTML tag name
 	 * @param array $attr HTML attributes including CLASS, ID, STYLE
-	 * @param array $inherited Under the standard cascade, what the element inherits, under everything else merged
 	 * @return array Merged CSS properties array
 	 */
-	public function merge($inherit, $tag, $attr, array $inherited = [])
+	public function merge($inherit, $tag, $attr)
 	{
 		$this->cssProperties = [];
 
 		$attr = is_array($attr) ? $attr : [];
 
 		if ($this->mpdf->cssMode === CssMode::STANDARD) {
-			return $this->mergeInCascadeOrder($inherit, $tag, $attr, $inherited);
+			return $this->mergeInCascadeOrder($inherit, $tag, $attr);
 		}
 
 		$classes = [];
@@ -220,20 +231,20 @@ public function merge($inherit, $tag, $attr, array $inherited = [])
 	}
 
 	/**
-	 * 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; then the !important declarations of the author
-	 * rules, of the inline style, and of the default stylesheet's rules. The rules of each stylesheet apply by
-	 * specificity, then in the order they were written. Each rule that reaches a table cell draws its borders over
-	 * those of its neighbours.
+	 * Merges an element's CSS as standard mode orders it, in layers, each over the one before: the computed values
+	 * it inherits from its parent's frame, 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; then the !important
+	 * declarations of the author rules, of the inline style, and of the default stylesheet's rules. The rules of each
+	 * stylesheet apply by specificity, then in the order they were written. Each rule that reaches a table cell draws
+	 * its borders over those of its neighbours. The CSS-wide keywords and currentColor are then resolved, and the
+	 * element's computed values kept on its frame.
 	 *
 	 * @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
-	 * @param array $inherited What the element inherits, besides what a block takes from its parent block
-	 * @return array Merged CSS properties array
+	 * @return array Merged CSS properties array. For an inline element, and a block in a table cell, only its own
 	 */
-	private function mergeInCascadeOrder($inherit, $tag, array $attr, array $inherited)
+	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
@@ -256,8 +267,18 @@ private function mergeInCascadeOrder($inherit, $tag, array $attr, array $inherit
 		$classes = $this->classesOf($attr);
 		$dominance = $tag === 'TD' || $tag === 'TH' ? 9 : false;
 
-		$this->cssProperties = $inherited;
-		$this->mergeInheritedBlockProperties($inherit, $tag);
+		// What the element starts from: the computed values of the inherited properties on its parent's frame
+		$parent = $this->parentFrameComputed($tag);
+		$this->cssProperties = $this->computedValues->inheritedFrom($parent);
+		if ($inherit === 'BLOCK') {
+			$this->mergeBlockExtras($tag);
+		}
+		// What inherit reads
+		$inheritable = $this->cssProperties;
+		if ($tag === 'UL' || $tag === 'OL') {
+			// A list starts its items' markers afresh, as a browser's default style gives each list its own
+			unset($this->cssProperties['LIST-STYLE-TYPE']);
+		}
 		$inherited = $this->cssProperties;
 
 		// The built-in defaults and the default stylesheet are merged on their own first, for revert to read
@@ -270,7 +291,7 @@ private function mergeInCascadeOrder($inherit, $tag, array $attr, array $inherit
 		if ($tag === 'TH' && isset($inherited['TEXT-ALIGN'])) {
 			$defaults['TEXT-ALIGN'] = $inherited['TEXT-ALIGN'];
 		}
-		$this->cssProperties = array_merge($inherited, $defaults);
+		$this->cssProperties = $defaults;
 
 		$this->mergePresentationalHints($tag, $attr);
 		$this->mergeTableSpecificCss($tag, $attr);
@@ -286,8 +307,9 @@ private function mergeInCascadeOrder($inherit, $tag, array $attr, array $inherit
 			list($importantBody, $html) = $this->mergeDocumentRules();
 			$importantRules = array_merge(isset($important['BODY']) ? [$important['BODY']] : [], $importantBody);
 			$importantDefaultRules = isset($importantDefault['BODY']) ? [$importantDefault['BODY']] : [];
-			// html is body's parent, which a keyword on body reads
-			$inherited = array_merge($inherited, $html);
+			// html is body's parent, which a keyword on body reads, and whose font size body's is taken of
+			$inheritable = array_merge($inheritable, $html);
+			$parent = ['FONT-SIZE' => $this->mpdf->root_font_size . 'pt'];
 		} else {
 			list($rules, $importantRules) = $this->cssManager->getRules()->matchingDeclarations($tag, $id, $classes, $path);
 		}
@@ -296,14 +318,92 @@ private function mergeInCascadeOrder($inherit, $tag, array $attr, array $inherit
 		list($inline, $importantInline) = isset($attr['STYLE']) ? $this->inlineStyleParser->parseByImportance($attr['STYLE']) : [[], []];
 		$this->mergeEach(array_merge([$inline], $importantRules, [$importantInline], $importantDefaultRules), $dominance);
 
+		$own = $this->cssProperties;
+		$this->cssProperties = array_merge($inherited, $own);
 		// Before currentColor, which takes the colour a keyword resolves to
-		$this->resolveWideKeywords($inherited, $defaults, $path, $inherit !== 'INLINE' && $inherit !== '', $html);
-		$this->resolveCurrentColor($inherit, $inherited);
+		$this->resolveWideKeywords($inheritable, $defaults, $html !== null ? $html : $parent);
+		$this->resolveCurrentColor($inherit, $inheritable);
+		// The default font size is body's, and a keyword on body is taken of the one html starts from
+		$computed = $this->computedValues->compute($this->cssProperties, $parent, $own, $tag === 'BODY' ? $this->mpdf->initial_font_size : null);
+		$this->lastComputed = $computed;
 		if ($this->sideEffects) {
-			$this->mpdf->recordStyledElementComputed($this->cssProperties);
+			$this->mpdf->recordStyledElementComputed($computed);
 		}
 
-		return $this->cssProperties;
+		// The handler draws the inherited properties in their computed values, and the rest as merged, since setCSS()
+		// reads those against the element's font size. Not through inheritedFrom(), whose last answer serves the
+		// element's siblings
+		$properties = array_merge($this->cssProperties, InheritedProperties::of($computed, InheritedProperties::names()));
+
+		// An inline element, and a block in a table cell, is drawn over the state of what it is in, which already
+		// holds what it inherits
+		return $inherit === 'INLINE' || $inherit === '' ? array_intersect_key($properties, $own) : $properties;
+	}
+
+	/**
+	 * @param string $tag The element's tag, uppercased
+	 * @return array The computed values an element being merged inherits from: its parent's, or, where the parent
+	 *               was not merged, the nearest ancestor's. A row written straight into a table inherits from the
+	 *               tbody a browser adds, whose CSS is previewed here
+	 */
+	private function parentFrameComputed($tag)
+	{
+		if ($tag === 'BODY') {
+			return [];
+		}
+
+		if ($this->sideEffects && $this->mpdf->styledElementOpensInImpliedTbody()) {
+			$this->previewTableCss('TBODY', []);
+			$this->mpdf->setImpliedTbodyComputed($this->lastComputed);
+
+			return $this->lastComputed;
+		}
+
+		return $this->mpdf->getInheritedComputed();
+	}
+
+	/**
+	 * @return array Under the standard cascade, the computed values of the element merged last
+	 */
+	public function getLastComputed()
+	{
+		return $this->lastComputed;
+	}
+
+	/**
+	 * @param array $properties Properties that no stylesheet was merged into
+	 * @param array $parent The computed values they are taken against
+	 * @return array Their computed values
+	 */
+	public function compute(array $properties, array $parent)
+	{
+		return $this->computedValues->compute($properties, $parent);
+	}
+
+	/**
+	 * The properties mPDF passes from a block to its child blocks besides the inherited ones: the custom
+	 * margin-collapse, the background of a block in columns, and to a list item the marker its list draws, which
+	 * the list's handler chooses where no rule does
+	 *
+	 * @param string $tag
+	 * @return void
+	 */
+	private function mergeBlockExtras($tag)
+	{
+		$previousBlockLevel = $this->getBlockLevel('BLOCK');
+		$previousBlock = isset($this->mpdf->blk[$previousBlockLevel]) ? $this->mpdf->blk[$previousBlockLevel] : [];
+
+		if (!empty($previousBlock['margin_collapse'])) {
+			$this->cssProperties['MARGIN-COLLAPSE'] = 'COLLAPSE';
+		}
+
+		if (!empty($previousBlock['bgcolorarray']) && $this->mpdf->ColActive) {
+			$this->cssProperties['BACKGROUND-COLOR'] = $this->colorConverter->colAtoString($previousBlock['bgcolorarray']);
+		}
+
+		if ($tag === 'LI' && !empty($previousBlock['list_style_type'])) {
+			$this->cssProperties['LIST-STYLE-TYPE'] = $previousBlock['list_style_type'];
+		}
 	}
 
 	/**
@@ -350,7 +450,7 @@ private function resolveCurrentColor($inherit, array $inherited = [])
 			}
 
 			if ($color === null) {
-				$color = $this->elementColor($inherit);
+				$color = $this->elementColor($inherit, $inherited);
 			}
 
 			$this->cssProperties[$property] = str_ireplace('currentcolor', $color, $this->cssProperties[$property]);
@@ -359,11 +459,10 @@ private function resolveCurrentColor($inherit, array $inherited = [])
 
 	/**
 	 * Resolves the CSS-wide keywords the cascade left in the element's properties:
-	 * - inherit: for an inherited property, the value the element starts from, which is its parent's. A block, a table
-	 *   and a table part are not handed every inherited value, so failing that they take the value their parent's frame
-	 *   on the stack of open elements holds. Failing both, the property is dropped, and the element keeps the state it
-	 *   is drawn in, as an inline element does. For any other property, the value its parent's frame holds, or failing
-	 *   that the initial value
+	 * - inherit: for an inherited property, the value the element starts from, which is its parent's computed value.
+	 *   Where it starts from none, the parent has the initial value, and the property is dropped so the element is
+	 *   drawn in its initial state. For any other property, the value its parent's frame holds, or failing that the
+	 *   initial value
 	 * - initial: the initial value CssWideKeywords gives, or the document's default font and size
 	 * - unset: inherit for an inherited property, and initial for any other
 	 * - revert and revert-layer: the value of the built-in defaults and the default stylesheet, or failing that unset
@@ -372,15 +471,11 @@ private function resolveCurrentColor($inherit, array $inherited = [])
 	 *
 	 * @param array $inherited The properties the element starts from, before the defaults
 	 * @param array $defaults The properties the built-in defaults and the default stylesheet give the element
-	 * @param callable $path Gives the open elements from the document down to the element, or null for none
-	 * @param bool $fromParent Whether an inherited property the element does not start from is read from its parent's
-	 *                         frame: for a block, a table and a table part
-	 * @param array|null $parentProperties The properties of a parent that has no frame, as html has none for body
+	 * @param array $parent The computed values on the parent's frame, or html's properties for body
 	 * @return void
 	 */
-	private function resolveWideKeywords(array $inherited, array $defaults, callable $path, $fromParent, $parentProperties = null)
+	private function resolveWideKeywords(array $inherited, array $defaults, array $parent)
 	{
-		$parent = null;
 		$sides = [];
 		foreach ($this->cssProperties as $property => $value) {
 			$keyword = CssWideKeywords::keywordOf($value);
@@ -407,14 +502,13 @@ private function resolveWideKeywords(array $inherited, array $defaults, callable
 			}
 
 			$resolved = null;
-			if ($keyword === 'inherit' && $isInherited && isset($inherited[$property])) {
-				$resolved = $inherited[$property];
-			} elseif ($keyword === 'inherit' && (!$isInherited || $fromParent)) {
-				if ($parent === null) {
-					$parent = $parentProperties !== null ? $parentProperties : $this->parentComputed($path);
-				}
+			if ($keyword === 'inherit' && $isInherited) {
+				// What the element starts from holds each inherited value of its parent's that is not the initial one,
+				// and one left out is drawn in its initial state
+				$resolved = isset($inherited[$property]) ? $inherited[$property] : null;
+			} elseif ($keyword === 'inherit') {
 				$resolved = $this->declaredValue($parent, $property);
-				if ($resolved === null && !$isInherited) {
+				if ($resolved === null) {
 					$resolved = $this->initialValue($property);
 				}
 			} elseif ($keyword === 'initial') {
@@ -437,13 +531,14 @@ private function resolveWideKeywords(array $inherited, array $defaults, callable
 	 * The colour currentColor stands for in the element's merged properties
 	 *
 	 * @param string $inherit Inheritance context
+	 * @param array $inherited Under the standard cascade, what the element inherits
 	 * @return string A colour with no spaces, which a border or shadow value keeps as one component
 	 */
-	private function elementColor($inherit)
+	private function elementColor($inherit, array $inherited)
 	{
 		$color = isset($this->cssProperties['COLOR']) ? $this->cssProperties['COLOR'] : '';
 		if (!$this->colorConverter->isColor($color) && strtolower($color) !== 'transparent') {
-			$color = $this->inheritedColor($inherit);
+			$color = $this->inheritedColor($inherit, $inherited);
 		}
 
 		if ($color === null) {
@@ -454,21 +549,21 @@ private function elementColor($inherit)
 	}
 
 	/**
-	 * The colour an element takes when it sets none, as mPDF passes it on in each context: a block takes the colour of
-	 * the block or inline elements it is opened in, a table's parts their row's, row group's or table's, and anything
-	 * else the colour of the text around it
+	 * The colour an element takes when it sets none. Under the standard cascade it is its parent's computed colour.
+	 * The legacy cascade passes it on in each context: a block takes the colour of the block it is opened in, a
+	 * table's parts the table's, and anything else the colour of the text around it
 	 *
 	 * @param string $inherit Inheritance context
 	 * @param array $inherited Under the standard cascade, what the element inherits
 	 * @return string|null Null for the document's default colour
 	 */
-	private function inheritedColor($inherit, array $inherited = [])
+	private function inheritedColor($inherit, array $inherited)
 	{
-		if ($inherit === 'TABLE' || $inherit === 'TOPTABLE') {
-			if (isset($inherited['COLOR'])) {
-				return $inherited['COLOR'];
-			}
+		if ($this->mpdf->cssMode === CssMode::STANDARD) {
+			return isset($inherited['COLOR']) ? $inherited['COLOR'] : null;
+		}
 
+		if ($inherit === 'TABLE' || $inherit === 'TOPTABLE') {
 			return isset($this->mpdf->base_table_properties['COLOR']) ? $this->mpdf->base_table_properties['COLOR'] : null;
 		}
 
@@ -526,22 +621,6 @@ private function declaredValue(array $properties, $property)
 		return count($border) === 3 ? $border[array_search($m[2], self::BORDER_PARTS, true)] : null;
 	}
 
-	/**
-	 * @param callable $path Gives the open elements from the document down to the element, or null for none
-	 * @return array The properties merged for the element's parent, or none if it has no parent or they were not kept
-	 */
-	private function parentComputed(callable $path)
-	{
-		$elements = $path();
-		if ($elements === null || count($elements) < 2) {
-			return [];
-		}
-
-		$parent = $elements[count($elements) - 2];
-
-		return $parent['computed'] !== null ? $parent['computed'] : [];
-	}
-
 	/**
 	 * @param string $property Uppercased
 	 * @return string|null The property's initial value, or null to leave the property unset
@@ -779,8 +858,9 @@ protected function mergeBlockCascadingCss($inherit, $tag, $attr, $classes)
 	}
 
 	/**
-	 * Merge the properties a block inherits from the block it is opened in. Under the standard cascade, a table that
-	 * is not in a cell inherits from the block it is opened in too.
+	 * Merge the properties a block inherits from the block it is opened in, as the legacy cascade hands them on: from
+	 * the block's fields and its saved text state, after the extras both cascades pass on. The standard cascade reads
+	 * the parent's frame instead
 	 *
 	 * @param string $inherit Inheritance type (TOPTABLE, TABLE, BLOCK)
 	 * @param string $tag HTML tag name
@@ -788,19 +868,15 @@ protected function mergeBlockCascadingCss($inherit, $tag, $attr, $classes)
 	 */
 	protected function mergeInheritedBlockProperties($inherit, $tag)
 	{
-		$table = $inherit === 'TOPTABLE' && $this->mpdf->cssMode === CssMode::STANDARD;
-		if ($inherit !== 'BLOCK' && !$table) {
+		if ($inherit !== 'BLOCK') {
 			return;
 		}
 
+		$this->mergeBlockExtras($tag);
+
 		$previousBlockLevel = $this->getBlockLevel($inherit);
 		$previousBlock = isset($this->mpdf->blk[$previousBlockLevel]) ? $this->mpdf->blk[$previousBlockLevel] : [];
 
-		// Block properties which are inherited
-		if (!empty($previousBlock['margin_collapse'])) {
-			$this->cssProperties['MARGIN-COLLAPSE'] = 'COLLAPSE';
-		}
-
 		// custom tag, but follows CSS principle that border-collapse is inherited
 		if (!empty($previousBlock['line_height'])) {
 			$this->cssProperties['LINE-HEIGHT'] = $previousBlock['line_height'];
@@ -819,11 +895,6 @@ protected function mergeInheritedBlockProperties($inherit, $tag)
 			$this->cssProperties['DIRECTION'] = $previousBlock['direction'];
 		}
 
-		// mPDF 6  Lists
-		if ($tag === 'LI' && !empty($previousBlock['list_style_type'])) {
-			$this->cssProperties['LIST-STYLE-TYPE'] = $previousBlock['list_style_type'];
-		}
-
 		if (!empty($previousBlock['list_style_image'])) {
 			$this->cssProperties['LIST-STYLE-IMAGE'] = $previousBlock['list_style_image'];
 		}
@@ -852,32 +923,15 @@ protected function mergeInheritedBlockProperties($inherit, $tag)
 			}
 		}
 
-		if (!empty($previousBlock['bgcolorarray']) && $this->mpdf->ColActive) {
-			// Doesn't officially inherit, but default value is transparent (?=inherited)
-			$cor = $previousBlock['bgcolorarray'];
-			$this->cssProperties['BACKGROUND-COLOR'] = $this->colorConverter->colAtoString($cor);
-		}
-
 		if (isset($previousBlock['text_indent'])) {
 			$this->cssProperties['TEXT-INDENT'] = $previousBlock['text_indent'];
 		}
 
-		$saved = InheritedProperties::blockTextState($this->mpdf->blk, $previousBlockLevel);
-		if ($saved !== null) {
-			if ($this->mpdf->cssMode === CssMode::LEGACY) {
-				// mPDF v7 did not hand a block's text shadow on to its child blocks
-				unset($saved['textshadow']);
-				$converted = $this->inlinePropertyConverter->convert($saved);
-			} else {
-				// Text decorations propagate as a set of their own (TextDecorations), and vertical-align is not inherited
-				$converted = InheritedProperties::of($this->inlinePropertyConverter->convert($saved), InheritedProperties::TEXT);
-			}
-			$this->cssProperties = array_merge($this->cssProperties, $converted); // mPDF 5.7.1
-		}
-
-		if ($table) {
-			// Not the margin collapse, column background, text decoration or vertical-align a child block takes
-			$this->cssProperties = InheritedProperties::of($this->cssProperties, InheritedProperties::names());
+		if (isset($previousBlock['InlineProperties'])) {
+			$saved = $previousBlock['InlineProperties'];
+			// mPDF v7 did not hand a block's text shadow on to its child blocks
+			unset($saved['textshadow']);
+			$this->cssProperties = array_merge($this->cssProperties, $this->inlinePropertyConverter->convert($saved)); // mPDF 5.7.1
 		}
 	}
 
diff --git a/src/Css/InheritedProperties.php b/src/Css/InheritedProperties.php
index 5b3adca95..bfac198f8 100644
--- a/src/Css/InheritedProperties.php
+++ b/src/Css/InheritedProperties.php
@@ -5,33 +5,16 @@
 /**
  * The inherited CSS properties mPDF supports, by the names the merged CSS uses for them.
  *
- * An element takes these from its parent unless it sets them itself. Under CssMode::STANDARD each channel that hands
- * them on takes them from here:
+ * An element takes these from its parent unless it sets them itself. Under CssMode::STANDARD each frame on the stack of
+ * open elements keeps its element's computed values of names(), and a child starts from its parent's frame
+ * (ComputedValues). TEXT lists those held in the text state that Mpdf::saveInlineProperties() saves, and BLOCK those a
+ * block, table or cell keeps in its own fields.
  *
- * - a block to its child blocks: CssMerger::mergeInheritedBlockProperties() reads TEXT back from the block's saved
- *   text state through InlinePropertyConverter, and BLOCK from the block's level of the block stack;
- * - inline elements to a block or table opened inside them: BlockTag and Table set their text state aside on the
- *   enclosing block, and blockTextState() gives it to mergeInheritedBlockProperties() in place of the enclosing
- *   block's own;
- * - a positioned block to its content: Mpdf::WriteFixedPosHTML() puts TEXT and BLOCK from the block's merged CSS on
- *   the <div> that stands in for the block;
- * - a block to a table in it: CssMerger::mergeInheritedBlockProperties() gives the table TEXT and BLOCK from the block,
- *   as it does a child block;
- * - a table to its cells: Table::open() puts TEXT and text-align from the table's merged CSS in
- *   base_table_properties, which each cell merges under its own CSS. The table also hands on text-align,
- *   line-height, the line stacking and direction through its own fields;
- * - a row group and a row to their cells: THead, TBody, TFoot and Tr put TEXT and BLOCK from their merged CSS over
- *   base_table_properties, and each cell merges what its row holds under its own CSS;
- * - a table cell to a table nested in it: Table::open() starts the nested table's base_table_properties and default
- *   font from the cell's text state, read back through InlinePropertyConverter, and merges the table's CSS over the
- *   cell's line-height and text-align.
+ * Under CssMode::LEGACY the channels mPDF v7 used hand them on, each carrying the list it did: a block's saved text
+ * state and fields to its child blocks, base_table_properties to a table's cells, and the <div> that stands in for a
+ * positioned block to its content.
  *
- * To carry another property, add it to TEXT when it lives in the text state that Mpdf::saveInlineProperties() saves,
- * and make InlinePropertyConverter::convert() read it back. Otherwise add it to BLOCK, and carry it on the block stack
- * in mergeInheritedBlockProperties().
- * InheritedPropertiesTest checks that each channel carries each TEXT property.
- *
- * Under CssMode::LEGACY the channels carry the lists mPDF v7 did.
+ * InheritedPropertiesTest checks that each TEXT property reaches a descendant's text everywhere it is handed on.
  */
 final class InheritedProperties
 {
@@ -111,7 +94,12 @@ final class InheritedProperties
 	 */
 	public static function names()
 	{
-		return array_merge(self::TEXT, self::BLOCK);
+		static $names = null;
+		if ($names === null) {
+			$names = array_merge(self::TEXT, self::BLOCK);
+		}
+
+		return $names;
 	}
 
 	/**
diff --git a/src/Css/InlinePropertyConverter.php b/src/Css/InlinePropertyConverter.php
index a502a11b3..2c175aa38 100644
--- a/src/Css/InlinePropertyConverter.php
+++ b/src/Css/InlinePropertyConverter.php
@@ -20,7 +20,8 @@ public function __construct(ColorConverter $colorConverter)
 	 * Convert inline properties back to CSS.
 	 *
 	 * Transforms internal inline property format (used in TextVars) back into
-	 * CSS property array. Used for property inheritance and cascading.
+	 * CSS property array. The legacy CSS mode hands a block's saved text state on to its child blocks through it; the
+	 * standard mode reads the parent's frame instead.
 	 *
 	 * @param array $properties Inline properties array
 	 * @return array Converted CSS properties
diff --git a/src/Css/RelativeFontValues.php b/src/Css/RelativeFontValues.php
index 040cb1ba6..c1841bdbd 100644
--- a/src/Css/RelativeFontValues.php
+++ b/src/Css/RelativeFontValues.php
@@ -128,7 +128,8 @@ public static function parentWeight(Mpdf $mpdf, $type)
 	/**
 	 * @param array $tableProperties The properties the table being written hands its cells, as Mpdf::$base_table_properties
 	 *
-	 * @return int|float The computed font-weight of the table, which its cells inherit
+	 * @return int|float The computed font-weight of the table, which a cell's bolder or lighter steps from under the
+	 *                   legacy CSS mode. The standard mode merges a cell's weight from its parent's frame
 	 */
 	public static function tableWeight(array $tableProperties)
 	{
diff --git a/src/Css/TextDecorations.php b/src/Css/TextDecorations.php
index d520739dc..dc57a25d5 100644
--- a/src/Css/TextDecorations.php
+++ b/src/Css/TextDecorations.php
@@ -64,6 +64,24 @@ public static function enter(Mpdf $mpdf, array $properties, $parent = null)
 		}
 	}
 
+	/**
+	 * @param Mpdf $mpdf
+	 *
+	 * @return array The decorations of the current text state, in the shape enter() takes a parent's
+	 */
+	public static function of(Mpdf $mpdf)
+	{
+		$decorations = ['textvar' => 0, 'textparam' => []];
+		foreach (self::PARAMETERS as $bit => $parameter) {
+			if (($mpdf->textvar & $bit) && isset($mpdf->textparam[$parameter])) {
+				$decorations['textvar'] |= $bit;
+				$decorations['textparam'][$parameter] = $mpdf->textparam[$parameter];
+			}
+		}
+
+		return $decorations;
+	}
+
 	/**
 	 * Whether the decorations an element sets are seen. Under CssMode::STANDARD a decoration is drawn in the colour of
 	 * the element that sets it, so an element whose color is transparent, set or inherited, draws its own unseen, and
diff --git a/src/Css/TextSpacing.php b/src/Css/TextSpacing.php
new file mode 100644
index 000000000..f1d5bb557
--- /dev/null
+++ b/src/Css/TextSpacing.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Mpdf\Css;
+
+use Mpdf\Mpdf;
+use Mpdf\SizeConverter;
+
+/**
+ * The letter and word spacing of the text state. Mpdf keeps each as the value letter-spacing or word-spacing was
+ * given in, and as the length it comes to at the current font size: fixedlSpacing, or false for none, and
+ * minwSpacing, or 0 for none.
+ */
+final class TextSpacing
+{
+
+	/**
+	 * Sets the letter and word spacing of the text state, each as given and as the length it comes to at the current
+	 * font size
+	 *
+	 * @param Mpdf $mpdf
+	 * @param SizeConverter $sizeConverter
+	 * @param string $letterSpacing A letter-spacing, as given
+	 * @param string $wordSpacing A word-spacing, as given
+	 */
+	public static function set(Mpdf $mpdf, SizeConverter $sizeConverter, $letterSpacing, $wordSpacing)
+	{
+		$mpdf->lSpacingCSS = $letterSpacing;
+		$mpdf->wSpacingCSS = $wordSpacing;
+		$mpdf->fixedlSpacing = self::length($sizeConverter, $letterSpacing, $mpdf->FontSize, false);
+		$mpdf->minwSpacing = self::length($sizeConverter, $wordSpacing, $mpdf->FontSize, 0);
+	}
+
+	/**
+	 * @param SizeConverter $sizeConverter
+	 * @param string $spacing A letter-spacing or word-spacing, as given
+	 * @param float $fontSize The current font size, in mm, which an em is taken of
+	 * @param false|int $none What stands for no fixed spacing
+	 *
+	 * @return float|false|int The length the spacing is, in mm, or $none where it gives none or is normal
+	 */
+	public static function length(SizeConverter $sizeConverter, $spacing, $fontSize, $none)
+	{
+		if (($spacing || $spacing === '0') && strtoupper($spacing) !== 'NORMAL') {
+			return $sizeConverter->convert($spacing, $fontSize);
+		}
+
+		return $none;
+	}
+}
diff --git a/src/CssManager.php b/src/CssManager.php
index 33a438a52..0427799b2 100644
--- a/src/CssManager.php
+++ b/src/CssManager.php
@@ -248,12 +248,11 @@ public function readInlineCss($html)
 	 * @param string $inherit Inheritance context (BLOCK, INLINE, TABLE, TOPTABLE)
 	 * @param string $tag HTML tag name
 	 * @param array $attr HTML attributes including CLASS, ID, STYLE
-	 * @param array $inherited Under the standard cascade, what the element inherits, under everything else merged
 	 * @return array Merged CSS properties array
 	 */
-	public function mergeCss($inherit, $tag, $attr, array $inherited = [])
+	public function mergeCss($inherit, $tag, $attr)
 	{
-		return $this->cssMerger->merge($inherit, $tag, $attr, $inherited);
+		return $this->cssMerger->merge($inherit, $tag, $attr);
 	}
 
 	/**
@@ -283,6 +282,24 @@ public function previewTableCss($tag, $attr)
 		return $this->cssMerger->previewTableCss($tag, $attr);
 	}
 
+	/**
+	 * @return array Under the standard CSS mode, the computed values of the element merged last
+	 */
+	public function getLastComputed()
+	{
+		return $this->cssMerger->getLastComputed();
+	}
+
+	/**
+	 * @param array $properties Properties that no stylesheet was merged into
+	 * @param array $parent The computed values they are taken against
+	 * @return array Their computed values
+	 */
+	public function computeValues(array $properties, array $parent)
+	{
+		return $this->cssMerger->compute($properties, $parent);
+	}
+
 	public function getUsedClassNames()
 	{
 		return $this->cssParser->getUsedClassNames();
diff --git a/src/Mpdf.php b/src/Mpdf.php
index 8dada2cc7..9da8da180 100644
--- a/src/Mpdf.php
+++ b/src/Mpdf.php
@@ -7,8 +7,10 @@
 use Mpdf\Conversion;
 use Mpdf\Css\Border;
 use Mpdf\Css\CommentParser;
+use Mpdf\Css\ComputedValues;
 use Mpdf\Css\InheritedProperties;
 use Mpdf\Css\RelativeFontValues;
+use Mpdf\Css\TextSpacing;
 use Mpdf\Color\IccProfile;
 use Mpdf\Css\TextDecorations;
 use Mpdf\Css\TextVars;
@@ -7200,18 +7202,7 @@ function restoreInlineProperties(&$saved)
 		$this->textparam = $saved['textparam'];
 		$this->inlineDisplayOff = $saved['display_off'];
 
-		$this->lSpacingCSS = $saved['lSpacingCSS'];
-		if (($this->lSpacingCSS || $this->lSpacingCSS === '0') && strtoupper($this->lSpacingCSS) != 'NORMAL') {
-			$this->fixedlSpacing = $this->sizeConverter->convert($this->lSpacingCSS, $this->FontSize);
-		} else {
-			$this->fixedlSpacing = false;
-		}
-		$this->wSpacingCSS = $saved['wSpacingCSS'];
-		if ($this->wSpacingCSS && strtoupper($this->wSpacingCSS) != 'NORMAL') {
-			$this->minwSpacing = $this->sizeConverter->convert($this->wSpacingCSS, $this->FontSize);
-		} else {
-			$this->minwSpacing = 0;
-		}
+		TextSpacing::set($this, $this->sizeConverter, $saved['lSpacingCSS'], $saved['wSpacingCSS']);
 
 		$this->SetFont($FontFamily, $saved['style'], $saved['sizePt'], false);
 
@@ -12294,7 +12285,7 @@ function SetDirectionality($dir = 'ltr')
 	// 0 == 'N' held before PHP 8
 	function fixLineheight($v)
 	{
-		if ($this->cssMode === CssMode::STANDARD && preg_match('/^[0.]*0(?:[a-z]+|%)?$/i', trim($v))) {
+		if ($this->cssMode === CssMode::STANDARD && preg_match(ComputedValues::ZERO_LINE_HEIGHT, trim($v))) {
 			return '0mm';
 		} elseif (preg_match('/^[0-9\.,]*$/', $v) && $v >= 0) {
 			return (float) $v === 0.0 ? 'N' : ($v + 0);
@@ -14593,7 +14584,7 @@ function WriteHTML($html, $mode = HTMLParserMode::DEFAULT_MODE, $init = true, $c
 			$properties = Arrays::uniqueRecursiveMerge($properties, $zproperties);
 		}
 		if ($this->cssMode === CssMode::STANDARD) {
-			$this->setDocumentComputed($properties);
+			$this->setDocumentComputed($this->cssManager->computeValues($properties, []));
 		}
 
 		if (isset($properties['DIRECTION']) && $properties['DIRECTION']) {
@@ -14606,6 +14597,9 @@ function WriteHTML($html, $mode = HTMLParserMode::DEFAULT_MODE, $init = true, $c
 		}
 
 		$this->setCSS($properties, '', 'BODY');
+		if ($this->cssMode === CssMode::STANDARD) {
+			$this->setDocumentDrawnState();
+		}
 
 		$this->blk[0]['InlineProperties'] = $this->saveInlineProperties();
 
@@ -15226,6 +15220,10 @@ function WriteHTML($html, $mode = HTMLParserMode::DEFAULT_MODE, $init = true, $c
 					if ($i === $token) {
 						if ($standIn) {
 							$standIn = false;
+							if ($this->cssMode === CssMode::STANDARD) {
+								// The positioned block's content is drawn over the <div> that stands in for it
+								$this->recordDrawnState($this->openElements[count($this->openElements) - 1]);
+							}
 						} else {
 							$this->startElement($tag, $attr, $selfClosing, $this->styledElement === null ? null : $this->styledElement['computed']);
 						}
@@ -15419,7 +15417,7 @@ function WriteFixedPosHTML($html, $x, $y, $w, $h, $overflow = 'visible', $boundi
 			$p = $this->cssManager->MergeCSS('BLOCK', $tag, $attr);
 			$this->styledElement = $outerElement;
 			if ($this->cssMode === CssMode::STANDARD) {
-				$this->setFixedPosBlockComputed($p);
+				$this->setFixedPosBlockComputed($this->cssManager->getLastComputed());
 			}
 			$this->fixedPosBlockCascadeCSS = $this->blk[1]['cascadeCSS'];
 			if (isset($p['ROTATE'])) {
@@ -15444,8 +15442,9 @@ function WriteFixedPosHTML($html, $x, $y, $w, $h, $overflow = 'visible', $boundi
 			if ($this->cssMode === CssMode::LEGACY) {
 				$carried = InheritedProperties::LEGACY_POSITIONED;
 			} else {
-				// Text decorations and the stacking order are not inherited, but the <div> stands in for the block
-				$carried = array_merge(InheritedProperties::names(), ['TEXT-DECORATION', 'Z-INDEX']);
+				// Its content inherits from its frame. Text decorations and the stacking order are not inherited, but
+				// the <div> stands in for the block
+				$carried = ['TEXT-DECORATION', 'Z-INDEX'];
 			}
 			$css = '';
 			foreach (InheritedProperties::of($p, $carried) as $property => $value) {
@@ -17307,6 +17306,30 @@ function printbuffer($arrayaux, $blockstate = 0, $is_table = false, $table_draft
 			}
 		}
 
+		if ($this->cssMode === CssMode::STANDARD) {
+			// Each piece of text is drawn in the state it was buffered with, over the block's own, and not over whatever
+			// is open when the buffer is drawn, such as an inline element the block opened in. Nothing here writes to
+			// the page
+			$this->SetTColor($this->colorConverter->convert(0, $this->PDFAXwarnings));
+			$this->colorarray = '';
+			$this->spanbgcolorarray = '';
+			$this->spanbgcolor = false;
+			$this->spanborder = false;
+			$this->spanborddet = [];
+			$this->HREF = '';
+			$this->textshadow = '';
+			$saved = isset($this->blk[$this->blklvl]['InlineProperties']) ? $this->blk[$this->blklvl]['InlineProperties'] : [];
+			TextSpacing::set(
+				$this,
+				$this->sizeConverter,
+				isset($saved['lSpacingCSS']) ? $saved['lSpacingCSS'] : '',
+				isset($saved['wSpacingCSS']) ? $saved['wSpacingCSS'] : ''
+			);
+			if ($this->B || $this->I) {
+				$this->ResetStyles();
+			}
+		}
+
 		for ($i = 0; $i < $array_size; $i++) {
 			// COLS
 			$oldcolumn = $this->CurrCol;
@@ -19254,6 +19277,25 @@ function ReadCharset($html)
 		}
 	}
 
+	/**
+	 * The font autoLangToFont chooses for a language: the one setCSS() draws an element with that lang in, and the one
+	 * its computed values hand on
+	 *
+	 * @param string $lang
+	 *
+	 * @return string|null The font, or null where the language chooses none
+	 */
+	public function fontForLanguage($lang)
+	{
+		if (!$lang || !$this->autoLangToFont || $this->usingCoreFont || $lang == $this->default_lang || $lang === 'UTF-8') {
+			return null;
+		}
+
+		list(, $font) = $this->languageToFont->getLanguageOptions($lang, $this->useAdobeCJK);
+
+		return $font ? $font : null;
+	}
+
 	function setCSS($arrayaux, $type = '', $tag = '')
 	{
 	// type= INLINE | BLOCK | TABLECELL // tag= BODY
@@ -19294,16 +19336,12 @@ function setCSS($arrayaux, $type = '', $tag = '')
 
 		// mPDF 6
 		if (isset($arrayaux['LANG']) && $arrayaux['LANG']) {
-			if ($this->autoLangToFont && !$this->usingCoreFont) {
-				if ($arrayaux['LANG'] != $this->default_lang && $arrayaux['LANG'] != 'UTF-8') {
-					list ($coreSuitable, $mpdf_pdf_unifont) = $this->languageToFont->getLanguageOptions($arrayaux['LANG'], $this->useAdobeCJK);
-					if ($mpdf_pdf_unifont) {
-						$arrayaux['FONT-FAMILY'] = $mpdf_pdf_unifont;
-					}
-					if ($tag == 'BODY') {
-						$this->default_lang = $arrayaux['LANG'];
-					}
-				}
+			$font = $this->fontForLanguage($arrayaux['LANG']);
+			if ($font !== null) {
+				$arrayaux['FONT-FAMILY'] = $font;
+			}
+			if ($tag == 'BODY' && $this->autoLangToFont && !$this->usingCoreFont && $arrayaux['LANG'] != 'UTF-8') {
+				$this->default_lang = $arrayaux['LANG'];
 			}
 			$this->currentLang = $arrayaux['LANG'];
 		}
diff --git a/src/ServiceFactory.php b/src/ServiceFactory.php
index fc0dbad3c..a0a410110 100644
--- a/src/ServiceFactory.php
+++ b/src/ServiceFactory.php
@@ -9,6 +9,7 @@
 use Mpdf\Css\BorderMerger;
 use Mpdf\Css\CssMerger;
 use Mpdf\Css\CssParser;
+use Mpdf\Css\ComputedValues;
 use Mpdf\Css\InlinePropertyConverter;
 use Mpdf\Css\InlineStyleParser;
 use Mpdf\Css\NormalizeProperties;
@@ -118,7 +119,8 @@ public function getServices(
 			$colorConverter,
 			$borderMerger,
 			new PresentationalHints($mpdf, $normalizeProperties),
-			$sizeConverter
+			$sizeConverter,
+			new ComputedValues($mpdf, $sizeConverter)
 		);
 
 		$cssManager = new CssManager($cssParser, $cssMerger);
diff --git a/src/Tag/BlockTag.php b/src/Tag/BlockTag.php
index e3e4cb97f..589f274b4 100644
--- a/src/Tag/BlockTag.php
+++ b/src/Tag/BlockTag.php
@@ -8,7 +8,6 @@
 use Mpdf\Conversion\DecToHebrew;
 use Mpdf\Conversion\DecToOther;
 use Mpdf\Conversion\DecToRoman;
-use Mpdf\Css\InheritedProperties;
 use Mpdf\Css\TextDecorations;
 use Mpdf\CssMode;
 use Mpdf\Mpdf;
@@ -113,13 +112,13 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->mpdf->blockjustfinished = false;
 
 
-		$this->mpdf->InlineBDF = []; // mPDF 6
-		$this->mpdf->InlineBDFctr = 0; // mPDF 6
 		if ($this->mpdf->cssMode === CssMode::LEGACY) {
 			$this->mpdf->InlineProperties = [];
 		} elseif (!$this->mpdf->tableLevel) {
 			$this->setOpenInlineElementsAside();
 		}
+		$this->mpdf->InlineBDF = []; // mPDF 6
+		$this->mpdf->InlineBDFctr = 0; // mPDF 6
 		$this->mpdf->divbegin = true;
 
 		$this->mpdf->linebreakjustfinished = false;
@@ -546,13 +545,12 @@ public function open($attr, &$ahtml, &$ihtml)
 			}
 		}
 
-		// The text state it inherits, the parent block's or the inline elements' it is opened in
-		$inherited = InheritedProperties::blockTextState($this->mpdf->blk, $this->mpdf->blklvl - 1);
-		TextDecorations::enter($this->mpdf, $properties, $inherited !== null ? $inherited : []);
+		$parent = $this->mpdf->cssMode === CssMode::LEGACY ? null : $this->mpdf->getParentFrame();
+		TextDecorations::enter($this->mpdf, $properties, $parent === null ? [] : $parent['decorations']);
 		$this->mpdf->setCSS($properties, 'BLOCK', $tag); //name(id/class/style) found in the CSS array!
-		if ($this->mpdf->cssMode !== CssMode::LEGACY) {
+		if ($parent !== null) {
 			// A link around the block covers its text
-			$this->mpdf->HREF = isset($inherited['HREF']) ? $inherited['HREF'] : '';
+			$this->mpdf->HREF = $parent['href'];
 		}
 		$currblk['InlineProperties'] = $this->mpdf->saveInlineProperties();
 
diff --git a/src/Tag/TBody.php b/src/Tag/TBody.php
index 9ea72d22a..09d4b4a92 100644
--- a/src/Tag/TBody.php
+++ b/src/Tag/TBody.php
@@ -12,7 +12,6 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->mpdf->lastoptionaltag = 'TBODY'; // Save current HTML specified optional endtag
 		$this->cssManager->tbCSSlvl++;
 		$properties = $this->cssManager->MergeCSS('TABLE', 'TBODY', $attr);
-		$this->inheritRowGroup($properties);
 	}
 
 	public function close(&$ahtml, &$ihtml)
diff --git a/src/Tag/TFoot.php b/src/Tag/TFoot.php
index ed05aacab..d6571b6e4 100644
--- a/src/Tag/TFoot.php
+++ b/src/Tag/TFoot.php
@@ -14,26 +14,7 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->mpdf->tabletfoot = 1;
 		$this->mpdf->tablethead = 0;
 		$properties = $this->cssManager->MergeCSS('TABLE', 'TFOOT', $attr);
-		$this->inheritRowGroup($properties);
-		if (isset($properties['FONT-WEIGHT'])) {
-			$this->mpdf->tfoot_font_weight = '';
-			if (strtoupper($properties['FONT-WEIGHT']) === 'BOLD') {
-				$this->mpdf->tfoot_font_weight = 'B';
-			}
-		}
-
-		if (isset($properties['FONT-STYLE'])) {
-			$this->mpdf->tfoot_font_style = '';
-			if (strtoupper($properties['FONT-STYLE']) === 'ITALIC') {
-				$this->mpdf->tfoot_font_style = 'I';
-			}
-		}
-		if (isset($properties['FONT-VARIANT'])) {
-			$this->mpdf->tfoot_font_smCaps = '';
-			if (strtoupper($properties['FONT-VARIANT']) === 'SMALL-CAPS') {
-				$this->mpdf->tfoot_font_smCaps = 'S';
-			}
-		}
+		$this->keepLegacyRowGroupFont($properties, 'tfoot');
 
 		if (isset($properties['VERTICAL-ALIGN'])) {
 			$this->mpdf->tfoot_valign_default = $properties['VERTICAL-ALIGN'];
diff --git a/src/Tag/THead.php b/src/Tag/THead.php
index 9249d6c21..701afe7c1 100644
--- a/src/Tag/THead.php
+++ b/src/Tag/THead.php
@@ -12,26 +12,7 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->mpdf->tablethead = 1;
 		$this->mpdf->tabletfoot = 0;
 		$properties = $this->cssManager->MergeCSS('TABLE', 'THEAD', $attr);
-		$this->inheritRowGroup($properties);
-		if (isset($properties['FONT-WEIGHT'])) {
-			$this->mpdf->thead_font_weight = '';
-			if (strtoupper($properties['FONT-WEIGHT']) === 'BOLD') {
-				$this->mpdf->thead_font_weight = 'B';
-			}
-		}
-
-		if (isset($properties['FONT-STYLE'])) {
-			$this->mpdf->thead_font_style = '';
-			if (strtoupper($properties['FONT-STYLE']) === 'ITALIC') {
-				$this->mpdf->thead_font_style = 'I';
-			}
-		}
-		if (isset($properties['FONT-VARIANT'])) {
-			$this->mpdf->thead_font_smCaps = '';
-			if (strtoupper($properties['FONT-VARIANT']) === 'SMALL-CAPS') {
-				$this->mpdf->thead_font_smCaps = 'S';
-			}
-		}
+		$this->keepLegacyRowGroupFont($properties, 'thead');
 
 		if (isset($properties['VERTICAL-ALIGN'])) {
 			$this->mpdf->thead_valign_default = $properties['VERTICAL-ALIGN'];
diff --git a/src/Tag/Table.php b/src/Tag/Table.php
index f88374c7a..f35351b7b 100644
--- a/src/Tag/Table.php
+++ b/src/Tag/Table.php
@@ -4,9 +4,6 @@
 
 use Mpdf\Css\Border;
 use Mpdf\Css\PresentationalHints;
-use Mpdf\Css\InheritedProperties;
-use Mpdf\Css\InlinePropertyConverter;
-use Mpdf\Css\RelativeFontValues;
 use Mpdf\CssMode;
 use Mpdf\Mpdf;
 use Mpdf\Utils\Rotation;
@@ -70,14 +67,11 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->mpdf->tableLevel++;
 		$this->cssManager->tbCSSlvl++;
 
-		$cellInherited = [];
 		if ($this->mpdf->tableLevel > 1) { // inherit table properties from cell in which nested
 			if ($this->mpdf->cssMode === CssMode::LEGACY) {
 				//$this->mpdf->base_table_properties['FONT-KERNING'] = ($this->mpdf->textvar & TextVars::FC_KERNING);	// mPDF 6
 				$this->mpdf->base_table_properties['LETTER-SPACING'] = $this->mpdf->lSpacingCSS;
 				$this->mpdf->base_table_properties['WORD-SPACING'] = $this->mpdf->wSpacingCSS;
-			} else {
-				$this->inheritFromParentCell($this->mpdf->cell['PARENTCELL']);
 			}
 			// mPDF 6
 			$direction = $this->mpdf->cell[$this->mpdf->row][$this->mpdf->col]['direction'];
@@ -85,14 +79,6 @@ public function open($attr, &$ahtml, &$ihtml)
 			$cellLineHeight = $this->mpdf->cell[$this->mpdf->row][$this->mpdf->col]['cellLineHeight'];
 			$cellLineStackingStrategy = $this->mpdf->cell[$this->mpdf->row][$this->mpdf->col]['cellLineStackingStrategy'];
 			$cellLineStackingShift = $this->mpdf->cell[$this->mpdf->row][$this->mpdf->col]['cellLineStackingShift'];
-			if ($this->mpdf->cssMode === CssMode::STANDARD) {
-				// It inherits the cell's line-height and text-align through its merged CSS too
-				$outerTable = $this->mpdf->table[$this->mpdf->tableLevel - 1][$this->mpdf->tbctr[$this->mpdf->tableLevel - 1]];
-				$cellInherited = array_filter([
-					'LINE-HEIGHT' => $cellLineHeight,
-					'TEXT-ALIGN' => isset($outerTable['cellTextAlign']) ? $outerTable['cellTextAlign'] : '',
-				]);
-			}
 		}
 
 		if (isset($this->mpdf->tbctr[$this->mpdf->tableLevel])) {
@@ -189,7 +175,7 @@ public function open($attr, &$ahtml, &$ihtml)
 		if ($this->cssManager->tbCSSlvl == 1) {
 			$properties = $this->cssManager->MergeCSS('TOPTABLE', 'TABLE', $attr);
 		} else {
-			$properties = $this->cssManager->MergeCSS('TABLE', 'TABLE', $attr, $cellInherited);
+			$properties = $this->cssManager->MergeCSS('TABLE', 'TABLE', $attr);
 		}
 
 		$w = '';
@@ -306,13 +292,9 @@ public function open($attr, &$ahtml, &$ihtml)
 
 		// mPDF 6
 		if (!empty($properties['LANG'])) {
-			if ($this->mpdf->autoLangToFont && !$this->mpdf->usingCoreFont) {
-				if ($properties['LANG'] != $this->mpdf->default_lang && $properties['LANG'] !== 'UTF-8') {
-					list ($coreSuitable, $mpdf_pdf_unifont) = $this->languageToFont->getLanguageOptions($properties['LANG'], $this->mpdf->useAdobeCJK);
-					if ($mpdf_pdf_unifont) {
-						$properties['FONT-FAMILY'] = $mpdf_pdf_unifont;
-					}
-				}
+			$font = $this->mpdf->fontForLanguage($properties['LANG']);
+			if ($font !== null) {
+				$properties['FONT-FAMILY'] = $font;
 			}
 			$this->mpdf->currentLang = $properties['LANG'];
 		}
@@ -325,12 +307,8 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->mpdf->base_table_properties['FONT-FAMILY'] = $this->mpdf->FontFamily;
 
 		if (isset($properties['FONT-SIZE'])) {
-			$inheritedState = InheritedProperties::blockTextState($this->mpdf->blk, $this->mpdf->blklvl);
 			if ($this->mpdf->tableLevel > 1) {
 				$parentSize = $this->sizeConverter->convert($this->mpdf->base_table_properties['FONT-SIZE']);
-			} elseif ($this->mpdf->cssMode === CssMode::STANDARD && isset($inheritedState['size'])) {
-				// Its size is relative to the size it inherits, the block's or the inline elements' it is opened in
-				$parentSize = $inheritedState['size'];
 			} else {
 				$parentSize = $this->mpdf->default_font_size / Mpdf::SCALE;
 			}
@@ -344,19 +322,6 @@ public function open($attr, &$ahtml, &$ihtml)
 
 		if ($this->mpdf->cssMode === CssMode::LEGACY) {
 			$this->setLegacyBaseProperties($properties);
-		} else {
-			// The font family and size are resolved above, and the weight is computed from the enclosing table's. A th in the
-			// table is centred unless it inherits a text-align
-			$inherited = InheritedProperties::of($properties, array_merge(array_diff(InheritedProperties::TEXT, ['FONT-FAMILY', 'FONT-SIZE']), ['TEXT-ALIGN']));
-			if (isset($inherited['FONT-WEIGHT'])) {
-				$weight = RelativeFontValues::weight($inherited['FONT-WEIGHT'], RelativeFontValues::tableWeight($this->mpdf->base_table_properties));
-				if ($weight === null) {
-					unset($inherited['FONT-WEIGHT']);
-				} else {
-					$inherited['FONT-WEIGHT'] = (string) $weight;
-				}
-			}
-			$this->mpdf->base_table_properties = array_merge($this->mpdf->base_table_properties, $inherited);
 		}
 		// In cssMode legacy line-height: 0 is skipped, as mPDF v7 did
 		$lineHeightSet = $this->mpdf->cssMode === CssMode::STANDARD
@@ -1281,22 +1246,6 @@ public function close(&$ahtml, &$ihtml)
 		}
 	}
 
-	/**
-	 * Start a nested table from the text state of the cell it is in: its cells inherit the cell's inherited text
-	 * properties, and its font and font size become the default its cells are reset to. close() puts the outer
-	 * table's back.
-	 *
-	 * @param array $parentCell The cell's text state, as Mpdf::saveInlineProperties() saved it
-	 */
-	private function inheritFromParentCell(array $parentCell)
-	{
-		$converter = new InlinePropertyConverter($this->colorConverter);
-
-		$this->mpdf->base_table_properties = InheritedProperties::of($converter->convert($parentCell), InheritedProperties::TEXT);
-		$this->mpdf->default_font = $parentCell['family'];
-		$this->mpdf->default_font_size = $parentCell['sizePt'];
-	}
-
 	/**
 	 * Hand a table's cells the text properties mPDF v7 did: its font weight when bold, its font style when italic, its
 	 * colour, kerning, spacing and hyphenation
diff --git a/src/Tag/Tag.php b/src/Tag/Tag.php
index 9671d2fc7..e26f9b9f8 100644
--- a/src/Tag/Tag.php
+++ b/src/Tag/Tag.php
@@ -208,6 +208,32 @@ protected function withSpanVisibility(array $objattr)
 		return $objattr;
 	}
 
+	/**
+	 * Keeps the bold, italic and small caps a row group's CSS gives its cells, as the legacy cascade hands them on.
+	 * Under the standard cascade the cells inherit the row group's font from its frame
+	 *
+	 * @param array $properties The row group's merged CSS
+	 * @param string $prefix thead or tfoot, naming the Mpdf fields that hold them
+	 */
+	protected function keepLegacyRowGroupFont(array $properties, $prefix)
+	{
+		if ($this->appliesStandardCascade()) {
+			return;
+		}
+
+		$fonts = [
+			'FONT-WEIGHT' => ['_font_weight', 'BOLD', 'B'],
+			'FONT-STYLE' => ['_font_style', 'ITALIC', 'I'],
+			'FONT-VARIANT' => ['_font_smCaps', 'SMALL-CAPS', 'S'],
+		];
+		foreach ($fonts as $property => $font) {
+			if (isset($properties[$property])) {
+				list($field, $value, $flag) = $font;
+				$this->mpdf->{$prefix . $field} = strtoupper($properties[$property]) === $value ? $flag : '';
+			}
+		}
+	}
+
 	/**
 	 * Sets the font size a font-size gives a form field or text circle, read against the document's size. larger and
 	 * smaller leave it as it is in the legacy CSS mode, which ignores them
@@ -263,65 +289,15 @@ protected function formFieldStyle(array $properties)
 		return $style;
 	}
 
-	/**
-	 * Under the standard cascade, keeps what a row group opened in the innermost table hands the cells of its rows.
-	 * Tr reads it back
-	 *
-	 * @param string[] $properties The row group's merged CSS
-	 */
-	protected function inheritRowGroup(array $properties)
-	{
-		if ($this->mpdf->cssMode === CssMode::STANDARD && $this->mpdf->tableLevel) {
-			$this->mpdf->table[$this->mpdf->tableLevel][$this->mpdf->tbctr[$this->mpdf->tableLevel]]['rowGroupInherited'] = $this->inheritedByTablePart($properties, $this->mpdf->base_table_properties);
-		}
-	}
-
-	/**
-	 * The inherited properties a row group or a row hands its cells under the standard cascade: its own, over those
-	 * of the table or row group it is in. Its font size is resolved against theirs
-	 *
-	 * @param string[] $properties Its merged CSS
-	 * @param string[] $parent What the table or row group it is in hands its cells, with a font size in mm
-	 *
-	 * @return string[]
-	 */
-	protected function inheritedByTablePart(array $properties, array $parent)
-	{
-		$inherited = array_merge($parent, InheritedProperties::of($properties, InheritedProperties::names()));
-
-		if (isset($properties['FONT-SIZE'])) {
-			$inherited['FONT-SIZE'] = $this->relativeFontSize($properties['FONT-SIZE'], $parent['FONT-SIZE']);
-		}
-
-		return $inherited;
-	}
-
-	/**
-	 * A font size given as a number, in any unit, resolved against the size it is relative to. Keywords such as small
-	 * are kept, since setCSS() reads them against the default size whatever the parent's
-	 *
-	 * @param string $size
-	 * @param string $parentSize With a unit
-	 *
-	 * @return string
-	 */
-	protected function relativeFontSize($size, $parentSize)
-	{
-		if (!$this->sizeConverter->isLength($size)) {
-			return $size;
-		}
-
-		return $this->sizeConverter->convert($size, $this->sizeConverter->convert($parentSize)) . 'mm';
-	}
-
 	abstract public function open($attr, &$ahtml, &$ihtml);
 
 	abstract public function close(&$ahtml, &$ihtml);
 
 	/**
-	 * Sets aside the inline elements a block or table opens inside, under CssMode::STANDARD: their saved states and the
-	 * text state they set go on the enclosing block. The block or table inherits that text state, and
-	 * restoreBlockTextState() puts both back when it closes, so the text after it is drawn in their style and their end tags restore what was there before them.
+	 * Sets aside the inline elements a block or table opens inside, under CssMode::STANDARD: their saved states, the
+	 * text state they set and their bidirectional embeddings go on the enclosing block. restoreBlockTextState() puts
+	 * them back when it closes, so the text after it is drawn in their style and their end tags restore what was there
+	 * before them.
 	 *
 	 * A block opened a second time, as a kept block laid out again or a block reopened after a forced page break, finds
 	 * them already set aside and keeps them, as by then the text state has changed
@@ -334,13 +310,9 @@ protected function setOpenInlineElementsAside()
 			$block['openInline'] = [
 				'properties' => $this->mpdf->InlineProperties,
 				'state' => $this->mpdf->saveInlineProperties(),
+				'bidi' => $this->mpdf->InlineBDF,
+				'bidiCount' => $this->mpdf->InlineBDFctr,
 			];
-
-			// The line before the block or table is printed next, and its text with no colour or link of its own is drawn in the
-			// current state
-			if (isset($block['InlineProperties'])) {
-				$this->mpdf->restoreInlineProperties($block['InlineProperties']);
-			}
 		}
 
 		$this->mpdf->InlineProperties = [];
@@ -360,8 +332,41 @@ protected function restoreBlockTextState()
 		$block = &$this->mpdf->blk[$this->mpdf->blklvl];
 		if (isset($block['openInline'])) {
 			$this->mpdf->InlineProperties = $block['openInline']['properties'];
+			$this->reopenBidiEmbeddings($block['openInline']['bidi'], $block['openInline']['bidiCount']);
 			unset($block['openInline']);
 		}
 	}
 
+	/**
+	 * Puts back the bidirectional embeddings of the inline elements a block or table opened in. It ended the paragraph
+	 * they were in, so they are opened again for the text after it, in the order they were opened, and their end tags
+	 * close them
+	 *
+	 * @param array $embeddings As Mpdf::$InlineBDF holds them
+	 * @param int $count As Mpdf::$InlineBDFctr holds it
+	 */
+	private function reopenBidiEmbeddings(array $embeddings, $count)
+	{
+		$this->mpdf->InlineBDF = $embeddings;
+		$this->mpdf->InlineBDFctr = $count;
+
+		$open = [];
+		foreach ($embeddings as $element) {
+			foreach ($element as $embedding) {
+				$open[$embedding[1]] = $embedding[0];
+			}
+		}
+		ksort($open);
+
+		$codes = '';
+		foreach ($open as $popd) {
+			$codes .= $this->mpdf->_setBidiCodes('start', $popd);
+		}
+		if ($codes !== '') {
+			$this->mpdf->OTLdata = [];
+			$this->mpdf->_saveTextBuffer($codes);
+			$this->mpdf->biDirectional = true;
+		}
+	}
+
 }
diff --git a/src/Tag/Td.php b/src/Tag/Td.php
index 231984589..c325325c9 100644
--- a/src/Tag/Td.php
+++ b/src/Tag/Td.php
@@ -174,12 +174,8 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->cssManager->setBorderDominance('T', 0);
 		$this->cssManager->setBorderDominance('B', 0);
 
-		if ($this->mpdf->cssMode === CssMode::STANDARD) {
-			$properties = $this->mergeInheritedCss($tag, $attr, isset($table['rowInherited']) ? $table['rowInherited'] : $this->mpdf->base_table_properties);
-			// For a table nested in the cell, which inherits it
-			$table['cellTextAlign'] = isset($properties['TEXT-ALIGN']) ? $properties['TEXT-ALIGN'] : '';
-		} else {
-			$properties = $this->cssManager->MergeCSS('TABLE', $tag, $attr);
+		$properties = $this->cssManager->MergeCSS('TABLE', $tag, $attr);
+		if ($this->mpdf->cssMode === CssMode::LEGACY) {
 			$properties = Arrays::uniqueRecursiveMerge($this->mpdf->base_table_properties, $properties);
 		}
 
@@ -494,25 +490,4 @@ public function close(&$ahtml, &$ihtml)
 			$this->mpdf->Reset();
 		}
 	}
-
-	/**
-	 * The cell's CSS, over what it inherits from its row, its row group and the table. setCSS() reads a font size
-	 * relative to the table's, so the cell's own is resolved here against its row's
-	 *
-	 * @param string $tag TD or TH
-	 * @param array $attr
-	 * @param string[] $row What the cell's row hands it, with what its row group and the table do
-	 *
-	 * @return array
-	 */
-	private function mergeInheritedCss($tag, array $attr, array $row)
-	{
-		$properties = $this->cssManager->MergeCSS('TABLE', $tag, $attr, $row);
-
-		if (isset($row['FONT-SIZE']) && $properties['FONT-SIZE'] !== $row['FONT-SIZE']) {
-			$properties['FONT-SIZE'] = $this->relativeFontSize($properties['FONT-SIZE'], $row['FONT-SIZE']);
-		}
-
-		return $properties;
-	}
 }
diff --git a/src/Tag/TextCircle.php b/src/Tag/TextCircle.php
index bcef38d5a..7a0bbf745 100644
--- a/src/Tag/TextCircle.php
+++ b/src/Tag/TextCircle.php
@@ -2,6 +2,8 @@
 
 namespace Mpdf\Tag;
 
+use Mpdf\Css\RelativeFontValues;
+use Mpdf\CssMode;
 use Mpdf\Mpdf;
 use Mpdf\Utils\UtfString;
 
@@ -100,10 +102,8 @@ public function open($attr, &$ahtml, &$ihtml)
 		}
 
 		$objattr['fontstyle'] = '';
-		if (isset($properties['FONT-WEIGHT'])) {
-			if (strtoupper($properties['FONT-WEIGHT']) === 'BOLD') {
-				$objattr['fontstyle'] .= 'B';
-			}
+		if (isset($properties['FONT-WEIGHT']) && $this->isBoldWeight($properties['FONT-WEIGHT'])) {
+			$objattr['fontstyle'] .= 'B';
 		}
 		if (isset($properties['FONT-STYLE'])) {
 			if (strtoupper($properties['FONT-STYLE']) === 'ITALIC') {
@@ -247,4 +247,21 @@ public function open($attr, &$ahtml, &$ihtml)
 	public function close(&$ahtml, &$ihtml)
 	{
 	}
+
+	/**
+	 * Whether a font-weight in the circle's merged CSS is drawn bold. The standard CSS mode merges the computed
+	 * weight, a number, and the legacy mode reads only bold
+	 *
+	 * @param string $weight
+	 *
+	 * @return bool
+	 */
+	private function isBoldWeight($weight)
+	{
+		if ($this->mpdf->cssMode === CssMode::STANDARD && is_numeric($weight)) {
+			return RelativeFontValues::isBold($weight);
+		}
+
+		return strtoupper($weight) === 'BOLD';
+	}
 }
diff --git a/src/Tag/Tr.php b/src/Tag/Tr.php
index 8cc837b43..4939be750 100644
--- a/src/Tag/Tr.php
+++ b/src/Tag/Tr.php
@@ -3,7 +3,6 @@
 namespace Mpdf\Tag;
 
 use Mpdf\Css\Border;
-use Mpdf\CssMode;
 
 class Tr extends Tag
 {
@@ -16,9 +15,7 @@ public function open($attr, &$ahtml, &$ihtml)
 		$this->mpdf->row++;
 		$this->mpdf->table[$this->mpdf->tableLevel][$this->mpdf->tbctr[$this->mpdf->tableLevel]]['nr'] ++;
 		$this->mpdf->col = -1;
-		$rowGroup = $this->rowGroupInherited();
-		$properties = $this->cssManager->MergeCSS('TABLE', 'TR', $attr, $rowGroup);
-		$this->inheritRow($properties, $rowGroup);
+		$properties = $this->cssManager->MergeCSS('TABLE', 'TR', $attr);
 
 		// write pagebreak markers into row list, so _tableWrite can respect it
 		if (isset($properties['PAGE-BREAK-BEFORE']) && strtoupper($properties['PAGE-BREAK-BEFORE']) === 'AVOID'
@@ -111,37 +108,4 @@ public function close(&$ahtml, &$ihtml)
 		}
 	}
 
-	/**
-	 * Under the standard cascade, what the row inherits from its row group. A row written straight into the table is
-	 * in a tbody that the HTML leaves out, which the tbody rules style as they would one that is written
-	 *
-	 * @return string[] Empty under legacy
-	 */
-	private function rowGroupInherited()
-	{
-		if ($this->mpdf->cssMode !== CssMode::STANDARD) {
-			return [];
-		}
-
-		if ($this->mpdf->opensInImpliedTbody('TR')) {
-			$this->inheritRowGroup($this->cssManager->previewTableCss('TBODY', []));
-		}
-
-		$table = $this->mpdf->table[$this->mpdf->tableLevel][$this->mpdf->tbctr[$this->mpdf->tableLevel]];
-
-		return isset($table['rowGroupInherited']) ? $table['rowGroupInherited'] : $this->mpdf->base_table_properties;
-	}
-
-	/**
-	 * Under the standard cascade, keeps what the row hands its cells, over what its row group does
-	 *
-	 * @param string[] $properties The row's merged CSS
-	 * @param string[] $rowGroup What the row group hands it
-	 */
-	private function inheritRow(array $properties, array $rowGroup)
-	{
-		if ($this->mpdf->cssMode === CssMode::STANDARD) {
-			$this->mpdf->table[$this->mpdf->tableLevel][$this->mpdf->tbctr[$this->mpdf->tableLevel]]['rowInherited'] = $this->inheritedByTablePart($properties, $rowGroup);
-		}
-	}
 }
diff --git a/src/TracksOpenElements.php b/src/TracksOpenElements.php
index 5cc8e57a1..9d86713e4 100644
--- a/src/TracksOpenElements.php
+++ b/src/TracksOpenElements.php
@@ -2,6 +2,8 @@
 
 namespace Mpdf;
 
+use Mpdf\Css\TextDecorations;
+
 /**
  * Keeps the tree of elements in the HTML WriteHTML() reads, so that each CSS rule can be applied to the elements its
  * selector matches, as in a browser. Selectors that name a parent, an ancestor or an earlier sibling, such as
@@ -27,6 +29,12 @@ trait TracksOpenElements
 	/** @var array|null The properties merged for <body>, which the document's frame carries as its computed values */
 	private $documentComputed;
 
+	/** @var array The text decorations <body> is drawn in, which the document's frame carries */
+	private $documentDecorations = [];
+
+	/** @var array|null The computed values of the tbody a browser adds around a row written straight into a table */
+	private $impliedTbodyComputed;
+
 	/** @var array[]|null The open elements as they stood inside the positioned block being written, for its content */
 	private $fixedPosBlockElements;
 
@@ -93,6 +101,9 @@ trait TracksOpenElements
 		'TR' => ['TD' => true, 'TH' => true],
 	];
 
+	/** @var array<string, true> The elements of a table, which draw no text of their own outside their cells */
+	private static $tableParts = ['TABLE' => true, 'THEAD' => true, 'TBODY' => true, 'TFOOT' => true, 'TR' => true, 'TD' => true, 'TH' => true];
+
 	/** @var array<string, true> The tags mPDF wraps substituted characters in, which are not the document's elements */
 	private static $substitutionTags = ['TTA' => true, 'TTS' => true, 'TTZ' => true];
 
@@ -134,11 +145,15 @@ trait TracksOpenElements
 	 *   found. Null when that is not known, as for an element still open at the end of a WriteHTML() call that
 	 *   leaves it open, and in the legacy CSS mode, which reads nothing ahead
 	 * - empty: whether it has no children and no text, white space included. Null when that is not known
-	 * - computed: under the standard CSS mode, the properties CssMerger merged for it, with the CSS-wide keywords
-	 *   resolved, keyed by the uppercased longhands the normalised declarations name. The document's frame carries
-	 *   those of <body>. Null for an element whose CSS was not merged, such as the tbody a table's rows are put in
-	 *   when the HTML leaves it out, and under the legacy mode. `inherit` on a property that is not inherited reads
-	 *   the parent's
+	 * - computed: under the standard CSS mode, its computed values, as ComputedValues makes them from the properties
+	 *   CssMerger merged for it, with the CSS-wide keywords resolved, keyed by the uppercased longhands the normalised
+	 *   declarations name. A property left out has its initial value. The document's frame carries those of <body>, and
+	 *   the tbody a table's rows are put in when the HTML leaves it out carries what the tbody rules give it. Its
+	 *   children start from the inherited ones, and `inherit` on a property that is not inherited reads the rest.
+	 *   Null for an element whose CSS was not merged, such as a void element, and under the legacy mode
+	 * - href and decorations: under the standard CSS mode, the link its content is drawn in and the text decorations
+	 *   that propagate to its content, as TextDecorations::of() gives them. A block opened in it starts from them.
+	 *   Empty for a positioned block, a table and its parts, and under the legacy mode
 	 *
 	 * @return array[]
 	 */
@@ -217,19 +232,6 @@ public function getDocumentPath()
 		return $this->newOpenElementStack();
 	}
 
-	/**
-	 * Whether an element opened now in the innermost open element would be put in a tbody that the HTML leaves out,
-	 * as a row written straight into a table is
-	 *
-	 * @param string $tag Uppercased
-	 *
-	 * @return bool
-	 */
-	public function opensInImpliedTbody($tag)
-	{
-		return self::impliesTbody($tag, $this->openElements[count($this->openElements) - 1]);
-	}
-
 	/**
 	 * 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
@@ -266,6 +268,110 @@ public function recordStyledElementComputed(array $properties)
 		}
 	}
 
+	/**
+	 * The computed values an element whose CSS is being merged inherits from, under the standard CSS mode: those on
+	 * its parent's frame, or, where its parent's CSS was never merged, as for the tbody the HTML leaves out, on the
+	 * nearest ancestor's that holds some
+	 *
+	 * @internal
+	 *
+	 * @return array
+	 */
+	public function getInheritedComputed()
+	{
+		list($path, $i) = $this->styledParentPosition();
+
+		for (; $i >= 0; $i--) {
+			if ($path[$i]['computed'] !== null) {
+				return $path[$i]['computed'];
+			}
+		}
+
+		return [];
+	}
+
+	/**
+	 * @internal
+	 *
+	 * @return array The frame of the parent of the element whose CSS is being merged, or the innermost open element's
+	 *               when none is
+	 */
+	public function getParentFrame()
+	{
+		list($path, $i) = $this->styledParentPosition();
+
+		return $path[$i];
+	}
+
+	/**
+	 * Where the parent of the element whose CSS is being merged is on its path: the frame before the element's own, or
+	 * the last when the element has not opened yet. With no element being merged, the innermost open element
+	 *
+	 * @return array The path of open elements and the parent's index in it
+	 */
+	private function styledParentPosition()
+	{
+		if ($this->styledElement === null) {
+			return [$this->openElements, count($this->openElements) - 1];
+		}
+
+		$path = $this->styledElement['path'];
+
+		return [$path, count($path) - ($this->styledElement['tag'] === null ? 2 : 1)];
+	}
+
+	/**
+	 * @internal
+	 *
+	 * @return bool Whether the element whose start tag is being read goes in a tbody the HTML leaves out, which the
+	 *              stack adds when the element is taken in
+	 */
+	public function styledElementOpensInImpliedTbody()
+	{
+		if ($this->styledElement === null || $this->styledElement['tag'] === null) {
+			return false;
+		}
+
+		$path = $this->styledElement['path'];
+
+		return self::impliesTbody($this->styledElement['tag'], $path[count($path) - 1]);
+	}
+
+	/**
+	 * Keeps the computed values of the tbody a browser adds around the row whose start tag is being read, for the
+	 * frame startElement() makes for it
+	 *
+	 * @internal
+	 *
+	 * @param array $computed
+	 */
+	public function setImpliedTbodyComputed(array $computed)
+	{
+		$this->impliedTbodyComputed = $computed;
+	}
+
+	/**
+	 * Keeps on a frame the parts of the text state its content is drawn over that are not inherited properties: the
+	 * link it is in and the text decorations that propagate to it. Its handler has just drawn it in them
+	 *
+	 * @param array $frame
+	 */
+	private function recordDrawnState(array &$frame)
+	{
+		$frame['href'] = $this->HREF;
+		$frame['decorations'] = TextDecorations::of($this);
+	}
+
+	/**
+	 * Keeps the text decorations of <body> on the document's frame and on each a header, footer or new document starts
+	 * from, once WriteHTML() has drawn <body> in them
+	 */
+	private function setDocumentDrawnState()
+	{
+		$this->documentDecorations = TextDecorations::of($this);
+		$this->openElements[0]['decorations'] = $this->documentDecorations;
+	}
+
 	/**
 	 * Keeps the properties merged for <body>, which the document's frame carries as its computed values, in the
 	 * stack being written and in each stack a header, footer or new document starts from. WriteHTML() calls it under
@@ -280,16 +386,20 @@ private function setDocumentComputed(array $properties)
 	}
 
 	/**
-	 * Keeps the properties merged for the positioned block being written, for the frame its content is written in.
-	 * Its start tag in the flow only previews its CSS, so WriteFixedPosHTML() calls it under the standard CSS mode
-	 * once it merges them
+	 * Keeps the computed values of the positioned block being written, for the frame its content is written in. Its
+	 * start tag in the flow only previews its CSS, so WriteFixedPosHTML() calls it under the standard CSS mode once
+	 * it merges them. Out of the flow, the block takes none of the decorations or the link it is in; the <div> that
+	 * stands in for it records its own when it opens
 	 *
-	 * @param array $properties
+	 * @param array $computed
 	 */
-	private function setFixedPosBlockComputed(array $properties)
+	private function setFixedPosBlockComputed(array $computed)
 	{
 		if ($this->fixedPosBlockElements !== null) {
-			$this->fixedPosBlockElements[count($this->fixedPosBlockElements) - 1]['computed'] = $properties;
+			$block = &$this->fixedPosBlockElements[count($this->fixedPosBlockElements) - 1];
+			$block['computed'] = $computed;
+			$block['href'] = '';
+			$block['decorations'] = [];
 		}
 	}
 
@@ -305,6 +415,7 @@ private function newOpenElementStack()
 	{
 		$document = $this->newElementFrame('', [], $this->documentLang, 1, 1, '');
 		$document['computed'] = $this->documentComputed;
+		$document['decorations'] = $this->documentDecorations;
 
 		return [$document];
 	}
@@ -338,6 +449,8 @@ private function newElementFrame($tag, array $attr, $lang, $nthChild, $nthOfType
 			'childTypeTotals' => null,
 			'empty' => null,
 			'computed' => null,
+			'href' => '',
+			'decorations' => [],
 		];
 
 		return isset($this->lookAhead[$key]) ? $this->lookAhead[$key] + $frame : $frame;
@@ -362,12 +475,18 @@ private function startElement($tag, array $attr, $selfClosing, $computed = null)
 
 		$parent = count($this->openElements) - 1;
 		if (self::impliesTbody($tag, $this->openElements[$parent])) {
-			$this->startElement('TBODY', [], false);
+			$this->startElement('TBODY', [], false, $this->impliedTbodyComputed);
+			$this->impliedTbodyComputed = null;
 			$parent++;
 		}
 
 		$frame = $this->newChildFrame($this->openElements[$parent], $tag, $attr);
 		$frame['computed'] = $computed;
+		// Only the content of a block or an inline element reads it: a table's content starts from a text state of its
+		// own, and a void element has none
+		if ($this->cssMode === CssMode::STANDARD && !isset(self::$tableParts[$tag]) && !isset(self::$voidTags[$tag])) {
+			$this->recordDrawnState($frame);
+		}
 
 		if ($selfClosing || isset(self::$voidTags[$tag])) {
 			$this->recordClosedElement($frame);
diff --git a/tests/Mpdf/ComputedValueInheritanceTest.php b/tests/Mpdf/ComputedValueInheritanceTest.php
new file mode 100644
index 000000000..c856398cf
--- /dev/null
+++ b/tests/Mpdf/ComputedValueInheritanceTest.php
@@ -0,0 +1,340 @@
+<?php
+
+namespace Mpdf;
+
+use Yoast\PHPUnitPolyfills\TestCases\TestCase;
+
+/**
+ * Under the standard CSS mode a descendant inherits its parent's computed values: a relative font size is taken of the
+ * parent's size, and a length given in em is handed on as the length it came to, not re-read against the
+ * descendant's own font size. The same goes for inherit on a property that is not inherited. Under legacy an
+ * inherited em length is read again against the descendant's size, and inherit is dropped
+ */
+class ComputedValueInheritanceTest extends TestCase
+{
+
+	use DrawnStyles;
+
+	/**
+	 * A font size relative to the parent's is taken of the parent's computed size, three deep, in every context
+	 *
+	 * @dataProvider fontSizeChains
+	 *
+	 * @param string $mode
+	 * @param string $context
+	 * @param string $html
+	 * @param float[] $expected The size, in points, each piece of text is drawn at
+	 */
+	public function testARelativeFontSizeIsTakenOfTheParentsComputedSize($mode, $context, $html, array $expected)
+	{
+		$mpdf = $this->drawDocument($this->inContext($context, $html), ['cssMode' => $mode]);
+		$mpdf->Close();
+
+		$sizes = $this->keyedByText($mpdf, $mpdf->drawnFontSize);
+		foreach ($expected as $text => $size) {
+			$this->assertArrayHasKey($text, $sizes, $text . ' is drawn');
+			$this->assertEqualsWithDelta($size, $sizes[$text], 0.001, $text);
+		}
+		$this->assertDrawnInContext($context, $mpdf, array_keys($expected));
+	}
+
+	/**
+	 * Chains of em and % font sizes, three deep, through blocks, inline elements, a table, its row group and row, and a
+	 * table nested in a cell, each in every context under both modes. Legacy does not read a row's or row group's
+	 * size, and starts a table from the document's size
+	 *
+	 * @return array[]
+	 */
+	public function fontSizeChains()
+	{
+		$chains = [
+			'blocks and inline elements' => [
+				'<div style="font-size: 20pt"><div style="font-size: 1.5em"><p style="font-size: 50%">aa'
+				. '<span style="font-size: 2em">bb<span style="font-size: 150%">cc</span></span></p></div></div>',
+				['aa' => 15, 'bb' => 30, 'cc' => 45],
+				['aa' => 15, 'bb' => 30, 'cc' => 45],
+			],
+			'a table in a block' => [
+				'<div style="font-size: 20pt"><table style="font-size: 1.5em"><tr><td style="font-size: 50%">aa'
+				. '<span style="font-size: 2em">bb</span></td></tr></table></div>',
+				['aa' => 15, 'bb' => 30],
+				['aa' => 8.25, 'bb' => 16.5],
+			],
+			'a row group and a row' => [
+				'<table style="font-size: 20pt"><tbody style="font-size: 150%"><tr style="font-size: 50%">'
+				. '<td style="font-size: 2em">aa<span style="font-size: 50%">bb</span></td></tr></tbody></table>',
+				['aa' => 30, 'bb' => 15],
+				['aa' => 40, 'bb' => 20],
+			],
+			'a table nested in a cell' => [
+				'<table><tr><td style="font-size: 20pt"><table style="font-size: 150%"><tr>'
+				. '<td style="font-size: 0.5em">aa<span style="font-size: 2em">bb</span></td></tr></table></td></tr></table>',
+				['aa' => 15, 'bb' => 30],
+				['aa' => 8.25, 'bb' => 16.5],
+			],
+		];
+
+		$data = [];
+		foreach (['flow', 'table cell', 'header', 'footer', 'positioned block', 'kept block', 'forced page break'] as $context) {
+			foreach ($chains as $name => $chain) {
+				// A table in a table cell is a nested table, whose own cases are above
+				if ($context === 'table cell' && $name !== 'blocks and inline elements') {
+					continue;
+				}
+				$data[CssMode::STANDARD . ': ' . $name . ' in ' . $context] = [CssMode::STANDARD, $context, $chain[0], $chain[1]];
+				$data[CssMode::LEGACY . ': ' . $name . ' in ' . $context] = [CssMode::LEGACY, $context, $chain[0], $chain[2]];
+			}
+		}
+
+		return $data;
+	}
+
+	/**
+	 * A spacing or indent given in em on an ancestor is handed on as the length it came to at the ancestor's size,
+	 * so the descendant is drawn as if it had set that length itself. Under legacy the descendant reads the em again
+	 * at its own size
+	 *
+	 * @dataProvider emLengths
+	 *
+	 * @param string $mode
+	 * @param string $html With {A} for the ancestor's declaration and {D} for the descendant's
+	 * @param string $declaration In em, on the ancestor, whose font size is 20pt
+	 * @param string $computed The same length at 20pt, which the descendant should be drawn with
+	 * @param string $reread The same length at the descendant's 10pt
+	 */
+	public function testAnEmLengthIsInheritedAsTheLengthItCameTo($mode, $html, $declaration, $computed, $reread)
+	{
+		// An indent moves where the line starts, and spacing makes it wider
+		$measure = strpos($declaration, 'text-indent') === 0 ? 0 : 1;
+		$inherited = $this->firstLine($mode, strtr($html, ['{A}' => $declaration, '{D}' => '']))[$measure];
+		$expected = $this->firstLine($mode, strtr($html, ['{A}' => '', '{D}' => $mode === CssMode::STANDARD ? $computed : $reread]))[$measure];
+		$none = $this->firstLine($mode, strtr($html, ['{A}' => '', '{D}' => '']))[$measure];
+
+		$this->assertNotEquals($none, $expected, 'The length does not change how the line is drawn');
+		$this->assertEqualsWithDelta($expected, $inherited, 0.002);
+	}
+
+	/**
+	 * Letter spacing, word spacing and text indent in em, from a block, a list, a cell, a positioned block and a block
+	 * laid out again after it is kept together, under both modes
+	 *
+	 * @return array[]
+	 */
+	public function emLengths()
+	{
+		$lengths = [
+			'letter-spacing' => ['letter-spacing: 0.1em', 'letter-spacing: 2pt', 'letter-spacing: 1pt'],
+			'word-spacing' => ['word-spacing: 1em', 'word-spacing: 20pt', 'word-spacing: 10pt'],
+			// mPDF has always handed a block's text indent on as the length it came to
+			'text-indent' => ['text-indent: 2em', 'text-indent: 40pt', 'text-indent: 40pt'],
+		];
+		$contexts = [
+			'block to block' => '<div style="font-size: 20pt; {A}"><p style="font-size: 10pt; {D}">qq qq</p></div>',
+			'block to inline' => '<p style="font-size: 20pt; {A}">zz <span style="font-size: 10pt; {D}">qq qq</span></p>',
+			'inline to inline' => '<p>zz <span style="font-size: 20pt; {A}">yy <b style="font-size: 10pt; {D}">qq qq</b></span></p>',
+			'list to item' => '<ul style="font-size: 20pt; {A}"><li style="font-size: 10pt; {D}">qq qq</li></ul>',
+			'cell to block' => '<table><tr><td style="font-size: 20pt; {A}"><div style="font-size: 10pt; {D}">qq qq</div></td></tr></table>',
+			'positioned block to block' => '<div style="position: absolute; top: 50mm; left: 20mm; width: 100mm; font-size: 20pt; {A}">'
+				. '<p style="font-size: 10pt; {D}">qq qq</p></div>',
+			'block to table cell' => '<div style="font-size: 20pt; {A}"><table><tr><td style="width: 100mm; font-size: 10pt; {D}">qq qq</td></tr></table></div>',
+		];
+
+		$data = [];
+		foreach ([CssMode::STANDARD, CssMode::LEGACY] as $mode) {
+			foreach ($contexts as $context => $html) {
+				foreach ($lengths as $property => $values) {
+					// mPDF lays out a block in a cell as the cell's own content, which is not indented, and an inline
+					// element's text is indented by the block its line is in
+					if ($property === 'text-indent' && (strpos($html, '<td') !== false || strpos($context, 'inline') !== false)) {
+						continue;
+					}
+					// Legacy hands a table nothing from the block it is in
+					if ($mode === CssMode::LEGACY && $context === 'block to table cell') {
+						continue;
+					}
+					// Legacy's positioned block hands its content no word spacing
+					if ($mode === CssMode::LEGACY && $context === 'positioned block to block' && $property === 'word-spacing') {
+						continue;
+					}
+					$data[$mode . ': ' . $context . ': ' . $property] = array_merge([$mode, $html], $values);
+				}
+			}
+		}
+
+		return $data;
+	}
+
+	/**
+	 * inherit on a length that is not inherited takes the length the parent's em came to, not the em read again at
+	 * the element's own size. Legacy does not read inherit on padding at all
+	 *
+	 * @dataProvider modes
+	 *
+	 * @param string $mode
+	 */
+	public function testInheritTakesTheLengthAnEmCameToOnTheParent($mode)
+	{
+		$html = '<div style="font-size: 20pt; padding-left: {A}"><p style="font-size: 10pt; padding-left: {D}">qq qq</p></div>';
+
+		// Where the line starts
+		$inherited = $this->firstLine($mode, strtr($html, ['{A}' => '1em', '{D}' => 'inherit']))[0];
+		$computed = $this->firstLine($mode, strtr($html, ['{A}' => '1em', '{D}' => '20pt']))[0];
+		$dropped = $this->firstLine($mode, strtr($html, ['{A}' => '1em', '{D}' => '0']))[0];
+
+		$this->assertNotEquals($computed, $dropped);
+		$this->assertEquals($mode === CssMode::STANDARD ? $computed : $dropped, $inherited);
+	}
+
+	/**
+	 * The content of a positioned block draws line-height: normal as a paragraph outside one does. Legacy draws it at
+	 * the fixed 1.33 the block's channel handed on
+	 *
+	 * @dataProvider modes
+	 *
+	 * @param string $mode
+	 */
+	public function testThePositionedBlocksContentDrawsANormalLineHeight($mode)
+	{
+		$positioned = $this->lineGap($mode, '<div style="position: absolute; top: 50mm; left: 20mm; width: 100mm"><p>qq qq<br>ww ww</p></div>');
+		$flow = $this->lineGap($mode, '<p>qq qq<br>ww ww</p>');
+		$fixed = $this->lineGap($mode, '<p style="line-height: 1.33">qq qq<br>ww ww</p>');
+
+		$this->assertNotEquals($flow, $fixed, 'normal is not drawn at 1.33 outside a positioned block');
+		$this->assertEquals($mode === CssMode::STANDARD ? $flow : $fixed, $positioned);
+	}
+
+	/**
+	 * A block ends the paragraph an inline element's bidirectional embedding is in. The embedding is opened again for
+	 * the inline element's text after the block, which legacy draws outside it
+	 *
+	 * @dataProvider modes
+	 *
+	 * @param string $mode
+	 */
+	public function testABidiEmbeddingIsOpenedAgainAfterABlock($mode)
+	{
+		$hebrew = html_entity_decode('&#x5d0;&#x5d1;', ENT_QUOTES, 'UTF-8');
+		$mpdf = new TextRecordingMpdf(['mode' => 'utf-8', 'default_font' => 'dejavusans', 'cssMode' => $mode]);
+		$mpdf->WriteHTML('<div><span dir="rtl">' . $hebrew . ' cd<div>qq</div>' . $hebrew . ' ef</span> zz</div>');
+		$mpdf->Close();
+
+		$drawn = array_map('trim', $mpdf->drawnText);
+		$reversed = html_entity_decode('&#x5d1;&#x5d0;', ENT_QUOTES, 'UTF-8');
+		$this->assertContains('cd ' . $reversed, $drawn, 'Before the block');
+		$this->assertContains($mode === CssMode::STANDARD ? 'ef ' . $reversed : $reversed . ' ef', $drawn, 'After the block');
+	}
+
+	/**
+	 * The text before a block opened in an inline element is drawn in its own style, not the inline element's: neither
+	 * italic nor shadowed. The inline element's text before, in and after the block is. Legacy draws that text in the
+	 * shadow of the inline element, and the block and the text after it in neither
+	 *
+	 * @dataProvider modes
+	 *
+	 * @param string $mode
+	 */
+	public function testTheLineBeforeABlockIsDrawnInItsOwnState($mode)
+	{
+		$mpdf = $this->drawDocument('<div>ww <span style="font-style: italic; text-shadow: 1px 1px #f00">xx<div>qq</div>yy</span> zz</div>', ['cssMode' => $mode]);
+		$mpdf->Close();
+
+		$styles = $this->keyedByText($mpdf, $mpdf->drawnFontStyles);
+		$shadowed = array_map(function ($shadow) {
+			return $shadow !== '';
+		}, $this->keyedByText($mpdf, $mpdf->drawnShadows));
+
+		if ($mode === CssMode::STANDARD) {
+			$this->assertSame(['ww' => '', 'xx' => 'I', 'qq' => 'I', 'yy' => 'I', 'zz' => ''], $styles);
+			$this->assertSame(['ww' => false, 'xx' => true, 'qq' => true, 'yy' => true, 'zz' => false], $shadowed);
+		} else {
+			$this->assertSame(['ww' => '', 'xx' => 'I', 'qq' => '', 'yy' => '', 'zz' => ''], $styles);
+			$this->assertSame(['ww' => true, 'xx' => true, 'qq' => false, 'yy' => false, 'zz' => false], $shadowed);
+		}
+	}
+
+	/**
+	 * The text before a block opened in a spaced inline element is drawn at its own letter and word spacing, as it is
+	 * where the inline element holds no block. Legacy draws it at the inline element's
+	 *
+	 * @dataProvider modes
+	 *
+	 * @param string $mode
+	 */
+	public function testTheLineBeforeABlockIsDrawnAtItsOwnSpacing($mode)
+	{
+		$boxes = [];
+		foreach (['<div>' => '</div>', '' => ''] as $open => $close) {
+			$mpdf = $this->drawDocument('<div>ww w <span style="letter-spacing: 3mm; word-spacing: 2mm">xx' . $open . 'qq' . $close . 'yy</span> zz</div>', ['cssMode' => $mode]);
+			$mpdf->Close();
+			$boxes[] = $this->keyedByText($mpdf, $mpdf->drawnBoxes)['ww w'];
+		}
+
+		if ($mode === CssMode::STANDARD) {
+			$this->assertSame($boxes[1], $boxes[0]);
+		} else {
+			$this->assertNotSame($boxes[1], $boxes[0]);
+		}
+	}
+
+	/**
+	 * A table opened in an inline element takes its style, and the inline element's text after the table is drawn in
+	 * it again. Legacy draws the table and the text after it in neither, and the text before the span in its colour
+	 *
+	 * @dataProvider modes
+	 *
+	 * @param string $mode
+	 */
+	public function testTheTextAfterATableInAnInlineElementIsDrawnInItsStyle($mode)
+	{
+		$mpdf = $this->drawDocument('<div>ww <span style="font-style: italic; color: #0f0">xx<table><tr><td>qq</td></tr></table>yy</span> zz</div>', ['cssMode' => $mode]);
+		$mpdf->Close();
+
+		$styles = $this->keyedByText($mpdf, $mpdf->drawnFontStyles);
+		$colours = $this->keyedByText($mpdf, $mpdf->drawnColours);
+		$green = '0.000 1.000 0.000 rg';
+		$black = '0.000 g';
+
+		if ($mode === CssMode::STANDARD) {
+			$this->assertSame(['ww' => '', 'xx' => 'I', 'qq' => 'I', 'yy' => 'I', 'zz' => ''], $styles);
+			$this->assertSame(['ww' => $black, 'xx' => $green, 'qq' => $green, 'yy' => $green, 'zz' => $black], $colours);
+		} else {
+			$this->assertSame(['ww' => '', 'xx' => 'I', 'qq' => '', 'yy' => '', 'zz' => ''], $styles);
+			$this->assertSame(['ww' => $green, 'xx' => $green, 'qq' => $black, 'yy' => $black, 'zz' => $black], $colours);
+		}
+	}
+
+	/**
+	 * How the first line of a document, "qq qq", is drawn: where it starts and how wide it is
+	 *
+	 * @param string $mode
+	 * @param string $html
+	 *
+	 * @return float[]
+	 */
+	private function firstLine($mode, $html)
+	{
+		$mpdf = $this->drawDocument($html, ['cssMode' => $mode]);
+		$mpdf->Close();
+
+		$boxes = $this->keyedByText($mpdf, $mpdf->drawnBoxes);
+		$this->assertArrayHasKey('qq qq', $boxes);
+
+		return [round($boxes['qq qq'][1], 3), round($boxes['qq qq'][2] - $boxes['qq qq'][1], 3)];
+	}
+
+	/**
+	 * @param string $mode
+	 * @param string $html Two lines, "qq qq" and "ww ww"
+	 *
+	 * @return float The distance between the tops of the two lines
+	 */
+	private function lineGap($mode, $html)
+	{
+		$mpdf = $this->drawDocument($html, ['cssMode' => $mode]);
+		$mpdf->Close();
+
+		$tops = $this->keyedByText($mpdf, $mpdf->drawnY);
+
+		return round($tops['ww ww'] - $tops['qq qq'], 3);
+	}
+}
diff --git a/tests/Mpdf/Css/TextSpacingTest.php b/tests/Mpdf/Css/TextSpacingTest.php
new file mode 100644
index 000000000..76fe51ab9
--- /dev/null
+++ b/tests/Mpdf/Css/TextSpacingTest.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace Mpdf\Css;
+
+use Mpdf\Mpdf;
+use Mpdf\SizeConverter;
+use Psr\Log\NullLogger;
+
+class TextSpacingTest extends \Yoast\PHPUnitPolyfills\TestCases\TestCase
+{
+
+	/**
+	 * @var Mpdf
+	 */
+	private $mpdf;
+
+	/**
+	 * @var SizeConverter
+	 */
+	private $sizeConverter;
+
+	/**
+	 * Builds a document at a 10mm font size, so that an em is 10mm
+	 */
+	protected function set_up()
+	{
+		parent::set_up();
+		$this->mpdf = new Mpdf(['mode' => 'c']);
+		$this->mpdf->FontSize = 10;
+		$this->sizeConverter = new SizeConverter(96, 11, $this->mpdf, new NullLogger());
+	}
+
+	/**
+	 * A spacing is the length it comes to at the font size, and normal or none is what stands for none
+	 */
+	public function testLength()
+	{
+		$this->assertSame(10.0, TextSpacing::length($this->sizeConverter, '1em', 10, false));
+		$this->assertSame(2.0, TextSpacing::length($this->sizeConverter, '2mm', 10, 0));
+		$this->assertSame(0.0, TextSpacing::length($this->sizeConverter, '0', 10, false));
+		$this->assertFalse(TextSpacing::length($this->sizeConverter, 'normal', 10, false));
+		$this->assertFalse(TextSpacing::length($this->sizeConverter, '', 10, false));
+		$this->assertSame(0, TextSpacing::length($this->sizeConverter, 'NORMAL', 10, 0));
+	}
+
+	/**
+	 * The text state keeps each spacing as given and as its length at the current font size
+	 */
+	public function testSet()
+	{
+		TextSpacing::set($this->mpdf, $this->sizeConverter, '0.5em', '2mm');
+
+		$this->assertSame('0.5em', $this->mpdf->lSpacingCSS);
+		$this->assertSame('2mm', $this->mpdf->wSpacingCSS);
+		$this->assertSame(5.0, $this->mpdf->fixedlSpacing);
+		$this->assertSame(2.0, $this->mpdf->minwSpacing);
+
+		TextSpacing::set($this->mpdf, $this->sizeConverter, 'normal', '');
+
+		$this->assertFalse($this->mpdf->fixedlSpacing);
+		$this->assertSame(0, $this->mpdf->minwSpacing);
+	}
+}
diff --git a/tests/Mpdf/CssWideKeywordContextTest.php b/tests/Mpdf/CssWideKeywordContextTest.php
index 93ca2b0f0..831444afc 100644
--- a/tests/Mpdf/CssWideKeywordContextTest.php
+++ b/tests/Mpdf/CssWideKeywordContextTest.php
@@ -98,14 +98,6 @@ public function testEachContextDrawsItsSubject($mode)
 		}
 	}
 
-	/**
-	 * @return string[][] Each CSS mode
-	 */
-	public function modes()
-	{
-		return [CssMode::STANDARD => [CssMode::STANDARD], CssMode::LEGACY => [CssMode::LEGACY]];
-	}
-
 	/**
 	 * Every keyword, for each property, in every context, under each mode
 	 *
diff --git a/tests/Mpdf/DrawnStyles.php b/tests/Mpdf/DrawnStyles.php
index b7e1c0503..14e8079a1 100644
--- a/tests/Mpdf/DrawnStyles.php
+++ b/tests/Mpdf/DrawnStyles.php
@@ -167,6 +167,16 @@ private function bothModes(array $rows)
 		return $cases;
 	}
 
+	/**
+	 * Each CSS mode, for a test that expects the same of both
+	 *
+	 * @return array[] Each mode, keyed by its name
+	 */
+	public function modes()
+	{
+		return [CssMode::STANDARD => [CssMode::STANDARD], CssMode::LEGACY => [CssMode::LEGACY]];
+	}
+
 	/**
 	 * 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/InheritanceMatrixTest.php b/tests/Mpdf/InheritanceMatrixTest.php
new file mode 100644
index 000000000..e2ccdad08
--- /dev/null
+++ b/tests/Mpdf/InheritanceMatrixTest.php
@@ -0,0 +1,255 @@
+<?php
+
+namespace Mpdf;
+
+use Yoast\PHPUnitPolyfills\TestCases\TestCase;
+
+/**
+ * The inheritance matrix of #547: each inherited property set on an ancestor, read from what the descendant's text
+ * is drawn with, for each relationship between two elements mPDF hands values on through. Under the standard CSS mode
+ * every descendant takes every value, as in a browser. Under legacy each relationship hands on what mPDF v7 did.
+ */
+class InheritanceMatrixTest extends TestCase
+{
+
+	use DrawnStyles;
+
+	/**
+	 * A declaration of each property in the matrix, which draws the descendant's text apart from its initial state
+	 */
+	const VALUES = [
+		'color' => 'color: #ff0000',
+		'font-size' => 'font-size: 16pt',
+		'font-family' => 'font-family: monospace',
+		'font-weight' => 'font-weight: bold',
+		'font-style' => 'font-style: italic',
+		'letter-spacing' => 'letter-spacing: 1mm',
+		'word-spacing' => 'word-spacing: 5mm',
+		'text-transform' => 'text-transform: uppercase',
+		'text-shadow' => 'text-shadow: 1px 1px #0000ff',
+		'text-align' => 'text-align: right',
+		'line-height' => 'line-height: 3',
+	];
+
+	/**
+	 * Each relationship: the document with {A} for the ancestor's declaration, and the same document with {D} where the
+	 * descendant sets it itself. The descendant's text is two lines, "qq qq" and "ww ww". A property that lays out
+	 * lines is set, as {B}, on what the descendant's lines are laid out in where that is not the descendant: the block
+	 * around an inline element, and the cell around a block, which mPDF lays out as the cell's own content
+	 */
+	const RELATIONSHIPS = [
+		'block to block' => [
+			'<div style="{A}"><p>qq qq<br>ww ww</p></div>',
+			'<div><p style="{D}">qq qq<br>ww ww</p></div>',
+		],
+		'block to inline' => [
+			'<div style="{A}">zz <span>qq qq<br>ww ww</span></div>',
+			'<div style="{B}">zz <span style="{D}">qq qq<br>ww ww</span></div>',
+		],
+		'inline to inline' => [
+			'<div>zz <span style="{A}">yy <span>qq qq<br>ww ww</span></span></div>',
+			'<div>zz <span>yy <span style="{D}">qq qq<br>ww ww</span></span></div>',
+		],
+		'inline to block' => [
+			'<span style="{A}">zz<div>qq qq<br>ww ww</div></span>',
+			'<span>zz<div style="{D}">qq qq<br>ww ww</div></span>',
+		],
+		'table to cell' => [
+			'<table style="{A}"><tr><td style="width: 100mm">qq qq<br>ww ww</td></tr></table>',
+			'<table><tr><td style="width: 100mm; {D}">qq qq<br>ww ww</td></tr></table>',
+		],
+		'tbody to cell' => [
+			'<table><tbody style="{A}"><tr><td style="width: 100mm">qq qq<br>ww ww</td></tr></tbody></table>',
+			'<table><tbody><tr><td style="width: 100mm; {D}">qq qq<br>ww ww</td></tr></tbody></table>',
+		],
+		'thead to th' => [
+			'<table><thead style="{A}"><tr><th style="width: 100mm">qq qq<br>ww ww</th></tr></thead><tbody><tr><td>zz</td></tr></tbody></table>',
+			'<table><thead><tr><th style="width: 100mm; {D}">qq qq<br>ww ww</th></tr></thead><tbody><tr><td>zz</td></tr></tbody></table>',
+		],
+		'tr to cell' => [
+			'<table><tr style="{A}"><td style="width: 100mm">qq qq<br>ww ww</td></tr></table>',
+			'<table><tr><td style="width: 100mm; {D}">qq qq<br>ww ww</td></tr></table>',
+		],
+		'cell to block' => [
+			'<table><tr><td style="width: 100mm; {A}"><div>qq qq<br>ww ww</div></td></tr></table>',
+			'<table><tr><td style="width: 100mm; {B}"><div style="{D}">qq qq<br>ww ww</div></td></tr></table>',
+		],
+		'cell to inline' => [
+			'<table><tr><td style="width: 100mm; {A}">zz <span>qq qq<br>ww ww</span></td></tr></table>',
+			'<table><tr><td style="width: 100mm; {B}">zz <span style="{D}">qq qq<br>ww ww</span></td></tr></table>',
+		],
+		'outer cell to nested table cell' => [
+			'<table><tr><td style="{A}"><table><tr><td style="width: 100mm">qq qq<br>ww ww</td></tr></table></td></tr></table>',
+			'<table><tr><td><table><tr><td style="width: 100mm; {D}">qq qq<br>ww ww</td></tr></table></td></tr></table>',
+		],
+		'block to table cell' => [
+			'<div style="{A}"><table><tr><td style="width: 100mm">qq qq<br>ww ww</td></tr></table></div>',
+			'<div><table><tr><td style="width: 100mm; {D}">qq qq<br>ww ww</td></tr></table></div>',
+		],
+		'list to item' => [
+			'<ul style="{A}"><li>qq qq<br>ww ww</li></ul>',
+			'<ul><li style="{D}">qq qq<br>ww ww</li></ul>',
+		],
+		'item to block' => [
+			'<ul><li style="{A}"><div>qq qq<br>ww ww</div></li></ul>',
+			'<ul><li><div style="{D}">qq qq<br>ww ww</div></li></ul>',
+		],
+		'positioned block to block' => [
+			'<div style="position: absolute; top: 50mm; left: 20mm; width: 120mm; {A}"><p>qq qq<br>ww ww</p></div>',
+			'<div style="position: absolute; top: 50mm; left: 20mm; width: 120mm"><p style="{D}">qq qq<br>ww ww</p></div>',
+		],
+		'body to block' => [
+			'<body style="{A}"><p>qq qq<br>ww ww</p></body>',
+			'<body><p style="{D}">qq qq<br>ww ww</p></body>',
+		],
+	];
+
+	/**
+	 * The properties laid out by the block, which an inline element cannot set itself
+	 */
+	const BLOCK_PROPERTIES = ['text-align', 'line-height'];
+
+	/**
+	 * What legacy hands on, as #547 measured it at d660a410: the properties each relationship drops
+	 */
+	const LEGACY_DROPPED = [
+		'block to block' => ['text-shadow'],
+		'block to inline' => [],
+		'inline to inline' => [],
+		'inline to block' => [
+			'color', 'font-size', 'font-family', 'font-weight', 'font-style', 'letter-spacing', 'word-spacing',
+			'text-transform', 'text-shadow', 'text-align', 'line-height',
+		],
+		'table to cell' => ['text-transform', 'text-shadow'],
+		'tbody to cell' => [
+			'color', 'font-size', 'font-family', 'font-weight', 'font-style', 'letter-spacing', 'word-spacing',
+			'text-transform', 'text-shadow', 'text-align', 'line-height',
+		],
+		'thead to th' => [
+			'color', 'font-size', 'font-family', 'font-style', 'letter-spacing', 'word-spacing', 'text-transform',
+			'text-shadow', 'text-align', 'line-height',
+		],
+		'tr to cell' => [
+			'color', 'font-size', 'font-family', 'font-weight', 'font-style', 'letter-spacing', 'word-spacing',
+			'text-transform', 'text-shadow', 'text-align', 'line-height',
+		],
+		'cell to block' => [],
+		'cell to inline' => [],
+		'outer cell to nested table cell' => [
+			'font-size', 'font-family', 'font-weight', 'font-style', 'text-transform', 'line-height',
+		],
+		'block to table cell' => [
+			'color', 'font-size', 'font-family', 'font-weight', 'font-style', 'letter-spacing', 'word-spacing',
+			'text-transform', 'text-shadow', 'text-align', 'line-height',
+		],
+		'list to item' => ['text-shadow'],
+		'item to block' => ['text-shadow'],
+		'positioned block to block' => ['word-spacing', 'text-shadow'],
+		'body to block' => ['text-shadow'],
+	];
+
+	/**
+	 * The descendant's text is drawn with the value the ancestor sets as it is with the value set on the descendant,
+	 * except, under legacy, where the relationship drops it
+	 *
+	 * @dataProvider cells
+	 *
+	 * @param string $mode
+	 * @param string $relationship
+	 * @param string $property
+	 */
+	public function testTheDescendantIsDrawnWithTheAncestorsValue($mode, $relationship, $property)
+	{
+		list($ancestorHtml, $ownHtml) = self::RELATIONSHIPS[$relationship];
+		$value = self::VALUES[$property];
+		$onBlock = in_array($property, self::BLOCK_PROPERTIES, true);
+
+		$inherited = $this->drawn($mode, strtr($ancestorHtml, ['{A}' => $value]), $property);
+		$none = $this->drawn($mode, strtr($ancestorHtml, ['{A}' => '']), $property);
+		// Set on the block the descendant's lines are laid out in, where that is not the descendant
+		$onBlock = $onBlock && strpos($ownHtml, '{B}') !== false;
+		$own = $this->drawn($mode, strtr($ownHtml, ['{D}' => $onBlock ? '' : $value, '{B}' => $onBlock ? $value : '']), $property);
+
+		// A th is bold whatever its row group sets
+		if ($relationship !== 'thead to th' || $property !== 'font-weight') {
+			$this->assertNotEquals($none, $own, 'The value does not change how the descendant is drawn');
+		}
+
+		if ($mode === CssMode::LEGACY && in_array($property, self::LEGACY_DROPPED[$relationship], true)) {
+			$this->assertNotEquals($own, $inherited);
+		} else {
+			$this->assertEquals($own, $inherited);
+		}
+	}
+
+	/**
+	 * Every relationship and property, under both modes. An inline element's own text is not laid out by its
+	 * alignment or line height, so those are left out of inline to inline
+	 *
+	 * @return array[]
+	 */
+	public function cells()
+	{
+		$data = [];
+		foreach ([CssMode::STANDARD, CssMode::LEGACY] as $mode) {
+			foreach (array_keys(self::RELATIONSHIPS) as $relationship) {
+				foreach (array_keys(self::VALUES) as $property) {
+					if ($relationship === 'inline to inline' && in_array($property, self::BLOCK_PROPERTIES, true)) {
+						continue;
+					}
+					$data[$mode . ': ' . $relationship . ': ' . $property] = [$mode, $relationship, $property];
+				}
+			}
+		}
+
+		return $data;
+	}
+
+	/**
+	 * What of the descendant's text a property changes: the first line's colour, font, size, style, shadow, drawn text
+	 * or width, the left edge of the second line, or the distance between the two lines
+	 *
+	 * @param string $mode
+	 * @param string $html
+	 * @param string $property
+	 *
+	 * @return mixed
+	 */
+	private function drawn($mode, $html, $property)
+	{
+		// In core-font mode a nested table's cells lose a font family that is the table's default (#648)
+		$mpdf = $this->drawDocument($html, ['mode' => 'utf-8', 'cssMode' => $mode]);
+		$mpdf->Close();
+
+		// Lowercased, as text-transform draws the lines in capitals
+		$lines = array_change_key_case($this->keyedByText($mpdf, array_keys($mpdf->drawnText)));
+		$this->assertArrayHasKey('qq qq', $lines, 'The first line is drawn');
+		$this->assertArrayHasKey('ww ww', $lines, 'The second line is drawn');
+		$first = $lines['qq qq'];
+		$second = $lines['ww ww'];
+
+		switch ($property) {
+			case 'color':
+				return $mpdf->drawnColours[$first];
+			case 'font-size':
+				return round($mpdf->drawnFontSize[$first], 3);
+			case 'font-family':
+				return $mpdf->drawnFontFamily[$first];
+			case 'font-weight':
+				return strpos($mpdf->drawnFontStyles[$first], 'B') !== false;
+			case 'font-style':
+				return strpos($mpdf->drawnFontStyles[$first], 'I') !== false;
+			case 'letter-spacing':
+			case 'word-spacing':
+				return round($mpdf->drawnBoxes[$first][2] - $mpdf->drawnBoxes[$first][1], 3);
+			case 'text-transform':
+				return $mpdf->drawnText[$first];
+			case 'text-shadow':
+				return $mpdf->drawnShadows[$first];
+			case 'text-align':
+				return round($mpdf->drawnBoxes[$second][1], 3);
+			default:
+				return round($mpdf->drawnY[$second] - $mpdf->drawnY[$first], 3);
+		}
+	}
+}
diff --git a/tests/Mpdf/OpenElementStackTest.php b/tests/Mpdf/OpenElementStackTest.php
index a0742fe8a..82fe3afbc 100644
--- a/tests/Mpdf/OpenElementStackTest.php
+++ b/tests/Mpdf/OpenElementStackTest.php
@@ -2,6 +2,8 @@
 
 namespace Mpdf;
 
+use Mpdf\Css\TextVars;
+
 use Yoast\PHPUnitPolyfills\TestCases\TestCase;
 
 /**
@@ -180,30 +182,76 @@ public function testAFrameDescribesItsElement()
 	}
 
 	/**
-	 * In the standard CSS mode a frame carries the properties merged for its element, with the CSS-wide keywords
-	 * resolved, and the document's frame carries those of body. A tbody the HTML leaves out is never styled. The
-	 * legacy mode keeps none
+	 * In the standard CSS mode a frame carries its element's computed values, with the CSS-wide keywords resolved, and
+	 * the document's frame carries those of body. A font size and an em length are absolute, so that a descendant
+	 * taking them, by inheriting them or through inherit, gets the length. A tbody the HTML leaves out carries what it
+	 * inherits from its table. The legacy mode keeps none
 	 */
-	public function testAFrameCarriesThePropertiesMergedForItsElement()
+	public function testAFrameCarriesItsElementsComputedValues()
 	{
-		$html = '<style>body { background-color: #ff0; } div { padding: 2mm; } p { padding: inherit; }</style>'
+		$html = '<style>body { background-color: #ff0; } div { font-size: 20pt; padding: 1em; letter-spacing: 0.1em; }'
+			. ' p { font-size: 50%; padding: inherit; } table { color: #00f; padding: 3mm; }</style>'
 			. '<div><p>text</p><table><tr><td>cell</td></tr></table></div>';
 
 		$mpdf = $this->write($html);
 		$frames = $this->framesAt($mpdf, 'text');
 		$this->assertSame('#ff0', $frames[0]['computed']['BACKGROUND-COLOR']);
-		$this->assertSame('2mm', $frames[1]['computed']['PADDING-LEFT']);
-		$this->assertSame('2mm', $frames[2]['computed']['PADDING-LEFT']);
-		$this->assertNull($this->frameAt($mpdf, 'cell', 3)['computed']);
-		$this->assertSame('TBODY', $this->frameAt($mpdf, 'cell', 3)['tag']);
+		$this->assertSame('20pt', $frames[1]['computed']['FONT-SIZE']);
+		$this->assertStringEndsWith('mm', $frames[1]['computed']['PADDING-LEFT']);
+		$this->assertEqualsWithDelta(20 / Mpdf::SCALE, (float) $frames[1]['computed']['PADDING-LEFT'], 1e-9);
+		$this->assertStringEndsWith('pt', $frames[2]['computed']['FONT-SIZE']);
+		$this->assertEqualsWithDelta(10, (float) $frames[2]['computed']['FONT-SIZE'], 1e-9);
+		$this->assertSame($frames[1]['computed']['PADDING-LEFT'], $frames[2]['computed']['PADDING-LEFT']);
+		$this->assertSame($frames[1]['computed']['LETTER-SPACING'], $frames[2]['computed']['LETTER-SPACING']);
+
+		$tbody = $this->frameAt($mpdf, 'cell', 3);
+		$this->assertSame('TBODY', $tbody['tag']);
+		$this->assertSame('#00f', $tbody['computed']['COLOR']);
+		$this->assertSame('20pt', $tbody['computed']['FONT-SIZE']);
+		$this->assertArrayNotHasKey('PADDING-LEFT', $tbody['computed']);
 
 		$mpdf = $this->mpdfRecording(['cssMode' => CssMode::LEGACY]);
 		$mpdf->WriteHTML($html, HTMLParserMode::DEFAULT_MODE, true, false);
-		foreach ($this->framesAt($mpdf, 'text') as $frame) {
+		foreach (array_merge($this->framesAt($mpdf, 'text'), $this->framesAt($mpdf, 'cell')) as $frame) {
 			$this->assertNull($frame['computed']);
 		}
 	}
 
+	/**
+	 * In the standard CSS mode a frame carries the link and the text decorations its element's content is drawn in:
+	 * those of the element itself, and none for a positioned block, which is out of the flow. The legacy mode keeps
+	 * none
+	 */
+	public function testAFrameCarriesTheLinkAndTheDecorationsOfItsContent()
+	{
+		$html = '<body style="text-decoration: underline"><div><a href="https://example.com/">link<span>text</span></a>'
+			. '</div><a href="https://example.com/"><div style="position: absolute; top: 50mm; left: 20mm; width: 50mm">'
+			. '<p>positioned</p></div></a></body>';
+
+		$mpdf = $this->mpdfRecording();
+		$mpdf->WriteHTML($html);
+		$frames = $this->framesAt($mpdf, 'text');
+		$this->assertSame(TextVars::FD_UNDERLINE, $frames[0]['decorations']['textvar']);
+		$this->assertSame('', $frames[1]['href']);
+		$this->assertSame(TextVars::FD_UNDERLINE, $frames[1]['decorations']['textvar']);
+		$this->assertSame('https://example.com/', $frames[2]['href']);
+		$this->assertSame('https://example.com/', $frames[3]['href']);
+		$this->assertSame(TextVars::FD_UNDERLINE, $frames[3]['decorations']['textvar'] & TextVars::FD_UNDERLINE);
+
+		$positioned = $this->framesAt($mpdf, 'positioned');
+		$this->assertSame('DIV', $positioned[2]['tag']);
+		$this->assertSame('', $positioned[2]['href']);
+		$this->assertSame(0, $positioned[2]['decorations']['textvar']);
+		$this->assertSame('', $positioned[3]['href']);
+
+		$mpdf = $this->mpdfRecording(['cssMode' => CssMode::LEGACY]);
+		$mpdf->WriteHTML($html);
+		foreach (array_merge($this->framesAt($mpdf, 'text'), $this->framesAt($mpdf, 'positioned')) as $frame) {
+			$this->assertSame('', $frame['href']);
+			$this->assertSame([], $frame['decorations']);
+		}
+	}
+
 	/**
 	 * Tables nested in cells keep their own rows and cells, and the outer cell is back on top after them
 	 */
diff --git a/tests/Mpdf/ParentRelativeFontValuesTest.php b/tests/Mpdf/ParentRelativeFontValuesTest.php
index 19ee01d9c..7c7a174d8 100644
--- a/tests/Mpdf/ParentRelativeFontValuesTest.php
+++ b/tests/Mpdf/ParentRelativeFontValuesTest.php
@@ -29,13 +29,13 @@ public function testNestedValues($mode, $context, $html, array $expected)
 	}
 
 	/**
-	 * A text circle reads larger and smaller against the document's size, as a form field does, and in the legacy mode
+	 * A text circle reads larger and smaller against its parent's size, as a form field does, and in the legacy mode
 	 * ignores them, keeping the paragraph's size rather than being drawn at 0pt
 	 */
-	public function testATextCircleReadsLargerAgainstTheDocumentSize()
+	public function testATextCircleReadsLargerAgainstItsParentsSize()
 	{
 		$html = '<p style="font-size: 14pt"><textcircle r="30mm" top-text="Circular" style="font-size: larger" /></p>';
-		foreach ([CssMode::STANDARD => '13.200', CssMode::LEGACY => '14.000'] as $mode => $size) {
+		foreach ([CssMode::STANDARD => '16.800', CssMode::LEGACY => '14.000'] as $mode => $size) {
 			$mpdf = new Mpdf(['mode' => 'c', 'cssMode' => $mode]);
 			$mpdf->SetCompression(false);
 			$mpdf->WriteHTML($html);
@@ -194,8 +194,8 @@ public function providerStartingValues()
 			],
 			'larger and smaller form fields' => [
 				'<p style="font-size: 14pt"><input type="text" style="font-size: larger" value="aa" /> <select style="font-size: smaller"><option>bb</option></select> <textarea style="font-size: larger">cc</textarea></p>',
-				// From the document's 11pt, as a field's other sizes are
-				['aa' => ['', 13.2], 'bb' => ['', 9.17], 'cc' => ['', 13.2]],
+				// From the paragraph's 14pt, as each font size is computed from the parent's
+				['aa' => ['', 16.8], 'bb' => ['', 11.67], 'cc' => ['', 16.8]],
 				// Ignored rather than drawn at 0pt, so each field keeps the paragraph's size, as an ignored size does elsewhere
 				['aa' => ['', 14.0], 'bb' => ['', 14.0], 'cc' => ['', 14.0]],
 			],
diff --git a/tests/Mpdf/TableInheritsFromBlockTest.php b/tests/Mpdf/TableInheritsFromBlockTest.php
index 007ca5ad6..7d6b7e03f 100644
--- a/tests/Mpdf/TableInheritsFromBlockTest.php
+++ b/tests/Mpdf/TableInheritsFromBlockTest.php
@@ -100,9 +100,8 @@ public function blockPropertiesInContexts()
 
 	/**
 	 * A table in a block that sets line-height: normal, or sets none, is laid out in the standard mode as one whose
-	 * cells set normal, which is drawn as a paragraph's is, from normalLineheight. A positioned block that sets none
-	 * hands its content normal as that number, as it does its paragraphs. In the legacy mode the table keeps its own
-	 * line-height of 1.2
+	 * cells set normal, which is drawn as a paragraph's is, from normalLineheight. In the legacy mode the table
+	 * keeps its own line-height of 1.2
 	 */
 	public function testALineHeightOfNormalIsDrawnAsAParagraphsInTheStandardMode()
 	{
@@ -111,9 +110,6 @@ public function testALineHeightOfNormalIsDrawnAsAParagraphsInTheStandardMode()
 			foreach (['block', 'list item', 'positioned block', 'cell'] as $context) {
 				$expected = $this->drawnBoxes($mode, $context, '', $lineHeight);
 				$this->assertEquals($expected, $this->drawnBoxes($mode, $context, 'line-height: normal', ''), $mode . ': ' . $context);
-				if ($mode === CssMode::STANDARD && $context === 'positioned block') {
-					$expected = $this->drawnBoxes($mode, $context, '', 'line-height: 1.33');
-				}
 				$this->assertEquals($expected, $this->drawnBoxes($mode, $context, '', ''), $mode . ': ' . $context . ', setting none');
 			}
 		}
diff --git a/tests/Mpdf/Tag/TFootTest.php b/tests/Mpdf/Tag/TFootTest.php
index df8110092..f8c8a722c 100644
--- a/tests/Mpdf/Tag/TFootTest.php
+++ b/tests/Mpdf/Tag/TFootTest.php
@@ -24,8 +24,12 @@ public function testOpen_TFoot()
 		$this->assertEquals('TFOOT', $this->mpdf->lastoptionaltag);
 	}
 
+	/**
+	 * Under the legacy cascade the row group's font weight is kept for its cells, as well as its vertical-align
+	 */
 	public function testOpen_TFoot_WithInlineStyle()
 	{
+		$this->mpdf->cssMode = \Mpdf\CssMode::LEGACY;
 		$attr = ['STYLE' => 'font-weight: bold; vertical-align: top;'];
 		$ahtml = [];
 		$ihtml = 0;
@@ -38,6 +42,21 @@ public function testOpen_TFoot_WithInlineStyle()
 		$this->assertEquals('top', $this->mpdf->tfoot_valign_default);
 	}
 
+	/**
+	 * Under the standard cascade the cells inherit the row group's font weight from its frame, so none is kept for them
+	 */
+	public function testOpen_TFoot_KeepsNoFontWeightUnderTheStandardCascade()
+	{
+		$attr = ['STYLE' => 'font-weight: bold; vertical-align: top;'];
+		$ahtml = [];
+		$ihtml = 0;
+
+		$this->tag->open($attr, $ahtml, $ihtml);
+
+		$this->assertEmpty($this->mpdf->tfoot_font_weight);
+		$this->assertEquals('top', $this->mpdf->tfoot_valign_default);
+	}
+
 	public function testClose_TFoot()
 	{
 		$ahtml = [];
diff --git a/tests/Mpdf/Tag/THeadTest.php b/tests/Mpdf/Tag/THeadTest.php
index fde4174fe..68dba1c86 100644
--- a/tests/Mpdf/Tag/THeadTest.php
+++ b/tests/Mpdf/Tag/THeadTest.php
@@ -24,8 +24,12 @@ public function testOpen_THead()
 		$this->assertEquals('THEAD', $this->mpdf->lastoptionaltag);
 	}
 
+	/**
+	 * Under the legacy cascade the row group's font weight is kept for its cells, as well as its vertical-align
+	 */
 	public function testOpen_THead_WithInlineStyle()
 	{
+		$this->mpdf->cssMode = \Mpdf\CssMode::LEGACY;
 		$attr = ['STYLE' => 'font-weight: bold; vertical-align: bottom;'];
 		$ahtml = [];
 		$ihtml = 0;
@@ -38,6 +42,21 @@ public function testOpen_THead_WithInlineStyle()
 		$this->assertEquals('bottom', $this->mpdf->thead_valign_default);
 	}
 
+	/**
+	 * Under the standard cascade the cells inherit the row group's font weight from its frame, so none is kept for them
+	 */
+	public function testOpen_THead_KeepsNoFontWeightUnderTheStandardCascade()
+	{
+		$attr = ['STYLE' => 'font-weight: bold; vertical-align: bottom;'];
+		$ahtml = [];
+		$ihtml = 0;
+
+		$this->tag->open($attr, $ahtml, $ihtml);
+
+		$this->assertEmpty($this->mpdf->thead_font_weight);
+		$this->assertEquals('bottom', $this->mpdf->thead_valign_default);
+	}
+
 	public function testClose_THead()
 	{
 		$ahtml = [];
diff --git a/tests/Mpdf/Tag/TableTest.php b/tests/Mpdf/Tag/TableTest.php
index 5071de4bd..9663e6fb1 100644
--- a/tests/Mpdf/Tag/TableTest.php
+++ b/tests/Mpdf/Tag/TableTest.php
@@ -3,6 +3,7 @@
 namespace Mpdf\Tag;
 
 use Mpdf\Css\Border;
+use Mpdf\CssMode;
 use Mpdf\Mpdf;
 
 class TableTest extends BaseTagTestCase
@@ -67,6 +68,9 @@ public function testOpenNestedTable()
 		$this->assertEquals([0, 0, 1], $table['nestedpos']);
 	}
 
+	/**
+	 * Under the legacy CSS mode a table hands its cells its text properties through base_table_properties
+	 */
 	public function testCssProperties()
 	{
 		$attr = [
@@ -75,19 +79,38 @@ public function testCssProperties()
 		$ahtml = [];
 		$ihtml = 0;
 
+		$this->mpdf->cssMode = CssMode::LEGACY;
 		$this->tag->open($attr, $ahtml, $ihtml);
 		$table = $this->mpdf->table[$this->mpdf->tableLevel][1];
 
 		$this->assertEquals('rtl', $table['direction']);
 		$this->assertEquals('#ff0000', $table['bgcolor'][-1]);
 		$this->assertEquals(Border::ALL, $table['border']);
-		$this->assertSame('700', $this->mpdf->base_table_properties['FONT-WEIGHT']); // the computed weight
+		$this->assertEqualsIgnoringCase('BOLD', $this->mpdf->base_table_properties['FONT-WEIGHT']);
 		$this->assertEqualsIgnoringCase('ITALIC', $this->mpdf->base_table_properties['FONT-STYLE']);
 		$this->assertEquals('blue', $this->mpdf->base_table_properties['COLOR']);
 		$this->assertEquals('2px', $this->mpdf->base_table_properties['LETTER-SPACING']);
 		$this->assertEquals('5px', $this->mpdf->base_table_properties['WORD-SPACING']);
 	}
 
+	/**
+	 * Under the standard CSS mode a table's cells inherit from its frame, and base_table_properties keeps only the
+	 * font and size a nested table's end puts back
+	 */
+	public function testStandardCssPropertiesAreNotHandedOnThroughBaseProperties()
+	{
+		$attr = ['STYLE' => 'direction: rtl; font-family: serif; font-size: 14pt; font-weight: bold; color: blue;'];
+		$ahtml = [];
+		$ihtml = 0;
+
+		$this->tag->open($attr, $ahtml, $ihtml);
+		$table = $this->mpdf->table[$this->mpdf->tableLevel][1];
+
+		$this->assertEquals('rtl', $table['direction']);
+		$this->assertSame(['FONT-FAMILY', 'FONT-SIZE'], array_keys($this->mpdf->base_table_properties));
+		$this->assertEqualsWithDelta(14 / Mpdf::SCALE, (float) $this->mpdf->base_table_properties['FONT-SIZE'], 1e-9);
+	}
+
 	public function testAttributes()
 	{
 		$attr = [
diff --git a/tests/Mpdf/UniversalSelectorTest.php b/tests/Mpdf/UniversalSelectorTest.php
index 9cae898bb..3d7c6dab7 100644
--- a/tests/Mpdf/UniversalSelectorTest.php
+++ b/tests/Mpdf/UniversalSelectorTest.php
@@ -338,8 +338,9 @@ public function testAResetReachesTheDefaultMarginsAndPadding()
 		$this->assertSame($inline->drawnText, $universal->drawnText);
 		$this->assertEquals($inline->drawnBoxes, $universal->drawnBoxes);
 		$this->assertEquals($inline->drawnY, $universal->drawnY);
-		$this->assertEquals($plain->drawnBoxes, $legacy->drawnBoxes);
-		$this->assertEquals($plain->drawnY, $legacy->drawnY);
+		// The standard mode computes the cell's lengths in another order, which can differ in the last bits
+		$this->assertEqualsWithDelta($plain->drawnBoxes, $legacy->drawnBoxes, 1e-9);
+		$this->assertEqualsWithDelta($plain->drawnY, $legacy->drawnY, 1e-9);
 	}
 
 	/**
diff --git a/tests/Snapshots/BarcodeSnapshotTest.php b/tests/Snapshots/BarcodeSnapshotTest.php
index caa6d2824..6a15d613e 100644
--- a/tests/Snapshots/BarcodeSnapshotTest.php
+++ b/tests/Snapshots/BarcodeSnapshotTest.php
@@ -442,7 +442,7 @@ public function generatePdf()
 
 		</div>
 
-		<div style="position:fixed; right: 50mm; top: 60mm; border: 0.2mm solid #000000; text-align: center; padding: 0.5mm; padding-top: 2mm;">
+		<div style="position:fixed; line-height: 1.33; right: 50mm; top: 60mm; border: 0.2mm solid #000000; text-align: center; padding: 0.5mm; padding-top: 2mm;">
 			<barcode code="00034698735346987355" type="EAN128C" /><br />
 			<div style="font-family: ocrb;">(00) 0346987 35346987 355</div>
 		</div>
diff --git a/tests/Snapshots/ComputedValuesBrochureLegacySnapshotTest.php b/tests/Snapshots/ComputedValuesBrochureLegacySnapshotTest.php
new file mode 100644
index 000000000..7d431f62c
--- /dev/null
+++ b/tests/Snapshots/ComputedValuesBrochureLegacySnapshotTest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * The brochure under the legacy cascade
+ *
+ * @group snapshot
+ */
+class ComputedValuesBrochureLegacySnapshotTest extends ComputedValuesBrochureSnapshot
+{
+
+	/**
+	 * @return string
+	 */
+	protected function cascade()
+	{
+		return \Mpdf\CssMode::LEGACY;
+	}
+
+}
diff --git a/tests/Snapshots/ComputedValuesBrochureSnapshot.php b/tests/Snapshots/ComputedValuesBrochureSnapshot.php
new file mode 100644
index 000000000..7c0b3bcff
--- /dev/null
+++ b/tests/Snapshots/ComputedValuesBrochureSnapshot.php
@@ -0,0 +1,102 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * A product brochure set the way a design system writes it, in em: a lead paragraph with em letter spacing and
+ * smaller runs in it, cards with em padding and a note that takes its card's padding through inherit, a price table
+ * whose row group and rows scale their text, a positioned offer badge, a Hebrew testimonial whose span wraps a block,
+ * and a highlighted run that a block interrupts. Written under each value of cssMode, with captions saying what each
+ * draws.
+ *
+ * @group snapshot
+ */
+abstract class ComputedValuesBrochureSnapshot extends Snapshot
+{
+
+	/**
+	 * @return string legacy or standard
+	 */
+	abstract protected function cascade();
+
+	/**
+	 * The fixture's name
+	 *
+	 * @return string
+	 */
+	public function getId()
+	{
+		return 'computed-values-brochure-' . $this->cascade();
+	}
+
+	/**
+	 * The brochure, each part under a caption saying what the standard and the legacy cascade draw
+	 */
+	public function generatePdf()
+	{
+		ob_start();
+		?>
+		<style>
+			body { font-family: dejavusans; font-size: 9pt; color: #2d3436; }
+			h1 { font-size: 2em; margin: 0 0 1mm 0; color: #0a3d62; letter-spacing: 0.05em; }
+			h2 { font-size: 1.3em; margin: 5mm 0 1mm 0; color: #0a3d62; }
+			p.caption { font-size: 7.5pt; color: #6c757d; margin: 0 0 1.5mm 0; letter-spacing: 0; word-spacing: 0; }
+
+			.lead { font-size: 1.4em; letter-spacing: 0.08em; word-spacing: 0.3em; color: #0a3d62; }
+			.lead small { font-size: 60%; color: #636e72; }
+
+			.card { font-size: 1.2em; padding: 0.8em; margin: 0 0 2mm 0; border: 0.3mm solid #82ccdd; background-color: #f1f9fc; }
+			.card .note { font-size: 0.75em; padding: inherit; border: 0.2mm dashed #82ccdd; }
+
+			table.prices { border-collapse: collapse; font-size: 1.1em; }
+			table.prices td, table.prices th { border: 0.2mm solid #b2bec3; padding: 1mm 2mm; }
+			table.prices thead { font-size: 120%; color: #0a3d62; }
+			table.prices tr.small { font-size: 80%; }
+
+			.badge { position: absolute; top: 240mm; left: 140mm; width: 45mm; background-color: #e55039; color: #ffffff; text-align: center; padding: 2mm; }
+			.highlight { font-style: italic; text-shadow: 0.3mm 0.3mm #f6b93b; }
+		</style>
+
+		<div class="badge"><p>Launch offer<br>20% off<br>until June</p></div>
+
+		<h1>The Harbour chair</h1>
+		<p class="caption">Written with cssMode set to <?php echo $this->cascade(); ?>.</p>
+		<p class="caption">The red badge, at the foot of the page, is a positioned block with line-height: normal. Standard: its three lines are as far apart as lines of the same size in the flow. Legacy: they are set at a fixed 1.33.</p>
+
+		<p class="caption">The lead paragraph sets letter-spacing: 0.08em and word-spacing: 0.3em at 12.6pt, and the small run in it is 60% of that. Standard: the small run is spaced as widely as the paragraph. Legacy: its spacing is read again at its own size, and is narrower.</p>
+		<p class="lead">Hand-built in oak, finished in linseed oil <small>and guaranteed for ten years</small></p>
+
+		<h2>Why it lasts</h2>
+		<p class="caption">Each card has padding: 0.8em at 10.8pt; the note in it is 0.75em and sets padding: inherit. Standard: the note's text is indented as far as the card's. Legacy: the note has no padding of its own.</p>
+		<div class="card">Solid oak frame, jointed without screws.
+			<div class="note">Joints are pegged, so the frame can be tightened after years of use.</div>
+		</div>
+		<div class="card">Seat woven from paper cord.
+			<div class="note">The cord is replaceable, and a kit comes with every chair.</div>
+		</div>
+
+		<h2>Prices</h2>
+		<p class="caption">The table is 1.1em of the body's 9pt, its header row group 120% of that, and the small row 80%. Standard: the header is 11.9pt and the small row 7.9pt. Legacy: the header and the small row are 9.9pt, as a row group and a row hand their cells nothing.</p>
+		<table class="prices">
+			<thead><tr><th>Finish</th><th>Price</th></tr></thead>
+			<tbody>
+				<tr><td>Natural oak</td><td>&#x20ac;480</td></tr>
+				<tr><td>Smoked oak</td><td>&#x20ac;540</td></tr>
+				<tr class="small"><td>Delivery in the EU</td><td>&#x20ac;35</td></tr>
+			</tbody>
+		</table>
+
+		<h2>What customers say</h2>
+		<p class="caption">A right-to-left span wraps the testimonial and a block that credits it. Standard: after the block, as before it, the Hebrew word is to the right of the brand name. Legacy: after the block it is to the left.</p>
+		<div><span dir="rtl">&#x5e0;&#x5d5;&#x5d7; Harbour<div style="font-size: 0.8em; color: #636e72">from a customer in Haifa</div>&#x5de;&#x5d5;&#x5de;&#x5dc;&#x5e5; Harbour</span></div>
+
+		<p class="caption">A highlighted run, italic with a gold shadow, is interrupted by a block. Standard: the words before the run are upright and unshadowed. Legacy: they take the run's shadow, and the block and the words after it lose the highlight.</p>
+		<div>Order before June and <span class="highlight">the delivery is free<div>for every chair in the range</div>anywhere in the EU</span>.</div>
+		<?php
+		$html = ob_get_clean();
+
+		$this->mpdf = $this->createMpdf(['cssMode' => $this->cascade()]);
+		$this->mpdf->WriteHTML($html);
+	}
+
+}
diff --git a/tests/Snapshots/ComputedValuesBrochureStandardSnapshotTest.php b/tests/Snapshots/ComputedValuesBrochureStandardSnapshotTest.php
new file mode 100644
index 000000000..0d887890c
--- /dev/null
+++ b/tests/Snapshots/ComputedValuesBrochureStandardSnapshotTest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * The brochure under the standard cascade
+ *
+ * @group snapshot
+ */
+class ComputedValuesBrochureStandardSnapshotTest extends ComputedValuesBrochureSnapshot
+{
+
+	/**
+	 * @return string
+	 */
+	protected function cascade()
+	{
+		return \Mpdf\CssMode::STANDARD;
+	}
+
+}
diff --git a/tests/Snapshots/ComputedValuesSnapshotTest.php b/tests/Snapshots/ComputedValuesSnapshotTest.php
new file mode 100644
index 000000000..cbcfc9121
--- /dev/null
+++ b/tests/Snapshots/ComputedValuesSnapshotTest.php
@@ -0,0 +1,78 @@
+<?php
+
+namespace Snapshots;
+
+/**
+ * Descendants inherit their parent's computed values under the standard cascade, one case per caption: em spacing
+ * handed on as the length it came to, inherit on an em padding, a font size three steps from its first ancestor with
+ * one, the content of a positioned block drawn at line-height: normal, a bidirectional embedding opened again after a
+ * block, the text before a block drawn in its own style, and a table in an inline element.
+ *
+ * @group snapshot
+ */
+class ComputedValuesSnapshotTest extends Snapshot
+{
+
+	/**
+	 * The fixture's name
+	 *
+	 * @return string
+	 */
+	public function getId()
+	{
+		return 'computed-values';
+	}
+
+	/**
+	 * Each case under a caption saying what should be seen
+	 */
+	public function generatePdf()
+	{
+		ob_start();
+		?>
+		<style>
+			body { font-family: dejavusans; font-size: 10pt; }
+			h1 { font-size: 15pt; margin: 0 0 2mm 0; }
+			p.caption { margin: 5mm 0 1mm 0; font-size: 8pt; color: #606060; letter-spacing: normal; word-spacing: normal; }
+			.box { border: 0.2mm solid #999999; }
+		</style>
+
+		<h1>Descendants inherit computed values</h1>
+
+		<div style="font-size: 20pt; letter-spacing: 0.1em">
+			<p class="caption">letter-spacing: 0.1em on a 20pt div. The 10pt paragraph inside it has its letters 2pt apart, like the one set to 2pt below it, not 1pt.</p>
+			<p style="font-size: 10pt">Spaced by the div's em</p>
+		</div>
+		<p style="letter-spacing: 2pt">Spaced by 2pt of its own</p>
+
+		<p class="caption">word-spacing: 1em on a 20pt paragraph. The words of the 10pt span in it are as far apart as the paragraph's own.</p>
+		<p style="font-size: 20pt; word-spacing: 1em">Big words <span style="font-size: 10pt">and small words in a span</span></p>
+
+		<div style="font-size: 20pt; padding-left: 1em" class="box">
+			<p class="caption">padding-left: 1em on a 20pt div, and padding-left: inherit on the 10pt paragraph in it. The paragraph's text starts two div paddings in, 14mm from the div's border.</p>
+			<p style="font-size: 10pt; padding-left: inherit" class="box">Padded by what the div's em came to</p>
+		</div>
+
+		<p class="caption">font-size: 20pt, then 1.5em, 50% and 2em. The words are 30pt, 15pt and 30pt.</p>
+		<div style="font-size: 20pt"><div style="font-size: 1.5em">Thirty <span style="font-size: 50%">fifteen <span style="font-size: 2em">thirty</span></span></div></div>
+
+		<p class="caption">A span set to dir="rtl" around a block. Before and after the block, the Hebrew word is to the right of the Latin one. The block inherits the span's direction and is aligned right.</p>
+		<div><span dir="rtl">&#x5e9;&#x5dc;&#x5d5;&#x5dd; before<div style="color: #606060">A block in the span</div>&#x5e9;&#x5dc;&#x5d5;&#x5dd; after</span></div>
+
+		<p class="caption">A block in an italic, shadowed span. The words before the span are upright and unshadowed; the span's words before, in and after the block are italic and shadowed.</p>
+		<div>Upright words <span style="font-style: italic; text-shadow: 0.4mm 0.4mm #6c9bd8">in the span<div>A block in the span</div>after the block</span> and upright again</div>
+
+		<p class="caption">A table in an italic, green span. The cell and the span's words before and after the table are italic and green; the words outside the span are not.</p>
+		<div>Plain words <span style="font-style: italic; color: #2e8b57">in the span<table><tr><td style="border: 0.2mm solid #999999">A cell in the span</td></tr></table>after the table</span> and plain again</div>
+
+		<p class="caption">A positioned block at the foot of the page, and a paragraph beside it in the flow. Both have line-height: normal, and their lines are the same distance apart.</p>
+		<div style="position: absolute; top: 240mm; left: 110mm; width: 80mm" class="box"><p>A positioned block<br>at line-height: normal<br>three lines</p></div>
+		<div style="width: 80mm" class="box"><p>A paragraph in the flow<br>at line-height: normal<br>three lines</p></div>
+		<?php
+		$html = ob_get_clean();
+
+		$this->mpdf = $this->createMpdf();
+		$this->mpdf->WriteHTML($html);
+	}
+
+}
diff --git a/tests/Snapshots/FixedPseudoClassSnapshotTest.php b/tests/Snapshots/FixedPseudoClassSnapshotTest.php
index 7e212471b..25c0f7783 100644
--- a/tests/Snapshots/FixedPseudoClassSnapshotTest.php
+++ b/tests/Snapshots/FixedPseudoClassSnapshotTest.php
@@ -91,7 +91,7 @@ public function generatePdf()
 		<table><tr><td>One</td><td>Two</td><td>Three</td></tr></table>
 
 		<p class="caption">In the page header, the link is red. In the positioned box at the foot of the page, :root div.box p makes the text red.</p>
-		<div class="box" style="position: absolute; bottom: 1mm; left: 20mm; width: 120mm; border: 0.2mm solid #999999; padding: 2mm;"><p>Positioned box: red</p></div>
+		<div class="box" style="position: absolute; line-height: 1.33; bottom: 1mm; left: 20mm; width: 120mm; border: 0.2mm solid #999999; padding: 2mm;"><p>Positioned box: red</p></div>
 		<?php
 		$html = ob_get_clean();
 
diff --git a/tests/Snapshots/InheritedReportSnapshot.php b/tests/Snapshots/InheritedReportSnapshot.php
index 261780db5..469431fd7 100644
--- a/tests/Snapshots/InheritedReportSnapshot.php
+++ b/tests/Snapshots/InheritedReportSnapshot.php
@@ -53,7 +53,7 @@ public function generatePdf()
 			td.panel { color: #1e5f74; font-weight: bold; font-family: monospace; font-size: 10pt; vertical-align: top; }
 			td.notes { vertical-align: top; }
 
-			.stamp { position: absolute; top: 12mm; left: 140mm; width: 55mm; border: 0.5mm solid #b33939; color: #b33939; font-size: 12pt; word-spacing: 4mm; text-align: center; }
+			.stamp { position: absolute; line-height: 1.33; top: 12mm; left: 140mm; width: 55mm; border: 0.5mm solid #b33939; color: #b33939; font-size: 12pt; word-spacing: 4mm; text-align: center; }
 		</style>
 
 		<div class="stamp"><p>DRAFT FOR REVIEW</p></div>
diff --git a/tests/Snapshots/ListStyleTypeSnapshotTest.php b/tests/Snapshots/ListStyleTypeSnapshotTest.php
index 6e953cee2..8197a197d 100644
--- a/tests/Snapshots/ListStyleTypeSnapshotTest.php
+++ b/tests/Snapshots/ListStyleTypeSnapshotTest.php
@@ -656,7 +656,7 @@ public function generatePdf()
 
 		<p>The following lists are rendered inside fixed-position containers.</p>
 
-		<div style="position: fixed; top: 50mm; left: 15mm; width: 80mm; border: 1px solid #999; padding: 5px;">
+		<div style="position: fixed; line-height: 1.33; top: 50mm; left: 15mm; width: 80mm; border: 1px solid #999; padding: 5px;">
 			<h4>Fixed top-left: decimal</h4>
 			<ol style="list-style-type: decimal;">
 				<li>Fixed One</li><li>Fixed Two</li><li>Fixed Three</li>
@@ -673,7 +673,7 @@ public function generatePdf()
 			</ul>
 		</div>
 
-		<div style="position: fixed; top: 50mm; right: 15mm; width: 80mm; border: 1px solid #999; padding: 5px;">
+		<div style="position: fixed; line-height: 1.33; top: 50mm; right: 15mm; width: 80mm; border: 1px solid #999; padding: 5px;">
 			<h4>Fixed top-right: lower-roman</h4>
 			<ol style="list-style-type: lower-roman;">
 				<li>Fixed One</li><li>Fixed Two</li><li>Fixed Three</li>
@@ -690,7 +690,7 @@ public function generatePdf()
 			</ol>
 		</div>
 
-		<div style="position: fixed; bottom: 20mm; left: 50mm; width: 100mm; border: 1px solid #999; padding: 5px;">
+		<div style="position: fixed; line-height: 1.33; bottom: 20mm; left: 50mm; width: 100mm; border: 1px solid #999; padding: 5px;">
 			<h4>Fixed bottom: hebrew</h4>
 			<ol style="list-style-type: hebrew; font-family: taameydavidclm;">
 				<li>Fixed One</li><li>Fixed Two</li><li>Fixed Three</li>
diff --git a/tests/Snapshots/LookAheadSelectorSnapshotTest.php b/tests/Snapshots/LookAheadSelectorSnapshotTest.php
index 9cabb9b99..e531672e1 100644
--- a/tests/Snapshots/LookAheadSelectorSnapshotTest.php
+++ b/tests/Snapshots/LookAheadSelectorSnapshotTest.php
@@ -91,7 +91,7 @@ public function generatePdf()
 		<ul class="not-last"><li>First item</li><li>Second item</li><li>Last item</li></ul>
 
 		<p class="caption">In the page header, the second line is red. In the positioned box at the foot of the page, its last line is red.</p>
-		<div class="box" style="position: absolute; bottom: 1mm; left: 20mm; width: 120mm; border: 0.2mm solid #999999; padding: 2mm;"><p>Positioned box, first line</p><p>Positioned box, last line: red</p></div>
+		<div class="box" style="position: absolute; line-height: 1.33; bottom: 1mm; left: 20mm; width: 120mm; border: 0.2mm solid #999999; padding: 2mm;"><p>Positioned box, first line</p><p>Positioned box, last line: red</p></div>
 		<?php
 		$html = ob_get_clean();
 
diff --git a/tests/Snapshots/NthChildTableContextsSnapshotTest.php b/tests/Snapshots/NthChildTableContextsSnapshotTest.php
index c2cc3998a..bf8930a1c 100644
--- a/tests/Snapshots/NthChildTableContextsSnapshotTest.php
+++ b/tests/Snapshots/NthChildTableContextsSnapshotTest.php
@@ -98,7 +98,7 @@ public function generatePdf()
 		</table>
 
 		<p class="caption">An absolutely positioned block at the foot of the page holds a table whose td:nth-child(2) is purple: Second is purple.</p>
-		<div style="position: absolute; bottom: 20mm; left: 20mm; width: 80mm;">
+		<div style="position: absolute; line-height: 1.33; bottom: 20mm; left: 20mm; width: 80mm;">
 			<table class="positioned"><tr><td>First</td><td>Second</td><td>Third</td></tr></table>
 		</div>
 
diff --git a/tests/Snapshots/PositionedBlockRotateSnapshotTest.php b/tests/Snapshots/PositionedBlockRotateSnapshotTest.php
index af14b02f9..050079f3f 100644
--- a/tests/Snapshots/PositionedBlockRotateSnapshotTest.php
+++ b/tests/Snapshots/PositionedBlockRotateSnapshotTest.php
@@ -37,8 +37,8 @@ public function generatePdf()
 		$html = '<style>
 			body { font-size: 9pt; }
 			h1 { font-size: 15pt; margin: 0; }
-			div.caption { position: absolute; left: 20mm; width: 90mm; font-size: 8pt; color: #606060; }
-			div.turned { position: absolute; left: 130mm; width: 34mm; border: 0.3mm solid #1f3a93; background: #d6eaf8; padding: 1mm; }
+			div.caption { position: absolute; line-height: 1.33; left: 20mm; width: 90mm; font-size: 8pt; color: #606060; }
+			div.turned { position: absolute; line-height: 1.33; left: 130mm; width: 34mm; border: 0.3mm solid #1f3a93; background: #d6eaf8; padding: 1mm; }
 		</style>
 		<h1>rotate on a positioned block</h1>';
 
diff --git a/tests/Snapshots/PositionedBlockSelectorSnapshotTest.php b/tests/Snapshots/PositionedBlockSelectorSnapshotTest.php
index 8541a9c2a..d33d92cbc 100644
--- a/tests/Snapshots/PositionedBlockSelectorSnapshotTest.php
+++ b/tests/Snapshots/PositionedBlockSelectorSnapshotTest.php
@@ -54,23 +54,23 @@ public function generatePdf()
 
 		// The same card in normal flow and positioned absolutely beside it
 		$this->mpdf->WriteHTML('<div class="card">' . $card . '</div>');
-		$this->mpdf->WriteHTML('<div class="card" style="position: absolute; top: 16mm; left: 110mm;">' . $card . '</div>');
+		$this->mpdf->WriteHTML('<div class="card" style="position: absolute; line-height: 1.33; top: 16mm; left: 110mm;">' . $card . '</div>');
 
 		// An id rule inside a fixed block
-		$this->mpdf->WriteHTML('<div id="side" style="position: fixed; top: 110mm; left: 10mm; width: 70mm; border: 0.3mm dashed #8e44ad; padding: 2mm;">'
+		$this->mpdf->WriteHTML('<div id="side" style="position: fixed; line-height: 1.33; top: 110mm; left: 10mm; width: 70mm; border: 0.3mm dashed #8e44ad; padding: 2mm;">'
 			. '<p>Fixed paragraph</p><table><tr><td>Fixed cell</td></tr></table></div>');
 
 		// A rule with an element between the block and the paragraph matches only the nested paragraph
-		$this->mpdf->WriteHTML('<div class="nest" style="position: absolute; top: 126mm; left: 110mm; width: 80mm; border: 0.3mm dashed #d35400; padding: 2mm;">'
+		$this->mpdf->WriteHTML('<div class="nest" style="position: absolute; line-height: 1.33; top: 126mm; left: 110mm; width: 80mm; border: 0.3mm dashed #d35400; padding: 2mm;">'
 			. '<p>Directly in the box, plain</p><div><p>Nested in a div, orange</p></div></div>');
 
 		// A rotated positioned block
-		$this->mpdf->WriteHTML('<div class="turned" style="position: absolute; top: 170mm; left: 10mm; width: 60mm; rotate: 90; border: 0.3mm solid #16a085; padding: 2mm;">'
+		$this->mpdf->WriteHTML('<div class="turned" style="position: absolute; line-height: 1.33; top: 170mm; left: 10mm; width: 60mm; rotate: 90; border: 0.3mm solid #16a085; padding: 2mm;">'
 			. '<p>Rotated paragraph</p></div>');
 
 		// Neighbouring positioned blocks: the card rules stay in the card
-		$this->mpdf->WriteHTML('<div class="card" style="position: absolute; top: 200mm; left: 60mm;"><h4>Card</h4><p>Card paragraph</p></div>');
-		$this->mpdf->WriteHTML('<div style="position: absolute; top: 240mm; left: 60mm; width: 80mm; border: 0.3mm solid #999999; padding: 3mm;">'
+		$this->mpdf->WriteHTML('<div class="card" style="position: absolute; line-height: 1.33; top: 200mm; left: 60mm;"><h4>Card</h4><p>Card paragraph</p></div>');
+		$this->mpdf->WriteHTML('<div style="position: absolute; line-height: 1.33; top: 240mm; left: 60mm; width: 80mm; border: 0.3mm solid #999999; padding: 3mm;">'
 			. '<h4>Plain heading</h4><p>Plain paragraph, not a card</p></div>');
 	}
 
diff --git a/tests/Snapshots/PositionedHtmlSnapshotTest.php b/tests/Snapshots/PositionedHtmlSnapshotTest.php
index 0b092b1ff..67119cad0 100644
--- a/tests/Snapshots/PositionedHtmlSnapshotTest.php
+++ b/tests/Snapshots/PositionedHtmlSnapshotTest.php
@@ -47,7 +47,7 @@ public function generatePdf()
 			}
 
 			.myfixed1 {
-				position: absolute;
+				position: absolute; line-height: 1.33;
 				overflow: visible;
 				left: 0;
 				bottom: 0;
@@ -60,7 +60,7 @@ public function generatePdf()
 			}
 
 			.myfixed2 {
-				position: fixed;
+				position: fixed; line-height: 1.33;
 				overflow: auto;
 				right: 0;
 				bottom: 0mm;
@@ -129,7 +129,7 @@ public function generatePdf()
 
 		<pagebreak />
 
-		<div style="position:fixed; left: 0; right: 0; bottom: 0; top: 0;">
+		<div style="position:fixed; line-height: 1.33; left: 0; right: 0; bottom: 0; top: 0;">
 			<h1>mPDF</h1>
 			<h4>Fixed-position block element with Autofit</h4>
 			<div>Using the CSS properties position and overflow:auto it is possible to fit text to a single page:</div>
diff --git a/tests/Snapshots/TableCellDescendantSelectorSnapshotTest.php b/tests/Snapshots/TableCellDescendantSelectorSnapshotTest.php
index 366294bbb..93dd4b6c9 100644
--- a/tests/Snapshots/TableCellDescendantSelectorSnapshotTest.php
+++ b/tests/Snapshots/TableCellDescendantSelectorSnapshotTest.php
@@ -128,7 +128,7 @@ public function generatePdf()
 
 		<h2>A table in a positioned block</h2>
 		<p class="caption">White on teal words from #side td span, in the block positioned at the bottom right of this page.</p>
-		<div id="side" style="position: absolute; bottom: 20mm; right: 15mm; width: 70mm; border: 0.3mm dashed #16a085; padding: 2mm;">
+		<div id="side" style="position: absolute; line-height: 1.33; bottom: 20mm; right: 15mm; width: 70mm; border: 0.3mm dashed #16a085; padding: 2mm;">
 			<table><tr><td>Fixed <span>cell text</span></td></tr></table>
 		</div>
 		<?php
diff --git a/tests/data/snapshots/computed-values-brochure-legacy.pdf b/tests/data/snapshots/computed-values-brochure-legacy.pdf
new file mode 100644
index 000000000..e503a3705
Binary files /dev/null and b/tests/data/snapshots/computed-values-brochure-legacy.pdf differ
diff --git a/tests/data/snapshots/computed-values-brochure-standard.pdf b/tests/data/snapshots/computed-values-brochure-standard.pdf
new file mode 100644
index 000000000..69286c54a
Binary files /dev/null and b/tests/data/snapshots/computed-values-brochure-standard.pdf differ
diff --git a/tests/data/snapshots/computed-values.pdf b/tests/data/snapshots/computed-values.pdf
new file mode 100644
index 000000000..bab2db9ae
Binary files /dev/null and b/tests/data/snapshots/computed-values.pdf differ
diff --git a/tests/data/snapshots/css-wide-keywords.pdf b/tests/data/snapshots/css-wide-keywords.pdf
index c61572606..596296c02 100644
Binary files a/tests/data/snapshots/css-wide-keywords.pdf and b/tests/data/snapshots/css-wide-keywords.pdf differ
diff --git a/tests/data/snapshots/inherited-channels.pdf b/tests/data/snapshots/inherited-channels.pdf
index 7dfc5786c..9bc92e33d 100644
Binary files a/tests/data/snapshots/inherited-channels.pdf and b/tests/data/snapshots/inherited-channels.pdf differ
diff --git a/tests/data/snapshots/unicode-zero-width-space.pdf b/tests/data/snapshots/unicode-zero-width-space.pdf
index a7a21873b..687a90836 100644
Binary files a/tests/data/snapshots/unicode-zero-width-space.pdf and b/tests/data/snapshots/unicode-zero-width-space.pdf differ