From 73abf5b2a3ae1d0529d4a2c98bde1b2789998e5c Mon Sep 17 00:00:00 2001
From: Mateusz Pusz <mateusz.pusz@gmail.com>
Date: Tue, 21 May 2024 10:18:47 +0200
Subject: [PATCH] build(qty-lib): HTML updated

---
 .../3045R1_quantities_and_units_library.html  | 3773 ++++++++---------
 1 file changed, 1849 insertions(+), 1924 deletions(-)

diff --git a/docs/papers/3045R1_quantities_and_units_library.html b/docs/papers/3045R1_quantities_and_units_library.html
index 3da8c5e..556be05 100644
--- a/docs/papers/3045R1_quantities_and_units_library.html
+++ b/docs/papers/3045R1_quantities_and_units_library.html
@@ -4,7 +4,7 @@
   <meta charset="utf-8" />
   <meta name="generator" content="mpark/wg21" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
-  <meta name="dcterms.date" content="2024-05-19" />
+  <meta name="dcterms.date" content="2024-05-21" />
   <title>Quantities and units library</title>
   <style>
       code{white-space: pre-wrap;}
@@ -462,7 +462,7 @@ <h1 class="title" style="text-align:center">Quantities and units
   </tr>
   <tr>
     <td>Date:</td>
-    <td>2024-05-19</td>
+    <td>2024-05-21</td>
   </tr>
   <tr>
     <td style="vertical-align:top">Project:</td>
@@ -499,7 +499,7 @@ <h1 id="toctitle">Contents</h1>
 <ul>
 <li><a href="#revision-history" id="toc-revision-history"><span class="toc-section-number">1</span> Revision history<span></span></a>
 <ul>
-<li><a href="#changes-since-p3045r0" id="toc-changes-since-p3045r0"><span class="toc-section-number">1.1</span> Changes since <span class="citation" data-cites="P3045R0">[<span><strong>P3045R0?</strong></span>]</span><span></span></a></li>
+<li><a href="#changes-since-p3045r0" id="toc-changes-since-p3045r0"><span class="toc-section-number">1.1</span> Changes since <span class="citation" data-cites="P3045R0">[<span>P3045R0</span>]</span><span></span></a></li>
 </ul></li>
 <li><a href="#introduction" id="toc-introduction"><span class="toc-section-number">2</span> Introduction<span></span></a></li>
 <li><a href="#terms-and-definitions" id="toc-terms-and-definitions"><span class="toc-section-number">3</span>
@@ -508,8 +508,9 @@ <h1 id="toctitle">Contents</h1>
 standard<span></span></a>
 <ul>
 <li><a href="#interaction-with-stdchrono-types-and-stdratio" id="toc-interaction-with-stdchrono-types-and-stdratio"><span class="toc-section-number">4.1</span> Interaction with
-<code class="sourceCode default">std::chrono</code> types and
-<code class="sourceCode default">std::ratio</code><span></span></a></li>
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
+types and
+<code class="sourceCode cpp">std<span class="op">::</span>ratio</code><span></span></a></li>
 <li><a href="#dependencies-on-other-proposals" id="toc-dependencies-on-other-proposals"><span class="toc-section-number">4.2</span> Dependencies on other
 proposals<span></span></a></li>
 </ul></li>
@@ -548,7 +549,7 @@ <h1 id="toctitle">Contents</h1>
 library for quantities and units<span></span></a>
 <ul>
 <li><a href="#the-proliferation-of-double" id="toc-the-proliferation-of-double"><span class="toc-section-number">7.1</span> The proliferation of
-<code class="sourceCode default">double</code><span></span></a></li>
+<code class="sourceCode cpp"><span class="dt">double</span></code><span></span></a></li>
 <li><a href="#the-proliferation-of-magic-numbers" id="toc-the-proliferation-of-magic-numbers"><span class="toc-section-number">7.2</span> The proliferation of magic
 numbers<span></span></a></li>
 <li><a href="#the-proliferation-of-conversion-macros" id="toc-the-proliferation-of-conversion-macros"><span class="toc-section-number">7.3</span> The proliferation of conversion
@@ -619,14 +620,14 @@ <h1 id="toctitle">Contents</h1>
 than most of us imagine<span></span></a></li>
 <li><a href="#displacement-vector-is-modeled-by-quantity" id="toc-displacement-vector-is-modeled-by-quantity"><span class="toc-section-number">10.4.3</span> <em>Displacement vector</em> is
 modeled by
-<code class="sourceCode default">quantity</code><span></span></a></li>
+<code class="sourceCode cpp">quantity</code><span></span></a></li>
 <li><a href="#point-is-modeled-by-quantity_point-and-pointorigin" id="toc-point-is-modeled-by-quantity_point-and-pointorigin"><span class="toc-section-number">10.4.4</span> <em>Point</em> is modeled by
-<code class="sourceCode default">quantity_point</code> and
-<code class="sourceCode default">PointOrigin</code><span></span></a>
+<code class="sourceCode cpp">quantity_point</code> and
+<code class="sourceCode cpp">PointOrigin</code><span></span></a>
 <ul>
 <li><a href="#quantity_point" id="toc-quantity_point"><span class="toc-section-number">10.4.4.1</span>
-<code class="sourceCode default">quantity_point</code><span></span></a></li>
-<li><a href="#zeroth_point_originquantityspec" id="toc-zeroth_point_originquantityspec"><span class="toc-section-number">10.4.4.2</span> <code class="sourceCode default">zeroth_point_origin&lt;QuantitySpec&gt;</code><span></span></a></li>
+<code class="sourceCode cpp">quantity_point</code><span></span></a></li>
+<li><a href="#zeroth_point_originquantityspec" id="toc-zeroth_point_originquantityspec"><span class="toc-section-number">10.4.4.2</span> <code class="sourceCode cpp">zeroth_point_origin<span class="op">&lt;</span>QuantitySpec<span class="op">&gt;</span></code><span></span></a></li>
 <li><a href="#absolute-point-origin" id="toc-absolute-point-origin"><span class="toc-section-number">10.4.4.3</span> Absolute <em>point</em>
 origin<span></span></a></li>
 <li><a href="#relative-point-origin" id="toc-relative-point-origin"><span class="toc-section-number">10.4.4.4</span> Relative <em>point</em>
@@ -726,8 +727,8 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#safety-introduced-by-the-affine-space-abstractions" id="toc-safety-introduced-by-the-affine-space-abstractions"><span class="toc-section-number">14.1.3</span> Safety introduced by the affine
 space abstractions<span></span></a></li>
 <li><a href="#explicit-is-not-explicit-enough" id="toc-explicit-is-not-explicit-enough"><span class="toc-section-number">14.1.4</span>
-<code class="sourceCode default">explicit</code> is not explicit
-enough<span></span></a></li>
+<code class="sourceCode cpp"><span class="kw">explicit</span></code> is
+not explicit enough<span></span></a></li>
 <li><a href="#safe-quantity-numerical-value-getters" id="toc-safe-quantity-numerical-value-getters"><span class="toc-section-number">14.1.5</span> Safe quantity numerical value
 getters<span></span></a></li>
 <li><a href="#preventing-dangling-references" id="toc-preventing-dangling-references"><span class="toc-section-number">14.1.6</span> Preventing dangling
@@ -774,14 +775,14 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#symbols-for-quantity-types" id="toc-symbols-for-quantity-types"><span class="toc-section-number">15.1.3</span> Symbols for quantity
 types<span></span></a></li>
 <li><a href="#fixed_string" id="toc-fixed_string"><span class="toc-section-number">15.1.4</span>
-<code class="sourceCode default">fixed_string</code><span></span></a></li>
+<code class="sourceCode cpp">fixed_string</code><span></span></a></li>
 <li><a href="#symbol_text" id="toc-symbol_text"><span class="toc-section-number">15.1.5</span>
-<code class="sourceCode default">symbol_text</code><span></span></a></li>
+<code class="sourceCode cpp">symbol_text</code><span></span></a></li>
 <li><a href="#symbols-for-derived-entities" id="toc-symbols-for-derived-entities"><span class="toc-section-number">15.1.6</span> Symbols for derived
 entities<span></span></a>
 <ul>
 <li><a href="#text_encoding" id="toc-text_encoding"><span class="toc-section-number">15.1.6.1</span>
-<code class="sourceCode default">text_encoding</code><span></span></a></li>
+<code class="sourceCode cpp">text_encoding</code><span></span></a></li>
 <li><a href="#symbols-of-derived-dimensions" id="toc-symbols-of-derived-dimensions"><span class="toc-section-number">15.1.6.2</span> Symbols of derived
 dimensions<span></span></a></li>
 <li><a href="#symbols-of-derived-units" id="toc-symbols-of-derived-units"><span class="toc-section-number">15.1.6.3</span> Symbols of derived
@@ -789,7 +790,7 @@ <h1 id="toctitle">Contents</h1>
 </ul></li>
 </ul></li>
 <li><a href="#space_before_unit_symbol-customization-point" id="toc-space_before_unit_symbol-customization-point"><span class="toc-section-number">15.2</span>
-<code class="sourceCode default">space_before_unit_symbol</code>
+<code class="sourceCode cpp">space_before_unit_symbol</code>
 customization point<span></span></a></li>
 <li><a href="#output-streams" id="toc-output-streams"><span class="toc-section-number">15.3</span> Output streams<span></span></a>
 <ul>
@@ -851,81 +852,61 @@ <h1 id="toctitle">Contents</h1>
 </ul></li>
 <li><a href="#concepts" id="toc-concepts"><span class="toc-section-number">16.3</span> Concepts<span></span></a>
 <ul>
-<li><a href="#Dimension-concept" id="toc-Dimension-concept"><span class="toc-section-number">16.3.1</span>
-<code class="sourceCode default">Dimension&lt;T&gt; concept</code><span></span></a>
+<li><a href="#Dimension-concept" id="toc-Dimension-concept"><span class="toc-section-number">16.3.1</span> <code class="sourceCode cpp">Dimension<span class="op">&lt;</span>T<span class="op">&gt;</span> <span class="kw">concept</span></code><span></span></a>
 <ul>
-<li><a href="#DimensionOf-concept" id="toc-DimensionOf-concept"><span class="toc-section-number">16.3.1.1</span>
-<code class="sourceCode default">DimensionOf&lt;T, V&gt;</code>
+<li><a href="#DimensionOf-concept" id="toc-DimensionOf-concept"><span class="toc-section-number">16.3.1.1</span> <code class="sourceCode cpp">DimensionOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#QuantitySpec-concept" id="toc-QuantitySpec-concept"><span class="toc-section-number">16.3.2</span>
-<code class="sourceCode default">QuantitySpec&lt;T&gt; concept</code><span></span></a>
+<li><a href="#QuantitySpec-concept" id="toc-QuantitySpec-concept"><span class="toc-section-number">16.3.2</span> <code class="sourceCode cpp">QuantitySpec<span class="op">&lt;</span>T<span class="op">&gt;</span> <span class="kw">concept</span></code><span></span></a>
 <ul>
-<li><a href="#QuantitySpecOf-concept" id="toc-QuantitySpecOf-concept"><span class="toc-section-number">16.3.2.1</span>
-<code class="sourceCode default">QuantitySpecOf&lt;T, V&gt;</code>
+<li><a href="#QuantitySpecOf-concept" id="toc-QuantitySpecOf-concept"><span class="toc-section-number">16.3.2.1</span> <code class="sourceCode cpp">QuantitySpecOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#Unit-concept" id="toc-Unit-concept"><span class="toc-section-number">16.3.3</span>
-<code class="sourceCode default">Unit&lt;T&gt;</code>
+<li><a href="#Unit-concept" id="toc-Unit-concept"><span class="toc-section-number">16.3.3</span> <code class="sourceCode cpp">Unit<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a>
 <ul>
-<li><a href="#AssociatedUnit-concept" id="toc-AssociatedUnit-concept"><span class="toc-section-number">16.3.3.1</span>
-<code class="sourceCode default">AssociatedUnit&lt;T&gt;</code>
+<li><a href="#AssociatedUnit-concept" id="toc-AssociatedUnit-concept"><span class="toc-section-number">16.3.3.1</span> <code class="sourceCode cpp">AssociatedUnit<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a></li>
-<li><a href="#PrefixableUnit-concept" id="toc-PrefixableUnit-concept"><span class="toc-section-number">16.3.3.2</span>
-<code class="sourceCode default">PrefixableUnit&lt;T&gt;</code>
+<li><a href="#PrefixableUnit-concept" id="toc-PrefixableUnit-concept"><span class="toc-section-number">16.3.3.2</span> <code class="sourceCode cpp">PrefixableUnit<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a></li>
-<li><a href="#UnitOf-concept" id="toc-UnitOf-concept"><span class="toc-section-number">16.3.3.3</span>
-<code class="sourceCode default">UnitOf&lt;T, V&gt;</code>
+<li><a href="#UnitOf-concept" id="toc-UnitOf-concept"><span class="toc-section-number">16.3.3.3</span> <code class="sourceCode cpp">UnitOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<span></span></a></li>
-<li><a href="#UnitCompatibleWith-concept" id="toc-UnitCompatibleWith-concept"><span class="toc-section-number">16.3.3.4</span> <code class="sourceCode default">UnitCompatibleWith&lt;T, V1, V2&gt;</code>
+<li><a href="#UnitCompatibleWith-concept" id="toc-UnitCompatibleWith-concept"><span class="toc-section-number">16.3.3.4</span> <code class="sourceCode cpp">UnitCompatibleWith<span class="op">&lt;</span>T, V1, V2<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#Reference-concept" id="toc-Reference-concept"><span class="toc-section-number">16.3.4</span>
-<code class="sourceCode default">Reference&lt;T&gt;</code>
+<li><a href="#Reference-concept" id="toc-Reference-concept"><span class="toc-section-number">16.3.4</span> <code class="sourceCode cpp">Reference<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a>
 <ul>
-<li><a href="#ReferenceOf-concept" id="toc-ReferenceOf-concept"><span class="toc-section-number">16.3.4.1</span>
-<code class="sourceCode default">ReferenceOf&lt;T, V&gt;</code>
+<li><a href="#ReferenceOf-concept" id="toc-ReferenceOf-concept"><span class="toc-section-number">16.3.4.1</span> <code class="sourceCode cpp">ReferenceOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#Representation-concept" id="toc-Representation-concept"><span class="toc-section-number">16.3.5</span>
-<code class="sourceCode default">Representation&lt;T&gt;</code>
+<li><a href="#Representation-concept" id="toc-Representation-concept"><span class="toc-section-number">16.3.5</span> <code class="sourceCode cpp">Representation<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a>
 <ul>
-<li><a href="#RepresentationOf-concept" id="toc-RepresentationOf-concept"><span class="toc-section-number">16.3.5.1</span>
-<code class="sourceCode default">RepresentationOf&lt;T, Ch&gt;</code>
+<li><a href="#RepresentationOf-concept" id="toc-RepresentationOf-concept"><span class="toc-section-number">16.3.5.1</span> <code class="sourceCode cpp">RepresentationOf<span class="op">&lt;</span>T, Ch<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#Quantity-concept" id="toc-Quantity-concept"><span class="toc-section-number">16.3.6</span>
-<code class="sourceCode default">Quantity&lt;T&gt;</code>
+<li><a href="#Quantity-concept" id="toc-Quantity-concept"><span class="toc-section-number">16.3.6</span> <code class="sourceCode cpp">Quantity<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a>
 <ul>
-<li><a href="#QuantityOf-concept" id="toc-QuantityOf-concept"><span class="toc-section-number">16.3.6.1</span>
-<code class="sourceCode default">QuantityOf&lt;T, V&gt;</code>
+<li><a href="#QuantityOf-concept" id="toc-QuantityOf-concept"><span class="toc-section-number">16.3.6.1</span> <code class="sourceCode cpp">QuantityOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#PointOrigin-concept" id="toc-PointOrigin-concept"><span class="toc-section-number">16.3.7</span>
-<code class="sourceCode default">PointOrigin&lt;T&gt;</code>
+<li><a href="#PointOrigin-concept" id="toc-PointOrigin-concept"><span class="toc-section-number">16.3.7</span> <code class="sourceCode cpp">PointOrigin<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a>
 <ul>
-<li><a href="#PointOriginFor-concept" id="toc-PointOriginFor-concept"><span class="toc-section-number">16.3.7.1</span>
-<code class="sourceCode default">PointOriginFor&lt;T, V&gt;</code>
+<li><a href="#PointOriginFor-concept" id="toc-PointOriginFor-concept"><span class="toc-section-number">16.3.7.1</span> <code class="sourceCode cpp">PointOriginFor<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#QuantityPoint-concept" id="toc-QuantityPoint-concept"><span class="toc-section-number">16.3.8</span>
-<code class="sourceCode default">QuantityPoint&lt;T&gt;</code>
+<li><a href="#QuantityPoint-concept" id="toc-QuantityPoint-concept"><span class="toc-section-number">16.3.8</span> <code class="sourceCode cpp">QuantityPoint<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a>
 <ul>
-<li><a href="#QuantityPointOf-concept" id="toc-QuantityPointOf-concept"><span class="toc-section-number">16.3.8.1</span>
-<code class="sourceCode default">QuantityPointOf&lt;T, V&gt;</code>
+<li><a href="#QuantityPointOf-concept" id="toc-QuantityPointOf-concept"><span class="toc-section-number">16.3.8.1</span> <code class="sourceCode cpp">QuantityPointOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
-<li><a href="#QuantityLike-concept" id="toc-QuantityLike-concept"><span class="toc-section-number">16.3.9</span>
-<code class="sourceCode default">QuantityLike&lt;T&gt;</code>
+<li><a href="#QuantityLike-concept" id="toc-QuantityLike-concept"><span class="toc-section-number">16.3.9</span> <code class="sourceCode cpp">QuantityLike<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a></li>
-<li><a href="#QuantityPointLike-concept" id="toc-QuantityPointLike-concept"><span class="toc-section-number">16.3.10</span>
-<code class="sourceCode default">QuantityPointLike&lt;T&gt;</code>
+<li><a href="#QuantityPointLike-concept" id="toc-QuantityPointLike-concept"><span class="toc-section-number">16.3.10</span> <code class="sourceCode cpp">QuantityPointLike<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<span></span></a></li>
 </ul></li>
 <li><a href="#operations-on-units-dimensions-and-quantity-types" id="toc-operations-on-units-dimensions-and-quantity-types"><span class="toc-section-number">16.4</span> Operations on units, dimensions,
@@ -964,7 +945,7 @@ <h1 id="toctitle">Contents</h1>
 arithmetics<span></span></a>
 <ul>
 <li><a href="#quantity-is-a-numeric-wrapper" id="toc-quantity-is-a-numeric-wrapper"><span class="toc-section-number">16.8.2.1</span>
-<code class="sourceCode default">quantity</code> is a numeric
+<code class="sourceCode cpp">quantity</code> is a numeric
 wrapper<span></span></a></li>
 <li><a href="#addition-and-subtraction" id="toc-addition-and-subtraction"><span class="toc-section-number">16.8.2.2</span> Addition and
 subtraction<span></span></a></li>
@@ -1003,7 +984,7 @@ <h1 id="toctitle">Contents</h1>
 <li><a href="#quantity-points-conversions" id="toc-quantity-points-conversions"><span class="toc-section-number">16.9.3</span> Quantity points
 conversions<span></span></a></li>
 <li><a href="#interoperability-with-the-stdchrono-abstractions" id="toc-interoperability-with-the-stdchrono-abstractions"><span class="toc-section-number">16.9.4</span> Interoperability with the
-<code class="sourceCode default">std::chrono</code>
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
 abstractions<span></span></a></li>
 </ul></li>
 </ul></li>
@@ -1014,25 +995,26 @@ <h1 id="toctitle">Contents</h1>
 </ul>
 </div>
 <h1 data-number="1" id="revision-history"><span class="header-section-number">1</span> Revision history<a href="#revision-history" class="self-link"></a></h1>
-<h2 data-number="1.1" id="changes-since-p3045r0"><span class="header-section-number">1.1</span> Changes since <span class="citation" data-cites="P3045R0">[<a href="#ref-P3045R0" role="doc-biblioref"><strong>P3045R0?</strong></a>]</span><a href="#changes-since-p3045r0" class="self-link"></a></h2>
+<h2 data-number="1.1" id="changes-since-p3045r0"><span class="header-section-number">1.1</span> Changes since <span class="citation" data-cites="P3045R0">[<a href="https://wg21.link/p3045r0" role="doc-biblioref">P3045R0</a>]</span><a href="#changes-since-p3045r0" class="self-link"></a></h2>
 <ul>
 <li>One more dependency added to the table in the <a href="#dependencies-on-other-proposals">Dependencies on other
 proposals</a> chapter.</li>
 <li><a href="#the-affine-space">The affine space</a> chapter rewritten
 nearly from scratch.</li>
-<li><code class="sourceCode default">qp.quantity_from_zero()</code> does
-not work for user’s named origins anymore.</li>
-<li><code class="sourceCode default">qp.quantity_from()</code> now works
-with other quantity points as well.</li>
-<li><code class="sourceCode default">basic_symbol_text</code> renamed to
-<code class="sourceCode default">symbol_text</code>.</li>
-<li><code class="sourceCode default">symbol_text</code> now always
-stores <code class="sourceCode default">char8_t</code> and
-<code class="sourceCode default">char</code> versions of symbols.</li>
+<li><code class="sourceCode cpp">qp<span class="op">.</span>quantity_from_zero<span class="op">()</span></code>
+does not work for user’s named origins anymore.</li>
+<li><code class="sourceCode cpp">qp<span class="op">.</span>quantity_from<span class="op">()</span></code>
+now works with other quantity points as well.</li>
+<li><code class="sourceCode cpp">basic_symbol_text</code> renamed to
+<code class="sourceCode cpp">symbol_text</code>.</li>
+<li><code class="sourceCode cpp">symbol_text</code> now always stores
+<code class="sourceCode cpp"><span class="dt">char8_t</span></code> and
+<code class="sourceCode cpp"><span class="dt">char</span></code>
+versions of symbols.</li>
 <li>In case UTF-8 symbol is used, now it has to be provided as an UTF-8
-(<code class="sourceCode default">u8</code>) literal.</li>
-<li><code class="sourceCode default">[[nodiscard]]</code> removed from
-<code class="sourceCode default">basic_symbol_text</code></li>
+(<code class="sourceCode cpp">u8</code>) literal.</li>
+<li><code class="sourceCode cpp"><span class="op">[[</span><span class="at">nodiscard</span><span class="op">]]</span></code>
+removed from <code class="sourceCode cpp">basic_symbol_text</code></li>
 <li><a href="#symbols-of-derived-dimensions">Symbols of derived
 dimensions</a> added and the entire symbols generation text refactored
 into the <a href="#symbols-for-derived-entities">Symbols for derived
@@ -1041,10 +1023,9 @@ <h2 data-number="1.1" id="changes-since-p3045r0"><span class="header-section-num
 Zverovich.</li>
 <li>Minor editorial changes and additional clarifications added to the
 <a href="#text-output">Text output</a> chapter.</li>
-<li><code class="sourceCode default">mag&lt;ratio{N, D}&gt;</code>
-replaced with
-<code class="sourceCode default">mag_ratio&lt;N, D&gt;</code> so the
-<code class="sourceCode default">ratio</code> type becomes the
+<li><code class="sourceCode cpp">mag<span class="op">&lt;</span>ratio<span class="op">{</span>N, D<span class="op">}&gt;</span></code>
+replaced with <code class="sourceCode cpp">mag_ratio<span class="op">&lt;</span>N, D<span class="op">&gt;</span></code>
+so the <code class="sourceCode cpp">ratio</code> type becomes the
 implementation detail rather than the public interface of the
 library</li>
 <li>Compiler Explorer links updated to reflect the latest design changes
@@ -1052,18 +1033,18 @@ <h2 data-number="1.1" id="changes-since-p3045r0"><span class="header-section-num
 </ul>
 <h1 data-number="2" id="introduction"><span class="header-section-number">2</span> Introduction<a href="#introduction" class="self-link"></a></h1>
 <p>Several groups in the ISO C++ Committee reviewed the “P1935: A C++
-Approach to Physical Units” <span class="citation" data-cites="P1935R2">[<a href="#ref-P1935R2" role="doc-biblioref">P1935R2</a>]</span> proposal in Belfast 2019 and
+Approach to Physical Units” <span class="citation" data-cites="P1935R2">[<a href="https://wg21.link/p1935r2" role="doc-biblioref">P1935R2</a>]</span> proposal in Belfast 2019 and
 Prague 2020. All those groups expressed interest in the potential
 standardization of such a library and encouraged further work. The
 authors also got valuable initial feedback that highly influenced the
-design of the V2 version of the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library.</p>
+design of the V2 version of the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library.</p>
 <p>In the following years, the library’s authors focused on getting more
 feedback from the production about the design and developed version 2 of
-the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library
-that resolves the issues raised by the users and Committee members. The
-features and interfaces of this version are close to being the best we
-can get with the current version of the C++ language standard.</p>
-<p>This paper is authored by the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library developers, the
+the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library that resolves the
+issues raised by the users and Committee members. The features and
+interfaces of this version are close to being the best we can get with
+the current version of the C++ language standard.</p>
+<p>This paper is authored by the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library developers, the
 authors of other actively maintained similar libraries on the market,
 and other active members of the C++ physical quantities and units
 community who have worked on this subject for many years. We join our
@@ -1075,11 +1056,10 @@ <h1 data-number="2" id="introduction"><span class="header-section-number">2</spa
 <p>During the Kona 2023 ISO C++ Committee meeting, we got repeating
 feedback that there should be one big, unified paper with all the
 contents inside. Addressing this requirement, this paper adds a detailed
-design description and also includes the most important parts of <span class="citation" data-cites="P2980R1">[<a href="#ref-P2980R1" role="doc-biblioref"><strong>P2980R1?</strong></a>]</span>, <span class="citation" data-cites="P2981R1">[<a href="#ref-P2981R1" role="doc-biblioref"><strong>P2981R1?</strong></a>]</span>, and <span class="citation" data-cites="P2982R1">[<a href="#ref-P2982R1" role="doc-biblioref"><strong>P2982R1?</strong></a>]</span>. With this,
-we assume that <span class="citation" data-cites="P2981R1">[<a href="#ref-P2981R1" role="doc-biblioref"><strong>P2981R1?</strong></a>]</span> and <span class="citation" data-cites="P2982R1">[<a href="#ref-P2982R1" role="doc-biblioref"><strong>P2982R1?</strong></a>]</span> are
-superseded by this paper. The plan and scope described in <span class="citation" data-cites="P2980R1">[<a href="#ref-P2980R1" role="doc-biblioref"><strong>P2980R1?</strong></a>]</span> might still
-be updated based on the current progress and feedback from the upcoming
-discussions.</p>
+design description and also includes the most important parts of <span class="citation" data-cites="P2980R1">[<a href="https://wg21.link/p2980r1" role="doc-biblioref">P2980R1</a>]</span>, <span class="citation" data-cites="P2981R1">[<a href="https://wg21.link/p2981r1" role="doc-biblioref">P2981R1</a>]</span>, and <span class="citation" data-cites="P2982R1">[<a href="https://wg21.link/p2982r1" role="doc-biblioref">P2982R1</a>]</span>. With this, we assume that
+<span class="citation" data-cites="P2981R1">[<a href="https://wg21.link/p2981r1" role="doc-biblioref">P2981R1</a>]</span> and <span class="citation" data-cites="P2982R1">[<a href="https://wg21.link/p2982r1" role="doc-biblioref">P2982R1</a>]</span> are superseded by this paper.
+The plan and scope described in <span class="citation" data-cites="P2980R1">[<a href="https://wg21.link/p2980r1" role="doc-biblioref">P2980R1</a>]</span> might still be updated based on
+the current progress and feedback from the upcoming discussions.</p>
 <!-- TODO remove this note in the future -->
 <p><em>Note: This paper is incomplete and many chapters are still
 missing. It is published to gather early feedback and possibly get
@@ -1087,28 +1067,32 @@ <h1 data-number="2" id="introduction"><span class="header-section-number">2</spa
 will arrive in the next revisions of this paper.</em></p>
 <h1 data-number="3" id="terms-and-definitions"><span class="header-section-number">3</span> Terms and definitions<a href="#terms-and-definitions" class="self-link"></a></h1>
 <p>This document consistently uses the official metrology vocabulary
-defined in the <span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span>
-and <span class="citation" data-cites="BIPM-VIM">[<a href="#ref-BIPM-VIM" role="doc-biblioref">JCGM 200:2012</a>]</span>.</p>
+defined in the <span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> and <span class="citation" data-cites="BIPM-VIM">[<a href="https://jcgm.bipm.org/vim/en" role="doc-biblioref">JCGM
+200:2012</a>]</span>.</p>
 <h1 data-number="4" id="impact-on-the-c-standard"><span class="header-section-number">4</span> Impact on the C++ standard<a href="#impact-on-the-c-standard" class="self-link"></a></h1>
 <p>This change is purely additive. It does not change, fix, or break any
 of the existing tools in the C++ standard library.</p>
 <h2 data-number="4.1" id="interaction-with-stdchrono-types-and-stdratio"><span class="header-section-number">4.1</span> Interaction with
-<code class="sourceCode default">std::chrono</code> types and
-<code class="sourceCode default">std::ratio</code><a href="#interaction-with-stdchrono-types-and-stdratio" class="self-link"></a></h2>
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
+types and
+<code class="sourceCode cpp">std<span class="op">::</span>ratio</code><a href="#interaction-with-stdchrono-types-and-stdratio" class="self-link"></a></h2>
 <p>The only interaction of this proposal with the C++ standard
 facilities is the compatibility mode with
-<code class="sourceCode default">std::chrono</code> types
-(<code class="sourceCode default">duration</code> and
-<code class="sourceCode default">time_point</code>) described in <a href="#interoperability-with-the-stdchrono-abstractions">Interoperability
-with the <code class="sourceCode default">std::chrono</code>
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
+types (<code class="sourceCode cpp">duration</code> and
+<code class="sourceCode cpp">time_point</code>) described in <a href="#interoperability-with-the-stdchrono-abstractions">Interoperability
+with the
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
 abstractions</a>.</p>
 <p>We should also mention the potential confusion of users with having
 two different ways to deal with time abstractions in the C++ standard
 library. If this proposal gets accepted:</p>
 <ul>
-<li><code class="sourceCode default">std::chrono</code> abstractions
-together with <code class="sourceCode default">std::ratio</code> should
-be used primarily to deal with calendars and threading facilities,</li>
+<li><code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
+abstractions together with
+<code class="sourceCode cpp">std<span class="op">::</span>ratio</code>
+should be used primarily to deal with calendars and threading
+facilities,</li>
 <li>abstractions introduced in this proposal should be used in all other
 use cases (e.g. physical quantities equations).</li>
 </ul>
@@ -1145,9 +1129,9 @@ <h2 data-number="4.2" id="dependencies-on-other-proposals"><span class="header-s
 </thead>
 <tbody>
 <tr class="odd">
-<td><code class="sourceCode default">fixed_string</code></td>
+<td><code class="sourceCode cpp">fixed_string</code></td>
 <td style="text-align: center;">1</td>
-<td style="text-align: center;"><span class="citation" data-cites="P3094R0">[<a href="#ref-P3094R0" role="doc-biblioref"><strong>P3094R0?</strong></a>]</span></td>
+<td style="text-align: center;"><span class="citation" data-cites="P3094R0">[<a href="https://wg21.link/p3094r0" role="doc-biblioref">P3094R0</a>]</span></td>
 <td>String-like structural type with inline storage (can be used as an
 NTTP).</td>
 </tr>
@@ -1161,27 +1145,27 @@ <h2 data-number="4.2" id="dependencies-on-other-proposals"><span class="header-s
 <tr class="odd">
 <td>Compile-time prime numbers</td>
 <td style="text-align: center;">2</td>
-<td style="text-align: center;"><span class="citation" data-cites="P3133R0">[<a href="#ref-P3133R0" role="doc-biblioref"><strong>P3133R0?</strong></a>]</span></td>
+<td style="text-align: center;"><span class="citation" data-cites="P3133R0">[<a href="https://wg21.link/p3133r0" role="doc-biblioref">P3133R0</a>]</span></td>
 <td>Compile-time facilities to break any integral value to a product of
 prime numbers and their powers.</td>
 </tr>
 <tr class="even">
 <td>Value-preserving conversions</td>
 <td style="text-align: center;">2</td>
-<td style="text-align: center;"><span class="citation" data-cites="P0870R5">[<a href="#ref-P0870R5" role="doc-biblioref">P0870R5</a>]</span>, <span class="citation" data-cites="P2509R0">[<a href="#ref-P2509R0" role="doc-biblioref">P2509R0</a>]</span></td>
+<td style="text-align: center;"><span class="citation" data-cites="P0870R5">[<a href="https://wg21.link/p0870r5" role="doc-biblioref">P0870R5</a>]</span>, <span class="citation" data-cites="P2509R0">[<a href="https://wg21.link/p2509r0" role="doc-biblioref">P2509R0</a>]</span></td>
 <td>Type trait stating if the conversion from one type to another is
 value preserving or not.</td>
 </tr>
 <tr class="odd">
 <td>Number concepts</td>
 <td style="text-align: center;">2</td>
-<td style="text-align: center;"><span class="citation" data-cites="P3003R0">[<a href="#ref-P3003R0" role="doc-biblioref"><strong>P3003R0?</strong></a>]</span></td>
+<td style="text-align: center;"><span class="citation" data-cites="P3003R0">[<a href="https://wg21.link/p3003r0" role="doc-biblioref">P3003R0</a>]</span></td>
 <td>Concepts for vector- and point-space numbers.</td>
 </tr>
 <tr class="even">
 <td>Bounded numeric types</td>
 <td style="text-align: center;">3</td>
-<td style="text-align: center;"><span class="citation" data-cites="P2993R0">[<a href="#ref-P2993R0" role="doc-biblioref"><strong>P2993R0?</strong></a>]</span></td>
+<td style="text-align: center;"><span class="citation" data-cites="P2993R0">[<a href="https://wg21.link/p2993r0" role="doc-biblioref">P2993R0</a>]</span></td>
 <td>Numerical type wrappers with values bounded to a provided interval
 (optionally with wraparound semantics).</td>
 </tr>
@@ -1210,46 +1194,48 @@ <h2 data-number="5.1" id="dominik-berner"><span class="header-section-number">5.
 developer. However, throughout his career, Dominik spent way too many
 hours debugging and fixing issues caused by these types being incorrect.
 In an attempt to bring a closer semantic meaning to these lists, he
-eventually wrote <span class="citation" data-cites="SI_LIB">[<a href="#ref-SI_LIB" role="doc-biblioref">SI library</a>]</span> as a side
-project.</p>
-<p>While <span class="citation" data-cites="SI_LIB">[<a href="#ref-SI_LIB" role="doc-biblioref">SI library</a>]</span> provides
-many useful features, such as type-safe conversion between physical
-quantities as well as zero-overhead computation for values of the same
-units, there are some shortcomings which would require major rework.
-Instead of creating yet another library, Dominik decided to join forces
-with the other authors of this paper to push for standardizing support
-for more type-safety for physical quantities. He hopes that this will
-eventually lead to a safer and more robust C++ and open many more
-opportunities for the language.</p>
+eventually wrote <span class="citation" data-cites="SI_LIB">[<a href="https://si.dominikberner.ch/doc" role="doc-biblioref">SI
+library</a>]</span> as a side project.</p>
+<p>While <span class="citation" data-cites="SI_LIB">[<a href="https://si.dominikberner.ch/doc" role="doc-biblioref">SI
+library</a>]</span> provides many useful features, such as type-safe
+conversion between physical quantities as well as zero-overhead
+computation for values of the same units, there are some shortcomings
+which would require major rework. Instead of creating yet another
+library, Dominik decided to join forces with the other authors of this
+paper to push for standardizing support for more type-safety for
+physical quantities. He hopes that this will eventually lead to a safer
+and more robust C++ and open many more opportunities for the
+language.</p>
 <h2 data-number="5.2" id="johel-ernesto-guerrero-peña"><span class="header-section-number">5.2</span> Johel Ernesto Guerrero Peña<a href="#johel-ernesto-guerrero-peña" class="self-link"></a></h2>
 <p>Johel got interested in the units domain while writing his first
 hundred lines of game development. He got up to opening the game window,
 so this milestone was not reached until years later. Instead, he looked
 for the missing piece of abstraction, called “pixel” in the GUI
 framework, but modeled as an
-<code class="sourceCode default">int</code>. He found out about <span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="#ref-NHOLTHAUS-UNITS" role="doc-biblioref">nholthaus/units</a>]</span>, and got fascinated
+<code class="sourceCode cpp"><span class="dt">int</span></code>. He
+found out about <span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="https://github.com/nholthaus/units" role="doc-biblioref">nholthaus/units</a>]</span>, and got fascinated
 with the idea of a library that succinctly allows expressing his
 domain’s units (<a href="https://github.com/nholthaus/units/issues/124#issuecomment-390773279" class="uri">https://github.com/nholthaus/units/issues/124#issuecomment-390773279</a>).</p>
-<p>Johel became a contributor to <span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="#ref-NHOLTHAUS-UNITS" role="doc-biblioref">nholthaus/units</a>]</span> v3 from 2018 to 2020.
+<p>Johel became a contributor to <span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="https://github.com/nholthaus/units" role="doc-biblioref">nholthaus/units</a>]</span> v3 from 2018 to 2020.
 He improved the interfaces and implementations by remodeling them after
-<code class="sourceCode default">std::chrono::duration</code>. This
-included parameterizing the representation type with a template
+<code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>.
+This included parameterizing the representation type with a template
 parameter instead of a macro. He also improved the error messages by
 mapping a list of types to an user-defined name.</p>
-<p>By 2020, Johel had been aware of <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> v0 <code class="sourceCode default">quantity&lt;dim_length, length, int&gt;</code>,
+<p>By 2020, Johel had been aware of <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> v0 <code class="sourceCode cpp">quantity<span class="op">&lt;</span>dim_length, length, <span class="dt">int</span><span class="op">&gt;</span></code>,
 put off by its verbosity. But then, he watched a talk by Mateusz Pusz on
-<span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span>. It described how good error
+<span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span>. It described how good error
 messages was a stake in the ground for the library. Thanks to his
-experience in the domain, Johel was convinced that <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> was the future.</p>
-<p>Since 2020, Johel has been contributing to <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span>. He added
-<code class="sourceCode default">quantity_point</code>, the
-generalization of
-<code class="sourceCode default">std::chrono::time_point</code>, closing
-#1. He also added <code class="sourceCode default">quantity_kind</code>,
-which explored the need of representing distinct quantities of the same
-dimension. To help guide its evolution, he’s been constantly pointing in
-the direction of <span class="citation" data-cites="BIPM-VIM">[<a href="#ref-BIPM-VIM" role="doc-biblioref">JCGM 200:2012</a>]</span> as a
-source of truth. And more recently, to <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>, also helping interpret
+experience in the domain, Johel was convinced that <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> was the future.</p>
+<p>Since 2020, Johel has been contributing to <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span>. He added
+<code class="sourceCode cpp">quantity_point</code>, the generalization
+of <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>time_point</code>,
+closing #1. He also added
+<code class="sourceCode cpp">quantity_kind</code>, which explored the
+need of representing distinct quantities of the same dimension. To help
+guide its evolution, he’s been constantly pointing in the direction of
+<span class="citation" data-cites="BIPM-VIM">[<a href="https://jcgm.bipm.org/vim/en" role="doc-biblioref">JCGM
+200:2012</a>]</span> as a source of truth. And more recently, to <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>, also helping interpret
 it.</p>
 <p>Computing systems engineering graduate. (C++) programmer since 2014.
 Lives at HEAD with C++Next and good practices. Performs in-depth code
@@ -1274,17 +1260,16 @@ <h2 data-number="5.3" id="charles-hogg"><span class="header-section-number">5.3<
 <p>He soon realized that there was a much broader need for Aurora’s
 units library. No publicly available units library for C++14 or C++17
 could match its ergonomics, developer experience, and performance. This
-motivated him to create <span class="citation" data-cites="AU">[<a href="#ref-AU" role="doc-biblioref">Au</a>]</span> in 2022: a new,
-zero-dependency units library, which was a drop-in replacement for
-Aurora’s original units library, but offered far more composable
-interfaces, and was built on simpler, stronger foundations. Once Au
-proved its value internally, Chip migrated it to a separate repository
-and led the open-sourcing process, culminating in its public release in
-2023.</p>
+motivated him to create <span class="citation" data-cites="AU">[<a href="https://aurora-opensource.github.io/au" role="doc-biblioref">Au</a>]</span> in 2022: a new, zero-dependency
+units library, which was a drop-in replacement for Aurora’s original
+units library, but offered far more composable interfaces, and was built
+on simpler, stronger foundations. Once Au proved its value internally,
+Chip migrated it to a separate repository and led the open-sourcing
+process, culminating in its public release in 2023.</p>
 <p>While Au provides excellent ergonomics and robustness for pre-C++20
 users, Chip also believes the C++ community would benefit from a
 standard units library. For that reason, he has joined forces with the
-<span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> project, contributing code and
+<span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> project, contributing code and
 design ideas.</p>
 <h2 data-number="5.4" id="nicolas-holthaus"><span class="header-section-number">5.4</span> Nicolas Holthaus<a href="#nicolas-holthaus" class="self-link"></a></h2>
 <p>Nicolas graduated Summa Cum Laude from Northwestern University with a
@@ -1297,18 +1282,18 @@ <h2 data-number="5.4" id="nicolas-holthaus"><span class="header-section-number">
 <p>Nicolas became obsessed with dimensional analysis as a high school
 JETS team member after learning that the $125M Mars Climate Orbiter was
 destroyed due to a simple feet-to-meters miscalculation. He developed
-the widely adopted C++ <span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="#ref-NHOLTHAUS-UNITS" role="doc-biblioref">nholthaus/units</a>]</span> library based on the
+the widely adopted C++ <span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="https://github.com/nholthaus/units" role="doc-biblioref">nholthaus/units</a>]</span> library based on the
 findings of the 2002 white paper “Dimensional Analysis in C++” by Scott
 Meyers. Astounded that no one smarter had already written such a
-library, he continued with <code class="sourceCode default">units</code>
-2.0 and 3.0 based on modern C++. Those libraries have been extensively
+library, he continued with <code class="sourceCode cpp">units</code> 2.0
+and 3.0 based on modern C++. Those libraries have been extensively
 adopted in many fields, including modeling &amp; simulation,
 agriculture, and geodesy.</p>
 <p>In 2023, recognizing the limits of
-<code class="sourceCode default">units</code>, he joined forces with
-Mateusz Pusz in his effort to standardize his evolutionary dimensional
-analysis library, with the goal of providing the highest-quality
-dimensional analysis to all C++ users via the C++ standard library.</p>
+<code class="sourceCode cpp">units</code>, he joined forces with Mateusz
+Pusz in his effort to standardize his evolutionary dimensional analysis
+library, with the goal of providing the highest-quality dimensional
+analysis to all C++ users via the C++ standard library.</p>
 <h2 data-number="5.5" id="roth-michaels"><span class="header-section-number">5.5</span> Roth Michaels<a href="#roth-michaels" class="self-link"></a></h2>
 <p>Roth Michaels is a Principal Software Engineer at <a href="https://www.native-instruments.com">Native Instruments</a>, a
 leading manufacturer of audio, and music, software and hardware. Working
@@ -1319,9 +1304,8 @@ <h2 data-number="5.5" id="roth-michaels"><span class="header-section-number">5.5
 encouraged Roth to explore various quantity/units libraries to see if
 they would apply to this domain. He has been doing research into
 defining and using digital audio and music domain-specific quantities
-and units using first <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> as
-proposed in <span class="citation" data-cites="P1935R2">[<a href="#ref-P1935R2" role="doc-biblioref">P1935R2</a>]</span> and the new
-V2 library described in this paper.</p>
+and units using first <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> as proposed in <span class="citation" data-cites="P1935R2">[<a href="https://wg21.link/p1935r2" role="doc-biblioref">P1935R2</a>]</span> and the new V2 library
+described in this paper.</p>
 <p>Before working for Native Instruments, Roth worked as a consultant in
 multiple industries using a variety of programming languages. He was
 involved with the Swift Evolution community in its early days before
@@ -1330,12 +1314,12 @@ <h2 data-number="5.5" id="roth-michaels"><span class="header-section-number">5.5
 <p>Holding a degree in music composition, Roth has over a decade of
 experience working with quantities and units of measure related to
 music, digital signal processing, analog audio, and acoustics. He has
-joined the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> project
-as a domain expert in these areas and to provide perspective on
-logarithmic and non-linear quantity/unit relationships.</p>
+joined the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> project as a domain expert in
+these areas and to provide perspective on logarithmic and non-linear
+quantity/unit relationships.</p>
 <h2 data-number="5.6" id="mateusz-pusz"><span class="header-section-number">5.6</span> Mateusz Pusz<a href="#mateusz-pusz" class="self-link"></a></h2>
 <p>Mateusz got interested in the physical units subject while
-contributing to the <span class="citation" data-cites="LK8000">[<a href="#ref-LK8000" role="doc-biblioref">LK8000</a>]</span> Tactical
+contributing to the <span class="citation" data-cites="LK8000">[<a href="http://lk8000.it" role="doc-biblioref">LK8000</a>]</span> Tactical
 Flight Computer Open Source project over 10 years ago. The project’s
 code was far from being “safe” in the C++ sense, and this is when
 Mateusz started to explore alternatives.</p>
@@ -1344,9 +1328,9 @@ <h2 data-number="5.6" id="mateusz-pusz"><span class="header-section-number">5.6<
 tried to write a better framework a few times from scratch by
 himself.</p>
 <p>Finally, with the availability of brand new Concepts TS in the gcc-7,
-the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> project
-was created. It was designed with safety and user experience in mind.
-After many years of working on the project, the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library is probably the most
+the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> project was created. It was
+designed with safety and user experience in mind. After many years of
+working on the project, the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library is probably the most
 modern and complete solution in the C++ market.</p>
 <p>Through the last few years, Mateusz has put much effort into building
 a community around physical units. He provided many talks and workshops
@@ -1360,7 +1344,7 @@ <h2 data-number="5.7" id="vincent-reverdy"><span class="header-section-number">5
 researcher at the French National Centre for Scientific Research (CNRS).
 He has been interested for years in units and quantities for programming
 languages to ensure higher levels of both expressivity and safety in
-computational physics codes. Back in 2019, he authored <span class="citation" data-cites="P1930R0">[<a href="#ref-P1930R0" role="doc-biblioref">P1930R0</a>]</span> to provide some context of what
+computational physics codes. Back in 2019, he authored <span class="citation" data-cites="P1930R0">[<a href="https://wg21.link/p1930r0" role="doc-biblioref">P1930R0</a>]</span> to provide some context of what
 could be a quantity and unit library for C++.</p>
 <p>After designing and implementing several Domain-Specific Language
 (DSL) demonstrators dedicated to units of measurements in C++, he became
@@ -1381,11 +1365,11 @@ <h2 data-number="6.1" id="safety"><span class="header-section-number">6.1</span>
 than it was a few years ago. However, writing safety-critical code
 requires extensive training and experience, both of which are in short
 demand. While there exists some standards and guidelines such as MISRA
-C++ <span class="citation" data-cites="MISRA_CPP">[<a href="#ref-MISRA_CPP" role="doc-biblioref">MISRA C++</a>]</span> with
-the aim of enforcing the creation of safe code in C++, they are
-cumbersome to use and tend to shift the burden on the discipline of the
-programmers to enforce these. At the time of writing, the C++ language
-does not change fast enough to enforce safe-by-construction code.</p>
+C++ <span class="citation" data-cites="MISRA_CPP">[<a href="https://misra.org.uk/misra-c-plus-plus/" role="doc-biblioref">MISRA C++</a>]</span> with the aim of enforcing the
+creation of safe code in C++, they are cumbersome to use and tend to
+shift the burden on the discipline of the programmers to enforce these.
+At the time of writing, the C++ language does not change fast enough to
+enforce safe-by-construction code.</p>
 <p>One of the ways C++ can significantly improve the safety of
 applications being written by thousands of developers is by introducing
 a type-safe, well-tested, standardized way to handle physical quantities
@@ -1396,16 +1380,15 @@ <h2 data-number="6.1" id="safety"><span class="header-section-number">6.1</span>
 <p>The most famous and probably the most expensive example in the
 software engineering domain is the Mars Climate Orbiter that in 1999
 failed to enter Mars’ orbit and crashed while entering its atmosphere
-<span class="citation" data-cites="MARS_ORBITER">[<a href="#ref-MARS_ORBITER" role="doc-biblioref">Mars Orbiter</a>]</span>.
-This is one of many examples here. People tend to confuse units quite
-often. We see similar errors occurring in various domains over the
-years:</p>
+<span class="citation" data-cites="MARS_ORBITER">[<a href="https://en.wikipedia.org/wiki/Mars_Climate_Orbiter" role="doc-biblioref">Mars Orbiter</a>]</span>. This is one of many
+examples here. People tend to confuse units quite often. We see similar
+errors occurring in various domains over the years:</p>
 <ul>
 <li>On October 12, 1492, Christopher Columbus unintentionally discovered
 the sea route from Europe to America because, during his travel
 preparations, he mixed the Arabic mile with a Roman mile, which led to
 the wrong estimation of the equator and his expected travel distance
-<span class="citation" data-cites="COLUMBUS">[<a href="#ref-COLUMBUS" role="doc-biblioref">Columbus</a>]</span>.</li>
+<span class="citation" data-cites="COLUMBUS">[<a href="https://en.wikipedia.org/wiki/Christopher_Columbus" role="doc-biblioref">Columbus</a>]</span>.</li>
 <li>In 1628, a new warship, Vasa, accidentally had an asymmetrical hull
 (being thicker on the port side than the starboard side), which was one
 of the reasons for her sinking less than a mile into her maiden voyage,
@@ -1413,47 +1396,46 @@ <h2 data-number="6.1" id="safety"><span class="header-section-number">6.1</span>
 been caused by the use of different systems of measurement, as
 archaeologists have found four rulers used by the workers who built the
 ship. Two were calibrated in Swedish feet, which had 12 inches, while
-the other two measured Amsterdam feet, which had 11 inches <span class="citation" data-cites="VASA">[<a href="#ref-VASA" role="doc-biblioref">Vasa</a>]</span>.</li>
+the other two measured Amsterdam feet, which had 11 inches <span class="citation" data-cites="VASA">[<a href="https://theworld.org/stories/2012-02-23/new-clues-emerge-centuries-old-swedish-shipwreck" role="doc-biblioref">Vasa</a>]</span>.</li>
 <li>Air Canada Flight 143 ran out of fuel on July 23, 1983, at an
 altitude of 41 000 feet (12 000 metres), midway through the flight
 because the fuel had been calculated in pounds instead of kilograms by
-the ground crew <span class="citation" data-cites="GIMLI_GLIDER">[<a href="#ref-GIMLI_GLIDER" role="doc-biblioref">Gimli
-Glider</a>]</span>.</li>
+the ground crew <span class="citation" data-cites="GIMLI_GLIDER">[<a href="https://en.wikipedia.org/wiki/Gimli_Glider" role="doc-biblioref">Gimli Glider</a>]</span>.</li>
 <li>The British rock band Black Sabbath, during its Born Again tour in
 1983, ordered a replica of Stonehenge as props for the scene.
 Unfortunately, they had to leave them in the storage area because, while
 submitting the order, their manager wrote dimensions down in meters when
 he meant feet, and so the stones didn’t fit the scene. “It cost a
 fortune to make, but there was not a building on Earth that you could
-fit it into” <span class="citation" data-cites="STONEHENGE">[<a href="#ref-STONEHENGE" role="doc-biblioref">Stonehenge</a>]</span>.</li>
+fit it into” <span class="citation" data-cites="STONEHENGE">[<a href="https://www.telegraph.co.uk/films/2020/05/01/tiny-stones-giant-laughs-story-behind-spinal-taps-stonehenge" role="doc-biblioref">Stonehenge</a>]</span>.</li>
 <li>On April 15, 1999, Korean Air Cargo Flight 6316 crashed due to a
-miscommunication between pilots about the desired flight altitude <span class="citation" data-cites="FLIGHT_6316">[<a href="#ref-FLIGHT_6316" role="doc-biblioref">Flight 6316</a>]</span>.</li>
+miscommunication between pilots about the desired flight altitude <span class="citation" data-cites="FLIGHT_6316">[<a href="https://web.archive.org/web/20210917190721/https://www.ntsb.gov/news/press-releases/Pages/Korean_Air_Flight_6316_MD-11_Shanghai_China_-_April_15_1999.aspx" role="doc-biblioref">Flight 6316</a>]</span>.</li>
 <li>In February 2001, the crew of the Moorpark College Zoo built an
 enclosure for Clarence the Tortoise with a weight of 250 pounds instead
-of 250 kilograms <span class="citation" data-cites="CLARENCE">[<a href="#ref-CLARENCE" role="doc-biblioref">Clarence</a>]</span>.</li>
+of 250 kilograms <span class="citation" data-cites="CLARENCE">[<a href="https://www.latimes.com/archives/la-xpm-2001-feb-09-me-23253-story.html" role="doc-biblioref">Clarence</a>]</span>.</li>
 <li>In December 2003, one of the roller coaster’s cars at Tokyo
 Disneyland’s Space Mountain attraction suddenly derailed due to a broken
 axle caused by confusion after upgrading the specification from imperial
-to metric units <span class="citation" data-cites="DISNEY">[<a href="#ref-DISNEY" role="doc-biblioref">Disney</a>]</span>.</li>
+to metric units <span class="citation" data-cites="DISNEY">[<a href="https://web.archive.org/web/20040209033827/http://www.olc.co.jp/news/20040121_01en.html" role="doc-biblioref">Disney</a>]</span>.</li>
 <li>During the construction of the Hochrheinbrücke bridge to connect the
 small German town of Laufenburg with Swiss Laufenburg, the construction
 team made a sign error that resulted in a discrepancy of 54 cm between
-the two outer ends of the bridge <span class="citation" data-cites="HOCHRHEINBRÜCKE">[<a href="#ref-HOCHRHEINBRÜCKE" role="doc-biblioref">Hochrheinbrücke</a>]</span>.</li>
+the two outer ends of the bridge <span class="citation" data-cites="HOCHRHEINBRÜCKE">[<a href="https://www.normaalamsterdamspeil.nl/wp-content/uploads/2015/03/website_bridge.pdf" role="doc-biblioref">Hochrheinbrücke</a>]</span>.</li>
 <li>An American company sold a shipment of wild rice to a Japanese
 customer, quoting a price of 39 cents per pound, but the customer
-thought the quote was for 39 cents per kilogram <span class="citation" data-cites="WILD_RICE">[<a href="#ref-WILD_RICE" role="doc-biblioref">Wild Rice</a>]</span>.</li>
+thought the quote was for 39 cents per kilogram <span class="citation" data-cites="WILD_RICE">[<a href="https://www.bizjournals.com/eastbay/stories/2001/07/09/focus3.html" role="doc-biblioref">Wild Rice</a>]</span>.</li>
 <li>On October 17, 2023, The Guardian published an article titled
 “Record Heat: Malawi swelters with temperatures nearly 68F above
 average” with many issues related to the affine space types and
 temperature units. Due to incorrect logic, probably during the
 translation of the article to the U.S. market,
-<code class="sourceCode default">20 °C</code> above the average
-temperature was converted to
-<code class="sourceCode default">68 °F</code>. The actual temperature
-increase was <code class="sourceCode default">32 °F</code>, not
-<code class="sourceCode default">68 °F</code> <span class="citation" data-cites="THE_GUARDIAN">[<a href="#ref-THE_GUARDIAN" role="doc-biblioref">The Guardian</a>]</span>.</li>
-<li>A whole set of <span class="citation" data-cites="MEDICATION_DOSE_ERRORS">[<a href="#ref-MEDICATION_DOSE_ERRORS" role="doc-biblioref">Medication dose
-errors</a>]</span>…</li>
+<code class="sourceCode cpp"><span class="dv">20</span> °C</code> above
+the average temperature was converted to
+<code class="sourceCode cpp"><span class="dv">68</span> °F</code>. The
+actual temperature increase was
+<code class="sourceCode cpp"><span class="dv">32</span> °F</code>, not
+<code class="sourceCode cpp"><span class="dv">68</span> °F</code> <span class="citation" data-cites="THE_GUARDIAN">[<a href="https://randomascii.wordpress.com/2023/10/17/localization-failure-temperature-is-hard" role="doc-biblioref">The Guardian</a>]</span>.</li>
+<li>A whole set of <span class="citation" data-cites="MEDICATION_DOSE_ERRORS">[<a href="https://onlinelibrary.wiley.com/doi/10.1111/jan.15072" role="doc-biblioref">Medication dose errors</a>]</span>…</li>
 </ul>
 <p>The safety subject is so vast and essential by itself that we
 dedicated an entire <a href="#safety-features">Safety features</a>
@@ -1465,21 +1447,22 @@ <h2 data-number="6.2" id="vocabulary-types"><span class="header-section-number">
 to provide a standardized way of communication between different
 vendors.</p>
 <p>Let’s imagine a world without
-<code class="sourceCode default">std::string</code> or
-<code class="sourceCode default">std::vector</code>. Every vendor has
-their version of it, and of course, they are highly incompatible with
-each other. As a result, when someone needs to integrate software from
-different vendors, it turns out to be an unnecessarily arduous task.</p>
-<p>Introducing
-<code class="sourceCode default">std::chrono::duration</code> and
-<code class="sourceCode default">std::chrono::time_point</code> improved
-the interfaces a lot, but time is only one of many quantities that we
-deal with in our software on a daily basis. We desperately need to be
-able to express more quantities and units in a standardized way so
+<code class="sourceCode cpp">std<span class="op">::</span>string</code>
+or
+<code class="sourceCode cpp">std<span class="op">::</span>vector</code>.
+Every vendor has their version of it, and of course, they are highly
+incompatible with each other. As a result, when someone needs to
+integrate software from different vendors, it turns out to be an
+unnecessarily arduous task.</p>
+<p>Introducing <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>
+and <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>time_point</code>
+improved the interfaces a lot, but time is only one of many quantities
+that we deal with in our software on a daily basis. We desperately need
+to be able to express more quantities and units in a standardized way so
 different libraries get means to communicate with each other.</p>
 <p>If Lockheed Martin and NASA could have used standardized vocabulary
 types in their interfaces, maybe they would not interpret pound-force
-seconds as newton seconds, and the <span class="citation" data-cites="MARS_ORBITER">[<a href="#ref-MARS_ORBITER" role="doc-biblioref">Mars Orbiter</a>]</span> would not have crashed
+seconds as newton seconds, and the <span class="citation" data-cites="MARS_ORBITER">[<a href="https://en.wikipedia.org/wiki/Mars_Climate_Orbiter" role="doc-biblioref">Mars Orbiter</a>]</span> would not have crashed
 during the Mars orbital insertion maneuver.</p>
 <h2 data-number="6.3" id="certification"><span class="header-section-number">6.3</span> Certification<a href="#certification" class="self-link"></a></h2>
 <p>Mission and life-critical projects, or those for embedded devices,
@@ -1517,11 +1500,11 @@ <h2 data-number="6.4" id="complex-and-complicated"><span class="header-section-n
 and create a correct implementation in C++. As a result, companies
 either use really simple and unsafe numeric wrappers, or abandon the
 effort entirely and just use built-in types, such as
-<code class="sourceCode default">float</code> or
-<code class="sourceCode default">int</code>, to express quantity values,
-thus losing all semantic categorization. This often leads to safety
-issues caused by accidentally using values representing the wrong
-quantity or having an incorrect unit.</p>
+<code class="sourceCode cpp"><span class="dt">float</span></code> or
+<code class="sourceCode cpp"><span class="dt">int</span></code>, to
+express quantity values, thus losing all semantic categorization. This
+often leads to safety issues caused by accidentally using values
+representing the wrong quantity or having an incorrect unit.</p>
 <h2 data-number="6.5" id="extensibility"><span class="header-section-number">6.5</span> Extensibility<a href="#extensibility" class="self-link"></a></h2>
 <p>Many applications of a quantity and units library may need to operate
 on a combination of standard (e.g., SI) and domain-specific quantities
@@ -1530,18 +1513,17 @@ <h2 data-number="6.5" id="extensibility"><span class="header-section-number">6.5
 that have all the expressivity and safety as those provided by the
 library.</p>
 <p>Experience with writing ad hoc typed quantities without library
-support that can be combined with or converted to
-<code class="sourceCode default">std::chrono::duration</code> has shown
-the downside of bespoke solutions: If not all operations or conversions
-are handled, users will need to leave the safety of typed quantities to
-operate on primitive types.</p>
+support that can be combined with or converted to <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>
+has shown the downside of bespoke solutions: If not all operations or
+conversions are handled, users will need to leave the safety of typed
+quantities to operate on primitive types.</p>
 <p>The interfaces of the this library were designed with ease of
 extensibility in mind. Each definition of a dimension, quantity type, or
 unit typically takes only a single line of code. This is possible thanks
 to the extensive usage of C++20 class types as Non-Type Template
 Parameters (NTTP). For example, the following code presents how second
-(a unit of time in the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>) and hertz (a unit of
-frequency in the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>) can be defined:</p>
+(a unit of time in the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>) and hertz (a unit of frequency in
+the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>) can be defined:</p>
 <div class="sourceCode" id="cb1"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> second <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;s&quot;</span>, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>time<span class="op">&gt;&gt;</span> <span class="op">{}</span> second;</span>
 <span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> hertz <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;Hz&quot;</span>, <span class="dv">1</span> <span class="op">/</span> second, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>frequency<span class="op">&gt;&gt;</span> <span class="op">{}</span> hertz;</span></code></pre></div>
 <h2 data-number="6.6" id="broad-industry-value"><span class="header-section-number">6.6</span> Broad industry value<a href="#broad-industry-value" class="self-link"></a></h2>
@@ -1578,15 +1560,17 @@ <h2 data-number="6.7" id="standardizing-existing-practice"><span class="header-s
 <p>Plenty of physical units libraries have been available to the public
 for many years. In 1998 Walter Brown provided an “Introduction to the SI
 Library of Unit-Based Computation” paper for the International
-Conference on Computing in High Energy Physics <span class="citation" data-cites="CHEP98">[<a href="#ref-CHEP98" role="doc-biblioref">CHEP’98</a>]</span>. It emphasizes the importance
+Conference on Computing in High Energy Physics <span class="citation" data-cites="CHEP98">[<a href="https://digital.library.unt.edu/ark:/67531/metadc668099" role="doc-biblioref">CHEP’98</a>]</span>. It emphasizes the importance
 of strong types and static type-checking. After that, it describes a
-library modeling the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> to provide “strict
-compile-time type-checking without run-time overhead”.</p>
+library modeling the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> to provide “strict compile-time
+type-checking without run-time overhead”.</p>
 <p>It also states that at this time, “in numeric programming,
 programmers make heavy, near-exclusive, use of a language’s native
-numeric types (e.g., <code class="sourceCode default">double</code>)”.
+numeric types (e.g.,
+<code class="sourceCode cpp"><span class="dt">double</span></code>)”.
 Today, twenty-five years later, plenty of “Modern C++” production code
-bases still use <code class="sourceCode default">double</code> to
+bases still use
+<code class="sourceCode cpp"><span class="dt">double</span></code> to
 represent various quantities and units. It is high time to change
 this.</p>
 <p>Throughout the years, we have learned the best practices for handling
@@ -1597,7 +1581,7 @@ <h2 data-number="6.7" id="standardizing-existing-practice"><span class="header-s
 <p>The authors of this paper developed and delivered multiple successful
 C++ libraries for this domain. Libraries developed by them <a href="https://github.com/topics/dimensional-analysis?l=c%2B%2B">have
 more than 90% of all the stars on GitHub in the field of physical units
-libraries for C++</a>. The <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library, which is the base of
+libraries for C++</a>. The <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library, which is the base of
 this proposal, has the most number of stars in this list, making it the
 most popular project in the C++ industry.</p>
 <p>The authors joined forces and are working together to propose the
@@ -1613,11 +1597,12 @@ <h1 data-number="7" id="common-smells-when-there-is-no-library-for-quantities-an
 projects, expensive revenue-generating production source code often is
 similar.</p>
 <h2 data-number="7.1" id="the-proliferation-of-double"><span class="header-section-number">7.1</span> The proliferation of
-<code class="sourceCode default">double</code><a href="#the-proliferation-of-double" class="self-link"></a></h2>
+<code class="sourceCode cpp"><span class="dt">double</span></code><a href="#the-proliferation-of-double" class="self-link"></a></h2>
 <p>It turns out that in the C++ software, most of our calculations in
 the physical quantities and units domain are handled with fundamental
-types like <code class="sourceCode default">double</code>. Code like
-below is a typical example here:</p>
+types like
+<code class="sourceCode cpp"><span class="dt">double</span></code>. Code
+like below is a typical example here:</p>
 <div class="sourceCode" id="cb2"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="dt">double</span> GlidePolar<span class="op">::</span>MacCreadyAltitude<span class="op">(</span><span class="dt">double</span> MCREADY,</span>
 <span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a>                                     <span class="dt">double</span> Distance,</span>
 <span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a>                                     <span class="kw">const</span> <span class="dt">double</span> Bearing,</span>
@@ -1633,17 +1618,16 @@ <h2 data-number="7.1" id="the-proliferation-of-double"><span class="header-secti
 <p><a href="https://github.com/LK8000/LK8000/blob/af404168ff5f92b03ab0c5db336ed8f01a792cda/Common/Header/McReady.h#L7-L21">Original
 code here</a>.</p>
 <p>There are several problems with such an approach: The abundance of
-<code class="sourceCode default">double</code> parameters makes it easy
-to accidentally switch values and there is no way of noticing such a
-mistake at compile-time. The code is not self-documenting in what units
-the parameters are expected. Is
-<code class="sourceCode default">Distance</code> in meters or
-kilometers? Is <code class="sourceCode default">WindSpeed</code> in
-meters per second or knots? Different code bases choose different ways
-to encode this information, which may be internally inconsistent. A
-strong type system would help answer these questions at the time the
-interface is written, and the compiler would verify it at
-compile-time.</p>
+<code class="sourceCode cpp"><span class="dt">double</span></code>
+parameters makes it easy to accidentally switch values and there is no
+way of noticing such a mistake at compile-time. The code is not
+self-documenting in what units the parameters are expected. Is
+<code class="sourceCode cpp">Distance</code> in meters or kilometers? Is
+<code class="sourceCode cpp">WindSpeed</code> in meters per second or
+knots? Different code bases choose different ways to encode this
+information, which may be internally inconsistent. A strong type system
+would help answer these questions at the time the interface is written,
+and the compiler would verify it at compile-time.</p>
 <h2 data-number="7.2" id="the-proliferation-of-magic-numbers"><span class="header-section-number">7.2</span> The proliferation of magic
 numbers<a href="#the-proliferation-of-magic-numbers" class="self-link"></a></h2>
 <p>There are a lot of constants and conversion factors involved in the
@@ -1659,8 +1643,8 @@ <h2 data-number="7.2" id="the-proliferation-of-magic-numbers"><span class="heade
 maintain, and it needs a lot of domain knowledge on the developer’s
 side. While it would be easy to replace these numbers with named
 constants, the question of which unit the constant is in remains. Is
-<code class="sourceCode default">287.06</code> in pounds per square inch
-(psi) or millibars (mbar)?</p>
+<code class="sourceCode cpp"><span class="fl">287.06</span></code> in
+pounds per square inch (psi) or millibars (mbar)?</p>
 <h2 data-number="7.3" id="the-proliferation-of-conversion-macros"><span class="header-section-number">7.3</span> The proliferation of conversion
 macros<a href="#the-proliferation-of-conversion-macros" class="self-link"></a></h2>
 <p>The lack of automated unit conversions often results in handwritten
@@ -1694,13 +1678,13 @@ <h2 data-number="7.3" id="the-proliferation-of-conversion-macros"><span class="h
 code here</a>.</p>
 <p>Again, the question of which unit the constant is in remains. Without
 looking at the code, it is impossible to tell from which unit
-<code class="sourceCode default">TOMETER</code> converts. Also, macros
-have the problem that they are not scoped to a namespace and thus can
-easily clash with other macros or functions, especially if they have
-such common names like <code class="sourceCode default">PI</code> or
-<code class="sourceCode default">RAD_TO_DEG</code>. A quick search
-through open source C++ code bases reveals that, for example, the
-<code class="sourceCode default">RAD_TO_DEG</code> macro is defined in a
+<code class="sourceCode cpp">TOMETER</code> converts. Also, macros have
+the problem that they are not scoped to a namespace and thus can easily
+clash with other macros or functions, especially if they have such
+common names like <code class="sourceCode cpp">PI</code> or
+<code class="sourceCode cpp">RAD_TO_DEG</code>. A quick search through
+open source C++ code bases reveals that, for example, the
+<code class="sourceCode cpp">RAD_TO_DEG</code> macro is defined in a
 multitude of different ways – sometimes even within the same
 repository:</p>
 <div class="sourceCode" id="cb5"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="pp">#define RAD_TO_DEG </span><span class="op">(</span><span class="dv">180</span><span class="pp"> </span><span class="op">/</span><span class="pp"> </span>PI<span class="op">)</span></span>
@@ -1720,7 +1704,7 @@ <h2 data-number="7.3" id="the-proliferation-of-conversion-macros"><span class="h
 necessary parentheses are missing, processing in a preprocessor ends up
 with redundant casts, or some compile-time constants use too many digits
 for a value to be exact for a specific type (e.g.,
-<code class="sourceCode default">float</code>).</p>
+<code class="sourceCode cpp"><span class="dt">float</span></code>).</p>
 <h2 data-number="7.4" id="lack-of-consistency"><span class="header-section-number">7.4</span> Lack of consistency<a href="#lack-of-consistency" class="self-link"></a></h2>
 <p>If we not only lack strong types to isolate the abstractions from
 each other, but also lack discipline to keep our code consistent, we end
@@ -1750,10 +1734,9 @@ <h2 data-number="7.4" id="lack-of-consistency"><span class="header-section-numbe
 code here</a>.</p>
 <p>Users can easily make errors if the interface designers are not
 consistent in ordering parameters. It is really hard to remember which
-function takes latitude or
-<code class="sourceCode default">Bearing</code> first and when a
-latitude or <code class="sourceCode default">Distance</code> is in the
-front.</p>
+function takes latitude or <code class="sourceCode cpp">Bearing</code>
+first and when a latitude or
+<code class="sourceCode cpp">Distance</code> is in the front.</p>
 <h2 data-number="7.5" id="lack-of-a-conceptual-framework"><span class="header-section-number">7.5</span> Lack of a conceptual
 framework<a href="#lack-of-a-conceptual-framework" class="self-link"></a></h2>
 <p>The previous points mean that the fundamental types can’t be
@@ -1761,14 +1744,15 @@ <h2 data-number="7.5" id="lack-of-a-conceptual-framework"><span class="header-se
 frameworks. There is no shared vocabulary between different libraries.
 User-facing APIs use ad-hoc conventions. Even internal interfaces are
 inconsistent between themselves.</p>
-<p>Arithmetic types such as <code class="sourceCode default">int</code>
-and <code class="sourceCode default">double</code> are used to model
-different concepts. They are used to represent any abstraction (be it a
-magnitude, difference, point, or kind) of any quantity type of any unit.
-These are weak types that make up weakly-typed interfaces. The resulting
-interfaces and implementations built with these types easily allow
-mixing up parameters and using operations that are not part of the
-represented quantity.</p>
+<p>Arithmetic types such as
+<code class="sourceCode cpp"><span class="dt">int</span></code> and
+<code class="sourceCode cpp"><span class="dt">double</span></code> are
+used to model different concepts. They are used to represent any
+abstraction (be it a magnitude, difference, point, or kind) of any
+quantity type of any unit. These are weak types that make up
+weakly-typed interfaces. The resulting interfaces and implementations
+built with these types easily allow mixing up parameters and using
+operations that are not part of the represented quantity.</p>
 <h1 data-number="8" id="design-goals"><span class="header-section-number">8</span> Design goals<a href="#design-goals" class="self-link"></a></h1>
 <p>The library facilities that we plan to propose in the upcoming papers
 is designed with the following goals in mind.</p>
@@ -1831,7 +1815,7 @@ <h2 data-number="8.6" id="low-standardization-cost"><span class="header-section-
 <p>Derived units do not need separate library types. Instead, they can
 be obtained through the composition of predefined named units. Units
 should not be associated with User-Defined Literals (UDLs), as it is the
-case with <code class="sourceCode default">std::chrono::duration</code>.
+case with <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>.
 UDLs do not compose, have very limited scope and functionality, and are
 expensive to standardize.</p>
 <p>The user interface should have no preprocessor macros.</p>
@@ -1839,7 +1823,7 @@ <h2 data-number="8.6" id="low-standardization-cost"><span class="header-section-
 output) to be freestanding.</p>
 <h1 data-number="9" id="quick-domain-introduction"><span class="header-section-number">9</span> Quick domain introduction<a href="#quick-domain-introduction" class="self-link"></a></h1>
 <p>This chapter provides a very brief introduction to the quantities and
-units domain. Please refer to <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> and <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> for more details.</p>
+units domain. Please refer to <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> and <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> for more details.</p>
 <!-- 
 flowchart TD
     dimension --- quantity_type["quantity type"]
@@ -1882,16 +1866,16 @@ <h2 data-number="9.1" id="dimension"><span class="header-section-number">9.1</sp
 <em>luminous intensity</em> (<span class="math inline">\(J\)</span>) are
 the base dimensions of the ISQ.</li>
 <li>A derived dimension of <em>force</em> in the ISQ is denoted by <span class="math inline">\(dim\;F = LMT^{–2}\)</span>.</li>
-<li><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-(part 13) provides <em>traffic intensity</em> quantity that is measured
-in erlangs but not in the unit one, which also implies that it should be
-introduced as a base quantity with its own dimension.</li>
+<li><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 13) provides
+<em>traffic intensity</em> quantity that is measured in erlangs but not
+in the unit one, which also implies that it should be introduced as a
+base quantity with its own dimension.</li>
 </ul>
 <h2 data-number="9.2" id="quantity-type"><span class="header-section-number">9.2</span> Quantity type<a href="#quantity-type" class="self-link"></a></h2>
-<p>Dimension is not enough to describe a quantity. This is why <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides hundreds of
+<p>Dimension is not enough to describe a quantity. This is why <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides hundreds of
 named quantity types. It turns out that there are many more quantity
-types in the ISQ than the named units in the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>.</p>
-<p><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> also defines the term
+types in the ISQ than the named units in the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>.</p>
+<p><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> also defines the term
 <strong>kind of quantity</strong> as an aspect common to mutually
 comparable quantities. It explicitly says that two or more quantities
 cannot be added or subtracted unless they belong to the same category of
@@ -1914,7 +1898,7 @@ <h2 data-number="9.2" id="quantity-type"><span class="header-section-number">9.2
 quantities in its quantity dimension are zero. Typically, they represent
 ratios of two quantities of the same dimension or counts of things.</p>
 <h2 data-number="9.3" id="quantity-reference"><span class="header-section-number">9.3</span> Quantity reference<a href="#quantity-reference" class="self-link"></a></h2>
-<p><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> defines a quantity
+<p><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> defines a quantity
 as:</p>
 <blockquote>
 <p>property of a phenomenon, body, or substance, where the property has
@@ -1957,8 +1941,8 @@ <h2 data-number="9.3" id="quantity-reference"><span class="header-section-number
 per mole equal to <span class="math inline">\(10^{−3}\)</span> and
 microgram per kilogram equal to <span class="math inline">\(10^{−9}\)</span>.</p>
 <h2 data-number="9.4" id="quantity"><span class="header-section-number">9.4</span> Quantity<a href="#quantity" class="self-link"></a></h2>
-<p>As stated above, <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-defines a quantity as:</p>
+<p>As stated above, <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> defines a quantity
+as:</p>
 <blockquote>
 <p>property of a phenomenon, body, or substance, where the property has
 a magnitude that can be expressed as a number and a reference.</p>
@@ -1969,7 +1953,7 @@ <h2 data-number="9.4" id="quantity"><span class="header-section-number">9.4</spa
 reference into the C++ type expressing the quantity so it does not
 occupy a space/storage at runtime.</p>
 <p>It is also worth mentioning here that the distinction between a
-quantity and a quantity type is not clearly defined in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>. <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> even explicitly
+quantity and a quantity type is not clearly defined in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>. <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> even explicitly
 states:</p>
 <blockquote>
 <p>It is customary to use the same term, “quantity”, to refer to both
@@ -1986,7 +1970,7 @@ <h2 data-number="9.4" id="quantity"><span class="header-section-number">9.4</spa
 <li>“quantity” when we mean the instance of a quantity that also stores
 its numerical value.</li>
 </ul>
-<p>It is also worth mentioning here that <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> does not distinguish
+<p>It is also worth mentioning here that <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> does not distinguish
 between point and vector/interval quantities of <a href="#the-affine-space">The affine space</a>.</p>
 <h1 data-number="10" id="api-overview"><span class="header-section-number">10</span> API overview<a href="#api-overview" class="self-link"></a></h1>
 <p>This chapter is intended to be a short overview and present the
@@ -2000,7 +1984,7 @@ <h1 data-number="10" id="api-overview"><span class="header-section-number">10</s
 <h2 data-number="10.1" id="unit-based-quantities-simple-mode"><span class="header-section-number">10.1</span> Unit-based quantities (simple
 mode)<a href="#unit-based-quantities-simple-mode" class="self-link"></a></h2>
 <p>Consistently with a <a href="#quantity">Quantity</a> definition, a
-<code class="sourceCode default">quantity</code> class template takes a
+<code class="sourceCode cpp">quantity</code> class template takes a
 reference and a representation type as parameters:</p>
 <div class="sourceCode" id="cb7"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>Reference <span class="kw">auto</span> R,</span>
 <span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a>         RepresentationOf<span class="op">&lt;</span>get_quantity_spec<span class="op">(</span>R<span class="op">).</span>character<span class="op">&gt;</span> Rep <span class="op">=</span> <span class="dt">double</span><span class="op">&gt;</span></span>
@@ -2013,21 +1997,22 @@ <h3 data-number="10.1.1" id="constructing-a-quantity"><span class="header-sectio
 and a representation type as provided in the initializer, it is
 recommended to use CTAD:</p>
 <div class="sourceCode" id="cb9"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a>quantity q<span class="op">{</span><span class="dv">42</span>, si<span class="op">::</span>metre<span class="op">}</span>;</span></code></pre></div>
-<p>Please, note that <code class="sourceCode default">double</code> is
+<p>Please, note that
+<code class="sourceCode cpp"><span class="dt">double</span></code> is
 used as a default representation type, so the following does not result
 with a quantity of integral representation type:</p>
 <div class="sourceCode" id="cb10"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">&gt;</span> q2<span class="op">{</span><span class="dv">42</span>, si<span class="op">::</span>metre<span class="op">}</span>;</span></code></pre></div>
 <p>This is why CTAD usage is recommended when the user wants to prevent
 potential conversion and just deduce the
-<code class="sourceCode default">quantity</code> class template
-parameters from the initializer. This often prevents unneeded
-conversions that can affect runtime performance or memory footprint.</p>
+<code class="sourceCode cpp">quantity</code> class template parameters
+from the initializer. This often prevents unneeded conversions that can
+affect runtime performance or memory footprint.</p>
 <p>CTAD-based spelling is shorter but is still quite verbose. Consider
 having to write:</p>
 <div class="sourceCode" id="cb11"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> quantity<span class="op">{</span><span class="dv">1</span>, si<span class="op">::</span>kilo<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">&gt;}</span> <span class="op">+</span> quantity<span class="op">{</span><span class="dv">200</span>, si<span class="op">::</span>metre<span class="op">}</span>;</span></code></pre></div>
 <p>This is why the library offers an alternative way to construct a
 quantity.</p>
-<p>The <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> says:</p>
+<p>The <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> says:</p>
 <blockquote>
 <p>The value of the quantity is the product of the number and the unit.
 The space between the number and the unit is regarded as a
@@ -2037,20 +2022,18 @@ <h3 data-number="10.1.1" id="constructing-a-quantity"><span class="header-sectio
 <p>Following the above, the value of a quantity can also be created by
 multiplying a number with a predefined unit:</p>
 <div class="sourceCode" id="cb12"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> si<span class="op">::</span>metre;</span></code></pre></div>
-<p>The above creates an instance of
-<code class="sourceCode default">quantity&lt;si::metre(), int&gt;</code>.
+<p>The above creates an instance of <code class="sourceCode cpp">quantity<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">()</span>, <span class="dt">int</span><span class="op">&gt;</span></code>.
 It is worth noting here that the syntax with the reversed order of
-arguments is invalid and will not compile (e.g., we can’t write
-<code class="sourceCode default">si::metre * 42</code>).</p>
+arguments is invalid and will not compile (e.g., we can’t write <code class="sourceCode cpp">si<span class="op">::</span>metre <span class="op">*</span> <span class="dv">42</span></code>).</p>
 <p>The same can be obtained using an optional unit symbol:</p>
 <div class="sourceCode" id="cb13"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> <span class="kw">namespace</span> si<span class="op">::</span>unit_symbols;</span>
 <span id="cb13-2"><a href="#cb13-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb13-3"><a href="#cb13-3" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> m;</span></code></pre></div>
 <p>Unit symbols introduce a lot of short identifiers into the current
 scope, which is why they are opt-in. A user has to explicitly “import”
-them from a dedicated
-<code class="sourceCode default">unit_symbols</code> namespace.</p>
-<p><span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> specifies 7 base and 22 coherent
+them from a dedicated <code class="sourceCode cpp">unit_symbols</code>
+namespace.</p>
+<p><span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> specifies 7 base and 22 coherent
 derived units with special names. Additionally, it specifies 24
 prefixes. There are also non-SI units accepted for use with SI. Some of
 them are really popular, for example, minute, hour, day, degree, litre,
@@ -2067,14 +2050,14 @@ <h3 data-number="10.1.1" id="constructing-a-quantity"><span class="header-sectio
 <p>The library is optimized to generate short and easy-to-understand
 types that highly improve the analysis of compile-time errors and
 debugging experience. All of the above definitions will create an
-instance of the type <code class="sourceCode default">quantity&lt;derived_unit&lt;si::kilo_&lt;si::metre&gt;, per&lt;non_si::hour&gt;&gt;{}, int&gt;&gt;</code>.
+instance of the type <code class="sourceCode cpp">quantity<span class="op">&lt;</span>derived_unit<span class="op">&lt;</span>si<span class="op">::</span>kilo_<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">&gt;</span>, per<span class="op">&lt;</span>non_si<span class="op">::</span>hour<span class="op">&gt;&gt;{}</span>, <span class="dt">int</span><span class="op">&gt;&gt;</span></code>.
 As we can see, the type generation is optimized to be easily understood
 even by non-experts in the domain. The library tries to keep the type’s
 readability as close to English as possible.</p>
 <p>To learn find more discussion on a quantity creation syntax please
 refer to the following chapters:</p>
 <ul>
-<li><a href="#explicit-is-not-explicit-enough"><code class="sourceCode default">explicit</code>
+<li><a href="#explicit-is-not-explicit-enough"><code class="sourceCode cpp"><span class="kw">explicit</span></code>
 is not explicit enough</a>,</li>
 <li><a href="#why-dont-we-use-udls-to-create-quantities">Why don’t we
 use UDLs to create quantities?</a>,</li>
@@ -2099,28 +2082,28 @@ <h3 data-number="10.1.2" id="typical-operations-on-quantities"><span class="head
 <p>The above prints:</p>
 <pre class="text"><code>Thanks for driving within the speed limit of 100 km/h :-)</code></pre>
 <h4 data-number="10.1.2.1" id="unit-conversions"><span class="header-section-number">10.1.2.1</span> Unit conversions<a href="#unit-conversions" class="self-link"></a></h4>
-<p>If we want to change the unit of a current quantity, we can use
-<code class="sourceCode default">.in(Unit)</code> member function:</p>
+<p>If we want to change the unit of a current quantity, we can use <code class="sourceCode cpp"><span class="op">.</span>in<span class="op">(</span>Unit<span class="op">)</span></code>
+member function:</p>
 <div class="sourceCode" id="cb17"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;The total distance in meters is &quot;</span> <span class="op">&lt;&lt;</span> <span class="op">(</span>dist1 <span class="op">+</span> dist2<span class="op">).</span>in<span class="op">(</span>m<span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span>;</span></code></pre></div>
-<p>The <code class="sourceCode default">.in</code> utility has safety
-mechanisms to prevent accidentally losing precision. For example, we
-could try doing the same thing to express
-<code class="sourceCode default">speed_limit</code> in
-<code class="sourceCode default">m/s</code>, which is equivalent to
-multiplying the underlying value by the non-integer factor <span class="math inline">\(5 / 18\)</span>:</p>
+<p>The <code class="sourceCode cpp"><span class="op">.</span>in</code>
+utility has safety mechanisms to prevent accidentally losing precision.
+For example, we could try doing the same thing to express
+<code class="sourceCode cpp">speed_limit</code> in
+<code class="sourceCode cpp">m<span class="op">/</span>s</code>, which
+is equivalent to multiplying the underlying value by the non-integer
+factor <span class="math inline">\(5 / 18\)</span>:</p>
 <div class="sourceCode" id="cb18"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb18-1"><a href="#cb18-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;The speed limit in m/s is &quot;</span> <span class="op">&lt;&lt;</span> speed_limit<span class="op">.</span>in<span class="op">(</span>m <span class="op">/</span> s<span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span>;</span>
 <span id="cb18-2"><a href="#cb18-2" aria-hidden="true" tabindex="-1"></a><span class="co">// Compiler error!  Does not work.</span></span></code></pre></div>
 <p>However, scaling an integral type by a rational or irrational factor
 is considered not value-preserving. To force such a conversion, we can
-use either a <code class="sourceCode default">.force_in(Unit)</code>
-member function or an explicit
-<code class="sourceCode default">value_cast&lt;Unit&gt;(Quantity)</code>.</p>
+use either a <code class="sourceCode cpp"><span class="op">.</span>force_in<span class="op">(</span>Unit<span class="op">)</span></code>
+member function or an explicit <code class="sourceCode cpp">value_cast<span class="op">&lt;</span>Unit<span class="op">&gt;(</span>Quantity<span class="op">)</span></code>.</p>
 <div class="sourceCode" id="cb19"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb19-1"><a href="#cb19-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;The speed limit in m/s is &quot;</span> <span class="op">&lt;&lt;</span> speed_limit<span class="op">.</span>force_in<span class="op">(</span>m <span class="op">/</span> s<span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span>;</span>
 <span id="cb19-2"><a href="#cb19-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;The speed limit in m/s is &quot;</span> <span class="op">&lt;&lt;</span> value_cast<span class="op">&lt;</span>m <span class="op">/</span> s<span class="op">&gt;(</span>speed_limit<span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span>;</span></code></pre></div>
-<p>We will get a truncated value of
-<code class="sourceCode default">27 m/s</code> in both cases.</p>
+<p>We will get a truncated value of <code class="sourceCode cpp"><span class="dv">27</span> m<span class="op">/</span>s</code>
+in both cases.</p>
 <p>To prevent truncation, we must explicitly change the quantity
-representation type to a value-preserving one with <code class="sourceCode default">value_cast&lt;Representation&gt;(Quantity)</code>
+representation type to a value-preserving one with <code class="sourceCode cpp">value_cast<span class="op">&lt;</span>Representation<span class="op">&gt;(</span>Quantity<span class="op">)</span></code>
 overload. For example:</p>
 <div class="sourceCode" id="cb20"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb20-1"><a href="#cb20-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;The speed limit in m/s is &quot;</span> <span class="op">&lt;&lt;</span> value_cast<span class="op">&lt;</span><span class="dt">double</span><span class="op">&gt;(</span>speed_limit<span class="op">).</span>in<span class="op">(</span>m <span class="op">/</span> s<span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span>;</span></code></pre></div>
 <p>This time, we will see the following in the text output:</p>
@@ -2131,20 +2114,18 @@ <h4 data-number="10.1.2.2" id="obtaining-a-numerical-value-of-a-quantity"><span
 value of a quantity<a href="#obtaining-a-numerical-value-of-a-quantity" class="self-link"></a></h4>
 <p>Last but not least, if we need to obtain the numerical value of a
 quantity and pass it to some the legacy unsafe interface, we can use
-either <code class="sourceCode default">.numerical_value_in(Unit)</code>
-or
-<code class="sourceCode default">.force_numerical_value_in(Unit)</code>
+either <code class="sourceCode cpp"><span class="op">.</span>numerical_value_in<span class="op">(</span>Unit<span class="op">)</span></code>
+or <code class="sourceCode cpp"><span class="op">.</span>force_numerical_value_in<span class="op">(</span>Unit<span class="op">)</span></code>
 member functions:</p>
 <div class="sourceCode" id="cb21"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb21-1"><a href="#cb21-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> legacy_check_speed_limit<span class="op">(</span><span class="dt">int</span> speed_in_km_per_h<span class="op">)</span>;</span></code></pre></div>
 <div class="sourceCode" id="cb22"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb22-1"><a href="#cb22-1" aria-hidden="true" tabindex="-1"></a>legacy_check_speed_limit<span class="op">(((</span>dist1 <span class="op">+</span> dist2<span class="op">)</span> <span class="op">/</span> duration<span class="op">).</span>numerical_value_in<span class="op">(</span>km <span class="op">/</span> h<span class="op">))</span>;</span></code></pre></div>
 <p>Such a getter will explicitly enforce the usage of a correct unit
 required by the underlying interface, which reduces a significant number
 of safety-related issues.</p>
-<p><code class="sourceCode default">numerical_value_in(Unit)</code>
+<p><code class="sourceCode cpp">numerical_value_in<span class="op">(</span>Unit<span class="op">)</span></code>
 always returns by value as a quantity value conversion may be required
 to adjust to the target unit. In case a user needs a reference to the
-underlying storage
-<code class="sourceCode default">.numerical_value_ref_in(Unit)</code>
+underlying storage <code class="sourceCode cpp"><span class="op">.</span>numerical_value_ref_in<span class="op">(</span>Unit<span class="op">)</span></code>
 should be used:</p>
 <div class="sourceCode" id="cb23"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb23-1"><a href="#cb23-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> legacy_set_speed_limit<span class="op">(</span><span class="dt">int</span><span class="op">*</span> speed_in_km_per_h<span class="op">)</span> <span class="op">{</span> <span class="op">*</span>speed_in_km_per_h <span class="op">=</span> <span class="dv">100</span>; <span class="op">}</span></span></code></pre></div>
 <div class="sourceCode" id="cb24"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb24-1"><a href="#cb24-1" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>km <span class="op">/</span> h, <span class="dt">int</span><span class="op">&gt;</span> speed_limit;</span>
@@ -2167,15 +2148,13 @@ <h2 data-number="10.2" id="typed-quantities-safer-mode"><span class="header-sect
 <span id="cb25-4"><a href="#cb25-4" aria-hidden="true" tabindex="-1"></a>quantity q4 <span class="op">=</span> isq<span class="op">::</span>height<span class="op">(</span><span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;</span></code></pre></div>
 <p>All of the above cases use a slightly different approach to get the
 quantity, but all of them result in exactly the same
-<code class="sourceCode default">quantity</code> class template
+<code class="sourceCode cpp">quantity</code> class template
 instantiation.</p>
-<p>In the above examples, an expression of
-<code class="sourceCode default">isq::height[m]</code> is called a
-quantity reference and results in <code class="sourceCode default">reference&lt;isq::height, si::metre&gt;</code>
+<p>In the above examples, an expression of <code class="sourceCode cpp">isq<span class="op">::</span>height<span class="op">[</span>m<span class="op">]</span></code>
+is called a quantity reference and results in <code class="sourceCode cpp">reference<span class="op">&lt;</span>isq<span class="op">::</span>height, si<span class="op">::</span>metre<span class="op">&gt;</span></code>
 class template instantiation.</p>
 <p><em>Note: The identifier
-<code class="sourceCode default">reference</code> is being used in the
-<span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library but definitely will
+<code class="sourceCode cpp">reference</code> is being used in the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library but definitely will
 need bikeshedding during the standardization process.</em></p>
 <p>More about typed quantities can be found in the following
 chapters:</p>
@@ -2236,31 +2215,31 @@ <h3 data-number="10.3.1" id="the-issues-with-unit-specific-interfaces"><span cla
 function’s parameters at each call. This involves potentially expensive
 multiplication/division operations at runtime.</p></li>
 <li><p>After the function returns the speed in a unit of
-<code class="sourceCode default">km/h</code>, another potentially
-expensive multiplication/division operations have to be performed to
-convert the resulting quantity into a unit being the derived unit of the
-initial function’s arguments.</p></li>
+<code class="sourceCode cpp">km<span class="op">/</span>h</code>,
+another potentially expensive multiplication/division operations have to
+be performed to convert the resulting quantity into a unit being the
+derived unit of the initial function’s arguments.</p></li>
 <li><p>Besides the obvious runtime cost, some unit conversions may
 result in a data truncation, which means that the result will not be
 exactly equal to a direct division of the function’s arguments.</p></li>
 <li><p>We have to use a floating-point representation type (the
-<code class="sourceCode default">quantity</code> class template by
-default uses <code class="sourceCode default">double</code> as a
-representation type) which is considered value preserving. Trying to use
-an integral type in this scenario will work only for
-<code class="sourceCode default">s1</code>, while
-<code class="sourceCode default">s2</code> and
-<code class="sourceCode default">s3</code> will fail to compile. Failing
-to compile is a good thing here as the library tries to prevent the user
+<code class="sourceCode cpp">quantity</code> class template by default
+uses <code class="sourceCode cpp"><span class="dt">double</span></code>
+as a representation type) which is considered value preserving. Trying
+to use an integral type in this scenario will work only for
+<code class="sourceCode cpp">s1</code>, while
+<code class="sourceCode cpp">s2</code> and
+<code class="sourceCode cpp">s3</code> will fail to compile. Failing to
+compile is a good thing here as the library tries to prevent the user
 from doing a clearly wrong thing. To make the code compile, the user
-needs to use dedicated
-<code class="sourceCode default">value_cast</code> or
-<code class="sourceCode default">force_in</code> like this:</p>
+needs to use dedicated <code class="sourceCode cpp">value_cast</code> or
+<code class="sourceCode cpp">force_in</code> like this:</p>
 <div class="sourceCode" id="cb30"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb30-1"><a href="#cb30-1" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>mi <span class="op">/</span> h<span class="op">&gt;</span> s2 <span class="op">=</span> avg_speed<span class="op">(</span>value_cast<span class="op">&lt;</span>km<span class="op">&gt;(</span><span class="dv">140</span> <span class="op">*</span> mi<span class="op">)</span>, <span class="dv">2</span> <span class="op">*</span> h<span class="op">)</span>;</span>
 <span id="cb30-2"><a href="#cb30-2" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>m <span class="op">/</span> s<span class="op">&gt;</span> s3 <span class="op">=</span> avg_speed<span class="op">((</span><span class="dv">20</span> <span class="op">*</span> m<span class="op">).</span>force_in<span class="op">(</span>km<span class="op">)</span>, <span class="op">(</span><span class="dv">2</span> <span class="op">*</span> s<span class="op">).</span>force_in<span class="op">(</span>h<span class="op">))</span>;</span></code></pre></div>
 <p>But the above will obviously provide an incorrect behavior (e.g.,
-division by <code class="sourceCode default">0</code> in the evaluation
-of <code class="sourceCode default">s3</code>).</p></li>
+division by
+<code class="sourceCode cpp"><span class="dv">0</span></code> in the
+evaluation of <code class="sourceCode cpp">s3</code>).</p></li>
 </ol>
 <h3 data-number="10.3.2" id="constraining-function-parameters-with-concepts"><span class="header-section-number">10.3.2</span> Constraining function
 parameters with concepts<a href="#constraining-function-parameters-with-concepts" class="self-link"></a></h3>
@@ -2272,12 +2251,14 @@ <h3 data-number="10.3.2" id="constraining-function-parameters-with-concepts"><sp
 <span id="cb31-4"><a href="#cb31-4" aria-hidden="true" tabindex="-1"></a>  <span class="cf">return</span> isq<span class="op">::</span>speed<span class="op">(</span>distance <span class="op">/</span> duration<span class="op">)</span>;</span>
 <span id="cb31-5"><a href="#cb31-5" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
 <p>This explicitly states that the arguments passed by the user must not
-only satisfy a <a href="#Quantity-concept"><code class="sourceCode default">Quantity</code></a>
+only satisfy a <a href="#Quantity-concept"><code class="sourceCode cpp">Quantity</code></a>
 concept, but also that their quantity specification must be implicitly
-convertible to <code class="sourceCode default">isq::length</code> and
-<code class="sourceCode default">isq::time</code>, respectively. This no
-longer leaves room for error while still allowing the compiler to
-generate the most efficient code.</p>
+convertible to
+<code class="sourceCode cpp">isq<span class="op">::</span>length</code>
+and
+<code class="sourceCode cpp">isq<span class="op">::</span>time</code>,
+respectively. This no longer leaves room for error while still allowing
+the compiler to generate the most efficient code.</p>
 <p>Please, note that now it is safe just to use integral types all the
 way, which again improves the runtime performance as the
 multiplication/division operations are often faster on integral rather
@@ -2296,8 +2277,8 @@ <h3 data-number="10.3.3" id="constraining-the-function-return-type"><span class=
 <ol type="1">
 <li>It informs the users of our interface about what to expect to be the
 result of a function invocation. It is superior to just returning
-<code class="sourceCode default">auto</code>, which does not provide any
-hint about the thing being returned there.</li>
+<code class="sourceCode cpp"><span class="kw">auto</span></code>, which
+does not provide any hint about the thing being returned there.</li>
 <li>Such a concept constrains the type returned from the function. This
 means that it works as a unit test to verify if our function actually
 performs what it is supposed to do. If there is an error in the quantity
@@ -2313,13 +2294,14 @@ <h3 data-number="10.3.4" id="constraining-a-variable-on-the-stack"><span class="
 sometimes are unsure about the return type. Even if we know it today, it
 might change a week from now due to some code refactoring.</p>
 <p>In such cases, we can again use
-<code class="sourceCode default">auto</code> to denote the type:</p>
+<code class="sourceCode cpp"><span class="kw">auto</span></code> to
+denote the type:</p>
 <div class="sourceCode" id="cb33"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb33-1"><a href="#cb33-1" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> s1 <span class="op">=</span> avg_speed<span class="op">(</span><span class="dv">220</span> <span class="op">*</span> km, <span class="dv">2</span> <span class="op">*</span> h<span class="op">)</span>;</span>
 <span id="cb33-2"><a href="#cb33-2" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> s2 <span class="op">=</span> avg_speed<span class="op">(</span><span class="dv">140</span> <span class="op">*</span> mi, <span class="dv">2</span> <span class="op">*</span> h<span class="op">)</span>;</span>
 <span id="cb33-3"><a href="#cb33-3" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> s3 <span class="op">=</span> avg_speed<span class="op">(</span><span class="dv">20</span> <span class="op">*</span> m, <span class="dv">2</span> <span class="op">*</span> s<span class="op">)</span>;</span></code></pre></div>
 <p>In this case, it is probably OK to do so as the
-<code class="sourceCode default">avg_speed</code> function name
-explicitly provides the information on what to expect as a result.</p>
+<code class="sourceCode cpp">avg_speed</code> function name explicitly
+provides the information on what to expect as a result.</p>
 <p>In other scenarios where the returned quantity type is not so
 obvious, it is again helpful to constrain the type with a concept like
 so:</p>
@@ -2384,69 +2366,66 @@ <h3 data-number="10.4.2" id="points-are-more-common-than-most-of-us-imagine"><sp
 <p>Improving the affine space’s <em>Points</em> intuition will allow us
 to write better and safer software.</p>
 <h3 data-number="10.4.3" id="displacement-vector-is-modeled-by-quantity"><span class="header-section-number">10.4.3</span> <em>Displacement vector</em>
-is modeled by <code class="sourceCode default">quantity</code><a href="#displacement-vector-is-modeled-by-quantity" class="self-link"></a></h3>
+is modeled by <code class="sourceCode cpp">quantity</code><a href="#displacement-vector-is-modeled-by-quantity" class="self-link"></a></h3>
 <p>Up until now, each time when we used a
-<code class="sourceCode default">quantity</code> in our code, we were
+<code class="sourceCode cpp">quantity</code> in our code, we were
 modeling some kind of a difference between two things:</p>
 <ul>
 <li>the <em>distance</em> between two points,</li>
 <li><em>duration</em> between two time points,</li>
 <li>the difference in <em>speed</em> (even if relative to
-<code class="sourceCode default">0</code>).</li>
+<code class="sourceCode cpp"><span class="dv">0</span></code>).</li>
 </ul>
-<p>As we already know, a
-<code class="sourceCode default">quantity</code> type provides all
-operations required for the <em>displacement vector</em> abstraction in
-an affine space.</p>
+<p>As we already know, a <code class="sourceCode cpp">quantity</code>
+type provides all operations required for the <em>displacement
+vector</em> abstraction in an affine space.</p>
 <h3 data-number="10.4.4" id="point-is-modeled-by-quantity_point-and-pointorigin"><span class="header-section-number">10.4.4</span> <em>Point</em> is modeled by
-<code class="sourceCode default">quantity_point</code> and
-<code class="sourceCode default">PointOrigin</code><a href="#point-is-modeled-by-quantity_point-and-pointorigin" class="self-link"></a></h3>
+<code class="sourceCode cpp">quantity_point</code> and
+<code class="sourceCode cpp">PointOrigin</code><a href="#point-is-modeled-by-quantity_point-and-pointorigin" class="self-link"></a></h3>
 <p>In the library, the <em>point</em> abstraction is modeled by:</p>
 <ul>
-<li>the <a href="#PointOrigin-concept"><code class="sourceCode default">PointOrigin</code></a>
+<li>the <a href="#PointOrigin-concept"><code class="sourceCode cpp">PointOrigin</code></a>
 concept that specifies a measurement’s origin, and</li>
-<li>the <code class="sourceCode default">quantity_point</code> class
+<li>the <code class="sourceCode cpp">quantity_point</code> class
 template that specifies a <em>point</em> relative to a predefined
 origin.</li>
 </ul>
 <h4 data-number="10.4.4.1" id="quantity_point"><span class="header-section-number">10.4.4.1</span>
-<code class="sourceCode default">quantity_point</code><a href="#quantity_point" class="self-link"></a></h4>
-<p>The <code class="sourceCode default">quantity_point</code> class
-template specifies an absolute quantity measured from a predefined
-origin:</p>
+<code class="sourceCode cpp">quantity_point</code><a href="#quantity_point" class="self-link"></a></h4>
+<p>The <code class="sourceCode cpp">quantity_point</code> class template
+specifies an absolute quantity measured from a predefined origin:</p>
 <div class="sourceCode" id="cb35"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb35-1"><a href="#cb35-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>Reference <span class="kw">auto</span> R,</span>
 <span id="cb35-2"><a href="#cb35-2" aria-hidden="true" tabindex="-1"></a>         PointOriginFor<span class="op">&lt;</span>get_quantity_spec<span class="op">(</span>R<span class="op">)&gt;</span> <span class="kw">auto</span> PO <span class="op">=</span> default_point_origin<span class="op">(</span>R<span class="op">)</span>,</span>
 <span id="cb35-3"><a href="#cb35-3" aria-hidden="true" tabindex="-1"></a>         RepresentationOf<span class="op">&lt;</span>get_quantity_spec<span class="op">(</span>R<span class="op">).</span>character<span class="op">&gt;</span> Rep <span class="op">=</span> <span class="dt">double</span><span class="op">&gt;</span></span>
 <span id="cb35-4"><a href="#cb35-4" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> quantity_point;</span></code></pre></div>
 <p>As we can see above, the
-<code class="sourceCode default">quantity_point</code> class template
+<code class="sourceCode cpp">quantity_point</code> class template
 exposes one additional parameter compared to
-<code class="sourceCode default">quantity</code>. The
-<code class="sourceCode default">PO</code> parameter satisfies a <a href="#PointOriginFor-concept"><code class="sourceCode default">PointOriginFor</code></a>
+<code class="sourceCode cpp">quantity</code>. The
+<code class="sourceCode cpp">PO</code> parameter satisfies a <a href="#PointOriginFor-concept"><code class="sourceCode cpp">PointOriginFor</code></a>
 concept and specifies the origin of our measurement scale.</p>
-<p>Each <code class="sourceCode default">quantity_point</code>
-internally stores a <code class="sourceCode default">quantity</code>
-object, which represents a <em>displacement vector</em> from the
-predefined origin. Thanks to this, an instantiation of a
-<code class="sourceCode default">quantity_point</code> can be considered
-as a model of a vector space from such an origin.</p>
+<p>Each <code class="sourceCode cpp">quantity_point</code> internally
+stores a <code class="sourceCode cpp">quantity</code> object, which
+represents a <em>displacement vector</em> from the predefined origin.
+Thanks to this, an instantiation of a
+<code class="sourceCode cpp">quantity_point</code> can be considered as
+a model of a vector space from such an origin.</p>
 <p>Forcing the user to manually predefine an origin for every domain may
 be cumbersome and discourage users from using such abstractions at all.
-This is why, by default, the <code class="sourceCode default">PO</code>
-template parameter is initialized with the
-<code class="sourceCode default">default_point_origin(R)</code> that
-provides the quantity points’ scale zeroth point using the following
-rules:</p>
+This is why, by default, the <code class="sourceCode cpp">PO</code>
+template parameter is initialized with the <code class="sourceCode cpp">default_point_origin<span class="op">(</span>R<span class="op">)</span></code>
+that provides the quantity points’ scale zeroth point using the
+following rules:</p>
 <ul>
 <li>if the measurement unit of a quantity specifies its point origin in
 its definition (e.g., degree Celsius), then this origin is being
 used,</li>
-<li>otherwise, an instantiation of <code class="sourceCode default">zeroth_point_origin&lt;QuantitySpec&gt;</code>
+<li>otherwise, an instantiation of <code class="sourceCode cpp">zeroth_point_origin<span class="op">&lt;</span>QuantitySpec<span class="op">&gt;</span></code>
 is being used which provides a well-established zeroth point for a
 specific quantity type.</li>
 </ul>
-<h4 data-number="10.4.4.2" id="zeroth_point_originquantityspec"><span class="header-section-number">10.4.4.2</span> <code class="sourceCode default">zeroth_point_origin&lt;QuantitySpec&gt;</code><a href="#zeroth_point_originquantityspec" class="self-link"></a></h4>
-<p><code class="sourceCode default">zeroth_point_origin&lt;QuantitySpec&gt;</code>
+<h4 data-number="10.4.4.2" id="zeroth_point_originquantityspec"><span class="header-section-number">10.4.4.2</span> <code class="sourceCode cpp">zeroth_point_origin<span class="op">&lt;</span>QuantitySpec<span class="op">&gt;</span></code><a href="#zeroth_point_originquantityspec" class="self-link"></a></h4>
+<p><code class="sourceCode cpp">zeroth_point_origin<span class="op">&lt;</span>QuantitySpec<span class="op">&gt;</span></code>
 is meant to be used in cases where the specific domain has a
 well-established, non-controversial, and unique zeroth point on the
 measurement scale. This saves the user from the need to write a
@@ -2464,19 +2443,19 @@ <h4 data-number="10.4.4.2" id="zeroth_point_originquantityspec"><span class="hea
 <span id="cb36-10"><a href="#cb36-10" aria-hidden="true" tabindex="-1"></a><span class="ot">assert</span><span class="op">(</span>qp1 <span class="op">-</span> qp2 <span class="op">==</span> <span class="op">-</span><span class="dv">20</span> <span class="op">*</span> m<span class="op">)</span>;</span>
 <span id="cb36-11"><a href="#cb36-11" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb36-12"><a href="#cb36-12" aria-hidden="true" tabindex="-1"></a><span class="co">// auto res = qp1 + qp2;   // Compile-time error</span></span></code></pre></div>
-<p>In the above code <code class="sourceCode default">100 * m</code> and
-<code class="sourceCode default">120 * m</code> still create two
-quantities that serve as <em>displacement vectors</em> here. Quantity
-point objects can be explicitly constructed from such quantities only
-when their origin is an instantiation of the <code class="sourceCode default">zeroth_point_origin&lt;QuantitySpec&gt;</code>.</p>
+<p>In the above code <code class="sourceCode cpp"><span class="dv">100</span> <span class="op">*</span> m</code>
+and <code class="sourceCode cpp"><span class="dv">120</span> <span class="op">*</span> m</code>
+still create two quantities that serve as <em>displacement vectors</em>
+here. Quantity point objects can be explicitly constructed from such
+quantities only when their origin is an instantiation of the <code class="sourceCode cpp">zeroth_point_origin<span class="op">&lt;</span>QuantitySpec<span class="op">&gt;</span></code>.</p>
 <p>It is really important to understand that even though we can use
-<code class="sourceCode default">.quantity_from_zero()</code> to obtain
-the <em>displacement vector</em> of a point from the origin, the point
-by itself does not represent or have any associated physical value. It
-is just a point in some space. The same point can be expressed with
-different <em>displacement vectors</em> from different origins.</p>
+<code class="sourceCode cpp"><span class="op">.</span>quantity_from_zero<span class="op">()</span></code>
+to obtain the <em>displacement vector</em> of a point from the origin,
+the point by itself does not represent or have any associated physical
+value. It is just a point in some space. The same point can be expressed
+with different <em>displacement vectors</em> from different origins.</p>
 <p>It is also worth mentioning that simplicity comes with a safety cost
-here. For some users, it might be surprising that the usage of <code class="sourceCode default">zeroth_point_origin&lt;QuantitySpec&gt;</code>
+here. For some users, it might be surprising that the usage of <code class="sourceCode cpp">zeroth_point_origin<span class="op">&lt;</span>QuantitySpec<span class="op">&gt;</span></code>
 makes various quantity point objects compatible as long as quantity
 types used in the origin and reference are compatible:</p>
 <div class="sourceCode" id="cb37"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb37-1"><a href="#cb37-1" aria-hidden="true" tabindex="-1"></a>quantity_point<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">&gt;</span> qp1<span class="op">{</span>isq<span class="op">::</span>distance<span class="op">(</span><span class="dv">100</span> <span class="op">*</span> m<span class="op">)}</span>;</span>
@@ -2540,10 +2519,10 @@ <h4 data-number="10.4.4.3" id="absolute-point-origin"><span class="header-sectio
 vector</em> measured from it to the point we create.</p>
 <p>Finally, please note that it is not allowed to subtract two point
 origins defined in terms of
-<code class="sourceCode default">absolute_point_origin</code> (e.g.,
-<code class="sourceCode default">origin - origin</code>) as those do not
-contain information about the unit, so we cannot determine a resulting
-<code class="sourceCode default">quantity</code> type.</p>
+<code class="sourceCode cpp">absolute_point_origin</code> (e.g., <code class="sourceCode cpp">origin <span class="op">-</span> origin</code>)
+as those do not contain information about the unit, so we cannot
+determine a resulting <code class="sourceCode cpp">quantity</code>
+type.</p>
 <h5 data-number="10.4.4.3.1" id="modeling-independent-spaces-in-one-domain"><span class="header-section-number">10.4.4.3.1</span> Modeling independent
 spaces in one domain<a href="#modeling-independent-spaces-in-one-domain" class="self-link"></a></h5>
 <p>Absolute point origins are also perfect for establishing independent
@@ -2627,7 +2606,7 @@ <h4 data-number="10.4.4.5" id="converting-between-different-representations-of-t
 <p>As we might represent the same <em>point</em> with <em>displacement
 vectors</em> from various origins, the library provides facilities to
 convert the same <em>point</em> to the
-<code class="sourceCode default">quantity_point</code> class templates
+<code class="sourceCode cpp">quantity_point</code> class templates
 expressed in terms of different origins.</p>
 <p><img src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="96.326942mm"
   height="21.466148mm"
   viewBox="0 0 96.326942 21.466148"
   version="1.1"
   id="svg1"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <defs
     id="defs1">
    <marker
       style="overflow:visible"
       id="DartArrow-4-6-5"
       refX="0"
       refY="0"
       orient="auto-start-reverse"
       markerWidth="1"
       markerHeight="1"
       viewBox="0 0 1 1"
       preserveAspectRatio="xMidYMid">
      <path
         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
         d="M 0,0 5,-5 -12.5,0 5,5 Z"
         transform="scale(-0.5)"
         id="path6-0-2-6" />
    </marker>
  </defs>
  <g
     id="layer1"
     transform="translate(-25.532292,-131.57026)">
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.5;stroke-dasharray:none;marker-end:url(#DartArrow-4-6-5)"
       d="M 25.532292,149.11196 H 118.52973"
       id="path4-5-0" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 38.816843,148.07189 v 2.08013"
       id="path7-68-2" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.297823;stroke-dasharray:1.19129, 0.297823;stroke-dashoffset:0;stroke-opacity:1"
       d="m 38.816843,132.79772 v 15.06402"
       id="path2-2-7-4-1" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.297823;stroke-dasharray:1.19129, 0.297823;stroke-dashoffset:0;stroke-opacity:1"
       d="m 106.5445,132.85104 v 15.0107"
       id="path2-2-1-5-6-4" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298001;stroke-dasharray:1.192, 0.298001;stroke-dashoffset:0;stroke-opacity:1"
       d="m 50.679452,137.04534 v 10.81639"
       id="path2-2-4-4-9-8-6" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="M 50.679451,148.07188 V 150.152"
       id="path2-5-4-7-5-3" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298001;stroke-dasharray:1.192, 0.298001;stroke-dashoffset:0;stroke-opacity:1"
       d="m 61.180332,141.0677 v 6.88446"
       id="path2-2-4-4-9-8-3-4" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 106.5445,148.07189 v 2.08013"
       id="path2-5-7-5-2-5" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.297823;stroke-dasharray:1.19129, 0.297823;stroke-dashoffset:0;stroke-opacity:1"
       d="m 68.596164,145.03322 v 2.82852"
       id="path2-2-1-5-6-6-3" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="M 68.596164,148.07187 V 150.152"
       id="path2-5-7-5-2-1-7" />
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#0000df;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
       x="49.774212"
       y="152.78926"
       id="text2-8-5-1"><tspan
         id="tspan2-6-7-2"
         style="font-size:2.46944px;fill:#0000df;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
         x="49.774212"
         y="152.78926">B</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#000000;fill-opacity:1;stroke:#279b14;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.818182"
       x="37.943703"
       y="152.78926"
       id="text2-8-7-4-7"><tspan
         id="tspan2-6-4-4-6"
         style="font-size:2.46944px;fill:#000000;fill-opacity:1;stroke:#279b14;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.818182"
         x="37.943703"
         y="152.78926">A</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="104.35661"
       y="152.54927"
       id="text2-2-2-3-0-1"><tspan
         id="tspan2-9-6-28-2-4"
         style="font-size:2.46944px;fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="104.35661"
         y="152.54927">qp2</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="85.873619"
       y="144.83266"
       id="text2-2-7-4-6-4-0"><tspan
         id="tspan2-9-0-9-4-4-0"
         style="font-size:2.11667px;fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="85.873619"
         y="144.83266">qD</tspan></text>
    <path
       style="color:#000000;fill:#d40000;-inkscape-stroke:none"
       d="m 68.55992,145.88757 h 37.43781"
       id="path53-6" />
    <path
       style="color:#000000;fill:#d40000;-inkscape-stroke:none"
       d="m 68.55995,145.77218 v 0.23046 h 37.4375 v -0.23046 z"
       id="path54-0" />
    <g
       id="g52-4"
       transform="translate(-0.34825269,41.850296)">
      <path
         style="color:#000000;fill:#d40000;-inkscape-stroke:none"
         d="m 105.14844,103.19922 -0.14649,0.29101 1.09375,0.54688 -1.09375,0.54687 0.14649,0.29297 1.67773,-0.83984 z"
         id="path52-9" />
    </g>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#0000df;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
       x="60.453445"
       y="152.78926"
       id="text2-8-5-8-6"><tspan
         id="tspan2-6-7-4-02"
         style="font-size:2.46944px;fill:#0000df;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
         x="60.453445"
         y="152.78926">C</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="67.676758"
       y="152.75911"
       id="text2-8-5-8-3-2"><tspan
         id="tspan2-6-7-4-0-9"
         style="font-size:2.46944px;fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="67.676758"
         y="152.75911">D</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.82222px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#000000;stroke:#000000;stroke-width:0"
       x="119.70123"
       y="152.83142"
       id="text1-9-2"><tspan
         id="tspan1-2-9"
         style="font-size:2.82222px;stroke-width:0"
         x="119.70123"
         y="152.83142">Q</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="82.138161"
       y="140.82449"
       id="text2-2-7-4-6-4-0-7"><tspan
         id="tspan2-9-0-9-4-4-0-4"
         style="font-size:2.11667px;fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="82.138161"
         y="140.82449">qC</tspan></text>
    <path
       style="color:#000000;fill:#d40000;-inkscape-stroke:none"
       d="M 68.527082,141.87939 H 105.96489"
       id="path53-6-8" />
    <path
       style="color:#000000;fill:#d40000;stroke-width:1;-inkscape-stroke:none"
       d="m 61.11878,141.764 v 0.23046 h 44.84583 V 141.764 Z"
       id="path54-0-4" />
    <g
       id="g52-4-1"
       transform="translate(-0.38109056,37.84212)">
      <path
         style="color:#000000;fill:#d40000;-inkscape-stroke:none"
         d="m 105.14844,103.19922 -0.14649,0.29101 1.09375,0.54688 -1.09375,0.54687 0.14649,0.29297 1.67773,-0.83984 z"
         id="path52-9-4" />
    </g>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="76.910576"
       y="136.98802"
       id="text2-2-7-4-6-4-0-7-1"><tspan
         id="tspan2-9-0-9-4-4-0-4-4"
         style="font-size:2.11667px;fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="76.910576"
         y="136.98802">qB</tspan></text>
    <path
       style="color:#000000;fill:#d40000;-inkscape-stroke:none"
       d="M 68.593228,138.04292 H 106.03104"
       id="path53-6-8-9" />
    <path
       style="color:#000000;fill:#d40000;stroke-width:1;-inkscape-stroke:none"
       d="m 50.60159,137.92753 v 0.23046 h 55.42917 v -0.23046 z"
       id="path54-0-4-2" />
    <g
       id="g52-4-1-6"
       transform="translate(-0.31494473,34.005647)">
      <path
         style="color:#000000;fill:#d40000;-inkscape-stroke:none"
         d="m 105.14844,103.19922 -0.14649,0.29101 1.09375,0.54688 -1.09375,0.54687 0.14649,0.29297 1.67773,-0.83984 z"
         id="path52-9-4-7" />
    </g>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="70.909393"
       y="133.08542"
       id="text2-2-7-4-6-4-0-7-16"><tspan
         id="tspan2-9-0-9-4-4-0-4-6"
         style="font-size:2.11667px;fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="70.909393"
         y="133.08542">qA</tspan></text>
    <path
       style="color:#000000;fill:#d40000;-inkscape-stroke:none"
       d="M 68.659374,134.00802 H 106.09718"
       id="path53-6-8-1" />
    <path
       style="color:#000000;fill:#d40000;stroke-width:1;-inkscape-stroke:none"
       d="m 38.629199,134.02493 v 0.23046 h 67.467711 v -0.23046 z"
       id="path54-0-4-0" />
    <g
       id="g52-4-1-9"
       transform="translate(-0.24879868,29.970751)">
      <path
         style="color:#000000;fill:#d40000;-inkscape-stroke:none"
         d="m 105.14844,103.19922 -0.14649,0.29101 1.09375,0.54688 -1.09375,0.54687 0.14649,0.29297 1.67773,-0.83984 z"
         id="path52-9-4-4" />
    </g>
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="M 61.180335,148.07187 V 150.152"
       id="path2-5-7-5-2-1-7-3" />
  </g>
</svg>
" style="display: block; margin-left: auto; margin-right: auto; width: 80%;" /></p>
 <p>For this purpose, we can use either:</p>
@@ -2649,20 +2628,20 @@ <h4 data-number="10.4.4.5" id="converting-between-different-representations-of-t
 <span id="cb44-3"><a href="#cb44-3" aria-hidden="true" tabindex="-1"></a><span class="ot">assert</span><span class="op">(</span>qp2 <span class="op">==</span> qp2A<span class="op">)</span>;</span></code></pre></div>
 <p>It is only allowed to convert between various origins defined in
 terms of the same
-<code class="sourceCode default">absolute_point_origin</code>. Even if
-it is possible to express the same <em>point</em> as a <em>displacement
+<code class="sourceCode cpp">absolute_point_origin</code>. Even if it is
+possible to express the same <em>point</em> as a <em>displacement
 vector</em> from another
-<code class="sourceCode default">absolute_point_origin</code>, the
-library will not provide such a conversion. A custom user-defined
-conversion function will be needed to add such a functionality.</p>
+<code class="sourceCode cpp">absolute_point_origin</code>, the library
+will not provide such a conversion. A custom user-defined conversion
+function will be needed to add such a functionality.</p>
 <p>Said another way, in the library, there is no way to spell how two
-distinct <code class="sourceCode default">absolute_point_origin</code>
-types relate to each other.</p>
+distinct <code class="sourceCode cpp">absolute_point_origin</code> types
+relate to each other.</p>
 <h4 data-number="10.4.4.6" id="temperature-support"><span class="header-section-number">10.4.4.6</span> Temperature support<a href="#temperature-support" class="self-link"></a></h4>
 <p>Support for temperature quantity points is probably one of the most
 common examples of relative point origins in action that we use in daily
 life.</p>
-<p>The <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> definition in the library provides a
+<p>The <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> definition in the library provides a
 few predefined point origins for this purpose:</p>
 <div class="sourceCode" id="cb45"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb45-1"><a href="#cb45-1" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> si <span class="op">{</span></span>
 <span id="cb45-2"><a href="#cb45-2" aria-hidden="true" tabindex="-1"></a></span>
@@ -2683,21 +2662,18 @@ <h4 data-number="10.4.4.6" id="temperature-support"><span class="header-section-
 <p>The above is a great example of how point origins can be stacked on
 top of each other:</p>
 <ul>
-<li><code class="sourceCode default">usc::zeroth_degree_Fahrenheit</code>
-is defined relative to
-<code class="sourceCode default">si::zeroth_degree_Celsius</code></li>
-<li><code class="sourceCode default">si::zeroth_degree_Celsius</code> is
-defined relative to
-<code class="sourceCode default">si::zeroth_kelvin</code>.</li>
+<li><code class="sourceCode cpp">usc<span class="op">::</span>zeroth_degree_Fahrenheit</code>
+is defined relative to <code class="sourceCode cpp">si<span class="op">::</span>zeroth_degree_Celsius</code></li>
+<li><code class="sourceCode cpp">si<span class="op">::</span>zeroth_degree_Celsius</code>
+is defined relative to <code class="sourceCode cpp">si<span class="op">::</span>zeroth_kelvin</code>.</li>
 </ul>
 <p>_Note: Notice that while stacking point origins, we can use not only
 different representation types and units for origins and a
 <em>point</em>. In the above example, the relative point origin for
 degree Celsius is defined in terms of
-<code class="sourceCode default">si::kelvin</code>, while the quantity
-point for it will use
-<code class="sourceCode default">si::degree_Celsius</code> as a
-unit.</p>
+<code class="sourceCode cpp">si<span class="op">::</span>kelvin</code>,
+while the quantity point for it will use <code class="sourceCode cpp">si<span class="op">::</span>degree_Celsius</code>
+as a unit.</p>
 <p>The temperature point origins defined above are provided explicitly
 in the respective units’ definitions:</p>
 <div class="sourceCode" id="cb46"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb46-1"><a href="#cb46-1" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> si <span class="op">{</span></span>
@@ -2716,9 +2692,8 @@ <h4 data-number="10.4.4.6" id="temperature-support"><span class="header-section-
 <span id="cb46-14"><a href="#cb46-14" aria-hidden="true" tabindex="-1"></a>               zeroth_degree_Fahrenheit<span class="op">&gt;</span> <span class="op">{}</span> degree_Fahrenheit;</span>
 <span id="cb46-15"><a href="#cb46-15" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb46-16"><a href="#cb46-16" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
-<p>As it was described above,
-<code class="sourceCode default">default_point_origin(R)</code> returns
-a <code class="sourceCode default">zeroth_point_origin&lt;QuantitySpec&gt;</code>
+<p>As it was described above, <code class="sourceCode cpp">default_point_origin<span class="op">(</span>R<span class="op">)</span></code>
+returns a <code class="sourceCode cpp">zeroth_point_origin<span class="op">&lt;</span>QuantitySpec<span class="op">&gt;</span></code>
 when a unit does not provide any origin in its definition. As of today,
 the units of temperature are the only ones in the entire library that
 provide such origins.</p>
@@ -2740,8 +2715,8 @@ <h4 data-number="10.4.4.6" id="temperature-support"><span class="header-section-
 <span id="cb49-3"><a href="#cb49-3" aria-hidden="true" tabindex="-1"></a>quantity_point q9<span class="op">{</span><span class="fl">20.5</span> <span class="op">*</span> deg_C<span class="op">}</span>;</span></code></pre></div></li>
 </ul>
 <p>In all of the above cases, we end up with the
-<code class="sourceCode default">quantity_point</code> of the same type
-and value.</p>
+<code class="sourceCode cpp">quantity_point</code> of the same type and
+value.</p>
 <p>To play a bit more with temperatures, we can implement a simple room
 AC temperature controller in the following way:</p>
 <p><img src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   width="96.122437mm"
   height="35.44648mm"
   viewBox="0 0 96.122437 35.44648"
   version="1.1"
   id="svg1"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <defs
     id="defs1">
    <marker
       style="overflow:visible"
       id="DartArrow-4-6-5-5"
       refX="0"
       refY="0"
       orient="auto-start-reverse"
       markerWidth="1"
       markerHeight="1"
       viewBox="0 0 1 1"
       preserveAspectRatio="xMidYMid">
      <path
         style="fill:context-stroke;fill-rule:evenodd;stroke:none"
         d="M 0,0 5,-5 -12.5,0 5,5 Z"
         transform="scale(-0.5)"
         id="path6-0-2-6-0" />
    </marker>
  </defs>
  <g
     id="layer1"
     transform="translate(-25.146041,-171.9546)">
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.5;stroke-dasharray:none;marker-end:url(#DartArrow-4-6-5-5)"
       d="m 25.14604,192.36757 h 92.99744"
       id="path4-5-0-6" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 38.430591,191.3275 v 2.08013"
       id="path7-68-2-1" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 53.468201,191.32749 v 2.08012"
       id="path2-5-4-7-5-3-6" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 98.901598,191.32748 v 2.08013"
       id="path2-5-7-5-2-1-7-6" />
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#eeb000;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
       x="51.997147"
       y="196.13815"
       id="text2-8-5-1-9"><tspan
         id="tspan2-6-7-2-9"
         style="font-size:2.46944px;fill:#eeb000;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
         x="51.997147"
         y="196.13815">F0</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#eeb000;fill-opacity:1;stroke:#279b14;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.818182"
       x="36.820873"
       y="196.13815"
       id="text2-8-7-4-7-2"><tspan
         id="tspan2-6-4-4-6-7"
         style="font-size:2.46944px;fill:#eeb000;fill-opacity:1;stroke:#279b14;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.818182"
         x="36.820873"
         y="196.13815">K0</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="106.03098"
       y="195.88976"
       id="text2-2-2-3-0-1-2"><tspan
         id="tspan2-9-6-28-2-4-2"
         style="font-size:2.46944px;fill:#d40000;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="106.03098"
         y="195.88976">high</tspan></text>
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 108.64149,191.3275 v 2.08013"
       id="path2-5-7-5-2-5-5" />
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 89.161704,191.29385 v 2.08013"
       id="path2-5-7-5-2-5-5-1" />
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#0000df;fill-opacity:1;stroke:#0000e1;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.0666667"
       x="87.016014"
       y="196.13513"
       id="text2-2-2-3-0-1-2-3"><tspan
         id="tspan2-9-6-28-2-4-2-0"
         style="font-size:2.46944px;fill:#0000df;fill-opacity:1;stroke:#0000e1;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.0666667"
         x="87.016014"
         y="196.13513">low</tspan></text>
    <path
       style="color:#000000;fill:#d40000;stroke-width:0.999998;-inkscape-stroke:none"
       d="m 98.979131,185.79123 v 0.23046 h 9.280659 v -0.23046 z"
       id="path54-0-8" />
    <g
       id="g52-4-2"
       transform="translate(1.9140822,81.868415)">
      <path
         style="color:#000000;fill:#d40000;-inkscape-stroke:none"
         d="m 105.14844,103.19922 -0.14649,0.29101 1.09375,0.54688 -1.09375,0.54687 0.14649,0.29297 1.67773,-0.83984 z"
         id="path52-9-2" />
    </g>
    <path
       style="color:#000000;fill:#0000df;fill-opacity:1;stroke-width:0.999998;-inkscape-stroke:none"
       d="m 98.783113,185.79123 v 0.23046 h -9.280648 v -0.23046 z"
       id="path54-0-8-6" />
    <g
       id="g52-4-2-4"
       transform="matrix(-1,0,0,1,195.84815,81.868375)"
       style="fill:#0000df;fill-opacity:1">
      <path
         style="color:#000000;fill:#0000df;fill-opacity:1;-inkscape-stroke:none"
         d="m 105.14844,103.19922 -0.14649,0.29101 1.09375,0.54688 -1.09375,0.54687 0.14649,0.29297 1.67773,-0.83984 z"
         id="path52-9-2-0" />
    </g>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#eeb000;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
       x="59.218128"
       y="196.14961"
       id="text2-8-5-8-6-8"><tspan
         id="tspan2-6-7-4-02-5"
         style="font-size:2.46944px;fill:#eeb000;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
         x="59.218128"
         y="196.14961">C0</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#eeb000;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
       x="96.399002"
       y="196.1496"
       id="text2-8-5-8-6-8-7"><tspan
         id="tspan2-6-7-4-02-5-6"
         style="font-size:2.46944px;fill:#eeb000;fill-opacity:1;stroke:#0000e0;stroke-width:0;stroke-dasharray:none;stroke-opacity:0.607843"
         x="96.399002"
         y="196.1496">REF</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.46944px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#09ad00;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
       x="97.205673"
       y="199.62463"
       id="text2-8-5-8-3-2-0"><tspan
         id="tspan2-6-7-4-0-9-9"
         style="font-size:2.46944px;fill:#09ad00;fill-opacity:1;stroke:#d40000;stroke-width:0;stroke-dasharray:none;stroke-opacity:1"
         x="97.205673"
         y="199.62463">ref</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.82222px;font-family:Arial;-inkscape-font-specification:'Arial Bold';fill:#000000;stroke:#000000;stroke-width:0"
       x="119.31499"
       y="196.08676"
       id="text1-9-2-9"><tspan
         id="tspan1-2-9-6"
         style="font-size:2.82222px;stroke-width:0"
         x="119.31499"
         y="196.08676">T</tspan></text>
    <path
       style="fill:#000000;stroke:#000000;stroke-width:0.381298;stroke-dasharray:none"
       d="m 60.794083,191.32748 v 2.08013"
       id="path2-5-7-5-2-1-7-3-0" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298001;stroke-dasharray:1.192, 0.298001;stroke-dashoffset:0;stroke-opacity:1"
       d="m 60.794083,181.33872 v 9.69079"
       id="path2-2-4-4-9-8-3-4-1" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298001;stroke-dasharray:1.192, 0.298001;stroke-dashoffset:0;stroke-opacity:1"
       d="m 108.64149,184.79985 v 6.22965"
       id="path2-2-4-4-9-8-3-4-1-8" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298002;stroke-dasharray:1.192, 0.298002;stroke-dashoffset:0;stroke-opacity:1"
       d="M 98.901599,173.60046 V 191.0295"
       id="path2-2-4-4-9-8-3-4-1-89" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298001;stroke-dasharray:1.192, 0.298001;stroke-dashoffset:0;stroke-opacity:1"
       d="m 89.161704,184.70631 v 6.32319"
       id="path2-2-4-4-9-8-3-4-1-89-0" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298001;stroke-dasharray:1.192, 0.298001;stroke-dashoffset:0;stroke-opacity:1"
       d="m 38.430591,173.2939 v 17.73561"
       id="path2-2-4-4-9-8-3-4-1-2" />
    <path
       style="fill:#000000;stroke:#a4a4a4;stroke-width:0.298001;stroke-dasharray:1.192, 0.298001;stroke-dashoffset:0;stroke-opacity:1"
       d="m 53.468201,177.40986 v 13.61965"
       id="path2-2-4-4-9-8-3-4-1-23" />
    <g
       id="path10">
      <path
         style="color:#000000;fill:#ffbf00;fill-opacity:0.0156863;stroke-dasharray:0.46, 0.23;-inkscape-stroke:none"
         d="M 38.540264,189.14302 H 60.354043"
         id="path80" />
      <path
         style="color:#000000;fill:#eeb000;stroke-dasharray:0.46, 0.23;-inkscape-stroke:none"
         d="m 38.541016,189.02734 v 0.23047 H 39 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691407,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689454,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689454,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691407,0 v 0.23047 H 56.25 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.423829 v -0.23047 z"
         id="path81" />
      <g
         id="g79">
        <path
           style="color:#000000;fill:#eeb000;-inkscape-stroke:none"
           d="m 59.162109,188.30664 -0.146484,0.29102 1.089844,0.54492 -1.089844,0.54492 0.146484,0.29102 1.669922,-0.83594 z"
           id="path79" />
      </g>
    </g>
    <g
       id="path10-3">
      <path
         style="color:#000000;fill:#ffbf00;fill-opacity:0.0156863;stroke-dasharray:0.46, 0.230001;-inkscape-stroke:none"
         d="m 60.932133,189.14303 h 37.77522"
         id="path83" />
      <path
         style="color:#000000;fill:#eeb000;stroke-dasharray:0.46, 0.230001;-inkscape-stroke:none"
         d="m 60.931641,189.02734 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689454,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691407,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 H 73.8125 v -0.23047 z m 0.691407,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689454,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689454,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691407,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 H 91.0625 v -0.23047 z m 0.691407,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460937 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458985 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689454,0 v 0.23047 h 0.460937 v -0.23047 z m 0.691406,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.458984 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z m 0.689453,0 v 0.23047 h 0.460938 v -0.23047 z"
         id="path84" />
      <g
         id="g82">
        <path
           style="color:#000000;fill:#eeb000;-inkscape-stroke:none"
           d="m 97.515625,188.30664 -0.146484,0.29102 1.089843,0.54492 -1.089843,0.54492 0.146484,0.29102 1.669922,-0.83594 z"
           id="path82" />
      </g>
    </g>
    <g
       id="path10-7"
       transform="translate(0,0.37033)">
      <path
         style="color:#000000;fill:#ffbf00;fill-opacity:0.0156863;stroke-dasharray:0.46, 0.23;-inkscape-stroke:none"
         d="M 60.715697,185.53631 H 53.875104"
         id="path77" />
      <path
         style="color:#000000;fill:#eeb000;stroke-dasharray:0.46, 0.23;-inkscape-stroke:none"
         d="m 54.044922,185.42187 v 0.22852 h 0.460937 v -0.22852 z m 0.691406,0 v 0.22852 h 0.458984 v -0.22852 z m 0.689453,0 v 0.22852 h 0.458985 v -0.22852 z m 0.689453,0 v 0.22852 h 0.460938 v -0.22852 z m 0.691407,0 v 0.22852 h 0.458984 v -0.22852 z m 0.689453,0 v 0.22852 h 0.458984 v -0.22852 z m 0.689453,0 v 0.22852 h 0.460937 v -0.22852 z m 0.689453,0 v 0.22852 h 0.460937 v -0.22852 z m 0.691406,0 v 0.22852 h 0.458985 v -0.22852 z m 0.689453,0 v 0.22852 h 0.458985 v -0.22852 z"
         id="path78" />
      <g
         id="g76">
        <path
           style="color:#000000;fill:#eeb000;-inkscape-stroke:none"
           d="m 55.066406,184.70117 -1.669922,0.83594 1.669922,0.83398 0.146485,-0.29101 -1.089844,-0.54492 1.089844,-0.54297 z"
           id="path76" />
      </g>
    </g>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';mix-blend-mode:normal;fill:#a4a4a4;fill-opacity:1;stroke:#000000;stroke-width:0;stroke-dasharray:none"
       x="67.405975"
       y="181.39328"
       id="text2-2-7-49-5-3-2-6-8"><tspan
         id="tspan2-9-0-96-4-1-8-8-5"
         style="font-size:2.11667px;fill:#a4a4a4;fill-opacity:1;stroke-width:0;stroke-dasharray:none"
         x="67.405975"
         y="181.39328">ref.quantity_from_zero()</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';mix-blend-mode:normal;fill:#a4a4a4;fill-opacity:1;stroke:#000000;stroke-width:0;stroke-dasharray:none"
       x="58.698536"
       y="177.26396"
       id="text2-2-7-49-5-3-2-6-8-0"><tspan
         id="tspan2-9-0-96-4-1-8-8-5-1"
         style="font-size:2.11667px;fill:#a4a4a4;fill-opacity:1;stroke-width:0;stroke-dasharray:none"
         x="58.698536"
         y="177.26396">ref.in(deg_F).quantity_from_zero()</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';mix-blend-mode:normal;fill:#a4a4a4;fill-opacity:1;stroke:#000000;stroke-width:0;stroke-dasharray:none"
       x="53.553532"
       y="173.49559"
       id="text2-2-7-49-5-3-2-6-8-0-2"><tspan
         id="tspan2-9-0-96-4-1-8-8-5-1-6"
         style="font-size:2.11667px;fill:#a4a4a4;fill-opacity:1;stroke-width:0;stroke-dasharray:none"
         x="53.553532"
         y="173.49559">ref.in(K).quantity_from_zero()</tspan></text>
    <path
       style="color:#000000;fill:#a4a4a4;fill-opacity:0.960784;-inkscape-stroke:none"
       d="M 96.795779,182.45468 H 108.41217"
       id="path59-4" />
    <path
       style="color:#000000;fill:#a4a4a4;fill-opacity:0.960784;stroke-width:1;-inkscape-stroke:none"
       d="m 60.875675,182.23658 v 0.25 h 37.435374 v -0.25 z"
       id="path60-2" />
    <g
       id="g58-4"
       transform="translate(-8.013114,83.289212)">
      <path
         style="color:#000000;fill:#a4a4a4;-inkscape-stroke:none"
         d="m 105.0293,98.164062 -0.15821,0.316407 1.1836,0.591797 -1.1836,0.591796 0.15821,0.316407 1.81445,-0.908203 z"
         id="path58-3" />
    </g>
    <path
       style="color:#000000;fill:#a4a4a4;fill-opacity:0.960784;stroke-width:0.999998;-inkscape-stroke:none"
       d="m 53.529259,178.23299 v 0.25 h 44.82539 v -0.25 z"
       id="path60-2-4" />
    <g
       id="g58-4-1"
       transform="translate(-7.9695261,79.285615)">
      <path
         style="color:#000000;fill:#a4a4a4;-inkscape-stroke:none"
         d="m 105.0293,98.164062 -0.15821,0.316407 1.1836,0.591797 -1.1836,0.591796 0.15821,0.316407 1.81445,-0.908203 z"
         id="path58-3-2" />
    </g>
    <path
       style="color:#000000;fill:#a4a4a4;fill-opacity:0.960784;stroke-width:1;-inkscape-stroke:none"
       d="m 38.454855,174.24041 v 0.25 h 59.979562 v -0.25 z"
       id="path60-2-4-4" />
    <g
       id="g58-4-1-0"
       transform="translate(-7.8897477,75.293022)">
      <path
         style="color:#000000;fill:#a4a4a4;-inkscape-stroke:none"
         d="m 105.0293,98.164062 -0.15821,0.316407 1.1836,0.591797 -1.1836,0.591796 0.15821,0.316407 1.81445,-0.908203 z"
         id="path58-3-2-1" />
    </g>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:0.298;stroke-miterlimit:4;stroke-dasharray:1.192, 0.298;stroke-dashoffset:0;stroke-opacity:0"
       x="107.69614"
       y="179.50262"
       id="text5-4"><tspan
         style="font-size:2.11667px;text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke-width:0.298"
         x="107.69614"
         y="179.50262"
         id="tspan6-5">origin doesn't</tspan><tspan
         style="font-size:2.11667px;text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke-width:0.298"
         x="107.69614"
         y="182.14847"
         id="tspan74">change</tspan></text>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:0.298;stroke-miterlimit:4;stroke-dasharray:1.192, 0.298;stroke-dashoffset:0;stroke-opacity:0"
       x="38.430073"
       y="204.1608"
       id="text5-7-4"><tspan
         style="font-size:2.11667px;text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke-width:0.298"
         x="38.430073"
         y="204.1608"
         id="tspan4-0">absolute</tspan><tspan
         style="font-size:2.11667px;text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke-width:0.298"
         x="38.430073"
         y="206.80664"
         id="tspan7-5">point origin</tspan></text>
    <g
       id="path9-0-6-5"
       transform="translate(-0.62311928,81.062942)">
      <path
         style="color:#000000;fill:#000000;-inkscape-stroke:none"
         d="m 38.974609,116.68945 -0.08789,4.44141 0.199218,0.004 0.08594,-4.44141 z"
         id="path62-8" />
      <g
         id="g61-4">
        <path
           style="color:#000000;fill:#000000;-inkscape-stroke:none"
           d="m 39.082031,116.2793 -0.748047,1.42383 0.248047,0.13085 0.488281,-0.92773 0.449219,0.94531 0.253906,-0.11914 z"
           id="path61-9" />
      </g>
    </g>
    <text
       xml:space="preserve"
       style="font-weight:bold;font-size:2.11667px;font-family:Arial;-inkscape-font-specification:'Arial Bold';text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:0.298;stroke-miterlimit:4;stroke-dasharray:1.192, 0.298;stroke-dashoffset:0;stroke-opacity:0"
       x="79.547623"
       y="204.1608"
       id="text5-7-3-4"><tspan
         style="font-size:2.11667px;text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke-width:0.298"
         x="79.547623"
         y="204.1608"
         id="tspan7-2-3">relative</tspan><tspan
         style="font-size:2.11667px;text-align:center;text-anchor:middle;fill:#000000;fill-opacity:1;stroke-width:0.298"
         x="79.547623"
         y="206.80664"
         id="tspan8-0">point origins</tspan></text>
    <g
       id="path9-0-62-3"
       transform="matrix(-0.88043225,-0.34268112,0.34149681,-0.88348559,74.3932,292.94917)"
       style="stroke-width:1.05711">
      <g
         id="path74-6">
        <path
           style="color:#000000;fill:#000000;-inkscape-stroke:none"
           d="M 55.543497,87.783264 34.863524,88.174435"
           id="path86" />
        <path
           style="color:#000000;fill:#000000;-inkscape-stroke:none"
           d="m 55.541016,87.677734 -20.679688,0.390625 0.0039,0.210938 20.679688,-0.390625 z"
           id="path87" />
        <g
           id="g85">
          <path
             style="color:#000000;fill:#000000;-inkscape-stroke:none"
             d="m 54.433594,87.037109 -0.128907,0.269532 1.009766,0.480468 -0.990234,0.519532 0.138672,0.265625 1.521484,-0.796875 z"
             id="path85" />
        </g>
      </g>
    </g>
    <g
       id="path74-6-5">
      <path
         style="color:#000000;fill:#000000;-inkscape-stroke:none"
         d="m 63.088004,196.09182 12.447609,6.08624"
         id="path89" />
      <path
         style="color:#000000;fill:#000000;-inkscape-stroke:none"
         d="m 63.132812,196.00195 -0.08789,0.17969 12.447265,6.08594 0.08789,-0.17969 z"
         id="path90" />
      <g
         id="g88">
        <path
           style="color:#000000;fill:#000000;-inkscape-stroke:none"
           d="m 64.337891,195.89453 -1.623047,0.0137 0.986328,1.29102 0.224609,-0.17188 -0.642578,-0.83984 1.058594,-0.01 z"
           id="path88" />
      </g>
    </g>
    <g
       id="path74-6-9">
      <path
         style="color:#000000;fill:#000000;-inkscape-stroke:none"
         d="m 95.737262,196.18309 -11.593285,7.11523"
         id="path92" />
      <path
         style="color:#000000;fill:#000000;-inkscape-stroke:none"
         d="m 95.685547,196.09766 -11.59375,7.11523 0.103515,0.16992 11.59375,-7.11523 z"
         id="path93" />
      <g
         id="g91">
        <path
           style="color:#000000;fill:#000000;-inkscape-stroke:none"
           d="m 96.091797,195.96484 -1.617188,0.14063 0.02344,0.2832 1.05664,-0.0918 -0.560546,0.89844 0.240234,0.14844 z"
           id="path91" />
      </g>
    </g>
    <circle
       style="fill:#09ad00;fill-opacity:1;stroke:none;stroke-width:0.2;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
       id="path75"
       cx="98.909256"
       cy="185.9398"
       r="0.49345818" />
    <g
       id="path9-0-62"
       transform="matrix(-0.88043226,-0.34268111,0.34149681,-0.88348558,112.41926,270.70219)"
       style="stroke-width:1.05711">
      <g
         id="path74">
        <path
           style="color:#000000;fill:#000000;-inkscape-stroke:none"
           d="m 45.118218,79.121239 -2.044871,4.333544"
           id="path95" />
        <path
           style="color:#000000;fill:#000000;-inkscape-stroke:none"
           d="M 45.023437,79.076172 42.978516,83.410156 43.169922,83.5 45.212891,79.166016 Z"
           id="path96" />
        <g
           id="g94">
          <path
             style="color:#000000;fill:#000000;-inkscape-stroke:none"
             d="m 45.306641,78.722656 -1.351563,1.0625 0.185547,0.234375 0.880859,-0.691406 0.02539,1.119141 0.298828,-0.0078 z"
             id="path94" />
        </g>
      </g>
    </g>
  </g>
</svg>
" style="display: block; margin-left: auto; margin-right: auto; width: 80%;" /></p>
@@ -2794,14 +2769,13 @@ <h2 data-number="10.5" id="user-defined-representation-types"><span class="heade
 <li>enable linear algebra usage.</li>
 </ul>
 <p>As of right now, we have two other concurrent proposals to SG6 in
-this subject on the fly (<span class="citation" data-cites="P2993R0">[<a href="#ref-P2993R0" role="doc-biblioref"><strong>P2993R0?</strong></a>]</span> and <span class="citation" data-cites="P3003R0">[<a href="#ref-P3003R0" role="doc-biblioref"><strong>P3003R0?</strong></a>]</span>), so we do
-not provide any concrete requirements or recommendations here so
-far.</p>
+this subject on the fly (<span class="citation" data-cites="P2993R0">[<a href="https://wg21.link/p2993r0" role="doc-biblioref">P2993R0</a>]</span> and <span class="citation" data-cites="P3003R0">[<a href="https://wg21.link/p3003r0" role="doc-biblioref">P3003R0</a>]</span>), so we do not provide any
+concrete requirements or recommendations here so far.</p>
 <p>Based on the results of discussions on the mentioned proposals, we
 will provide correct guidelines in the next revisions of this paper.</p>
 <p>By default all floating-point and integral (besides
-<code class="sourceCode default">bool</code>) types are treated as
-scalars.</p>
+<code class="sourceCode cpp"><span class="dt">bool</span></code>) types
+are treated as scalars.</p>
 <h2 data-number="10.6" id="vector-and-tensor-quantities"><span class="header-section-number">10.6</span> Vector and tensor quantities<a href="#vector-and-tensor-quantities" class="self-link"></a></h2>
 <p>TBD</p>
 <h2 data-number="10.7" id="logarithmic-quantities-and-units"><span class="header-section-number">10.7</span> Logarithmic quantities and
@@ -2837,8 +2811,7 @@ <h2 data-number="11.1" id="basic-quantity-equations"><span class="header-section
 Explorer</a>.</p>
 <h2 data-number="11.2" id="hello-units"><span class="header-section-number">11.2</span> Hello units<a href="#hello-units" class="self-link"></a></h2>
 <p>The next example serves as a showcase of various features available
-in the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span>
-library.</p>
+in the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library.</p>
 <div class="sourceCode" id="cb52"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb52-1"><a href="#cb52-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> mp_units;</span>
 <span id="cb52-2"><a href="#cb52-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> std;</span>
 <span id="cb52-3"><a href="#cb52-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -2885,8 +2858,7 @@ <h2 data-number="11.3" id="storage-tank"><span class="header-section-number">11.
 <li>how easy it is to <a href="https://mpusz.github.io/mp-units/2.0/users_guide/framework_basics/systems_of_quantities/#defining-quantities">add
 custom quantity types</a> when needed, and</li>
 <li><a href="https://mpusz.github.io/mp-units/2.1/users_guide/framework_basics/concepts/#QuantityLike">interoperability
-with
-<code class="sourceCode default">std::chrono::duration</code></a>.</li>
+with <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code></a>.</li>
 </ul>
 <div class="sourceCode" id="cb53"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb53-1"><a href="#cb53-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> mp_units;</span>
 <span id="cb53-2"><a href="#cb53-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> std;</span>
@@ -3006,7 +2978,7 @@ <h2 data-number="11.3" id="storage-tank"><span class="header-section-number">11.
 <h2 data-number="11.4" id="bridge-across-the-rhine"><span class="header-section-number">11.4</span> Bridge across the Rhine<a href="#bridge-across-the-rhine" class="self-link"></a></h2>
 <p>The following example codifies the history of a famous issue during
 the construction of a bridge across the Rhine River between the German
-and Swiss parts of the town Laufenburg <span class="citation" data-cites="HOCHRHEINBRÜCKE">[<a href="#ref-HOCHRHEINBRÜCKE" role="doc-biblioref">Hochrheinbrücke</a>]</span>. It also nicely
+and Swiss parts of the town Laufenburg <span class="citation" data-cites="HOCHRHEINBRÜCKE">[<a href="https://www.normaalamsterdamspeil.nl/wp-content/uploads/2015/03/website_bridge.pdf" role="doc-biblioref">Hochrheinbrücke</a>]</span>. It also nicely
 presents how <a href="https://mpusz.github.io/mp-units/latest/users_guide/framework_basics/the_affine_space/">the
 Affine Space is being modeled in the library</a>.</p>
 <div class="sourceCode" id="cb54"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb54-1"><a href="#cb54-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> mp_units;</span>
@@ -3298,14 +3270,15 @@ <h3 data-number="12.1.1" id="no-way-to-specify-a-quantity-type-in-generic-interf
 type in generic interfaces<a href="#no-way-to-specify-a-quantity-type-in-generic-interfaces" class="self-link"></a></h3>
 <p>A common requirement in the domain is to write unit-agnostic generic
 interfaces. For example, let’s try to implement a generic
-<code class="sourceCode default">avg_speed</code> function template that
+<code class="sourceCode cpp">avg_speed</code> function template that
 takes a quantity of any unit and produces the result. So if we call it
-with <em>distance</em> in <code class="sourceCode default">km</code> and
-<em>time</em> in <code class="sourceCode default">h</code>, we will get
-<code class="sourceCode default">km / h</code> as a result, but if we
-call it with <code class="sourceCode default">mi</code> and
-<code class="sourceCode default">h</code>, we expect
-<code class="sourceCode default">mi / h</code> to be returned.</p>
+with <em>distance</em> in <code class="sourceCode cpp">km</code> and
+<em>time</em> in <code class="sourceCode cpp">h</code>, we will get
+<code class="sourceCode cpp">km <span class="op">/</span> h</code> as a
+result, but if we call it with <code class="sourceCode cpp">mi</code>
+and <code class="sourceCode cpp">h</code>, we expect
+<code class="sourceCode cpp">mi <span class="op">/</span> h</code> to be
+returned.</p>
 <div class="sourceCode" id="cb56"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb56-1"><a href="#cb56-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>Unit <span class="kw">auto</span> U1, <span class="kw">typename</span> Rep1, Unit <span class="kw">auto</span> U2, <span class="kw">typename</span> Rep2<span class="op">&gt;</span></span>
 <span id="cb56-2"><a href="#cb56-2" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> avg_speed<span class="op">(</span>quantity<span class="op">&lt;</span>U1, Rep1<span class="op">&gt;</span> distance, quantity<span class="op">&lt;</span>U2, Rep2<span class="op">&gt;</span> time<span class="op">)</span></span>
 <span id="cb56-3"><a href="#cb56-3" aria-hidden="true" tabindex="-1"></a><span class="op">{</span></span>
@@ -3328,11 +3301,10 @@ <h3 data-number="12.1.1" id="no-way-to-specify-a-quantity-type-in-generic-interf
 <span id="cb57-6"><a href="#cb57-6" aria-hidden="true" tabindex="-1"></a>avg_speed<span class="op">(</span><span class="dv">120</span> <span class="op">*</span> km, <span class="dv">2</span> <span class="op">*</span> h<span class="op">).</span>in<span class="op">(</span>km <span class="op">/</span> h<span class="op">)</span>;</span></code></pre></div>
 <p>The above code decreased the performance because we always pay for
 the conversion at the function’s input and output. Moreover, we had to
-force <code class="sourceCode default">double</code> as a representation
-type to prevent narrowing, which can affect not only the performance,
-but also precision and memory footprint.</p>
-<p>We could try to provide concepts like
-<code class="sourceCode default">ScaledUnitOf&lt;si::metre&gt;</code>
+force <code class="sourceCode cpp"><span class="dt">double</span></code>
+as a representation type to prevent narrowing, which can affect not only
+the performance, but also precision and memory footprint.</p>
+<p>We could try to provide concepts like <code class="sourceCode cpp">ScaledUnitOf<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">&gt;</span></code>
 that will try to constrain somehow the arguments, but it leads to even
 more problems with the unit definitions. For example, are Hz and Bq
 scaled versions of 1 / s? What about radian and steradian or a litre and
@@ -3356,8 +3328,8 @@ <h2 data-number="12.2" id="limitations-of-dimensions"><span class="header-sectio
 <span id="cb58-4"><a href="#cb58-4" aria-hidden="true" tabindex="-1"></a>  <span class="cf">return</span> distance <span class="op">/</span> time;</span>
 <span id="cb58-5"><a href="#cb58-5" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
 <p>and the second one by specifying that both EURO and USD are units of
-<code class="sourceCode default">dim_currency</code>. This is a
-significant improvement but still has some issues.</p>
+<code class="sourceCode cpp">dim_currency</code>. This is a significant
+improvement but still has some issues.</p>
 <p>Let’s first look again at the above solution. A domain expert seeing
 this code will immediately say there is no such thing as a speed
 dimension. The ISQ specifies only 7 dimensions with unique symbols
@@ -3373,14 +3345,14 @@ <h2 data-number="12.2" id="limitations-of-dimensions"><span class="header-sectio
 <p>Most of the libraries on the market ignore this fact and try to model
 distinct quantities through their dimensions, giving a false sense of
 safety. A dimension is not enough to describe a quantity. This has been
-known for a long time now. The <span class="citation" data-cites="MSRMT_DATA">[<a href="#ref-MSRMT_DATA" role="doc-biblioref">Measurement Data</a>]</span> report from 1996 says
+known for a long time now. The <span class="citation" data-cites="MSRMT_DATA">[<a href="https://www.bkent.net/Doc/mdarchiv.pdf" role="doc-biblioref">Measurement Data</a>]</span> report from 1996 says
 explicitly, “Dimensional analysis does not adequately model the
 semantics of measurement data”.</p>
 <p>In the following chapters, we will see a few use cases that can’t be
 solved with an approach that only relies on units or dimensions.</p>
 <h3 data-number="12.2.1" id="si-units-of-quantities-of-the-same-dimension-but-different-kinds"><span class="header-section-number">12.2.1</span> SI units of quantities of
 the same dimension but different kinds<a href="#si-units-of-quantities-of-the-same-dimension-but-different-kinds" class="self-link"></a></h3>
-<p>The <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> provides several units for distinct
+<p>The <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> provides several units for distinct
 quantities of the same dimension but different kinds. For example:</p>
 <ul>
 <li>hertz (Hz) is a unit of <em>frequency</em> and becquerel (Bq) is a
@@ -3393,23 +3365,23 @@ <h3 data-number="12.2.1" id="si-units-of-quantities-of-the-same-dimension-but-di
 <em>solid angle</em> defined as <span class="math inline">\(m^2/m^2\)</span>. Both are quantities of dimension
 one, which also has its own units like one (1) and percent (%).</li>
 </ul>
-<p>There are many more similar examples in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>. For example, <em>storage
+<p>There are many more similar examples in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>. For example, <em>storage
 capacity</em> quantity can be measured in units of one, bit, octet, and
 byte.</p>
 <p>The above conflicts can’t be solved with dimensions, and they yield
 many safety issues. For example, we can ask ourselves what should be the
 result of the following:</p>
 <ol type="1">
-<li><code class="sourceCode default">quantity q = 1 * Hz + 1 * Bq;</code></li>
-<li><code class="sourceCode default">quantity&lt;Gy&gt; q = 42 * Sv;</code></li>
-<li><code class="sourceCode default">bool b = (1 * rad + 1 * bit) == 2 * sr;</code></li>
+<li><code class="sourceCode cpp">quantity q <span class="op">=</span> <span class="dv">1</span> <span class="op">*</span> Hz <span class="op">+</span> <span class="dv">1</span> <span class="op">*</span> Bq;</code></li>
+<li><code class="sourceCode cpp">quantity<span class="op">&lt;</span>Gy<span class="op">&gt;</span> q <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> Sv;</code></li>
+<li><code class="sourceCode cpp"><span class="dt">bool</span> b <span class="op">=</span> <span class="op">(</span><span class="dv">1</span> <span class="op">*</span> rad <span class="op">+</span> <span class="dv">1</span> <span class="op">*</span> bit<span class="op">)</span> <span class="op">==</span> <span class="dv">2</span> <span class="op">*</span> sr;</code></li>
 </ol>
 <p>None of the above code should compile, but most of the libraries on
 the market happily accept it and provide meaningless results. Some of
 them decide not to define one or more of the above units at all to avoid
 potential safety issues. For example, <a href="https://github.com/aurora-opensource/au/pull/157">the Au library
-does not define <code class="sourceCode default">Sv</code> to avoid
-mixing it up with Gy</a>.</p>
+does not define <code class="sourceCode cpp">Sv</code> to avoid mixing
+it up with Gy</a>.</p>
 <h3 data-number="12.2.2" id="derived-quantities-of-the-same-dimension-but-different-kinds"><span class="header-section-number">12.2.2</span> Derived quantities of the
 same dimension but different kinds<a href="#derived-quantities-of-the-same-dimension-but-different-kinds" class="self-link"></a></h3>
 <p>Even if some quantities do not have a specially assigned unit, they
@@ -3477,7 +3449,7 @@ <h1 data-number="13" id="systems-of-quantities-and-units"><span class="header-se
 seven base quantities: <em>length</em>, <em>mass</em>, <em>time</em>,
 <em>electric current</em>, <em>thermodynamic temperature</em>,
 <em>amount of substance</em>, and <em>luminous intensity</em>. This
-system of quantities is published in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>, “Quantities and
+system of quantities is published in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>, “Quantities and
 units”.</p>
 <p>A <a href="https://jcgm.bipm.org/vim/en/1.13.html">system of
 units</a> is a set of base units and derived units, together with their
@@ -3494,14 +3466,13 @@ <h2 data-number="13.1" id="systems-of-quantities"><span class="header-section-nu
 modeling one or more systems of units. However, this is not the only
 system kind to model. Another, and maybe even more important, is a
 system of quantities. The most important example here is the
-International System of Quantities (ISQ) defined by <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>.</p>
+International System of Quantities (ISQ) defined by <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>.</p>
 <h3 data-number="13.1.1" id="quantities-of-the-same-kind"><span class="header-section-number">13.1.1</span> Quantities of the same
 kind<a href="#quantities-of-the-same-kind" class="self-link"></a></h3>
 <p>As it was described in <a href="#limitations-of-dimensions">Limitations of dimensions</a>,
 dimension is not enough to describe a quantity. We need a better
 abstraction to provide safety to our calculations.</p>
-<p>The <span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span>
-says:</p>
+<p>The <span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> says:</p>
 <ul>
 <li>Quantities may be grouped together into categories of quantities
 that are <strong>mutually comparable</strong></li>
@@ -3515,7 +3486,7 @@ <h3 data-number="13.1.1" id="quantities-of-the-same-kind"><span class="header-se
 <li>Quantities of the <strong>same dimension are not necessarily of the
 same kind</strong></li>
 </ul>
-<p><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> also explicitly
+<p><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> also explicitly
 notes:</p>
 <blockquote>
 <p><strong>Measurement units of quantities of the same quantity
@@ -3545,17 +3516,16 @@ <h3 data-number="13.1.1" id="quantities-of-the-same-kind"><span class="header-se
 belong to the same quantity kind.</p>
 <h3 data-number="13.1.2" id="system-of-quantities-is-not-only-about-kinds"><span class="header-section-number">13.1.2</span> System of quantities is not
 only about kinds<a href="#system-of-quantities-is-not-only-about-kinds" class="self-link"></a></h3>
-<p><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> specifies hundreds of
+<p><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> specifies hundreds of
 different quantities. Plenty of various kinds are provided, and often,
 each kind contains more than one quantity. It turns out that such
 quantities form a hierarchy of quantities of the same kind.</p>
 <p>For example, here are all quantities of the kind <em>length</em>
-provided in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-(part 1):</p>
+provided in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 1):</p>
 <p><img src="data:image/svg+xml;base64,<svg aria-roledescription="flowchart-v2" role="graphics-document document" viewBox="-8 -8 1072.7578125 346" style="max-width: 100%;" xmlns="http://www.w3.org/2000/svg" width="100%" id="graph-div" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink"><style>@import url("https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.2/css/all.min.css");'</style><style>#graph-div{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#graph-div .error-icon{fill:#552222;}#graph-div .error-text{fill:#552222;stroke:#552222;}#graph-div .edge-thickness-normal{stroke-width:2px;}#graph-div .edge-thickness-thick{stroke-width:3.5px;}#graph-div .edge-pattern-solid{stroke-dasharray:0;}#graph-div .edge-pattern-dashed{stroke-dasharray:3;}#graph-div .edge-pattern-dotted{stroke-dasharray:2;}#graph-div .marker{fill:#333333;stroke:#333333;}#graph-div .marker.cross{stroke:#333333;}#graph-div svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#graph-div .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#graph-div .cluster-label text{fill:#333;}#graph-div .cluster-label span,#graph-div p{color:#333;}#graph-div .label text,#graph-div span,#graph-div p{fill:#333;color:#333;}#graph-div .node rect,#graph-div .node circle,#graph-div .node ellipse,#graph-div .node polygon,#graph-div .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#graph-div .flowchart-label text{text-anchor:middle;}#graph-div .node .label{text-align:center;}#graph-div .node.clickable{cursor:pointer;}#graph-div .arrowheadPath{fill:#333333;}#graph-div .edgePath .path{stroke:#333333;stroke-width:2.0px;}#graph-div .flowchart-link{stroke:#333333;fill:none;}#graph-div .edgeLabel{background-color:#e8e8e8;text-align:center;}#graph-div .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#graph-div .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#graph-div .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#graph-div .cluster text{fill:#333;}#graph-div .cluster span,#graph-div p{color:#333;}#graph-div div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#graph-div .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#graph-div :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g><marker orient="auto" markerHeight="12" markerWidth="12" markerUnits="userSpaceOnUse" refY="5" refX="6" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-pointEnd"><path style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 0 0 L 10 5 L 0 10 z"></path></marker><marker orient="auto" markerHeight="12" markerWidth="12" markerUnits="userSpaceOnUse" refY="5" refX="4.5" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-pointStart"><path style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 0 5 L 10 10 L 10 0 z"></path></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5" refX="11" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-circleEnd"><circle style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" r="5" cy="5" cx="5"></circle></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5" refX="-1" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-circleStart"><circle style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" r="5" cy="5" cx="5"></circle></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5.2" refX="12" viewBox="0 0 11 11" class="marker cross flowchart" id="graph-div_flowchart-crossEnd"><path style="stroke-width: 2; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 1,1 l 9,9 M 10,1 l -9,9"></path></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5.2" refX="-1" viewBox="0 0 11 11" class="marker cross flowchart" id="graph-div_flowchart-crossStart"><path style="stroke-width: 2; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 1,1 l 9,9 M 10,1 l -9,9"></path></marker><g class="root"><g class="clusters"></g><g class="edgePaths"><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-length LE-width" id="L-length-width-0" d="M607.273,22.148L527.86,29.124C448.447,36.099,289.62,50.049,210.206,63.191C130.793,76.333,130.793,88.667,130.793,94.833L130.793,101"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-length LE-height" id="L-length-height-0" d="M607.273,23.893L561.391,30.577C515.508,37.262,423.742,50.631,377.859,63.482C331.977,76.333,331.977,88.667,331.977,94.833L331.977,101"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-width LE-thickness" id="L-width-thickness-0" d="M99.641,140L89.789,146.167C79.938,152.333,60.234,164.667,50.383,175C40.531,185.333,40.531,193.667,40.531,197.833L40.531,202"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-width LE-diameter" id="L-width-diameter-0" d="M144.722,140L149.127,146.167C153.532,152.333,162.342,164.667,166.747,175C171.152,185.333,171.152,193.667,171.152,197.833L171.152,202"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-width LE-radius" id="L-width-radius-0" d="M185.879,140L203.3,146.167C220.72,152.333,255.561,164.667,272.982,175C290.402,185.333,290.402,193.667,290.402,197.833L290.402,202"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-length LE-path_length" id="L-length-path_length-0" d="M607.273,31.175L593.144,36.646C579.014,42.117,550.755,53.058,536.626,64.696C522.496,76.333,522.496,88.667,522.496,94.833L522.496,101"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-path_length LE-distance" id="L-path_length-distance-0" d="M522.496,140L522.496,146.167C522.496,152.333,522.496,164.667,522.496,175C522.496,185.333,522.496,193.667,522.496,197.833L522.496,202"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-distance LE-radial_distance" id="L-distance-radial_distance-0" d="M522.496,241L522.496,245.167C522.496,249.333,522.496,257.667,522.496,266C522.496,274.333,522.496,282.667,522.496,286.833L522.496,291"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-length LE-wavelength" id="L-length-wavelength-0" d="M652.417,39L655.62,43.167C658.824,47.333,665.23,55.667,668.433,66C671.637,76.333,671.637,88.667,671.637,94.833L671.637,101"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-length LE-position_vector" id="L-length-position_vector-0" d="M667.578,26.356L695.169,32.63C722.76,38.904,777.943,51.452,805.534,61.893C833.125,72.333,833.125,80.667,833.125,84.833L833.125,89"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-length LE-displacement" id="L-length-displacement-0" d="M667.578,23.187L723.214,29.989C778.849,36.791,890.12,50.396,945.755,61.364C1001.391,72.333,1001.391,80.667,1001.391,84.833L1001.391,89"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-radius LE-radius_of_curvature" id="L-radius-radius_of_curvature-0" d="M290.402,241L290.402,245.167C290.402,249.333,290.402,257.667,290.402,266C290.402,274.333,290.402,282.667,290.402,286.833L290.402,291"></path></g><g class="edgeLabels"><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g></g><g class="nodes"><g transform="translate(637.42578125, 19.5)" id="flowchart-length-188" class="node default default flowchart-label"><rect height="39" width="60.3046875" y="-19.5" x="-30.15234375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-22.65234375, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="45.3046875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">length</span></div></foreignObject></g></g><g transform="translate(130.79296875, 120.5)" id="flowchart-width-189" class="node default default flowchart-label"><rect height="39" width="122.4296875" y="-19.5" x="-61.21484375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-53.71484375, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="107.4296875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">width, breadth</span></div></foreignObject></g></g><g transform="translate(331.9765625, 120.5)" id="flowchart-height-191" class="node default default flowchart-label"><rect height="39" width="179.9375" y="-19.5" x="-89.96875" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-82.46875, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="164.9375"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">height, depth, altitude</span></div></foreignObject></g></g><g transform="translate(40.53125, 221.5)" id="flowchart-thickness-193" class="node default default flowchart-label"><rect height="39" width="81.0625" y="-19.5" x="-40.53125" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-33.03125, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="66.0625"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">thickness</span></div></foreignObject></g></g><g transform="translate(171.15234375, 221.5)" id="flowchart-diameter-195" class="node default default flowchart-label"><rect height="39" width="80.1796875" y="-19.5" x="-40.08984375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-32.58984375, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="65.1796875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">diameter</span></div></foreignObject></g></g><g transform="translate(290.40234375, 221.5)" id="flowchart-radius-197" class="node default default flowchart-label"><rect height="39" width="58.3203125" y="-19.5" x="-29.16015625" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-21.66015625, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="43.3203125"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">radius</span></div></foreignObject></g></g><g transform="translate(522.49609375, 120.5)" id="flowchart-path_length-199" class="node default default flowchart-label"><rect height="39" width="101.1015625" y="-19.5" x="-50.55078125" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-43.05078125, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="86.1015625"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">path_length</span></div></foreignObject></g></g><g transform="translate(522.49609375, 221.5)" id="flowchart-distance-201" class="node default default flowchart-label"><rect height="39" width="75.09375" y="-19.5" x="-37.546875" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-30.046875, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="60.09375"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">distance</span></div></foreignObject></g></g><g transform="translate(522.49609375, 310.5)" id="flowchart-radial_distance-203" class="node default default flowchart-label"><rect height="39" width="124.7109375" y="-19.5" x="-62.35546875" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-54.85546875, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="109.7109375"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">radial_distance</span></div></foreignObject></g></g><g transform="translate(671.63671875, 120.5)" id="flowchart-wavelength-205" class="node default default flowchart-label"><rect height="39" width="97.1796875" y="-19.5" x="-48.58984375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-41.08984375, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="82.1796875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">wavelength</span></div></foreignObject></g></g><g transform="translate(833.125, 120.5)" id="flowchart-position_vector-207" class="node default default flowchart-label"><rect height="63" width="125.796875" y="-31.5" x="-62.8984375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-55.3984375, -24)" style="" class="label"><rect></rect><foreignObject height="48" width="110.796875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">position_vector<br/>{vector}</span></div></foreignObject></g></g><g transform="translate(1001.390625, 120.5)" id="flowchart-displacement-209" class="node default default flowchart-label"><rect height="63" width="110.734375" y="-31.5" x="-55.3671875" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-47.8671875, -24)" style="" class="label"><rect></rect><foreignObject height="48" width="95.734375"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">displacement<br/>{vector}</span></div></foreignObject></g></g><g transform="translate(290.40234375, 310.5)" id="flowchart-radius_of_curvature-211" class="node default default flowchart-label"><rect height="39" width="158.7578125" y="-19.5" x="-79.37890625" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-71.87890625, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="143.7578125"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">radius_of_curvature</span></div></foreignObject></g></g></g></g></g></svg>" /></p>
 <p>Each of the above quantities expresses some kind of <em>length</em>,
 and each can be measured with meters, which is the unit defined by the
-<span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> for quantities of <em>length</em>.
+<span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> for quantities of <em>length</em>.
 However, each has different properties, usage, and sometimes even a
 different character (<em>position vector</em> and <em>displacement</em>
 are vector quantities).</p>
@@ -3582,20 +3552,18 @@ <h3 data-number="13.1.2" id="system-of-quantities-is-not-only-about-kinds"><span
 <span id="cb60-19"><a href="#cb60-19" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> displacement <span class="op">:</span> quantity_spec<span class="op">&lt;</span>length, quantity_character<span class="op">::</span>vector<span class="op">&gt;</span> <span class="op">{}</span> displacement;</span></code></pre></div>
 <p>In the above code:</p>
 <ul>
-<li><code class="sourceCode default">length</code> takes the base
-dimension to indicate that we are creating a base quantity that will
-serve as a root for a tree of quantities of the same kind,</li>
-<li><code class="sourceCode default">width</code> and following
-quantities are branches and leaves of this tree with the parent always
-provided as the argument to
-<code class="sourceCode default">quantity_spec</code> class
+<li><code class="sourceCode cpp">length</code> takes the base dimension
+to indicate that we are creating a base quantity that will serve as a
+root for a tree of quantities of the same kind,</li>
+<li><code class="sourceCode cpp">width</code> and following quantities
+are branches and leaves of this tree with the parent always provided as
+the argument to <code class="sourceCode cpp">quantity_spec</code> class
 template,</li>
-<li><code class="sourceCode default">breadth</code> is an alias name for
-the same quantity as <code class="sourceCode default">width</code>.</li>
+<li><code class="sourceCode cpp">breadth</code> is an alias name for the
+same quantity as <code class="sourceCode cpp">width</code>.</li>
 </ul>
-<p>Please note that some quantities may be specified by <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> as vector or tensor
-quantities (e.g.,
-<code class="sourceCode default">displacement</code>).</p>
+<p>Please note that some quantities may be specified by <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> as vector or tensor
+quantities (e.g., <code class="sourceCode cpp">displacement</code>).</p>
 <h3 data-number="13.1.3" id="converting-between-quantities-of-the-same-kind"><span class="header-section-number">13.1.3</span> Converting between
 quantities of the same kind<a href="#converting-between-quantities-of-the-same-kind" class="self-link"></a></h3>
 <p>Quantity conversion rules can be defined based on the same hierarchy
@@ -3626,7 +3594,7 @@ <h3 data-number="13.1.3" id="converting-between-quantities-of-the-same-kind"><sp
 <span id="cb64-5"><a href="#cb64-5" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>explicitly_convertible<span class="op">(</span>isq<span class="op">::</span>length, isq<span class="op">::</span>radius<span class="op">))</span>;</span>
 <span id="cb64-6"><a href="#cb64-6" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>explicitly_convertible<span class="op">(</span>isq<span class="op">::</span>width, isq<span class="op">::</span>radius<span class="op">))</span>;</span></code></pre></div>
 <p>Explicit conversions are forced by passing the quantity to a call
-operator of a <code class="sourceCode default">quantity_spec</code>
+operator of a <code class="sourceCode cpp">quantity_spec</code>
 type:</p>
 <div class="sourceCode" id="cb65"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb65-1"><a href="#cb65-1" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&lt;</span>m<span class="op">&gt;&gt;</span> q1 <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> m;</span>
 <span id="cb65-2"><a href="#cb65-2" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>isq<span class="op">::</span>height<span class="op">&lt;</span>m<span class="op">&gt;&gt;</span> q2 <span class="op">=</span> isq<span class="op">::</span>height<span class="op">(</span>q1<span class="op">)</span>;  <span class="co">// explicit quantity conversion</span></span></code></pre></div></li>
@@ -3640,7 +3608,7 @@ <h3 data-number="13.1.3" id="converting-between-quantities-of-the-same-kind"><sp
 <span id="cb66-2"><a href="#cb66-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>explicitly_convertible<span class="op">(</span>isq<span class="op">::</span>height, isq<span class="op">::</span>width<span class="op">))</span>;</span>
 <span id="cb66-3"><a href="#cb66-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>castable<span class="op">(</span>isq<span class="op">::</span>height, isq<span class="op">::</span>width<span class="op">))</span>;</span></code></pre></div>
 <p>Explicit casts are forced with a dedicated
-<code class="sourceCode default">quantity_cast</code> function:</p>
+<code class="sourceCode cpp">quantity_cast</code> function:</p>
 <div class="sourceCode" id="cb67"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb67-1"><a href="#cb67-1" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>isq<span class="op">::</span>width<span class="op">&lt;</span>m<span class="op">&gt;&gt;</span> q1 <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> m;</span>
 <span id="cb67-2"><a href="#cb67-2" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>isq<span class="op">::</span>height<span class="op">&lt;</span>m<span class="op">&gt;&gt;</span> q2 <span class="op">=</span> quantity_cast<span class="op">&lt;</span>isq<span class="op">::</span>height<span class="op">&gt;(</span>q1<span class="op">)</span>;  <span class="co">// explicit quantity cast</span></span></code></pre></div></li>
 <li><p><strong>No conversion</strong></p>
@@ -3656,19 +3624,18 @@ <h3 data-number="13.1.3" id="converting-between-quantities-of-the-same-kind"><sp
 </ol>
 <h3 data-number="13.1.4" id="comparing-adding-and-subtracting-quantities-of-the-same-kind"><span class="header-section-number">13.1.4</span> Comparing, adding, and
 subtracting quantities of the same kind<a href="#comparing-adding-and-subtracting-quantities-of-the-same-kind" class="self-link"></a></h3>
-<p><span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span>
-explicitly states that <em>width</em> and <em>height</em> are quantities
-of the same kind and as such they:</p>
+<p><span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> explicitly states that
+<em>width</em> and <em>height</em> are quantities of the same kind and
+as such they:</p>
 <ul>
 <li>are mutually comparable, and</li>
 <li>can be added and subtracted.</li>
 </ul>
-<p>If we take the above for granted, the only reasonable result of
-<code class="sourceCode default">1 * width + 1 * height</code> is
-<code class="sourceCode default">2 * length</code>, where the result of
-<code class="sourceCode default">length</code> is known as a common
-quantity type. A result of such an equation is always the first common
-node in a hierarchy tree of the same kind. For example:</p>
+<p>If we take the above for granted, the only reasonable result of <code class="sourceCode cpp"><span class="dv">1</span> <span class="op">*</span> width <span class="op">+</span> <span class="dv">1</span> <span class="op">*</span> height</code>
+is <code class="sourceCode cpp"><span class="dv">2</span> <span class="op">*</span> length</code>,
+where the result of <code class="sourceCode cpp">length</code> is known
+as a common quantity type. A result of such an equation is always the
+first common node in a hierarchy tree of the same kind. For example:</p>
 <div class="sourceCode" id="cb71"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb71-1"><a href="#cb71-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>common_quantity_spec<span class="op">(</span>isq<span class="op">::</span>width, isq<span class="op">::</span>height<span class="op">)</span> <span class="op">==</span> isq<span class="op">::</span>length<span class="op">)</span>;</span>
 <span id="cb71-2"><a href="#cb71-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>common_quantity_spec<span class="op">(</span>isq<span class="op">::</span>thickness, isq<span class="op">::</span>radius<span class="op">)</span> <span class="op">==</span> isq<span class="op">::</span>width<span class="op">)</span>;</span>
 <span id="cb71-3"><a href="#cb71-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>common_quantity_spec<span class="op">(</span>isq<span class="op">::</span>distance, isq<span class="op">::</span>path_length<span class="op">)</span> <span class="op">==</span> isq<span class="op">::</span>path_length<span class="op">)</span>;</span></code></pre></div>
@@ -3676,7 +3643,7 @@ <h3 data-number="13.1.4" id="comparing-adding-and-subtracting-quantities-of-the-
 <span id="cb72-2"><a href="#cb72-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>q<span class="op">.</span>quantity_spec <span class="op">==</span> isq<span class="op">::</span>width<span class="op">)</span>;</span></code></pre></div>
 <p>One could argue that allowing to add or compare quantities of
 <em>height</em> and <em>width</em> might be a safety issue, but we need
-to be consistent with the requirements of <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>. Moreover, from our
+to be consistent with the requirements of <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>. Moreover, from our
 experience, disallowing such operations and requiring an explicit cast
 to a common quantity in every single place makes the code so cluttered
 with casts that it nearly renders the library unusable.</p>
@@ -3711,16 +3678,17 @@ <h3 data-number="13.1.4" id="comparing-adding-and-subtracting-quantities-of-the-
 <span id="cb73-27"><a href="#cb73-27" aria-hidden="true" tabindex="-1"></a>  std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;- area = &quot;</span> <span class="op">&lt;&lt;</span> paper<span class="op">[</span><span class="dv">0</span><span class="op">]</span> <span class="op">*</span> paper<span class="op">[</span><span class="dv">1</span><span class="op">]</span> <span class="op">&lt;&lt;</span> <span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span>;     <span class="co">// - area = 0.65625 m²</span></span>
 <span id="cb73-28"><a href="#cb73-28" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
 <p>In the beginning, we introduce a custom quantity
-<code class="sourceCode default">horizontal_length</code> of a kind
+<code class="sourceCode cpp">horizontal_length</code> of a kind
 <em>length</em>, which then, together with
-<code class="sourceCode default">isq::width</code> and
-<code class="sourceCode default">isq::height</code>, are used to define
-the dimensions of a Christmas gift. Next, we provide a function that
-calculates the dimensions of a gift wrapping paper with some wraparound.
-The result of both those expressions is a quantity of
-<code class="sourceCode default">isq::length</code>, as this is the
-closest common quantity for the arguments used in this quantity
-equation.</p>
+<code class="sourceCode cpp">isq<span class="op">::</span>width</code>
+and
+<code class="sourceCode cpp">isq<span class="op">::</span>height</code>,
+are used to define the dimensions of a Christmas gift. Next, we provide
+a function that calculates the dimensions of a gift wrapping paper with
+some wraparound. The result of both those expressions is a quantity of
+<code class="sourceCode cpp">isq<span class="op">::</span>length</code>,
+as this is the closest common quantity for the arguments used in this
+quantity equation.</p>
 <p>Regarding safety, it is important to mention here, that thanks to the
 conversion rules provided above, it would be impossible to accidentally
 do the following:</p>
@@ -3730,9 +3698,10 @@ <h3 data-number="13.1.4" id="comparing-adding-and-subtracting-quantities-of-the-
 <span id="cb74-4"><a href="#cb74-4" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>isq<span class="op">::</span>height<span class="op">[</span>m<span class="op">]&gt;</span> q2<span class="op">{</span>dim1<span class="op">}</span>;  <span class="co">// Compile-time error</span></span>
 <span id="cb74-5"><a href="#cb74-5" aria-hidden="true" tabindex="-1"></a>foo<span class="op">(</span>dim1<span class="op">)</span>;                          <span class="co">// Compile-time error</span></span></code></pre></div>
 <p>The reason of compilation errors above is the fact that
-<code class="sourceCode default">isq::length</code> is not implicitly
-convertible to the quantities defined based on it. To make the above
-code compile, an explicit conversion of a quantity type is needed:</p>
+<code class="sourceCode cpp">isq<span class="op">::</span>length</code>
+is not implicitly convertible to the quantities defined based on it. To
+make the above code compile, an explicit conversion of a quantity type
+is needed:</p>
 <div class="sourceCode" id="cb75"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb75-1"><a href="#cb75-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> foo<span class="op">(</span>quantity<span class="op">&lt;</span>horizontal_length<span class="op">[</span>m<span class="op">]&gt;</span> q<span class="op">)</span>;</span>
 <span id="cb75-2"><a href="#cb75-2" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb75-3"><a href="#cb75-3" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>isq<span class="op">::</span>width<span class="op">[</span>m<span class="op">]&gt;</span> q1 <span class="op">=</span> isq<span class="op">::</span>width<span class="op">(</span>dim1<span class="op">)</span>;</span>
@@ -3749,14 +3718,14 @@ <h3 data-number="13.1.5" id="hierarchies-of-derived-quantities"><span class="hea
 <div class="sourceCode" id="cb76"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb76-1"><a href="#cb76-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> horizontal_length <span class="op">:</span> quantity_spec<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;</span> <span class="op">{}</span> horizontal_length;</span>
 <span id="cb76-2"><a href="#cb76-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> horizontal_area <span class="op">:</span> quantity_spec<span class="op">&lt;</span>isq<span class="op">::</span>area, horizontal_length <span class="op">*</span> isq<span class="op">::</span>width<span class="op">&gt;</span> <span class="op">{}</span> horizontal_area;</span></code></pre></div>
 <p>The first definition says that a
-<code class="sourceCode default">horizontal_length</code> is a more
+<code class="sourceCode cpp">horizontal_length</code> is a more
 specialized quantity than
-<code class="sourceCode default">isq::length</code> and belongs to the
-same quantity kind. The second line defines a
-<code class="sourceCode default">horizontal_area</code>, which is a more
+<code class="sourceCode cpp">isq<span class="op">::</span>length</code>
+and belongs to the same quantity kind. The second line defines a
+<code class="sourceCode cpp">horizontal_area</code>, which is a more
 specialized quantity than
-<code class="sourceCode default">isq::area</code>, so it has a more
-constrained recipe as well. Thanks to that:</p>
+<code class="sourceCode cpp">isq<span class="op">::</span>area</code>,
+so it has a more constrained recipe as well. Thanks to that:</p>
 <div class="sourceCode" id="cb77"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb77-1"><a href="#cb77-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>implicitly_convertible<span class="op">(</span>horizontal_length, isq<span class="op">::</span>length<span class="op">))</span>;</span>
 <span id="cb77-2"><a href="#cb77-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>implicitly_convertible<span class="op">(</span>isq<span class="op">::</span>length, horizontal_length<span class="op">))</span>;</span>
 <span id="cb77-3"><a href="#cb77-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>explicitly_convertible<span class="op">(</span>isq<span class="op">::</span>length, horizontal_length<span class="op">))</span>;</span>
@@ -3773,7 +3742,7 @@ <h3 data-number="13.1.5" id="hierarchies-of-derived-quantities"><span class="hea
 <span id="cb77-14"><a href="#cb77-14" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>implicitly_convertible<span class="op">(</span>horizontal_length <span class="op">*</span> isq<span class="op">::</span>width, horizontal_area<span class="op">))</span>;</span></code></pre></div>
 <p>Unfortunately, derived quantity equations often do not automatically
 form a hierarchy tree. This is why sometimes it is not obvious what such
-a tree should look like. Also, the <span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> explicitly states:</p>
+a tree should look like. Also, the <span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> explicitly states:</p>
 <blockquote>
 <p>The division of ‘quantity’ according to ‘kind of quantity’ is, to
 some extent, arbitrary.</p>
@@ -3785,37 +3754,35 @@ <h3 data-number="13.1.5" id="hierarchies-of-derived-quantities"><span class="hea
 dimension and can be expressed in the same units, they have different
 quantity equations used to create them implicitly:</p>
 <ul>
-<li><p><code class="sourceCode default">energy</code> is the most
-generic one and thus can be created from base quantities of
-<code class="sourceCode default">mass</code>,
-<code class="sourceCode default">length</code>, and
-<code class="sourceCode default">time</code>. As those are also the
-roots of quantities of their kinds and all other quantities are
-implicitly convertible to them, it means that an
-<code class="sourceCode default">energy</code> can be implicitly
-constructed from any quantity having proper powers of <em>mass</em>,
+<li><p><code class="sourceCode cpp">energy</code> is the most generic
+one and thus can be created from base quantities of
+<code class="sourceCode cpp">mass</code>,
+<code class="sourceCode cpp">length</code>, and
+<code class="sourceCode cpp">time</code>. As those are also the roots of
+quantities of their kinds and all other quantities are implicitly
+convertible to them, it means that an
+<code class="sourceCode cpp">energy</code> can be implicitly constructed
+from any quantity having proper powers of <em>mass</em>,
 <em>length</em>, and <em>time</em>.</p>
 <div class="sourceCode" id="cb78"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb78-1"><a href="#cb78-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>implicitly_convertible<span class="op">(</span>isq<span class="op">::</span>mass <span class="op">*</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>length<span class="op">)</span> <span class="op">/</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>time<span class="op">)</span>, isq<span class="op">::</span>energy<span class="op">))</span>;</span>
 <span id="cb78-2"><a href="#cb78-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>implicitly_convertible<span class="op">(</span>isq<span class="op">::</span>mass <span class="op">*</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>height<span class="op">)</span> <span class="op">/</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>time<span class="op">)</span>, isq<span class="op">::</span>energy<span class="op">))</span>;</span></code></pre></div></li>
-<li><p><code class="sourceCode default">mechanical_energy</code> is a
-more “specialized” quantity than
-<code class="sourceCode default">energy</code> (not every
-<code class="sourceCode default">energy</code> is a
-<code class="sourceCode default">mechanical_energy</code>). It is why an
+<li><p><code class="sourceCode cpp">mechanical_energy</code> is a more
+“specialized” quantity than <code class="sourceCode cpp">energy</code>
+(not every <code class="sourceCode cpp">energy</code> is a
+<code class="sourceCode cpp">mechanical_energy</code>). It is why an
 explicit cast is needed to convert from either
-<code class="sourceCode default">energy</code> or the results of its
+<code class="sourceCode cpp">energy</code> or the results of its
 quantity equation.</p>
 <div class="sourceCode" id="cb79"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb79-1"><a href="#cb79-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>implicitly_convertible<span class="op">(</span>isq<span class="op">::</span>energy, isq<span class="op">::</span>mechanical_energy<span class="op">))</span>;</span>
 <span id="cb79-2"><a href="#cb79-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>explicitly_convertible<span class="op">(</span>isq<span class="op">::</span>energy, isq<span class="op">::</span>mechanical_energy<span class="op">))</span>;</span>
 <span id="cb79-3"><a href="#cb79-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>implicitly_convertible<span class="op">(</span>isq<span class="op">::</span>mass <span class="op">*</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>length<span class="op">)</span> <span class="op">/</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>time<span class="op">)</span>, isq<span class="op">::</span>mechanical_energy<span class="op">))</span>;</span>
 <span id="cb79-4"><a href="#cb79-4" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>explicitly_convertible<span class="op">(</span>isq<span class="op">::</span>mass <span class="op">*</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>length<span class="op">)</span> <span class="op">/</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>isq<span class="op">::</span>time<span class="op">)</span>, isq<span class="op">::</span>mechanical_energy<span class="op">))</span>;</span></code></pre></div></li>
-<li><p><code class="sourceCode default">gravitational_potential_energy</code>
+<li><p><code class="sourceCode cpp">gravitational_potential_energy</code>
 is not only even more specialized one but additionally, it is special in
 a way that it provides its own “constrained” quantity equation. Maybe
-not every <code class="sourceCode default">mass * pow&lt;2&gt;(length) / pow&lt;2&gt;(time)</code>
-is a
-<code class="sourceCode default">gravitational_potential_energy</code>,
-but every <code class="sourceCode default">mass * acceleration_of_free_fall * height</code>
+not every <code class="sourceCode cpp">mass <span class="op">*</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>length<span class="op">)</span> <span class="op">/</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>time<span class="op">)</span></code>
+is a <code class="sourceCode cpp">gravitational_potential_energy</code>,
+but every <code class="sourceCode cpp">mass <span class="op">*</span> acceleration_of_free_fall <span class="op">*</span> height</code>
 is.</p>
 <div class="sourceCode" id="cb80"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb80-1"><a href="#cb80-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>implicitly_convertible<span class="op">(</span>isq<span class="op">::</span>energy, gravitational_potential_energy<span class="op">))</span>;</span>
 <span id="cb80-2"><a href="#cb80-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>explicitly_convertible<span class="op">(</span>isq<span class="op">::</span>energy, gravitational_potential_energy<span class="op">))</span>;</span>
@@ -3829,11 +3796,10 @@ <h3 data-number="13.1.6" id="modeling-a-quantity-kind"><span class="header-secti
 not only the same dimension but also can be expressed in the same
 units.</p>
 <p>To annotate a quantity to represent its kind (and not just a
-hierarchy tree’s root quantity), we introduced a
-<code class="sourceCode default">kind_of&lt;&gt;</code> specifier. For
-example, to express any quantity of <em>length</em>, we need to specify
-<code class="sourceCode default">kind_of&lt;isq::length&gt;</code>. That
-entity behaves as any quantity of its kind. This means that it is
+hierarchy tree’s root quantity), we introduced a <code class="sourceCode cpp">kind_of<span class="op">&lt;&gt;</span></code>
+specifier. For example, to express any quantity of <em>length</em>, we
+need to specify <code class="sourceCode cpp">kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;</span></code>.
+That entity behaves as any quantity of its kind. This means that it is
 implicitly convertible to any quantity in a tree:</p>
 <div class="sourceCode" id="cb81"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb81-1"><a href="#cb81-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>implicitly_convertible<span class="op">(</span>isq<span class="op">::</span>length, isq<span class="op">::</span>height<span class="op">))</span>;</span>
 <span id="cb81-2"><a href="#cb81-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>implicitly_convertible<span class="op">(</span>kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;</span>, isq<span class="op">::</span>height<span class="op">))</span>;</span></code></pre></div>
@@ -3846,14 +3812,13 @@ <h3 data-number="13.1.6" id="modeling-a-quantity-kind"><span class="header-secti
 <div class="sourceCode" id="cb83"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb83-1"><a href="#cb83-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>same_type<span class="op">&lt;</span>kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;</span> <span class="op">/</span> isq<span class="op">::</span>time, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length <span class="op">/</span> isq<span class="op">::</span>time<span class="op">&gt;&gt;)</span>;</span>
 <span id="cb83-2"><a href="#cb83-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>same_type<span class="op">&lt;</span>kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;</span> <span class="op">/</span> isq<span class="op">::</span>time, isq<span class="op">::</span>length <span class="op">/</span> isq<span class="op">::</span>time<span class="op">&gt;)</span>;</span></code></pre></div>
 <p>Please note that only a root quantity from the hierarchy tree or the
-one marked with <code class="sourceCode default">is_kind</code>
-specifier in the <code class="sourceCode default">quantity_spec</code>
-definition can be put as a template parameter to the
-<code class="sourceCode default">kind_of</code> specifier. For example,
-<code class="sourceCode default">kind_of&lt;isq::width&gt;</code> will
-fail to compile. However, we can call
-<code class="sourceCode default">get_kind(q)</code> to obtain a kind of
-any quantity:</p>
+one marked with <code class="sourceCode cpp">is_kind</code> specifier in
+the <code class="sourceCode cpp">quantity_spec</code> definition can be
+put as a template parameter to the
+<code class="sourceCode cpp">kind_of</code> specifier. For example,
+<code class="sourceCode cpp">kind_of<span class="op">&lt;</span>isq<span class="op">::</span>width<span class="op">&gt;</span></code>
+will fail to compile. However, we can call <code class="sourceCode cpp">get_kind<span class="op">(</span>q<span class="op">)</span></code>
+to obtain a kind of any quantity:</p>
 <div class="sourceCode" id="cb84"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb84-1"><a href="#cb84-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>get_kind<span class="op">(</span>isq<span class="op">::</span>width<span class="op">)</span> <span class="op">==</span> kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;)</span>;</span></code></pre></div>
 <h2 data-number="13.2" id="systems-of-units"><span class="header-section-number">13.2</span> Systems of units<a href="#systems-of-units" class="self-link"></a></h2>
 <p>Modeling a system of units is the most important feature and a
@@ -3861,7 +3826,7 @@ <h2 data-number="13.2" id="systems-of-units"><span class="header-section-number"
 library can protect users from performing invalid operations on
 quantities and provide automated conversion factors between various
 compatible units.</p>
-<p>Probably all the libraries in the wild model the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> or at least most of it (refer to <a href="#si-units-of-quantities-of-the-same-dimension-but-different-kinds">SI
+<p>Probably all the libraries in the wild model the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> or at least most of it (refer to <a href="#si-units-of-quantities-of-the-same-dimension-but-different-kinds">SI
 units of quantities of the same dimension but different kinds</a> for
 more details) and many of them provide support for additional units
 belonging to various other systems (e.g., imperial).</p>
@@ -3872,34 +3837,33 @@ <h3 data-number="13.2.1" id="systems-of-units-are-based-on-systems-of-quantities
 numerical representation into account at all. In order to create a
 quantity, we need to add those missing pieces of information. This is
 where a system of units kicks in.</p>
-<p>The <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> is explicitly stated to be based on
+<p>The <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> is explicitly stated to be based on
 the ISQ. Among others, it defines seven base units, one for each base
 quantity. In the library, this is expressed by associating a quantity
 kind to a unit being defined:</p>
 <div class="sourceCode" id="cb85"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb85-1"><a href="#cb85-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> metre <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;m&quot;</span>, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;&gt;</span> <span class="op">{}</span> metre;</span></code></pre></div>
-<p>The
-<code class="sourceCode default">kind_of&lt;isq::length&gt;</code> above
-states explicitly that this unit has an associated quantity kind. In
-other words, <code class="sourceCode default">si::metre</code> (and
-scaled units based on it) can be used to express the amount of any
+<p>The <code class="sourceCode cpp">kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;</span></code>
+above states explicitly that this unit has an associated quantity kind.
+In other words,
+<code class="sourceCode cpp">si<span class="op">::</span>metre</code>
+(and scaled units based on it) can be used to express the amount of any
 quantity of kind <em>length</em>.</p>
 <p>Associated units are so useful and common in the library that they
-got their own <a href="#AssociatedUnit-concept"><code class="sourceCode default">AssociatedUnit&lt;T&gt;</code></a>
+got their own <a href="#AssociatedUnit-concept"><code class="sourceCode cpp">AssociatedUnit<span class="op">&lt;</span>T<span class="op">&gt;</span></code></a>
 concept to improve the interfaces.</p>
 <p>Please note that for some systems of units (e.g., natural units), a
 unit may not have an associated quantity type. For example, if we define
-the speed of light constant as
-<code class="sourceCode default">c = 1</code>, we can define a system
-where both <em>length</em> and <em>time</em> will be measured in
-seconds, and <em>speed</em> will be a quantity measured with the unit
-<code class="sourceCode default">one</code>. In such case, the
+the speed of light constant as <code class="sourceCode cpp">c <span class="op">=</span> <span class="dv">1</span></code>,
+we can define a system where both <em>length</em> and <em>time</em> will
+be measured in seconds, and <em>speed</em> will be a quantity measured
+with the unit <code class="sourceCode cpp">one</code>. In such case, the
 definition will look as follows:</p>
 <div class="sourceCode" id="cb86"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb86-1"><a href="#cb86-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> second <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;s&quot;</span><span class="op">&gt;</span> <span class="op">{}</span> second;</span></code></pre></div>
 <h3 data-number="13.2.2" id="units-compose"><span class="header-section-number">13.2.2</span> Units compose<a href="#units-compose" class="self-link"></a></h3>
-<p>One of the strongest points of the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>
-system is that its units compose. This allows providing thousands of
-different units for hundreds of various quantities with a really small
-set of predefined units and prefixes. For example, one can write:</p>
+<p>One of the strongest points of the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> system is that its units compose.
+This allows providing thousands of different units for hundreds of
+various quantities with a really small set of predefined units and
+prefixes. For example, one can write:</p>
 <div class="sourceCode" id="cb87"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb87-1"><a href="#cb87-1" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>si<span class="op">::</span>metre <span class="op">/</span> si<span class="op">::</span>second<span class="op">&gt;</span> q;</span></code></pre></div>
 <p>to express a quantity of speed. The resulting quantity type is
 implicitly inferred from the unit equation by repeating exactly the same
@@ -3910,7 +3874,7 @@ <h3 data-number="13.2.2" id="units-compose"><span class="header-section-number">
 <span id="cb88-2"><a href="#cb88-2" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>mps<span class="op">&gt;</span> q;</span></code></pre></div>
 <h3 data-number="13.2.3" id="many-shades-of-the-same-unit"><span class="header-section-number">13.2.3</span> Many shades of the same
 unit<a href="#many-shades-of-the-same-unit" class="self-link"></a></h3>
-<p>The <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> provides the names for 22 common
+<p>The <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> provides the names for 22 common
 coherent units of 22 derived quantities.</p>
 <p>Each such named derived unit is a result of a specific predefined
 unit equation. For example, a unit of power quantity is defined as:</p>
@@ -3932,7 +3896,7 @@ <h3 data-number="13.2.3" id="many-shades-of-the-same-unit"><span class="header-s
 <h3 data-number="13.2.4" id="constraining-a-derived-unit-to-work-only-with-a-specific-derived-quantity"><span class="header-section-number">13.2.4</span> Constraining a derived unit
 to work only with a specific derived quantity<a href="#constraining-a-derived-unit-to-work-only-with-a-specific-derived-quantity" class="self-link"></a></h3>
 <p>Some derived units are valid only for specific derived quantities.
-For example, <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> specifies both hertz and becquerel
+For example, <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> specifies both hertz and becquerel
 derived units with the same unit equation <span class="math inline">\(s^{-1}\)</span>. However, it also explicitly
 states:</p>
 <blockquote>
@@ -3944,18 +3908,20 @@ <h3 data-number="13.2.4" id="constraining-a-derived-unit-to-work-only-with-a-spe
 such units to be used only with a specific quantity kind:</p>
 <div class="sourceCode" id="cb91"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb91-1"><a href="#cb91-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> hertz <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;Hz&quot;</span>, one <span class="op">/</span> second, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>frequency<span class="op">&gt;&gt;</span> <span class="op">{}</span> hertz;</span>
 <span id="cb91-2"><a href="#cb91-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> becquerel <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;Bq&quot;</span>, one <span class="op">/</span> second, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>activity<span class="op">&gt;&gt;</span> <span class="op">{}</span> becquerel;</span></code></pre></div>
-<p>With the above, <code class="sourceCode default">hertz</code> can
-only be used for <em>frequencies</em>, while
-<code class="sourceCode default">becquerel</code> should only be used
-for quantities of <em>activity</em>. This means that the following
-equation will not compile, improving the type-safety of the library:</p>
+<p>With the above, <code class="sourceCode cpp">hertz</code> can only be
+used for <em>frequencies</em>, while
+<code class="sourceCode cpp">becquerel</code> should only be used for
+quantities of <em>activity</em>. This means that the following equation
+will not compile, improving the type-safety of the library:</p>
 <div class="sourceCode" id="cb92"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb92-1"><a href="#cb92-1" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> q <span class="op">=</span> <span class="dv">1</span> <span class="op">*</span> Hz <span class="op">+</span> <span class="dv">1</span> <span class="op">*</span> Bq;   <span class="co">// Fails to compile</span></span></code></pre></div>
 <h3 data-number="13.2.5" id="prefixed-units"><span class="header-section-number">13.2.5</span> Prefixed units<a href="#prefixed-units" class="self-link"></a></h3>
 <p>Besides named units, the <a href="../../appendix/glossary.md#si">SI</a> specifies also 24 prefixes
-(all being a power of <code class="sourceCode default">10</code>) that
-can be prepended to all named units to obtain various scaled versions of
+(all being a power of
+<code class="sourceCode cpp"><span class="dv">10</span></code>) that can
+be prepended to all named units to obtain various scaled versions of
 them.</p>
-<p>Implementation of <code class="sourceCode default">std::ratio</code>
+<p>Implementation of
+<code class="sourceCode cpp">std<span class="op">::</span>ratio</code>
 provided by all major compilers is able to express only 16 of them. This
 is why, we had to find an alternative way to represent a unit’s
 magnitude in a more flexible way.</p>
@@ -3964,9 +3930,9 @@ <h3 data-number="13.2.5" id="prefixed-units"><span class="header-section-number"
 <span id="cb93-2"><a href="#cb93-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>PrefixableUnit <span class="kw">auto</span> U<span class="op">&gt;</span> <span class="kw">inline</span> <span class="kw">constexpr</span> quecto_<span class="op">&lt;</span>std<span class="op">::</span>remove_const_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">(</span>U<span class="op">)&gt;&gt;</span> quecto;</span></code></pre></div>
 <p>and then a unit can be prefixed in the following way:</p>
 <div class="sourceCode" id="cb94"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb94-1"><a href="#cb94-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">auto</span> qm <span class="op">=</span> quecto<span class="op">&lt;</span>metre<span class="op">&gt;</span>;</span></code></pre></div>
-<p>The usage of <code class="sourceCode default">mag_power</code> not
-only enables providing support for SI prefixes, but it can also
-efficiently represent any rational magnitude. For example, <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 13) prefixes used
+<p>The usage of <code class="sourceCode cpp">mag_power</code> not only
+enables providing support for SI prefixes, but it can also efficiently
+represent any rational magnitude. For example, <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 13) prefixes used
 in the IT industry can be implemented as:</p>
 <div class="sourceCode" id="cb95"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb95-1"><a href="#cb95-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>PrefixableUnit U<span class="op">&gt;</span> <span class="kw">struct</span> yobi_ <span class="op">:</span> prefixed_unit<span class="op">&lt;</span><span class="st">&quot;Yi&quot;</span>, mag_power<span class="op">&lt;</span><span class="dv">2</span>, <span class="dv">80</span><span class="op">&gt;</span>, U<span class="op">{}&gt;</span> <span class="op">{}</span>;</span>
 <span id="cb95-2"><a href="#cb95-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>PrefixableUnit <span class="kw">auto</span> U<span class="op">&gt;</span> <span class="kw">inline</span> <span class="kw">constexpr</span> yobi_<span class="op">&lt;</span>std<span class="op">::</span>remove_const_t<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">(</span>U<span class="op">)&gt;&gt;</span> yobi;</span></code></pre></div>
@@ -3975,12 +3941,12 @@ <h3 data-number="13.2.5" id="prefixed-units"><span class="header-section-number"
 takes an NTTP and converts it to its type before passing the argument to
 the associated class template.</em></p>
 <h3 data-number="13.2.6" id="scaled-units"><span class="header-section-number">13.2.6</span> Scaled units<a href="#scaled-units" class="self-link"></a></h3>
-<p>In the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>, all units are either base or
+<p>In the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>, all units are either base or
 derived units or prefixed versions of those. However, those are not the
 only options possible.</p>
 <p>For example, there is a list of off-system units accepted for use
-with <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>. All of those are scaled versions of
-the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> units with ratios that can’t be
+with <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>. All of those are scaled versions of
+the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> units with ratios that can’t be
 explicitly expressed with predefined SI prefixes. Those include units
 like minute, hour, or electronvolt:</p>
 <div class="sourceCode" id="cb96"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb96-1"><a href="#cb96-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> minute <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;min&quot;</span>, mag<span class="op">&lt;</span><span class="dv">60</span><span class="op">&gt;</span> <span class="op">*</span> si<span class="op">::</span>second<span class="op">&gt;</span> <span class="op">{}</span> minute;</span>
@@ -3991,13 +3957,13 @@ <h3 data-number="13.2.6" id="scaled-units"><span class="header-section-number">1
 scaled versions of other (often SI) units. For example, the
 international yard is defined as:</p>
 <div class="sourceCode" id="cb97"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb97-1"><a href="#cb97-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> yard <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;yd&quot;</span>, mag_ratio<span class="op">&lt;</span><span class="dv">9&#39;144</span>, <span class="dv">10&#39;000</span><span class="op">&gt;</span> <span class="op">*</span> si<span class="op">::</span>metre<span class="op">&gt;</span> <span class="op">{}</span> yard;</span></code></pre></div>
-<p>and then a <code class="sourceCode default">foot</code> can be
-defined as:</p>
+<p>and then a <code class="sourceCode cpp">foot</code> can be defined
+as:</p>
 <div class="sourceCode" id="cb98"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb98-1"><a href="#cb98-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> foot <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;ft&quot;</span>, mag_ratio<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">3</span><span class="op">&gt;</span> <span class="op">*</span> yard<span class="op">&gt;</span> <span class="op">{}</span> foot;</span></code></pre></div>
 <p>For some units, a magnitude might also be irrational. The best
-example here is a <code class="sourceCode default">degree</code> which
-is defined using a floating-point magnitude having a factor of the
-number π (Pi):</p>
+example here is a <code class="sourceCode cpp">degree</code> which is
+defined using a floating-point magnitude having a factor of the number π
+(Pi):</p>
 <div class="sourceCode" id="cb99"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb99-1"><a href="#cb99-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> mag_pi <span class="op">:</span> magnitude<span class="op">&lt;</span>std<span class="op">::</span>numbers<span class="op">::</span>pi_v<span class="op">&lt;</span><span class="dt">long</span> <span class="dt">double</span><span class="op">&gt;&gt;</span> <span class="op">{}</span> mag_pi;</span></code></pre></div>
 <div class="sourceCode" id="cb100"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb100-1"><a href="#cb100-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> degree <span class="op">:</span> named_unit<span class="op">&lt;{</span><span class="st">u8&quot;°&quot;</span>, <span class="st">&quot;deg&quot;</span><span class="op">}</span>, mag_pi <span class="op">/</span> mag<span class="op">&lt;</span><span class="dv">180</span><span class="op">&gt;</span> <span class="op">*</span> si<span class="op">::</span>radian<span class="op">&gt;</span> <span class="op">{}</span> degree;</span></code></pre></div>
 <h3 data-number="13.2.7" id="unit-symbols"><span class="header-section-number">13.2.7</span> Unit symbols<a href="#unit-symbols" class="self-link"></a></h3>
@@ -4011,7 +3977,7 @@ <h3 data-number="13.2.7" id="unit-symbols"><span class="header-section-number">1
 <p>Unit symbols introduce a lot of short identifiers into the current
 namespace, and that is why they are opt-in. A user has to explicitly
 “import” them from a dedicated
-<code class="sourceCode default">unit_symbols</code> namespace.</p>
+<code class="sourceCode cpp">unit_symbols</code> namespace.</p>
 <h1 data-number="14" id="safety-1"><span class="header-section-number">14</span> Safety<a href="#safety-1" class="self-link"></a></h1>
 <h2 data-number="14.1" id="safety-features"><span class="header-section-number">14.1</span> Safety features<a href="#safety-features" class="self-link"></a></h2>
 <p>This chapter describes the features that enforce safety in our code
@@ -4029,9 +3995,8 @@ <h3 data-number="14.1.1" id="safe-unit-conversions"><span class="header-section-
 <p>The first thing that comes to our mind when discussing the safety of
 such libraries is automated unit conversions between values of the same
 physical quantity. This is probably the most important subject here. We
-learned about its huge benefits long ago thanks to the
-<code class="sourceCode default">std::chrono::duration</code> that made
-conversions of time durations error-proof.</p>
+learned about its huge benefits long ago thanks to the <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>
+that made conversions of time durations error-proof.</p>
 <p>Unit conversions are typically performed either via a converting
 constructor or a dedicated conversion function:</p>
 <div class="sourceCode" id="cb103"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb103-1"><a href="#cb103-1" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> q1 <span class="op">=</span> <span class="dv">5</span> <span class="op">*</span> km;</span>
@@ -4041,16 +4006,16 @@ <h3 data-number="14.1.1" id="safe-unit-conversions"><span class="header-section-
 the magnitudes of the source and destination units at compile-time, and
 may use that information to calculate and apply a conversion factor
 automatically for the user.</p>
-<p>In <code class="sourceCode default">std::chrono::duration</code>, the
-magnitude of a unit is always expressed with
-<code class="sourceCode default">std::ratio</code>. This is not enough
-for a general-purpose physical units library. Some of the derived units
-have huge or tiny ratios. The difference from the base units is so huge
-that it cannot be expressed with
-<code class="sourceCode default">std::ratio</code>, which is implemented
-in terms of <code class="sourceCode default">std::intmax_t</code>. This
-makes it impossible to define units like electronvolt (eV), where 1 eV =
-1.602176634×10<sup>−19</sup> J, or Dalton (Da), where 1 Da =
+<p>In <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>,
+the magnitude of a unit is always expressed with
+<code class="sourceCode cpp">std<span class="op">::</span>ratio</code>.
+This is not enough for a general-purpose physical units library. Some of
+the derived units have huge or tiny ratios. The difference from the base
+units is so huge that it cannot be expressed with
+<code class="sourceCode cpp">std<span class="op">::</span>ratio</code>,
+which is implemented in terms of <code class="sourceCode cpp">std<span class="op">::</span><span class="dt">intmax_t</span></code>.
+This makes it impossible to define units like electronvolt (eV), where 1
+eV = 1.602176634×10<sup>−19</sup> J, or Dalton (Da), where 1 Da =
 1.660539040(20)×10<sup>−27</sup> kg. Moreover, some conversions, such as
 radian to a degree, require a conversion factor based on an irrational
 number like pi.</p>
@@ -4065,14 +4030,16 @@ <h3 data-number="14.1.2" id="preventing-truncation-of-data"><span class="header-
 <p>We can’t preserve the value of a source quantity when we convert it
 to one with a unit of a lower resolution while dealing with an integral
 representation type for a quantity. In the example above, converting
-<code class="sourceCode default">5</code> meters would result in
-<code class="sourceCode default">0</code> kilometers if internal
-conversion is performed using regular integer arithmetic.</p>
+<code class="sourceCode cpp"><span class="dv">5</span></code> meters
+would result in
+<code class="sourceCode cpp"><span class="dv">0</span></code> kilometers
+if internal conversion is performed using regular integer
+arithmetic.</p>
 <p>While this could be a valid behavior, the problem arises when the
 user expects to be able to convert the quantity back to the original
 unit without loss of information. So the library should prevent such
 conversions from happening implicitly. This is why it offers the named
-cast <code class="sourceCode default">value_cast</code> for these
+cast <code class="sourceCode cpp">value_cast</code> for these
 conversions marked as unsafe.</p>
 <p>To make the above conversions compile, we could use a floating-point
 representation type:</p>
@@ -4116,7 +4083,7 @@ <h3 data-number="14.1.3" id="safety-introduced-by-the-affine-space-abstractions"
 vectors. This greatly helps to prevent quantity equations that do not
 have physical sense.</p>
 <p>People often think that affine space is needed only to model
-<em>temperatures</em> and maybe <em>time</em> points (following the <a href="https://en.cppreference.com/w/cpp/chrono/time_point"><code class="sourceCode default">std::chrono::time_point</code></a>
+<em>temperatures</em> and maybe <em>time</em> points (following the <a href="https://en.cppreference.com/w/cpp/chrono/time_point"><code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>time_point</code></a>
 example). Still, the applicability of this concept is much wider.</p>
 <p>For example, if we would like to model a Mount Everest climbing
 expedition, we would deal with two kinds of altitude-related entities.
@@ -4128,58 +4095,58 @@ <h3 data-number="14.1.3" id="safety-introduced-by-the-affine-space-abstractions"
 adding the <em>altitude</em> of a base camp and the mountain peak mean
 after all?</p>
 <p>Modeling such affine space entities with the
-<code class="sourceCode default">quantity</code> (vector) and
-<code class="sourceCode default">quantity_point</code> (point) class
+<code class="sourceCode cpp">quantity</code> (vector) and
+<code class="sourceCode cpp">quantity_point</code> (point) class
 templates improves the overall project’s safety by only providing the
 operators defined by the concepts.</p>
 <p>The following operations are not allowed in the affine space:</p>
 <ul>
 <li><strong>adding</strong> two
-<code class="sourceCode default">quantity_point</code> objects
+<code class="sourceCode cpp">quantity_point</code> objects
 <ul>
 <li>It is physically impossible to add the positions of home and Denver
 airport.</li>
 </ul></li>
 <li><strong>subtracting</strong> a
-<code class="sourceCode default">quantity_point</code> from a
-<code class="sourceCode default">quantity</code>
+<code class="sourceCode cpp">quantity_point</code> from a
+<code class="sourceCode cpp">quantity</code>
 <ul>
 <li>What would it mean to subtract the DEN airport location from a
 distance?</li>
 </ul></li>
 <li><strong>multiplying/dividing</strong> a
-<code class="sourceCode default">quantity_point</code> with a scalar
+<code class="sourceCode cpp">quantity_point</code> with a scalar
 <ul>
-<li>What is the position of <code class="sourceCode default">2 *</code>
+<li>What is the position of <code class="sourceCode cpp"><span class="dv">2</span> <span class="op">*</span></code>
 DEN airport location?</li>
 </ul></li>
 <li><strong>multiplying/dividing</strong> a
-<code class="sourceCode default">quantity_point</code> with a quantity
+<code class="sourceCode cpp">quantity_point</code> with a quantity
 <ul>
 <li>What would multiplying a distance with the DEN airport location
 mean?</li>
 </ul></li>
 <li><strong>multiplying/dividing</strong> two
-<code class="sourceCode default">quantity_point</code> objects
+<code class="sourceCode cpp">quantity_point</code> objects
 <ul>
 <li>What would multiplying the home and DEN airport location mean?</li>
 </ul></li>
 <li><strong>mixing</strong>
-<code class="sourceCode default">quantity_points</code> of different
+<code class="sourceCode cpp">quantity_points</code> of different
 quantity kinds
 <ul>
 <li>It is physically impossible to subtract ISQ time from ISQ
 length.</li>
 </ul></li>
 <li><strong>mixing</strong>
-<code class="sourceCode default">quantity_points</code> of inconvertible
+<code class="sourceCode cpp">quantity_points</code> of inconvertible
 quantities
 <ul>
 <li>What does it mean to subtract a distance point to DEN airport from
 the Mount Everest base camp altitude?</li>
 </ul></li>
 <li><strong>mixing</strong>
-<code class="sourceCode default">quantity_points</code> of convertible
+<code class="sourceCode cpp">quantity_points</code> of convertible
 quantities but with unrelated origins
 <ul>
 <li>How to subtract a point on our trip to CppCon measured relatively to
@@ -4187,12 +4154,12 @@ <h3 data-number="14.1.3" id="safety-introduced-by-the-affine-space-abstractions"
 Solar System?</li>
 </ul></li>
 </ul>
-<p>The usage of <code class="sourceCode default">quantity_point</code>,
-and affine space types in general, improves expressiveness and
-type-safety of the code we write.</p>
+<p>The usage of <code class="sourceCode cpp">quantity_point</code>, and
+affine space types in general, improves expressiveness and type-safety
+of the code we write.</p>
 <h3 data-number="14.1.4" id="explicit-is-not-explicit-enough"><span class="header-section-number">14.1.4</span>
-<code class="sourceCode default">explicit</code> is not explicit
-enough<a href="#explicit-is-not-explicit-enough" class="self-link"></a></h3>
+<code class="sourceCode cpp"><span class="kw">explicit</span></code> is
+not explicit enough<a href="#explicit-is-not-explicit-enough" class="self-link"></a></h3>
 <p>Consider the following structure and a code using it:</p>
 <div class="sourceCode" id="cb110"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb110-1"><a href="#cb110-1" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> X <span class="op">{</span></span>
 <span id="cb110-2"><a href="#cb110-2" aria-hidden="true" tabindex="-1"></a>  std<span class="op">::</span>vector<span class="op">&lt;</span>std<span class="op">::</span>chrono<span class="op">::</span>milliseconds<span class="op">&gt;</span> vec;</span>
@@ -4220,11 +4187,11 @@ <h3 data-number="14.1.4" id="explicit-is-not-explicit-enough"><span class="heade
 <span id="cb114-2"><a href="#cb114-2" aria-hidden="true" tabindex="-1"></a>x<span class="op">.</span>vec<span class="op">.</span>emplace_back<span class="op">(</span><span class="dv">42</span><span class="op">)</span>;       <span class="co">// Compile-time error</span></span>
 <span id="cb114-3"><a href="#cb114-3" aria-hidden="true" tabindex="-1"></a>x<span class="op">.</span>vec<span class="op">.</span>emplace_back<span class="op">(</span><span class="dv">42</span> <span class="op">*</span> ms<span class="op">)</span>;  <span class="co">// OK</span></span></code></pre></div>
 <p>For consistency and to prevent similar safety issues, the
-<code class="sourceCode default">quantity_point</code> using explicit
-point origins can’t be created from a standalone value of a
-<code class="sourceCode default">quantity</code> (contrary to the
-<code class="sourceCode default">std::chrono::time_point</code> design).
-Such a point has to always be associated with an explicit origin:</p>
+<code class="sourceCode cpp">quantity_point</code> using explicit point
+origins can’t be created from a standalone value of a
+<code class="sourceCode cpp">quantity</code> (contrary to the <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>time_point</code>
+design). Such a point has to always be associated with an explicit
+origin:</p>
 <div class="sourceCode" id="cb115"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb115-1"><a href="#cb115-1" aria-hidden="true" tabindex="-1"></a>quantity_point qp1 <span class="op">=</span> mean_sea_level <span class="op">+</span> <span class="dv">42</span> <span class="op">*</span> m;</span>
 <span id="cb115-2"><a href="#cb115-2" aria-hidden="true" tabindex="-1"></a>quantity_point qp2 <span class="op">=</span> default_ac_temperature <span class="op">+</span> <span class="dv">2</span> <span class="op">*</span> deg_C;</span></code></pre></div>
 <h3 data-number="14.1.5" id="safe-quantity-numerical-value-getters"><span class="header-section-number">14.1.5</span> Safe quantity numerical
@@ -4240,8 +4207,7 @@ <h3 data-number="14.1.5" id="safe-quantity-numerical-value-getters"><span class=
 quantity equal to 42 s, it is not stored in seconds (it’s either
 microseconds or milliseconds, depending on which of the interfaces from
 the previous chapter is the current one). Such issues can be prevented
-with the usage of
-<code class="sourceCode default">std::chrono::duration_cast</code>:</p>
+with the usage of <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration_cast</code>:</p>
 <div class="sourceCode" id="cb118"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb118-1"><a href="#cb118-1" aria-hidden="true" tabindex="-1"></a>legacy_func<span class="op">(</span>duration_cast<span class="op">&lt;</span>seconds<span class="op">&gt;(</span>x<span class="op">.</span>vec<span class="op">[</span><span class="dv">0</span><span class="op">]).</span>count<span class="op">())</span>;</span></code></pre></div>
 <p>However, users often forget about this step, especially when, at the
 moment of writing such code, the duration stores the underlying raw
@@ -4265,27 +4231,26 @@ <h3 data-number="14.1.6" id="preventing-dangling-references"><span class="header
 references<a href="#preventing-dangling-references" class="self-link"></a></h3>
 <p>Besides returning prvalues, sometimes users need to get an actual
 reference to the underlying numerical value stored in a
-<code class="sourceCode default">quantity</code>. For those cases, the
-library exposes <code class="sourceCode default">quantity::numerical_value_ref_in(Unit)</code>
+<code class="sourceCode cpp">quantity</code>. For those cases, the
+library exposes <code class="sourceCode cpp">quantity<span class="op">::</span>numerical_value_ref_in<span class="op">(</span>Unit<span class="op">)</span></code>
 that participates in overload resolution only:</p>
 <ul>
 <li>for lvalues (rvalue reference qualified overload is explicitly
 deleted),</li>
-<li>when the provided <code class="sourceCode default">Unit</code> has
-the same magnitude as the one currently used by the quantity.</li>
+<li>when the provided <code class="sourceCode cpp">Unit</code> has the
+same magnitude as the one currently used by the quantity.</li>
 </ul>
 <p>The first condition above aims to limit the possibility of dangling
 references. We want to increase the chances that the reference/pointer
 provided to an underlying API remains valid for the time of its usage.
 (We’re much less concerned about performance aspects for a
-<code class="sourceCode default">quantity</code> here, as we expect the
+<code class="sourceCode cpp">quantity</code> here, as we expect the
 majority (if not all) of representation types to be cheap to copy.)</p>
 <p>That said, we acknowledge that this approach to preventing dangling
 references conflates value category with lifetime. While it may prevent
 the majority of dangling references, it also admits both false positives
-and false negatives, as explained in <span class="citation" data-cites="VCINL">[<a href="#ref-VCINL" role="doc-biblioref">Value
-Category Is Not Lifetime</a>]</span>. We want to highlight this dilemma
-for the committee’s consideration.</p>
+and false negatives, as explained in <span class="citation" data-cites="VCINL">[<a href="https://quuxplusone.github.io/blog/2019/03/11/value-category-is-not-lifetime/" role="doc-biblioref">Value Category Is Not Lifetime</a>]</span>. We want
+to highlight this dilemma for the committee’s consideration.</p>
 <p>In case we do decide to keep this policy of deleting rvalue
 overloads, here’s an example of code that it would prevent from
 compiling.</p>
@@ -4299,11 +4264,12 @@ <h3 data-number="14.1.6" id="preventing-dangling-references"><span class="header
 <div class="sourceCode" id="cb124"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb124-1"><a href="#cb124-1" aria-hidden="true" tabindex="-1"></a>legacy_func<span class="op">((</span><span class="dv">4</span> <span class="op">*</span> s <span class="op">+=</span> <span class="dv">2</span> <span class="op">*</span> s<span class="op">).</span>numerical_value_ref_in<span class="op">(</span>si<span class="op">::</span>second<span class="op">))</span>;    <span class="co">// Compile-time error</span></span>
 <span id="cb124-2"><a href="#cb124-2" aria-hidden="true" tabindex="-1"></a>legacy_func<span class="op">((++</span>get_duration<span class="op">()).</span>numerical_value_ref_in<span class="op">(</span>si<span class="op">::</span>second<span class="op">))</span>;  <span class="co">// Compile-time error</span></span></code></pre></div>
 <p>The second condition above enables the usage of various equivalent
-units. For example, <code class="sourceCode default">J</code> is
-equivalent to <code class="sourceCode default">N * m</code>, and
-<code class="sourceCode default">kg * m2 / s2</code>. As those have the
-same magnitude, it does not matter exactly which one is being used here,
-as the same numerical value should be returned for all of them.</p>
+units. For example, <code class="sourceCode cpp">J</code> is equivalent
+to <code class="sourceCode cpp">N <span class="op">*</span> m</code>,
+and <code class="sourceCode cpp">kg <span class="op">*</span> m2 <span class="op">/</span> s2</code>.
+As those have the same magnitude, it does not matter exactly which one
+is being used here, as the same numerical value should be returned for
+all of them.</p>
 <div class="sourceCode" id="cb125"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb125-1"><a href="#cb125-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> legacy_func<span class="op">(</span><span class="kw">const</span> <span class="dt">int</span><span class="op">&amp;</span> joules<span class="op">)</span>;</span></code></pre></div>
 <div class="sourceCode" id="cb126"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb126-1"><a href="#cb126-1" aria-hidden="true" tabindex="-1"></a>quantity q1 <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> J;</span>
 <span id="cb126-2"><a href="#cb126-2" aria-hidden="true" tabindex="-1"></a>quantity q2 <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> N <span class="op">*</span> <span class="op">(</span><span class="dv">2</span> <span class="op">*</span> m<span class="op">)</span>;</span>
@@ -4318,17 +4284,17 @@ <h3 data-number="14.1.7" id="quantity-kinds-improve-safety"><span class="header-
 <p>We have checked a few leading libraries on the market, and here are
 the results:</p>
 <ul>
-<li><span class="citation" data-cites="BOOST-UNITS">[<a href="#ref-BOOST-UNITS" role="doc-biblioref">Boost.Units</a>]</span>
-claims the answer to be 2 Hz (bauds are not supported by it, so we
-removed it from the equation),</li>
-<li><span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="#ref-NHOLTHAUS-UNITS" role="doc-biblioref">nholthaus/units</a>]</span> claims it is 2
+<li><span class="citation" data-cites="BOOST-UNITS">[<a href="https://www.boost.org/doc/libs/1_83_0/doc/html/boost_units.html" role="doc-biblioref">Boost.Units</a>]</span> claims the answer to be 2
+Hz (bauds are not supported by it, so we removed it from the
+equation),</li>
+<li><span class="citation" data-cites="NHOLTHAUS-UNITS">[<a href="https://github.com/nholthaus/units" role="doc-biblioref">nholthaus/units</a>]</span> claims it is 2
 s<sup>-1</sup> (no support for bauds as well),</li>
-<li><span class="citation" data-cites="PINT">[<a href="#ref-PINT" role="doc-biblioref">Pint</a>]</span> library in Python claims that the
+<li><span class="citation" data-cites="PINT">[<a href="https://pint.readthedocs.io/en/stable/index.html" role="doc-biblioref">Pint</a>]</span> library in Python claims that the
 result is 3.0 Hz,</li>
-<li><span class="citation" data-cites="JSR-385">[<a href="#ref-JSR-385" role="doc-biblioref">JSR 385</a>]</span> library in Java throws an
+<li><span class="citation" data-cites="JSR-385">[<a href="https://unitsofmeasurement.github.io/indriya" role="doc-biblioref">JSR 385</a>]</span> library in Java throws an
 exception saying that we can’t add those quantities.</li>
 </ul>
-<p>Now let’s check what <span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> says about quantity
+<p>Now let’s check what <span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> says about quantity
 kinds:</p>
 <ul>
 <li>Quantities may be grouped together into categories of quantities
@@ -4343,7 +4309,7 @@ <h3 data-number="14.1.7" id="quantity-kinds-improve-safety"><span class="header-
 <li>Quantities of the <strong>same dimension are not necessarily of the
 same kind</strong></li>
 </ul>
-<p><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> also explicitly
+<p><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> also explicitly
 notes:</p>
 <blockquote>
 <p><strong>Measurement units of quantities of the same quantity
@@ -4360,15 +4326,14 @@ <h3 data-number="14.1.7" id="quantity-kinds-improve-safety"><span class="header-
 is used as a unit of energy, but never as a unit of moment of force,
 i.e. the newton metre (N · m).</p>
 </blockquote>
-<p>To summarize the above, <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> explicitly states that
+<p>To summarize the above, <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> explicitly states that
 <em>frequency</em> is measured in Hz and <em>activity</em> is measured
 in Bq, which are quantities of different kinds. As such, they should not
 be able to be compared, added, or subtracted. So, the only library from
-the above that was correct was <span class="citation" data-cites="JSR-385">[<a href="#ref-JSR-385" role="doc-biblioref">JSR
-385</a>]</span>. The rest of them are wrong to allow such operations.
-Doing so may lead to vulnerable safety issues when two unrelated
-quantities of the same dimension are accidentally added or assigned to
-each other.</p>
+the above that was correct was <span class="citation" data-cites="JSR-385">[<a href="https://unitsofmeasurement.github.io/indriya" role="doc-biblioref">JSR 385</a>]</span>. The rest of them are wrong to
+allow such operations. Doing so may lead to vulnerable safety issues
+when two unrelated quantities of the same dimension are accidentally
+added or assigned to each other.</p>
 <p>The reason for most of the libraries on the market to be wrong in
 this field is the fact that their quantities are implemented only in
 terms of the concept of dimension. However, we’ve learned that a
@@ -4397,7 +4362,7 @@ <h3 data-number="14.1.8" id="additional-safety-introduced-by-modeling-various-qu
 <span id="cb129-8"><a href="#cb129-8" aria-hidden="true" tabindex="-1"></a>  <span class="co">// ...</span></span>
 <span id="cb129-9"><a href="#cb129-9" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
 <p>This does not provide strongly typed interfaces anymore.</p>
-<p>Again, it turns out that <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> has an answer. This
+<p>Again, it turns out that <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> has an answer. This
 specification standardizes hundreds of quantities, many of which are of
 the same kind. Various quantities of the same kind are not a flat set.
 They form a hierarchy tree which influences:</p>
@@ -4409,23 +4374,21 @@ <h3 data-number="14.1.8" id="additional-safety-introduced-by-modeling-various-qu
 <p>More information on this subject can be found in the <a href="#systems-of-quantities">Systems of quantities</a> chapter.</p>
 <h3 data-number="14.1.9" id="non-negative-quantities"><span class="header-section-number">14.1.9</span> Non-negative quantities<a href="#non-negative-quantities" class="self-link"></a></h3>
 <!-- TODO refactor this to state that we can benefit for points -->
-<p>Some quantity types are defined by <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> as explicitly
+<p>Some quantity types are defined by <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> as explicitly
 non-negative. Those include quantities like width, thickness, diameter,
 and radius. However, it turns out that it is possible to have negative
-values of quantities defined as non-negative. For example,
-<code class="sourceCode default">-1 * isq::diameter[mm]</code> could
-represent a change in the diameter of some object. Also, a subtraction
-<code class="sourceCode default">4 * width[mm] - 6 * width[mm]</code>
+values of quantities defined as non-negative. For example, <code class="sourceCode cpp"><span class="op">-</span><span class="dv">1</span> <span class="op">*</span> isq<span class="op">::</span>diameter<span class="op">[</span>mm<span class="op">]</span></code>
+could represent a change in the diameter of some object. Also, a
+subtraction <code class="sourceCode cpp"><span class="dv">4</span> <span class="op">*</span> width<span class="op">[</span>mm<span class="op">]</span> <span class="op">-</span> <span class="dv">6</span> <span class="op">*</span> width<span class="op">[</span>mm<span class="op">]</span></code>
 results in a negative value as the width of the second argument is
 larger than the first one.</p>
 <p>Non-negative quantities are not limited to those explicitly stated as
-being non-negative in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>.
-Some quantities are implicitly non-negative from their definition. The
-most obvious example here might be scalar quantities specified as
-magnitudes of a vector quantity. For example, speed is defined as the
-magnitude of velocity. Again,
-<code class="sourceCode default">-1 * speed[m/s]</code> could represent
-a change in average speed between two measurements.</p>
+being non-negative in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>. Some quantities are
+implicitly non-negative from their definition. The most obvious example
+here might be scalar quantities specified as magnitudes of a vector
+quantity. For example, speed is defined as the magnitude of velocity.
+Again, <code class="sourceCode cpp"><span class="op">-</span><span class="dv">1</span> <span class="op">*</span> speed<span class="op">[</span>m<span class="op">/</span>s<span class="op">]</span></code>
+could represent a change in average speed between two measurements.</p>
 <p>This means that enforcing such constraints for quantity types might
 be impossible as those typically are used to represent a difference
 between two states or measurements. However, we could apply such
@@ -4472,36 +4435,39 @@ <h3 data-number="14.1.10" id="safe-operations-of-vector-and-tensor-quantities"><
 quantity</p>
 <p>This provides all the required type safety, but requires the library
 to implement more operations on quantities and properly constrain them
-so they are selectively enabled when needed. Besides <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span>, the only library that
-supports such an approach is <span class="citation" data-cites="PINT">[<a href="#ref-PINT" role="doc-biblioref">Pint</a>]</span>. Such a solution requires the
+so they are selectively enabled when needed. Besides <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span>, the only library that
+supports such an approach is <span class="citation" data-cites="PINT">[<a href="https://pint.readthedocs.io/en/stable/index.html" role="doc-biblioref">Pint</a>]</span>. Such a solution requires the
 following operations to be exposed for quantity types (note that
 character refers to the algebraic structure of either scalar, vector and
 tensor):</p>
 <ul>
-<li><code class="sourceCode default">a + b</code> - addition where both
-arguments should be of the same quantity kind and character</li>
-<li><code class="sourceCode default">a - b</code> - subtraction where
-both arguments should be of the same quantity kind and character</li>
-<li><code class="sourceCode default">a % b</code> - modulo where both
-arguments should be of the same quantity kind and character</li>
-<li><code class="sourceCode default">a * b</code> - multiplication where
-one of the arguments has to be a scalar</li>
-<li><code class="sourceCode default">a / b</code> - division where the
-divisor has to be scalar</li>
-<li><code class="sourceCode default">a ⋅ b</code> - dot product of two
+<li><code class="sourceCode cpp">a <span class="op">+</span> b</code> -
+addition where both arguments should be of the same quantity kind and
+character</li>
+<li><code class="sourceCode cpp">a <span class="op">-</span> b</code> -
+subtraction where both arguments should be of the same quantity kind and
+character</li>
+<li><code class="sourceCode cpp">a <span class="op">%</span> b</code> -
+modulo where both arguments should be of the same quantity kind and
+character</li>
+<li><code class="sourceCode cpp">a <span class="op">*</span> b</code> -
+multiplication where one of the arguments has to be a scalar</li>
+<li><code class="sourceCode cpp">a <span class="op">/</span> b</code> -
+division where the divisor has to be scalar</li>
+<li><code class="sourceCode cpp">a ⋅ b</code> - dot product of two
 vectors</li>
-<li><code class="sourceCode default">a × b</code> - cross product of two
+<li><code class="sourceCode cpp">a × b</code> - cross product of two
 vectors</li>
-<li><code class="sourceCode default">|a|</code> - magnitude of a
-vector</li>
-<li><code class="sourceCode default">a ⊗ b</code> - tensor product of
-two vectors or tensors</li>
-<li><code class="sourceCode default">a ⋅ b</code> - inner product of two
+<li><code class="sourceCode cpp"><span class="op">|</span>a<span class="op">|</span></code>
+- magnitude of a vector</li>
+<li><code class="sourceCode cpp">a ⊗ b</code> - tensor product of two
+vectors or tensors</li>
+<li><code class="sourceCode cpp">a ⋅ b</code> - inner product of two
 tensors</li>
-<li><code class="sourceCode default">a ⋅ b</code> - inner product of
-tensor and vector</li>
-<li><code class="sourceCode default">a : b</code> - scalar product of
-two tensors</li>
+<li><code class="sourceCode cpp">a ⋅ b</code> - inner product of tensor
+and vector</li>
+<li><code class="sourceCode cpp">a <span class="op">:</span> b</code> -
+scalar product of two tensors</li>
 </ul></li>
 </ol>
 <p>Additionally, the library knows the expected quantity character,
@@ -4515,11 +4481,10 @@ <h3 data-number="14.1.10" id="safe-operations-of-vector-and-tensor-quantities"><
 <span id="cb130-4"><a href="#cb130-4" aria-hidden="true" tabindex="-1"></a>QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>force<span class="op">&gt;</span> q4 <span class="op">=</span> <span class="dv">80</span> <span class="op">*</span> kg <span class="op">*</span> <span class="op">(</span>la_vector<span class="op">{</span><span class="dv">0</span>, <span class="dv">0</span>, <span class="op">-</span><span class="dv">10</span><span class="op">}</span> <span class="op">*</span> m <span class="op">/</span> s2<span class="op">)</span>;  <span class="co">// OK</span></span>
 <span id="cb130-5"><a href="#cb130-5" aria-hidden="true" tabindex="-1"></a>QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>power<span class="op">&gt;</span> q5 <span class="op">=</span> q2 <span class="op">*</span> q4;                                    <span class="co">// Compile-time error</span></span>
 <span id="cb130-6"><a href="#cb130-6" aria-hidden="true" tabindex="-1"></a>QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>power<span class="op">&gt;</span> q5 <span class="op">=</span> dot<span class="op">(</span>q2, q4<span class="op">)</span>;                                <span class="co">// OK</span></span></code></pre></div>
-<p><em>Note: <code class="sourceCode default">q1</code> and
-<code class="sourceCode default">q3</code> can be permitted to compile
-by explicitly specializing the
-<code class="sourceCode default">is_vector&lt;T&gt;</code> trait for the
-representation type.</em></p>
+<p><em>Note: <code class="sourceCode cpp">q1</code> and
+<code class="sourceCode cpp">q3</code> can be permitted to compile by
+explicitly specializing the <code class="sourceCode cpp">is_vector<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
+trait for the representation type.</em></p>
 <p>As we can see above, such features additionally improves the
 compile-time safety of the library by ensuring that quantities are
 created with proper quantity equations and are using correct
@@ -4530,13 +4495,12 @@ <h3 data-number="14.2.1" id="integer-division"><span class="header-section-numbe
 the division operator. All logic has to be done at compile-time when the
 actual values are not known, and the quantity types can’t change at
 runtime.</p>
-<p>If we expect
-<code class="sourceCode default">120 * km / (2 * h)</code> to return
-<code class="sourceCode default">60 km / h</code>, we have to agree with
-the fact that <code class="sourceCode default">5 * km / (24 * h)</code>
-returns <code class="sourceCode default">0 km/h</code>. We can’t do a
-range check at runtime to dynamically adjust scales and types based on
-the values of provided function arguments.</p>
+<p>If we expect <code class="sourceCode cpp"><span class="dv">120</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">2</span> <span class="op">*</span> h<span class="op">)</span></code>
+to return <code class="sourceCode cpp"><span class="dv">60</span> km <span class="op">/</span> h</code>,
+we have to agree with the fact that <code class="sourceCode cpp"><span class="dv">5</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">24</span> <span class="op">*</span> h<span class="op">)</span></code>
+returns <code class="sourceCode cpp"><span class="dv">0</span> km<span class="op">/</span>h</code>.
+We can’t do a range check at runtime to dynamically adjust scales and
+types based on the values of provided function arguments.</p>
 <p>The same applies to:</p>
 <div class="sourceCode" id="cb131"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb131-1"><a href="#cb131-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span><span class="dv">5</span> <span class="op">*</span> h <span class="op">/</span> <span class="op">(</span><span class="dv">120</span> <span class="op">*</span> min<span class="op">)</span> <span class="op">==</span> <span class="dv">0</span> <span class="op">*</span> one<span class="op">)</span>;</span></code></pre></div>
 <p>This is why floating-point representation types are recommended as a
@@ -4554,17 +4518,15 @@ <h3 data-number="14.2.1" id="integer-division"><span class="header-section-numbe
 instead use safer representation types.</p>
 <h3 data-number="14.2.2" id="lack-of-safe-numeric-types"><span class="header-section-number">14.2.2</span> Lack of safe numeric types<a href="#lack-of-safe-numeric-types" class="self-link"></a></h3>
 <p>Integers can overflow on arithmetics. This has already caused some
-expensive failures in engineering <span class="citation" data-cites="ARIANE">[<a href="#ref-ARIANE" role="doc-biblioref">Ariane
-flight V88</a>]</span>.</p>
+expensive failures in engineering <span class="citation" data-cites="ARIANE">[<a href="https://en.wikipedia.org/wiki/Ariane_flight_V88" role="doc-biblioref">Ariane flight V88</a>]</span>.</p>
 <p>Integers can also be truncated during assignment to a narrower
 type.</p>
 <p>Floating-point types may lose precision during assignment to a
-narrower type. Conversion from
-<code class="sourceCode default">std::int64_t</code> to
-<code class="sourceCode default">double</code> may also lose
-precision.</p>
+narrower type. Conversion from <code class="sourceCode cpp">std<span class="op">::</span><span class="dt">int64_t</span></code>
+to <code class="sourceCode cpp"><span class="dt">double</span></code>
+may also lose precision.</p>
 <p>If we had safe numeric types in the C++ standard library, they could
-easily be used as a <code class="sourceCode default">quantity</code>
+easily be used as a <code class="sourceCode cpp">quantity</code>
 representation type in the physical quantities and units library, which
 would address these safety concerns.</p>
 <p>Also, having a type trait informing if a conversion from one type to
@@ -4580,17 +4542,19 @@ <h3 data-number="14.2.3" id="potential-surprises-during-units-composition"><span
 <p>We can also easily obtain a quantity with:</p>
 <div class="sourceCode" id="cb133"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb133-1"><a href="#cb133-1" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> <span class="dv">60</span> <span class="op">*</span> km <span class="op">/</span> h;</span></code></pre></div>
 <p>Such a solution is an industry standard and is implemented not only
-in this library, but also is available for many years now in both <span class="citation" data-cites="BOOST-UNITS">[<a href="#ref-BOOST-UNITS" role="doc-biblioref">Boost.Units</a>]</span> and <span class="citation" data-cites="PINT">[<a href="#ref-PINT" role="doc-biblioref">Pint</a>]</span>.</p>
+in this library, but also is available for many years now in both <span class="citation" data-cites="BOOST-UNITS">[<a href="https://www.boost.org/doc/libs/1_83_0/doc/html/boost_units.html" role="doc-biblioref">Boost.Units</a>]</span> and <span class="citation" data-cites="PINT">[<a href="https://pint.readthedocs.io/en/stable/index.html" role="doc-biblioref">Pint</a>]</span>.</p>
 <p>We believe that is the correct thing to do. However, we want to make
 it straight in this paper that some potential issues are associated with
 such a syntax. Inexperienced users are often surprised by the results of
 the following expression:</p>
 <div class="sourceCode" id="cb134"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb134-1"><a href="#cb134-1" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> <span class="dv">60</span> <span class="op">*</span> km <span class="op">/</span> <span class="dv">2</span> <span class="op">*</span> h;</span></code></pre></div>
-<p>This looks like like <code class="sourceCode default">30 km/h</code>,
+<p>This looks like like <code class="sourceCode cpp"><span class="dv">30</span> km<span class="op">/</span>h</code>,
 right? But it is not. Thanks to the order of operations, it results in
-<code class="sourceCode default">30 km⋅h</code>. In case we want to
-divide <code class="sourceCode default">60 km</code> by
-<code class="sourceCode default">2 h</code>, parentheses are needed:</p>
+<code class="sourceCode cpp"><span class="dv">30</span> km⋅h</code>. In
+case we want to divide
+<code class="sourceCode cpp"><span class="dv">60</span> km</code> by
+<code class="sourceCode cpp"><span class="dv">2</span> h</code>,
+parentheses are needed:</p>
 <div class="sourceCode" id="cb135"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb135-1"><a href="#cb135-1" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> <span class="dv">60</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">2</span> <span class="op">*</span> h<span class="op">)</span>;</span></code></pre></div>
 <p>Another surprising issue may result from the following code:</p>
 <div class="sourceCode" id="cb136"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb136-1"><a href="#cb136-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> T<span class="op">&gt;</span></span>
@@ -4605,7 +4569,7 @@ <h3 data-number="14.2.3" id="potential-surprises-during-units-composition"><span
 <p>The above function call will result in a quantity of <em>area</em>
 instead of the expected quantity of <em>length</em>.</p>
 <p>The issues mentioned above could be turned into compilation errors by
-disallowing multiplying or dividing a quantity by a unit. The <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library initially provided
+disallowing multiplying or dividing a quantity by a unit. The <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library initially provided
 such an approach, but with time, we decided this to not be
 user-friendly. Forcing the user to put the parenthesis around all
 derived units in quantity equations like the one below, was too verbose
@@ -4684,24 +4648,23 @@ <h4 data-number="14.2.4.2" id="arithmetic-and-compatibility-of-quantities-of-dim
 <span id="cb146-3"><a href="#cb146-3" aria-hidden="true" tabindex="-1"></a>quantity q3 <span class="op">=</span> isq<span class="op">::</span>height<span class="op">(</span><span class="dv">1</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">/</span> isq<span class="op">::</span>length<span class="op">(</span><span class="dv">10</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">+</span> isq<span class="op">::</span>time<span class="op">(</span><span class="dv">1</span> <span class="op">*</span> us<span class="op">)</span> <span class="op">/</span> isq<span class="op">::</span>time<span class="op">(</span><span class="dv">1</span> <span class="op">*</span> h<span class="op">)</span>;</span></code></pre></div>
 <p>The fact that the above code compiles fine might again be surprising
 to some users of such a library. The result of all such quantity
-equations is a <code class="sourceCode default">dimensionless</code>
+equations is a <code class="sourceCode cpp">dimensionless</code>
 quantity as it is the root of this hierarchy tree.</p>
 <p>Now, let’s try to convert such results to some quantities of
-dimension one. The <code class="sourceCode default">q1</code> was
-obtained from the expression that only used units in the equation, which
-means that the actual result of it is a quantity of
-<code class="sourceCode default">kind_of&lt;dimensionless&gt;</code>,
+dimension one. The <code class="sourceCode cpp">q1</code> was obtained
+from the expression that only used units in the equation, which means
+that the actual result of it is a quantity of <code class="sourceCode cpp">kind_of<span class="op">&lt;</span>dimensionless<span class="op">&gt;</span></code>,
 which behaves like any quantity from the tree. Because of it, all of the
-below will compile for <code class="sourceCode default">q1</code>:</p>
+below will compile for <code class="sourceCode cpp">q1</code>:</p>
 <div class="sourceCode" id="cb147"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb147-1"><a href="#cb147-1" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;</span>si<span class="op">::</span>metre <span class="op">/</span> si<span class="op">::</span>metre<span class="op">&gt;</span> ok1 <span class="op">=</span> q1;</span>
 <span id="cb147-2"><a href="#cb147-2" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;(</span>isq<span class="op">::</span>length <span class="op">/</span> isq<span class="op">::</span>length<span class="op">)[</span>m <span class="op">/</span> m<span class="op">]&gt;</span> ok2 <span class="op">=</span> q1;</span>
 <span id="cb147-3"><a href="#cb147-3" aria-hidden="true" tabindex="-1"></a>quantity<span class="op">&lt;(</span>isq<span class="op">::</span>height <span class="op">/</span> isq<span class="op">::</span>length<span class="op">)[</span>m <span class="op">/</span> m<span class="op">]&gt;</span> ok3 <span class="op">=</span> q1;</span></code></pre></div>
-<p>For <code class="sourceCode default">q2</code> and
-<code class="sourceCode default">q3</code>, the two first conversions
-also succeed. The first one passes because all quantities of a kind are
-convertible to such kind. The type of the second quantity is <code class="sourceCode default">quantity&lt;dimensionless[one]&gt;</code> in
-disguise. Such a quantity is a root of the kind tree, so again, all the
-quantities from such a tree are convertible to it.</p>
+<p>For <code class="sourceCode cpp">q2</code> and
+<code class="sourceCode cpp">q3</code>, the two first conversions also
+succeed. The first one passes because all quantities of a kind are
+convertible to such kind. The type of the second quantity is <code class="sourceCode cpp">quantity<span class="op">&lt;</span>dimensionless<span class="op">[</span>one<span class="op">]&gt;</span></code>
+in disguise. Such a quantity is a root of the kind tree, so again, all
+the quantities from such a tree are convertible to it.</p>
 <p>The third conversion fails in both cases, though. Not every
 dimensionless quantity is a result of dividing height and length, so an
 explicit conversion would be needed to force it to work.</p>
@@ -4734,10 +4697,10 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 <p>outputs:</p>
 <pre class="text"><code>q3: 30 K
 q4: 30 °C</code></pre>
-<p>Even though <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-provides dedicated quantity types for <em>thermodynamic temperature</em>
-and <em>Celsius temperature</em>, it explicitly states in the
-description of the first one:</p>
+<p>Even though <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides dedicated
+quantity types for <em>thermodynamic temperature</em> and <em>Celsius
+temperature</em>, it explicitly states in the description of the first
+one:</p>
 <blockquote>
 <p>Differences of thermodynamic temperatures or changes may be expressed
 either in kelvin, symbol K, or in degrees Celsius, symbol °C</p>
@@ -4749,14 +4712,14 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 definition equal in magnitude to the kelvin. A difference or interval of
 temperature may be expressed in kelvin or in degrees Celsius.</p>
 </blockquote>
-<p>As the <code class="sourceCode default">quantity</code> is a
-differential quantity type, it is okay to use any <em>temperature</em>
-unit for those, and the results should differ only by the conversion
-factor. No offset should be applied here to convert between the origins
-of different unit scales.</p>
+<p>As the <code class="sourceCode cpp">quantity</code> is a differential
+quantity type, it is okay to use any <em>temperature</em> unit for
+those, and the results should differ only by the conversion factor. No
+offset should be applied here to convert between the origins of
+different unit scales.</p>
 <p>It is important to mention here that the existence of <em>Celsius
-temperature</em> quantity type in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> is controversial.</p>
-<p><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 1) says:</p>
+temperature</em> quantity type in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> is controversial.</p>
+<p><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 1) says:</p>
 <blockquote>
 <p>The system of quantities presented in this document is named the
 International System of Quantities (ISQ), in all languages. This name
@@ -4765,8 +4728,8 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 system of quantities underlying the International System of Units,
 denoted “SI”, in all languages according to the SI Brochure.</p>
 </blockquote>
-<p>According to the <span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span>,
-a system of quantities is a “set of quantities together with a set of
+<p>According to the <span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span>, a system of
+quantities is a “set of quantities together with a set of
 non-contradictory equations relating those quantities”. It also defines
 the system of units as “set of base units and derived units, together
 with their multiples and submultiples, defined in accordance with given
@@ -4776,7 +4739,7 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 systems of units can be defined on top of it, and none of those should
 be favored.</p>
 <p>However, the <em>Celsius temperature</em> quantity type is defined in
-<span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 5) as:</p>
+<span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 5) as:</p>
 <blockquote>
 <p>temperature difference from the thermodynamic temperature of the ice
 point is called the Celsius temperature <span class="math inline">\(t\)</span>, which is defined by the quantity
@@ -4790,15 +4753,14 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 it uses specific SI units in its definition. This breaks the direction
 of dependencies between systems of quantities and units and imposes
 significant implementation issues.</p>
-<p>As <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span>
-implementation clearly distinguishes between systems of quantities and
-units and assumes that the latter directly depends on the former, this
-quantity definition does not enforce any units or offsets. It is defined
-as just a more specialized quantity of the kind of <em>thermodynamic
-temperature</em>. We have added the Celsius temperature quantity type
-for completeness and to gain more experience with it. Still, maybe a
-good decision would be to skip it in the standardization process not to
-confuse users.</p>
+<p>As <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> implementation clearly
+distinguishes between systems of quantities and units and assumes that
+the latter directly depends on the former, this quantity definition does
+not enforce any units or offsets. It is defined as just a more
+specialized quantity of the kind of <em>thermodynamic temperature</em>.
+We have added the Celsius temperature quantity type for completeness and
+to gain more experience with it. Still, maybe a good decision would be
+to skip it in the standardization process not to confuse users.</p>
 <p>After quoting the official definitions and terms and presenting how
 quantities work, let’s discuss quantity points. Those describe specific
 points and are measured relative to a provided origin:</p>
@@ -4806,12 +4768,12 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 <span id="cb151-2"><a href="#cb151-2" aria-hidden="true" tabindex="-1"></a>quantity_point qp2 <span class="op">=</span> si<span class="op">::</span>zeroth_degree_Celsius <span class="op">+</span> isq<span class="op">::</span>Celsius_temperature<span class="op">(</span><span class="fl">30.</span> <span class="op">*</span> deg_C<span class="op">)</span>;</span></code></pre></div>
 <p>The above provides two different temperature points. The first one is
 measured as a relative quantity to the absolute zero
-(<code class="sourceCode default">0 K</code>), and the second one stores
-the value relative to the ice point being the beginning of the degree
-Celsius scale.</p>
+(<code class="sourceCode cpp"><span class="dv">0</span> K</code>), and
+the second one stores the value relative to the ice point being the
+beginning of the degree Celsius scale.</p>
 <p>Thanks to the
-<code class="sourceCode default">default_point_origin</code> used in the
-<code class="sourceCode default">quantity_point</code> class template
+<code class="sourceCode cpp">default_point_origin</code> used in the
+<code class="sourceCode cpp">quantity_point</code> class template
 definition and benefiting from the fact that units of temperature have
 point origins provided in their definitions we can obtain exactly the
 same quantity points with the following:</p>
@@ -4837,8 +4799,7 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 <span id="cb154-6"><a href="#cb154-6" aria-hidden="true" tabindex="-1"></a>            <span class="op">(</span>qp2 <span class="op">-</span> si<span class="op">::</span>zeroth_kelvin<span class="op">).</span>in<span class="op">(</span>K<span class="op">)</span>,</span>
 <span id="cb154-7"><a href="#cb154-7" aria-hidden="true" tabindex="-1"></a>            qp2 <span class="op">-</span> si<span class="op">::</span>zeroth_degree_Celsius,</span>
 <span id="cb154-8"><a href="#cb154-8" aria-hidden="true" tabindex="-1"></a>            <span class="op">(</span>qp2 <span class="op">-</span> usc<span class="op">::</span>zeroth_degree_Fahrenheit<span class="op">).</span>in<span class="op">(</span>deg_F<span class="op">))</span>;</span></code></pre></div></li>
-<li><p>Using
-<code class="sourceCode default">quantity_from(PointOrigin)</code>
+<li><p>Using <code class="sourceCode cpp">quantity_from<span class="op">(</span>PointOrigin<span class="op">)</span></code>
 member function:</p>
 <div class="sourceCode" id="cb155"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb155-1"><a href="#cb155-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;qp1: {}, {}, {}&quot;</span>,</span>
 <span id="cb155-2"><a href="#cb155-2" aria-hidden="true" tabindex="-1"></a>            qp1<span class="op">.</span>quantity_from<span class="op">(</span>si<span class="op">::</span>zeroth_kelvin<span class="op">)</span>,</span>
@@ -4848,9 +4809,8 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 <span id="cb155-6"><a href="#cb155-6" aria-hidden="true" tabindex="-1"></a>            qp2<span class="op">.</span>quantity_from<span class="op">(</span>si<span class="op">::</span>zeroth_kelvin<span class="op">).</span>in<span class="op">(</span>K<span class="op">)</span>,</span>
 <span id="cb155-7"><a href="#cb155-7" aria-hidden="true" tabindex="-1"></a>            qp2<span class="op">.</span>quantity_from<span class="op">(</span>si<span class="op">::</span>zeroth_degree_Celsius<span class="op">)</span>,</span>
 <span id="cb155-8"><a href="#cb155-8" aria-hidden="true" tabindex="-1"></a>            qp2<span class="op">.</span>quantity_from<span class="op">(</span>usc<span class="op">::</span>zeroth_degree_Fahrenheit<span class="op">).</span>in<span class="op">(</span>deg_F<span class="op">))</span>;</span></code></pre></div></li>
-<li><p>Using
-<code class="sourceCode default">quantity_from_zero()</code> member
-function that will use the point origin defined for the current
+<li><p>Using <code class="sourceCode cpp">quantity_from_zero<span class="op">()</span></code>
+member function that will use the point origin defined for the current
 unit:</p>
 <div class="sourceCode" id="cb156"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb156-1"><a href="#cb156-1" aria-hidden="true" tabindex="-1"></a>fmt<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;qp1: {}, {}, {}&quot;</span>,</span>
 <span id="cb156-2"><a href="#cb156-2" aria-hidden="true" tabindex="-1"></a>            qp1<span class="op">.</span>quantity_from_zero<span class="op">()</span>,</span>
@@ -4867,15 +4827,15 @@ <h3 data-number="14.2.5" id="potential-surprises-while-working-with-temperatures
 <p>Of course, all other combinations are also possible. For example,
 nothing should prevent us from checking how many degrees of Celsius are
 there starting from the
-<code class="sourceCode default">zeroth_degree_Fahrenheit</code> for a
+<code class="sourceCode cpp">zeroth_degree_Fahrenheit</code> for a
 quantity point using kelvins with the
-<code class="sourceCode default">zeroth_kelvin</code> origin:</p>
+<code class="sourceCode cpp">zeroth_kelvin</code> origin:</p>
 <div class="sourceCode" id="cb157"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb157-1"><a href="#cb157-1" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> qp1<span class="op">.</span>quantity_from<span class="op">(</span>usc<span class="op">::</span>zeroth_degree_Fahrenheit<span class="op">).</span>in<span class="op">(</span>deg_C<span class="op">)</span>;</span></code></pre></div>
 <h3 data-number="14.2.6" id="structural-types"><span class="header-section-number">14.2.6</span> Structural types<a href="#structural-types" class="self-link"></a></h3>
-<p>The <code class="sourceCode default">quantity</code> and
-<code class="sourceCode default">quantity_point</code> class templates
-are structural types to allow them to be passed as template arguments.
-For example, we can write the following:</p>
+<p>The <code class="sourceCode cpp">quantity</code> and
+<code class="sourceCode cpp">quantity_point</code> class templates are
+structural types to allow them to be passed as template arguments. For
+example, we can write the following:</p>
 <div class="sourceCode" id="cb158"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb158-1"><a href="#cb158-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">struct</span> amsterdam_sea_level <span class="op">:</span> absolute_point_origin<span class="op">&lt;</span>isq<span class="op">::</span>altitude<span class="op">&gt;</span> <span class="op">{</span></span>
 <span id="cb158-2"><a href="#cb158-2" aria-hidden="true" tabindex="-1"></a><span class="op">}</span> amsterdam_sea_level;</span>
 <span id="cb158-3"><a href="#cb158-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -4899,9 +4859,8 @@ <h1 data-number="15" id="text-output"><span class="header-section-number">15</sp
 <p>This chapter will discuss the different options we have here.</p>
 <p><em>Note: For now, there is no standardized way to handle formatted
 text input in the C++ standard library, so this paper does not propose
-any approach to convert text to quantities. If <span class="citation" data-cites="P1729R3">[<a href="#ref-P1729R3" role="doc-biblioref"><strong>P1729R3?</strong></a>]</span> will be
-accepted by the LEWG, then we will add a proper “Text input” chapter as
-well.</em></p>
+any approach to convert text to quantities. If <span class="citation" data-cites="P1729R3">[<a href="https://wg21.link/p1729r3" role="doc-biblioref">P1729R3</a>]</span> will be accepted by the LEWG,
+then we will add a proper “Text input” chapter as well.</em></p>
 <h2 data-number="15.1" id="symbols"><span class="header-section-number">15.1</span> Symbols<a href="#symbols" class="self-link"></a></h2>
 <p>The definitions of dimensions, units, prefixes, and constants require
 unique text symbols to be assigned for each entity. Those symbols can be
@@ -4909,9 +4868,8 @@ <h2 data-number="15.1" id="symbols"><span class="header-section-number">15.1</sp
 quantities.</p>
 <h3 data-number="15.1.1" id="symbol-definition-examples"><span class="header-section-number">15.1.1</span> Symbol definition examples<a href="#symbol-definition-examples" class="self-link"></a></h3>
 <p><em>Note: The below code examples are based on the latest version of
-the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library
-and might not be the final version proposed for
-standardization.</em></p>
+the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library and might not be the
+final version proposed for standardization.</em></p>
 <p>Dimensions:</p>
 <div class="sourceCode" id="cb159"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb159-1"><a href="#cb159-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> dim_length <span class="op">:</span> base_dimension<span class="op">&lt;</span><span class="st">&quot;L&quot;</span><span class="op">&gt;</span> <span class="op">{}</span> dim_length;</span>
 <span id="cb159-2"><a href="#cb159-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> dim_mass <span class="op">:</span> base_dimension<span class="op">&lt;</span><span class="st">&quot;M&quot;</span><span class="op">&gt;</span> <span class="op">{}</span> dim_mass;</span>
@@ -4967,13 +4925,13 @@ <h3 data-number="15.1.2" id="lack-of-unicode-subscript-characters"><span class="
 characters<a href="#lack-of-unicode-subscript-characters" class="self-link"></a></h3>
 <p>Unicode provides only a minimal set of characters available as
 subscripts, which are often used to differentiate various constants and
-quantities of the same kind. To workaround this issue, <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> uses ’_’ character to specify
+quantities of the same kind. To workaround this issue, <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> uses ’_’ character to specify
 that the following characters should be considered a subscript of the
 symbol.</p>
 <h3 data-number="15.1.3" id="symbols-for-quantity-types"><span class="header-section-number">15.1.3</span> Symbols for quantity types<a href="#symbols-for-quantity-types" class="self-link"></a></h3>
-<p>Although the ISQ defined in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides symbols for each
+<p>Although the ISQ defined in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides symbols for each
 quantity type, there is little use for them in the C++ code. In the
-<span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> project, we never had a
+<span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> project, we never had a
 request to provide such symbol definitions. Even though having them for
 completeness could be nice, they seem to not be required by the domain
 experts for their daily jobs. Also, it is worth noting that providing
@@ -4983,14 +4941,14 @@ <h3 data-number="15.1.3" id="symbols-for-quantity-types"><span class="header-sec
 the domain information to assess the complexity and potential issues
 with standardization and implementation of those.</p>
 <p>All ISQ quantities have an official symbol assigned in their
-definitions, and how those should be printed is exactly specified. <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> explicitly states:</p>
+definitions, and how those should be printed is exactly specified. <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> explicitly states:</p>
 <blockquote>
 <p>The quantity symbols shall be written in italic (sloping) type,
 irrespective of the type used in the rest of the text.</p>
 </blockquote>
-<p>Additionally, <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-provides additional requirements for printing quantities of vector and
-tensor characters:</p>
+<p>Additionally, <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides additional
+requirements for printing quantities of vector and tensor
+characters:</p>
 <ul>
 <li>vectors should be printed with a boldface type or have a right arrow
 above the letter symbol (e.g., <strong><em>a</em></strong> or <span class="math inline">\(\mathit{\overrightarrow{a}}\)</span>),</li>
@@ -5002,8 +4960,7 @@ <h3 data-number="15.1.3" id="symbols-for-quantity-types"><span class="header-sec
 should also use letters written in italics. The author could not find a
 way to format it properly in this document.</em></p>
 <p>There are also a few requirements for printing subscripts of quantity
-types. <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-states:</p>
+types. <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> states:</p>
 <blockquote>
 <p>The following principles for the printing of subscripts apply:</p>
 <ul>
@@ -5034,7 +4991,7 @@ <h3 data-number="15.1.3" id="symbols-for-quantity-types"><span class="header-sec
 definitions. For them, in the <a href="#symbol-definition-examples">Symbol definition examples</a>
 chapter, we proposed to use the ’_’ character instead, as stated in <a href="#lack-of-unicode-subscript-characters">Lack of Unicode subscript
 characters</a>. We could use the same practice here.</p>
-<p>Another challenge here might be related to the fact that <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> often provides more than
+<p>Another challenge here might be related to the fact that <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> often provides more than
 one symbol for the same quantity. For example:</p>
 <ul>
 <li><em>frequency</em> can use <em>f</em> or <em>ν</em>,</li>
@@ -5116,7 +5073,7 @@ <h3 data-number="15.1.3" id="symbols-for-quantity-types"><span class="header-sec
 propose providing quantity type symbols in their definitions and any
 text input/output support for those.</p>
 <h3 data-number="15.1.4" id="fixed_string"><span class="header-section-number">15.1.4</span>
-<code class="sourceCode default">fixed_string</code><a href="#fixed_string" class="self-link"></a></h3>
+<code class="sourceCode cpp">fixed_string</code><a href="#fixed_string" class="self-link"></a></h3>
 <p>As shown above, symbols are provided as class NTTPs in the library.
 This means that the string type used for such a purpose has to satisfy
 the structural type requirements of the C++ language. One of such
@@ -5133,12 +5090,11 @@ <h3 data-number="15.1.4" id="fixed_string"><span class="header-section-number">1
 <li>provide at least read-only access to the contained storage.</li>
 </ul>
 <p>Such a type does not need to expose a string-like interface. In case
-its interface is immutable, we can easily wrap it with
-<code class="sourceCode default">std::string_view</code> to get such an
-interface for free.</p>
-<p>This type is being proposed separately in <span class="citation" data-cites="P3094R0">[<a href="#ref-P3094R0" role="doc-biblioref"><strong>P3094R0?</strong></a>]</span>.</p>
+its interface is immutable, we can easily wrap it with <code class="sourceCode cpp">std<span class="op">::</span>string_view</code>
+to get such an interface for free.</p>
+<p>This type is being proposed separately in <span class="citation" data-cites="P3094R0">[<a href="https://wg21.link/p3094r0" role="doc-biblioref">P3094R0</a>]</span>.</p>
 <h3 data-number="15.1.5" id="symbol_text"><span class="header-section-number">15.1.5</span>
-<code class="sourceCode default">symbol_text</code><a href="#symbol_text" class="self-link"></a></h3>
+<code class="sourceCode cpp">symbol_text</code><a href="#symbol_text" class="self-link"></a></h3>
 <p>Many symbols of units, prefixes, and constants require using a
 Unicode character set. For example:</p>
 <ul>
@@ -5166,9 +5122,9 @@ <h3 data-number="15.1.5" id="symbol_text"><span class="header-section-number">15
 prefer to work with a basic literal character set. This is why all such
 entities should provide an alternative spelling in their
 definitions.</p>
-<p>This is where <code class="sourceCode default">symbol_text</code>
-comes into play. It is a simple wrapper over the two
-<code class="sourceCode default">fixed_string</code> objects:</p>
+<p>This is where <code class="sourceCode cpp">symbol_text</code> comes
+into play. It is a simple wrapper over the two
+<code class="sourceCode cpp">fixed_string</code> objects:</p>
 <div class="sourceCode" id="cb163"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb163-1"><a href="#cb163-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>std<span class="op">::</span><span class="dt">size_t</span> N, std<span class="op">::</span><span class="dt">size_t</span> M<span class="op">&gt;</span></span>
 <span id="cb163-2"><a href="#cb163-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> symbol_text <span class="op">{</span></span>
 <span id="cb163-3"><a href="#cb163-3" aria-hidden="true" tabindex="-1"></a>  fixed_u8string<span class="op">&lt;</span>N<span class="op">&gt;</span> unicode_;  <span class="co">// exposition only</span></span>
@@ -5211,8 +5167,8 @@ <h3 data-number="15.1.5" id="symbol_text"><span class="header-section-number">15
 <h3 data-number="15.1.6" id="symbols-for-derived-entities"><span class="header-section-number">15.1.6</span> Symbols for derived
 entities<a href="#symbols-for-derived-entities" class="self-link"></a></h3>
 <h4 data-number="15.1.6.1" id="text_encoding"><span class="header-section-number">15.1.6.1</span>
-<code class="sourceCode default">text_encoding</code><a href="#text_encoding" class="self-link"></a></h4>
-<p>ISQ and <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> standards always specify symbols
+<code class="sourceCode cpp">text_encoding</code><a href="#text_encoding" class="self-link"></a></h4>
+<p>ISQ and <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> standards always specify symbols
 using Unicode encoding. This is why it is a default and primary target
 for text output. However, in some applications or environments, a
 standard ASCII-like text output using only the characters from the <a href="https://en.cppreference.com/w/cpp/language/charset">basic literal
@@ -5227,26 +5183,23 @@ <h4 data-number="15.1.6.1" id="text_encoding"><span class="header-section-number
 <h4 data-number="15.1.6.2" id="symbols-of-derived-dimensions"><span class="header-section-number">15.1.6.2</span> Symbols of derived
 dimensions<a href="#symbols-of-derived-dimensions" class="self-link"></a></h4>
 <h5 data-number="15.1.6.2.1" id="dimension_symbol_formatting"><span class="header-section-number">15.1.6.2.1</span>
-<code class="sourceCode default">dimension_symbol_formatting</code><a href="#dimension_symbol_formatting" class="self-link"></a></h5>
-<p><code class="sourceCode default">dimension_symbol_formatting</code>
-is a data type describing the configuration of the symbol generation
+<code class="sourceCode cpp">dimension_symbol_formatting</code><a href="#dimension_symbol_formatting" class="self-link"></a></h5>
+<p><code class="sourceCode cpp">dimension_symbol_formatting</code> is a
+data type describing the configuration of the symbol generation
 algorithm.</p>
 <div class="sourceCode" id="cb165"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb165-1"><a href="#cb165-1" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> dimension_symbol_formatting <span class="op">{</span></span>
 <span id="cb165-2"><a href="#cb165-2" aria-hidden="true" tabindex="-1"></a>  text_encoding encoding <span class="op">=</span> text_encoding<span class="op">::</span>default_encoding;</span>
 <span id="cb165-3"><a href="#cb165-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
-<h5 data-number="15.1.6.2.2" id="dimension_symbol"><span class="header-section-number">15.1.6.2.2</span>
-<code class="sourceCode default">dimension_symbol()</code><a href="#dimension_symbol" class="self-link"></a></h5>
-<p>Returns a <code class="sourceCode default">std::string_view</code>
+<h5 data-number="15.1.6.2.2" id="dimension_symbol"><span class="header-section-number">15.1.6.2.2</span> <code class="sourceCode cpp">dimension_symbol<span class="op">()</span></code><a href="#dimension_symbol" class="self-link"></a></h5>
+<p>Returns a <code class="sourceCode cpp">std<span class="op">::</span>string_view</code>
 with the symbol of a dimension for the provided configuration:</p>
 <div class="sourceCode" id="cb166"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb166-1"><a href="#cb166-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>dimension_symbol_formatting fmt <span class="op">=</span> dimension_symbol_formatting<span class="op">{}</span>, <span class="kw">typename</span> CharT <span class="op">=</span> <span class="dt">char</span>, Dimension D<span class="op">&gt;</span></span>
 <span id="cb166-2"><a href="#cb166-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> std<span class="op">::</span>string_view dimension_symbol<span class="op">(</span>D<span class="op">)</span>;</span></code></pre></div>
-<p><em>Note: It could be refactored to
-<code class="sourceCode default">dimension_symbol(D, fmt)</code> when
-<span class="citation" data-cites="P1045R1">[<a href="#ref-P1045R1" role="doc-biblioref">P1045R1</a>]</span> is available.</em></p>
+<p><em>Note: It could be refactored to <code class="sourceCode cpp">dimension_symbol<span class="op">(</span>D, fmt<span class="op">)</span></code>
+when <span class="citation" data-cites="P1045R1">[<a href="https://wg21.link/p1045r1" role="doc-biblioref">P1045R1</a>]</span> is available.</em></p>
 <p>For example:</p>
 <div class="sourceCode" id="cb167"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb167-1"><a href="#cb167-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>dimension_symbol<span class="op">&lt;{.</span>encoding <span class="op">=</span> text_encoding<span class="op">::</span>ascii<span class="op">}&gt;(</span>isq<span class="op">::</span>power<span class="op">.</span>dimension<span class="op">)</span> <span class="op">==</span> <span class="st">&quot;L^2MT^-3&quot;</span><span class="op">)</span>;</span></code></pre></div>
-<h5 data-number="15.1.6.2.3" id="dimension_symbol_to"><span class="header-section-number">15.1.6.2.3</span>
-<code class="sourceCode default">dimension_symbol_to()</code><a href="#dimension_symbol_to" class="self-link"></a></h5>
+<h5 data-number="15.1.6.2.3" id="dimension_symbol_to"><span class="header-section-number">15.1.6.2.3</span> <code class="sourceCode cpp">dimension_symbol_to<span class="op">()</span></code><a href="#dimension_symbol_to" class="self-link"></a></h5>
 <p>Inserts the generated dimension symbol into the output text iterator
 at runtime.</p>
 <div class="sourceCode" id="cb168"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb168-1"><a href="#cb168-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> CharT <span class="op">=</span> <span class="dt">char</span>, std<span class="op">::</span>output_iterator<span class="op">&lt;</span>CharT<span class="op">&gt;</span> Out, Dimension D<span class="op">&gt;</span></span>
@@ -5259,11 +5212,10 @@ <h5 data-number="15.1.6.2.3" id="dimension_symbol_to"><span class="header-sectio
 <pre class="text"><code>L^2MT^-3</code></pre>
 <h4 data-number="15.1.6.3" id="symbols-of-derived-units"><span class="header-section-number">15.1.6.3</span> Symbols of derived units<a href="#symbols-of-derived-units" class="self-link"></a></h4>
 <h5 data-number="15.1.6.3.1" id="unit_symbol_formatting"><span class="header-section-number">15.1.6.3.1</span>
-<code class="sourceCode default">unit_symbol_formatting</code><a href="#unit_symbol_formatting" class="self-link"></a></h5>
-<p><code class="sourceCode default">unit_symbol_formatting</code> is a
-data type describing the configuration of the symbol generation
-algorithm. It contains three orthogonal fields, each with a default
-value.</p>
+<code class="sourceCode cpp">unit_symbol_formatting</code><a href="#unit_symbol_formatting" class="self-link"></a></h5>
+<p><code class="sourceCode cpp">unit_symbol_formatting</code> is a data
+type describing the configuration of the symbol generation algorithm. It
+contains three orthogonal fields, each with a default value.</p>
 <div class="sourceCode" id="cb170"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb170-1"><a href="#cb170-1" aria-hidden="true" tabindex="-1"></a><span class="kw">enum</span> <span class="kw">class</span> unit_symbol_solidus <span class="op">:</span> std<span class="op">::</span><span class="dt">int8_t</span> <span class="op">{</span></span>
 <span id="cb170-2"><a href="#cb170-2" aria-hidden="true" tabindex="-1"></a>  one_denominator,  <span class="co">// m/s;   kg m⁻¹ s⁻¹</span></span>
 <span id="cb170-3"><a href="#cb170-3" aria-hidden="true" tabindex="-1"></a>  always,           <span class="co">// m/s;   kg/(m s)</span></span>
@@ -5282,26 +5234,24 @@ <h5 data-number="15.1.6.3.1" id="unit_symbol_formatting"><span class="header-sec
 <span id="cb170-16"><a href="#cb170-16" aria-hidden="true" tabindex="-1"></a>  unit_symbol_solidus solidus <span class="op">=</span> unit_symbol_solidus<span class="op">::</span>default_denominator;</span>
 <span id="cb170-17"><a href="#cb170-17" aria-hidden="true" tabindex="-1"></a>  unit_symbol_separator separator <span class="op">=</span> unit_symbol_separator<span class="op">::</span>default_separator;</span>
 <span id="cb170-18"><a href="#cb170-18" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
-<p><code class="sourceCode default">unit_symbol_solidus</code> impacts
-how the division of unit symbols is being presented in the text output.
-By default, the ‘/’ will be printed if only one unit component is in the
+<p><code class="sourceCode cpp">unit_symbol_solidus</code> impacts how
+the division of unit symbols is being presented in the text output. By
+default, the ‘/’ will be printed if only one unit component is in the
 denominator. Otherwise, the exponent syntax will be used.</p>
-<p><code class="sourceCode default">unit_symbol_separator</code>
-specifies how multiple multiplied units should be separated from each
-other. By default, the space (’ ’) will be used as a separator.</p>
-<h5 data-number="15.1.6.3.2" id="unit_symbol"><span class="header-section-number">15.1.6.3.2</span>
-<code class="sourceCode default">unit_symbol()</code><a href="#unit_symbol" class="self-link"></a></h5>
-<p>Returns a <code class="sourceCode default">std::string_view</code>
+<p><code class="sourceCode cpp">unit_symbol_separator</code> specifies
+how multiple multiplied units should be separated from each other. By
+default, the space (’ ’) will be used as a separator.</p>
+<h5 data-number="15.1.6.3.2" id="unit_symbol"><span class="header-section-number">15.1.6.3.2</span> <code class="sourceCode cpp">unit_symbol<span class="op">()</span></code><a href="#unit_symbol" class="self-link"></a></h5>
+<p>Returns a <code class="sourceCode cpp">std<span class="op">::</span>string_view</code>
 with the symbol of a unit for the provided configuration:</p>
 <div class="sourceCode" id="cb171"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb171-1"><a href="#cb171-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>unit_symbol_formatting fmt <span class="op">=</span> unit_symbol_formatting<span class="op">{}</span>, <span class="kw">typename</span> CharT <span class="op">=</span> <span class="dt">char</span>, Unit U<span class="op">&gt;</span></span>
 <span id="cb171-2"><a href="#cb171-2" aria-hidden="true" tabindex="-1"></a><span class="kw">consteval</span> std<span class="op">::</span>string_view unit_symbol<span class="op">(</span>U<span class="op">)</span>;</span></code></pre></div>
-<p><em>Note: It could be refactored to
-<code class="sourceCode default">unit_symbol(U, fmt)</code> when <span class="citation" data-cites="P1045R1">[<a href="#ref-P1045R1" role="doc-biblioref">P1045R1</a>]</span> is available.</em></p>
+<p><em>Note: It could be refactored to <code class="sourceCode cpp">unit_symbol<span class="op">(</span>U, fmt<span class="op">)</span></code>
+when <span class="citation" data-cites="P1045R1">[<a href="https://wg21.link/p1045r1" role="doc-biblioref">P1045R1</a>]</span> is available.</em></p>
 <p>For example:</p>
 <div class="sourceCode" id="cb172"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb172-1"><a href="#cb172-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>unit_symbol<span class="op">&lt;{.</span>solidus <span class="op">=</span> unit_symbol_solidus<span class="op">::</span>never,</span>
 <span id="cb172-2"><a href="#cb172-2" aria-hidden="true" tabindex="-1"></a>                           <span class="op">.</span>separator <span class="op">=</span> unit_symbol_separator<span class="op">::</span>half_high_dot<span class="op">}&gt;(</span>kg <span class="op">*</span> m <span class="op">/</span> s2<span class="op">)</span> <span class="op">==</span> <span class="st">&quot;kg⋅m⋅s⁻²&quot;</span><span class="op">)</span>;</span></code></pre></div>
-<h5 data-number="15.1.6.3.3" id="unit_symbol_to"><span class="header-section-number">15.1.6.3.3</span>
-<code class="sourceCode default">unit_symbol_to()</code><a href="#unit_symbol_to" class="self-link"></a></h5>
+<h5 data-number="15.1.6.3.3" id="unit_symbol_to"><span class="header-section-number">15.1.6.3.3</span> <code class="sourceCode cpp">unit_symbol_to<span class="op">()</span></code><a href="#unit_symbol_to" class="self-link"></a></h5>
 <p>Inserts the generated unit symbol into the output text iterator at
 runtime.</p>
 <div class="sourceCode" id="cb173"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb173-1"><a href="#cb173-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> CharT <span class="op">=</span> <span class="dt">char</span>, std<span class="op">::</span>output_iterator<span class="op">&lt;</span>CharT<span class="op">&gt;</span> Out, Unit U<span class="op">&gt;</span></span>
@@ -5314,39 +5264,39 @@ <h5 data-number="15.1.6.3.3" id="unit_symbol_to"><span class="header-section-num
 <p>The above prints:</p>
 <pre class="text"><code>kg⋅m⋅s⁻²</code></pre>
 <h2 data-number="15.2" id="space_before_unit_symbol-customization-point"><span class="header-section-number">15.2</span>
-<code class="sourceCode default">space_before_unit_symbol</code>
+<code class="sourceCode cpp">space_before_unit_symbol</code>
 customization point<a href="#space_before_unit_symbol-customization-point" class="self-link"></a></h2>
-<p>The <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> says:</p>
+<p>The <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> says:</p>
 <blockquote>
 <p>The numerical value always precedes the unit and a space is always
 used to separate the unit from the number. … The only exceptions to this
 rule are for the unit symbols for degree, minute and second for plane
-angle, <code class="sourceCode default">°</code>,
-<code class="sourceCode default">′</code> and
-<code class="sourceCode default">″</code>, respectively, for which no
-space is left between the numerical value and the unit symbol.</p>
+angle, <code class="sourceCode cpp">°</code>,
+<code class="sourceCode cpp">′</code> and
+<code class="sourceCode cpp">″</code>, respectively, for which no space
+is left between the numerical value and the unit symbol.</p>
 </blockquote>
 <p>There are more units with such properties. For example, percent
-(<code class="sourceCode default">%</code>) and per
-mille(<code class="sourceCode default">‰</code>).</p>
+(<code class="sourceCode cpp"><span class="op">%</span></code>) and per
+mille(<code class="sourceCode cpp">‰</code>).</p>
 <p>To support the above, the library exposes
-<code class="sourceCode default">space_before_unit_symbol</code>
+<code class="sourceCode cpp">space_before_unit_symbol</code>
 customization point. By default, its value is
-<code class="sourceCode default">true</code> for all the units. This
-means that a number and a unit will be separated by the space in the
-output text. To change this behavior, a user should provide a partial
-specialization for a specific unit:</p>
+<code class="sourceCode cpp"><span class="kw">true</span></code> for all
+the units. This means that a number and a unit will be separated by the
+space in the output text. To change this behavior, a user should provide
+a partial specialization for a specific unit:</p>
 <div class="sourceCode" id="cb175"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb175-1"><a href="#cb175-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;&gt;</span></span>
 <span id="cb175-2"><a href="#cb175-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="dt">bool</span> space_before_unit_symbol<span class="op">&lt;</span>non_si<span class="op">::</span>degree<span class="op">&gt;</span> <span class="op">=</span> <span class="kw">false</span>;</span></code></pre></div>
 <p>The above works only for the default formatting or for the format
-strings that use <code class="sourceCode default">%?</code> placement
-field
-(<code class="sourceCode default">std::format(&quot;{}&quot;, q)</code>
-is equivalent to <code class="sourceCode default">std::format(&quot;{:%N%?%U}&quot;, q)</code>).</p>
-<p>In case a user provides custom format specification (e.g., <code class="sourceCode default">std::format(&quot;{:%N %U}&quot;, q)</code>),
+strings that use
+<code class="sourceCode cpp"><span class="op">%?</span></code> placement
+field (<code class="sourceCode cpp">std<span class="op">::</span>format<span class="op">(</span><span class="st">&quot;{}&quot;</span>, q<span class="op">)</span></code>
+is equivalent to <code class="sourceCode cpp">std<span class="op">::</span>format<span class="op">(</span><span class="st">&quot;{:%N%?%U}&quot;</span>, q<span class="op">)</span></code>).</p>
+<p>In case a user provides custom format specification (e.g., <code class="sourceCode cpp">std<span class="op">::</span>format<span class="op">(</span><span class="st">&quot;{:%N %U}&quot;</span>, q<span class="op">)</span></code>),
 the library will always obey this specification for all the units (no
 matter what the actual value of the
-<code class="sourceCode default">space_before_unit_symbol</code>
+<code class="sourceCode cpp">space_before_unit_symbol</code>
 customization point is) and the separating space will always be used in
 this case.</p>
 <h2 data-number="15.3" id="output-streams"><span class="header-section-number">15.3</span> Output streams<a href="#output-streams" class="self-link"></a></h2>
@@ -5370,22 +5320,20 @@ <h3 data-number="15.3.1" id="output-stream-formatting"><span class="header-secti
 <div class="sourceCode" id="cb177"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb177-1"><a href="#cb177-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;|&quot;</span> <span class="op">&lt;&lt;</span> std<span class="op">::</span>setw<span class="op">(</span><span class="dv">10</span><span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="dv">123</span> <span class="op">*</span> m <span class="op">&lt;&lt;</span> <span class="st">&quot;|</span><span class="sc">\n</span><span class="st">&quot;</span>;                       <span class="co">// |     123 m|</span></span>
 <span id="cb177-2"><a href="#cb177-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;|&quot;</span> <span class="op">&lt;&lt;</span> std<span class="op">::</span>setw<span class="op">(</span><span class="dv">10</span><span class="op">)</span> <span class="op">&lt;&lt;</span> std<span class="op">::</span>left <span class="op">&lt;&lt;</span> <span class="dv">123</span> <span class="op">*</span> m <span class="op">&lt;&lt;</span> <span class="st">&quot;|</span><span class="sc">\n</span><span class="st">&quot;</span>;          <span class="co">// |123 m     |</span></span>
 <span id="cb177-3"><a href="#cb177-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;|&quot;</span> <span class="op">&lt;&lt;</span> std<span class="op">::</span>setw<span class="op">(</span><span class="dv">10</span><span class="op">)</span> <span class="op">&lt;&lt;</span> std<span class="op">::</span>setfill<span class="op">(</span><span class="ch">&#39;*&#39;</span><span class="op">)</span> <span class="op">&lt;&lt;</span> <span class="dv">123</span> <span class="op">*</span> m <span class="op">&lt;&lt;</span> <span class="st">&quot;|</span><span class="sc">\n</span><span class="st">&quot;</span>;  <span class="co">// |123 m*****|</span></span></code></pre></div>
-<p>Detailed formatting of any entity may be obtained with
-<code class="sourceCode default">std::format()</code> usage and then
-provided to the stream output if needed.</p>
+<p>Detailed formatting of any entity may be obtained with <code class="sourceCode cpp">std<span class="op">::</span>format<span class="op">()</span></code>
+usage and then provided to the stream output if needed.</p>
 <p><em>Note: Custom stream manipulators may be provided to control a
 dimension and unit symbol output if requested by WG21.</em></p>
 <h2 data-number="15.4" id="text-formatting"><span class="header-section-number">15.4</span> Text formatting<a href="#text-formatting" class="self-link"></a></h2>
 <p>The library provides custom formatters for
-<code class="sourceCode default">std::format</code> facility, which
-allows fine-grained control over what and how it is being printed in the
-text output.</p>
+<code class="sourceCode cpp">std<span class="op">::</span>format</code>
+facility, which allows fine-grained control over what and how it is
+being printed in the text output.</p>
 <h3 data-number="15.4.1" id="controlling-width-fill-and-alignment"><span class="header-section-number">15.4.1</span> Controlling width, fill, and
 alignment<a href="#controlling-width-fill-and-alignment" class="self-link"></a></h3>
 <p>Formatting grammar for all the entities provides control over width,
-fill, and alignment. The C++ standard grammar tokens
-<code class="sourceCode default">fill-and-align</code> and
-<code class="sourceCode default">width</code> are being used. They treat
+fill, and alignment. The C++ standard grammar tokens <code class="sourceCode cpp">fill<span class="op">-</span><span class="kw">and</span><span class="op">-</span>align</code>
+and <code class="sourceCode cpp">width</code> are being used. They treat
 the entity as a contiguous text to be aligned. For example, here are a
 few examples of the quantity numerical value and symbol formatting:</p>
 <div class="sourceCode" id="cb178"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb178-1"><a href="#cb178-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;|{:0}|&quot;</span>, <span class="dv">123</span> <span class="op">*</span> m<span class="op">)</span>;     <span class="co">// |123 m|</span></span>
@@ -5406,31 +5354,30 @@ <h3 data-number="15.4.2" id="dimension-formatting"><span class="header-section-n
 text-encoding         = &#39;U&#39; | &#39;A&#39;;</code></pre>
 <p>In the above grammar:</p>
 <ul>
-<li><code class="sourceCode default">fill-and-align</code> and
-<code class="sourceCode default">width</code> tokens are defined in the
+<li><code class="sourceCode cpp">fill<span class="op">-</span><span class="kw">and</span><span class="op">-</span>align</code>
+and <code class="sourceCode cpp">width</code> tokens are defined in the
 <span>22.14.2.2
 <a href="https://wg21.link/format.string.std">[format.string.std]</a></span>
 chapter of the C++ standard specification,</li>
-<li><code class="sourceCode default">text-encoding</code> token
-specifies the symbol text encoding:
-<ul>
-<li><code class="sourceCode default">U</code> (default) uses the
-<strong>Unicode</strong> symbols defined by <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> (e.g.,
-<code class="sourceCode default">LT⁻²</code>),</li>
-<li><code class="sourceCode default">A</code> forces non-standard
-<strong>ASCII</strong>-only output (e.g.,
-<code class="sourceCode default">LT^-2</code>).</li>
+<li><code class="sourceCode cpp">text<span class="op">-</span>encoding</code>
+token specifies the symbol text encoding:
+<ul>
+<li><code class="sourceCode cpp">U</code> (default) uses the
+<strong>Unicode</strong> symbols defined by <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (e.g.,
+<code class="sourceCode cpp">LT⁻²</code>),</li>
+<li><code class="sourceCode cpp">A</code> forces non-standard
+<strong>ASCII</strong>-only output (e.g., <code class="sourceCode cpp">LT<span class="op">^-</span><span class="dv">2</span></code>).</li>
 </ul></li>
 </ul>
 <p>Dimension symbols of some quantities are specified to use Unicode
-signs by the ISQ (e.g., <code class="sourceCode default">Θ</code> symbol
-for the <em>thermodynamic temperature</em> dimension). The library
-follows this by default. From the engineering point of view, sometimes
-Unicode text might not be the best solution as terminals of many
-(especially embedded) devices can output only letters from the basic
-literal character set only. In such a case, the dimension symbol can be
-forced to be printed using such characters thanks to
-<code class="sourceCode default">text-encoding</code> token:</p>
+signs by the ISQ (e.g., <code class="sourceCode cpp">Θ</code> symbol for
+the <em>thermodynamic temperature</em> dimension). The library follows
+this by default. From the engineering point of view, sometimes Unicode
+text might not be the best solution as terminals of many (especially
+embedded) devices can output only letters from the basic literal
+character set only. In such a case, the dimension symbol can be forced
+to be printed using such characters thanks to <code class="sourceCode cpp">text<span class="op">-</span>encoding</code>
+token:</p>
 <div class="sourceCode" id="cb179"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb179-1"><a href="#cb179-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{}&quot;</span>, isq<span class="op">::</span>dim_thermodynamic_temperature<span class="op">)</span>;   <span class="co">// Θ</span></span>
 <span id="cb179-2"><a href="#cb179-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:A}&quot;</span>, isq<span class="op">::</span>dim_thermodynamic_temperature<span class="op">)</span>; <span class="co">// O</span></span>
 <span id="cb179-3"><a href="#cb179-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{}&quot;</span>, isq<span class="op">::</span>power<span class="op">.</span>dimension<span class="op">)</span>;                 <span class="co">// L²MT⁻³</span></span>
@@ -5447,54 +5394,53 @@ <h3 data-number="15.4.3" id="unit-formatting"><span class="header-section-number
 unit-symbol-separator = &#39;s&#39; | &#39;d&#39;;</code></pre>
 <p>In the above grammar:</p>
 <ul>
-<li><code class="sourceCode default">fill-and-align</code> and
-<code class="sourceCode default">width</code> tokens are defined in the
+<li><code class="sourceCode cpp">fill<span class="op">-</span><span class="kw">and</span><span class="op">-</span>align</code>
+and <code class="sourceCode cpp">width</code> tokens are defined in the
 <span>22.14.2.2
 <a href="https://wg21.link/format.string.std">[format.string.std]</a></span>
 chapter of the C++ standard specification,</li>
-<li><code class="sourceCode default">unit-symbol-solidus</code> token
-specifies how the division of units should look like:
-<ul>
-<li>‘1’ (default) outputs <code class="sourceCode default">/</code> only
-when there is only <strong>one</strong> unit in the denominator,
-otherwise negative exponents are printed (e.g.,
-<code class="sourceCode default">m/s</code>,
-<code class="sourceCode default">kg m⁻¹ s⁻¹</code>)</li>
+<li><code class="sourceCode cpp">unit<span class="op">-</span>symbol<span class="op">-</span>solidus</code>
+token specifies how the division of units should look like:
+<ul>
+<li>‘1’ (default) outputs
+<code class="sourceCode cpp"><span class="op">/</span></code> only when
+there is only <strong>one</strong> unit in the denominator, otherwise
+negative exponents are printed (e.g.,
+<code class="sourceCode cpp">m<span class="op">/</span>s</code>,
+<code class="sourceCode cpp">kg m⁻¹ s⁻¹</code>)</li>
 <li>‘a’ <strong>always</strong> uses solidus (e.g.,
-<code class="sourceCode default">m/s</code>,
-<code class="sourceCode default">kg/(m s)</code>)</li>
+<code class="sourceCode cpp">m<span class="op">/</span>s</code>, <code class="sourceCode cpp">kg<span class="op">/(</span>m s<span class="op">)</span></code>)</li>
 <li>‘n’ <strong>never</strong> prints solidus, which means that negative
 exponents are always used (e.g.,
-<code class="sourceCode default">m s⁻¹</code>,
-<code class="sourceCode default">kg m⁻¹ s⁻¹</code>)</li>
+<code class="sourceCode cpp">m s⁻¹</code>,
+<code class="sourceCode cpp">kg m⁻¹ s⁻¹</code>)</li>
 </ul></li>
-<li><code class="sourceCode default">unit-symbol-separator</code> token
-specifies how multiplied unit symbols should be separated:
+<li><code class="sourceCode cpp">unit<span class="op">-</span>symbol<span class="op">-</span>separator</code>
+token specifies how multiplied unit symbols should be separated:
 <ul>
 <li>‘s’ (default) uses <strong>space</strong> as a separator (e.g.,
-<code class="sourceCode default">kg m²/s²</code>)</li>
+<code class="sourceCode cpp">kg m²<span class="op">/</span>s²</code>)</li>
 <li>‘d’ uses half-high <strong>dot</strong>
-(<code class="sourceCode default">⋅</code>) as a separator (e.g.,
-<code class="sourceCode default">kg⋅m²/s²</code>) (requires the Unicode
-encoding)</li>
+(<code class="sourceCode cpp">⋅</code>) as a separator (e.g.,
+<code class="sourceCode cpp">kg⋅m²<span class="op">/</span>s²</code>)
+(requires the Unicode encoding)</li>
 </ul></li>
 <li>‘L’ is reserved for possible future localization use in case C++
 standard library gets access to the ICU-like database.</li>
 </ul>
 <p><em>Note: The intent of the above grammar was that the elements of
-<code class="sourceCode default">unit-spec</code> can appear in any
-order as they have unique characters. Users shouldn’t have to remember
-the order of those tokens to control the formatting of a unit
-symbol.</em></p>
+<code class="sourceCode cpp">unit<span class="op">-</span>spec</code>
+can appear in any order as they have unique characters. Users shouldn’t
+have to remember the order of those tokens to control the formatting of
+a unit symbol.</em></p>
 <p>Unit symbols of some quantities are specified to use Unicode signs by
-the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> (e.g.,
-<code class="sourceCode default">Ω</code> symbol for the
-<em>resistance</em> quantity). The library follows this by default. From
-the engineering point of view, sometimes Unicode text might not be the
-best solution as terminals of many (especially embedded) devices can
-output only letters from the basic literal character set only. In such a
-case, the unit symbol can be forced to be printed using such characters
-thanks to <code class="sourceCode default">text-encoding</code>
+the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> (e.g.,
+<code class="sourceCode cpp">Ω</code> symbol for the <em>resistance</em>
+quantity). The library follows this by default. From the engineering
+point of view, sometimes Unicode text might not be the best solution as
+terminals of many (especially embedded) devices can output only letters
+from the basic literal character set only. In such a case, the unit
+symbol can be forced to be printed using such characters thanks to <code class="sourceCode cpp">text<span class="op">-</span>encoding</code>
 token:</p>
 <div class="sourceCode" id="cb180"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb180-1"><a href="#cb180-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{}&quot;</span>, si<span class="op">::</span>ohm<span class="op">)</span>;      <span class="co">// Ω</span></span>
 <span id="cb180-2"><a href="#cb180-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:A}&quot;</span>, si<span class="op">::</span>ohm<span class="op">)</span>;    <span class="co">// ohm</span></span>
@@ -5502,17 +5448,17 @@ <h3 data-number="15.4.3" id="unit-formatting"><span class="header-section-number
 <span id="cb180-4"><a href="#cb180-4" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:A}&quot;</span>, us<span class="op">)</span>;         <span class="co">// us</span></span>
 <span id="cb180-5"><a href="#cb180-5" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{}&quot;</span>, m <span class="op">/</span> s2<span class="op">)</span>;       <span class="co">// m/s²</span></span>
 <span id="cb180-6"><a href="#cb180-6" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:A}&quot;</span>, m <span class="op">/</span> s2<span class="op">)</span>;     <span class="co">// m/s^2</span></span></code></pre></div>
-<p>Additionally, both <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> and
-<span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> leave some freedom on how to print
+<p>Additionally, both <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> and <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> leave some freedom on how to print
 unit symbols. This is why two additional tokens were introduced.</p>
-<p><code class="sourceCode default">unit-symbol-solidus</code> specifies
-how the division of units should look like. By default,
-<code class="sourceCode default">/</code> will be used only when the
-denominator contains only one unit. However, with the ‘a’ or ‘n’
-options, we can force the facility to print the
-<code class="sourceCode default">/</code> character always (even when
-there are more units in the denominator), or never, in which case a
-parenthesis will be added to enclose all denominator units.</p>
+<p><code class="sourceCode cpp">unit<span class="op">-</span>symbol<span class="op">-</span>solidus</code>
+specifies how the division of units should look like. By default,
+<code class="sourceCode cpp"><span class="op">/</span></code> will be
+used only when the denominator contains only one unit. However, with the
+‘a’ or ‘n’ options, we can force the facility to print the
+<code class="sourceCode cpp"><span class="op">/</span></code> character
+always (even when there are more units in the denominator), or never, in
+which case a parenthesis will be added to enclose all denominator
+units.</p>
 <div class="sourceCode" id="cb181"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb181-1"><a href="#cb181-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{}&quot;</span>, m <span class="op">/</span> s<span class="op">)</span>;          <span class="co">// m/s</span></span>
 <span id="cb181-2"><a href="#cb181-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{}&quot;</span>, kg <span class="op">/</span> m <span class="op">/</span> s2<span class="op">)</span>;    <span class="co">// kg m⁻¹ s⁻²</span></span>
 <span id="cb181-3"><a href="#cb181-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:a}&quot;</span>, m <span class="op">/</span> s<span class="op">)</span>;        <span class="co">// m/s</span></span>
@@ -5520,24 +5466,24 @@ <h3 data-number="15.4.3" id="unit-formatting"><span class="header-section-number
 <span id="cb181-5"><a href="#cb181-5" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:n}&quot;</span>, m <span class="op">/</span> s<span class="op">)</span>;        <span class="co">// m s⁻¹</span></span>
 <span id="cb181-6"><a href="#cb181-6" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:n}&quot;</span>, kg <span class="op">/</span> m <span class="op">/</span> s2<span class="op">)</span>;  <span class="co">// kg m⁻¹ s⁻²</span></span></code></pre></div>
 <p>Also, there are a few options to separate the units being multiplied.
-<span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 1) says:</p>
+<span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 1) says:</p>
 <blockquote>
 <p>When symbols for quantities are combined in a product of two or more
 quantities, this combination is indicated in one of the following ways:
-<code class="sourceCode default">ab</code>,
-<code class="sourceCode default">a b</code>,
-<code class="sourceCode default">a · b</code>,
-<code class="sourceCode default">a × b</code></p>
+<code class="sourceCode cpp">ab</code>,
+<code class="sourceCode cpp">a b</code>,
+<code class="sourceCode cpp">a · b</code>,
+<code class="sourceCode cpp">a × b</code></p>
 <p><em>NOTE 1</em> In some fields, e.g., vector algebra, distinction is
-made between <code class="sourceCode default">a ∙ b</code> and
-<code class="sourceCode default">a × b</code>.</p>
+made between <code class="sourceCode cpp">a ∙ b</code> and
+<code class="sourceCode cpp">a × b</code>.</p>
 </blockquote>
-<p>The library supports <code class="sourceCode default">a b</code> and
-<code class="sourceCode default">a · b</code> only. Additionally, we
-decided that the extraneous space in the latter case makes the result
-too verbose, so we decided just to use the
-<code class="sourceCode default">·</code> symbol as a separator.</p>
-<p>The <code class="sourceCode default">unit-symbol-separator</code>
+<p>The library supports <code class="sourceCode cpp">a b</code> and
+<code class="sourceCode cpp">a · b</code> only. Additionally, we decided
+that the extraneous space in the latter case makes the result too
+verbose, so we decided just to use the
+<code class="sourceCode cpp">·</code> symbol as a separator.</p>
+<p>The <code class="sourceCode cpp">unit<span class="op">-</span>symbol<span class="op">-</span>separator</code>
 token allows us to obtain the following outputs:</p>
 <div class="sourceCode" id="cb182"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb182-1"><a href="#cb182-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{}&quot;</span>, kg <span class="op">*</span> m2 <span class="op">/</span> s2<span class="op">)</span>;    <span class="co">// kg m²/s²</span></span>
 <span id="cb182-2"><a href="#cb182-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{:d}&quot;</span>, kg <span class="op">*</span> m2 <span class="op">/</span> s2<span class="op">)</span>;  <span class="co">// kg⋅m²/s²</span></span></code></pre></div>
@@ -5558,13 +5504,13 @@ <h3 data-number="15.4.4" id="quantity-formatting"><span class="header-section-nu
 format-spec                 = ? as specified by the formatter for the argument type ?;</code></pre>
 <p>In the above grammar:</p>
 <ul>
-<li><code class="sourceCode default">fill-and-align</code> and
-<code class="sourceCode default">width</code> tokens are defined in the
+<li><code class="sourceCode cpp">fill<span class="op">-</span><span class="kw">and</span><span class="op">-</span>align</code>
+and <code class="sourceCode cpp">width</code> tokens are defined in the
 <span>22.14.2.2
 <a href="https://wg21.link/format.string.std">[format.string.std]</a></span>
 chapter of the C++ standard specification,</li>
-<li><code class="sourceCode default">placement-type</code> token
-specifies which entity should be put and where:
+<li><code class="sourceCode cpp">placement<span class="op">-</span>type</code>
+token specifies which entity should be put and where:
 <ul>
 <li>‘N’ inserts a default-formatted numerical value of the
 quantity,</li>
@@ -5572,34 +5518,32 @@ <h3 data-number="15.4.4" id="quantity-formatting"><span class="header-section-nu
 <li>‘D’ inserts a default-formatted dimension of the quantity,</li>
 <li>‘?’ inserts an optional separator between the number and a unit
 based on the value of
-<code class="sourceCode default">space_before_unit_symbol</code> for
-this unit,</li>
+<code class="sourceCode cpp">space_before_unit_symbol</code> for this
+unit,</li>
 <li>‘%’ just inserts ‘%’ character.</li>
 </ul></li>
-<li><code class="sourceCode default">defaults-specs</code> token allows
-overwriting defaults for the underlying formatters with the custom
-format string. Each override starts with a subentity identifier (‘N’,
-‘U’, or ‘D’) followed by the format string enclosed in square
+<li><code class="sourceCode cpp">defaults<span class="op">-</span>specs</code>
+token allows overwriting defaults for the underlying formatters with the
+custom format string. Each override starts with a subentity identifier
+(‘N’, ‘U’, or ‘D’) followed by the format string enclosed in square
 brackets.</li>
 </ul>
 <h4 data-number="15.4.4.1" id="default-formatting"><span class="header-section-number">15.4.4.1</span> Default formatting<a href="#default-formatting" class="self-link"></a></h4>
-<p>To format <code class="sourceCode default">quantity</code> values,
-the formatting facility uses
-<code class="sourceCode default">quantity-format-spec</code>. If left
-empty, the default formatting is applied. The same default formatting is
-also applied to the output streams. This is why the following code lines
-produce the same output:</p>
+<p>To format <code class="sourceCode cpp">quantity</code> values, the
+formatting facility uses <code class="sourceCode cpp">quantity<span class="op">-</span>format<span class="op">-</span>spec</code>.
+If left empty, the default formatting is applied. The same default
+formatting is also applied to the output streams. This is why the
+following code lines produce the same output:</p>
 <div class="sourceCode" id="cb183"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb183-1"><a href="#cb183-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> <span class="st">&quot;Distance: &quot;</span> <span class="op">&lt;&lt;</span> <span class="dv">123</span> <span class="op">*</span> km <span class="op">&lt;&lt;</span> <span class="st">&quot;</span><span class="sc">\n</span><span class="st">&quot;</span>;</span>
 <span id="cb183-2"><a href="#cb183-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> std<span class="op">::</span>format<span class="op">(</span><span class="st">&quot;Distance: {}</span><span class="sc">\n</span><span class="st">&quot;</span>, <span class="dv">123</span> <span class="op">*</span> km<span class="op">)</span>;</span>
 <span id="cb183-3"><a href="#cb183-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>cout <span class="op">&lt;&lt;</span> std<span class="op">::</span>format<span class="op">(</span><span class="st">&quot;Distance: {:%N%?%U}</span><span class="sc">\n</span><span class="st">&quot;</span>, <span class="dv">123</span> <span class="op">*</span> km<span class="op">)</span>;</span></code></pre></div>
-<p>Please note that for some quantities the
-<code class="sourceCode default">{:%N %U}</code> format may provide a
-different output than the default one, as some units have
-<code class="sourceCode default">space_before_unit_symbol</code>
+<p>Please note that for some quantities the <code class="sourceCode cpp"><span class="op">{:%</span>N <span class="op">%</span>U<span class="op">}</span></code>
+format may provide a different output than the default one, as some
+units have <code class="sourceCode cpp">space_before_unit_symbol</code>
 customization point explicitly set to
-<code class="sourceCode default">false</code> (e.g.,
-<code class="sourceCode default">%</code> and
-<code class="sourceCode default">°</code>).</p>
+<code class="sourceCode cpp"><span class="kw">false</span></code> (e.g.,
+<code class="sourceCode cpp"><span class="op">%</span></code> and
+<code class="sourceCode cpp">°</code>).</p>
 <h4 data-number="15.4.4.2" id="quantity-numerical-value-unit-symbol-or-both"><span class="header-section-number">15.4.4.2</span> Quantity numerical value,
 unit symbol, or both?<a href="#quantity-numerical-value-unit-symbol-or-both" class="self-link"></a></h4>
 <p>Thanks to the grammar provided above, the user can easily decide to
@@ -5622,17 +5566,17 @@ <h4 data-number="15.4.4.2" id="quantity-numerical-value-unit-symbol-or-both"><sp
 - unit: km/h
 - dimension: LT⁻¹</code></pre></li>
 </ul>
-<p><code class="sourceCode default">placement-type</code> greatly
-simplify element access to the elements of the quantity. Without them
-the second case above would require the following:</p>
+<p><code class="sourceCode cpp">placement<span class="op">-</span>type</code>
+greatly simplify element access to the elements of the quantity. Without
+them the second case above would require the following:</p>
 <div class="sourceCode" id="cb188"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb188-1"><a href="#cb188-1" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> <span class="kw">auto</span> q <span class="op">=</span> <span class="dv">120</span> <span class="op">*</span> km <span class="op">/</span> h;</span>
 <span id="cb188-2"><a href="#cb188-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;Speed:</span><span class="sc">\n</span><span class="st">- number: {}</span><span class="sc">\n</span><span class="st">- unit: {}</span><span class="sc">\n</span><span class="st">- dimension: {}&quot;</span>,</span>
 <span id="cb188-3"><a href="#cb188-3" aria-hidden="true" tabindex="-1"></a>             q<span class="op">.</span>numerical_value_ref_in<span class="op">(</span>q<span class="op">.</span>unit<span class="op">)</span>, q<span class="op">.</span>unit, q<span class="op">.</span>dimension<span class="op">)</span>;</span></code></pre></div>
-<p><code class="sourceCode default">default-spec</code> is crutial to
-provide formatting of user-defined representation types. Initially,
-<span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library was providing
+<p><code class="sourceCode cpp"><span class="cf">default</span><span class="op">-</span>spec</code>
+is crutial to provide formatting of user-defined representation types.
+Initially, <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library was providing
 numerical value modifiers inplace of its format specification similarly
-to <code class="sourceCode default">std::chrono::duration</code>
+to <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>
 formatter. However, it:</p>
 <ul>
 <li>worked only with fundamental arithmetic types and was not able to
@@ -5647,29 +5591,30 @@ <h4 data-number="15.4.4.3" id="formatting-of-the-quantity-numerical-value"><span
 <p>The representation type used as a numerical value of a quantity must
 provide its own formatter specialization. It will be called by the
 quantity formatter with the format-spec provided by the user in the
-<code class="sourceCode default">N</code> defaults specification.</p>
+<code class="sourceCode cpp">N</code> defaults specification.</p>
 <p>In case we use C++ fundamental arithmetic types with our quantities
 the standard formatter specified in <a href="https://wg21.link/format.string.std">format.string.std</a> will be
 used. The rest of this chapter assumes that it is the case and provides
 some usage examples.</p>
-<p><code class="sourceCode default">sign</code> token allows us to
-specify how the value’s sign is being printed:</p>
+<p><code class="sourceCode cpp">sign</code> token allows us to specify
+how the value’s sign is being printed:</p>
 <div class="sourceCode" id="cb189"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb189-1"><a href="#cb189-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{0},{0::N[+]},{0::N[-]},{0::N[ ]}&quot;</span>, <span class="dv">1</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 1 m,+1 m,1 m, 1 m</span></span>
 <span id="cb189-2"><a href="#cb189-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{0},{0::N[+]},{0::N[-]},{0::N[ ]}&quot;</span>, <span class="op">-</span><span class="dv">1</span> <span class="op">*</span> m<span class="op">)</span>;  <span class="co">// -1 m,-1 m,-1 m,-1 m</span></span></code></pre></div>
 <p>where:</p>
 <ul>
-<li><code class="sourceCode default">+</code> indicates that a sign
-should be used for both non-negative and negative numbers,</li>
-<li><code class="sourceCode default">-</code> indicates that a sign
-should be used for negative numbers and negative zero only (this is the
-default behavior),</li>
-<li><code class="sourceCode default">&lt;space&gt;</code> indicates that
-a leading space should be used for non-negative numbers other than
-negative zero, and a minus sign for negative numbers and negative
-zero.</li>
+<li><code class="sourceCode cpp"><span class="op">+</span></code>
+indicates that a sign should be used for both non-negative and negative
+numbers,</li>
+<li><code class="sourceCode cpp"><span class="op">-</span></code>
+indicates that a sign should be used for negative numbers and negative
+zero only (this is the default behavior),</li>
+<li><code class="sourceCode cpp"><span class="op">&lt;</span>space<span class="op">&gt;</span></code>
+indicates that a leading space should be used for non-negative numbers
+other than negative zero, and a minus sign for negative numbers and
+negative zero.</li>
 </ul>
-<p><code class="sourceCode default">precision</code> token is allowed
-only for floating-point representation types:</p>
+<p><code class="sourceCode cpp">precision</code> token is allowed only
+for floating-point representation types:</p>
 <div class="sourceCode" id="cb190"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb190-1"><a href="#cb190-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[.0]}&quot;</span>, <span class="fl">1.2345</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 1 m</span></span>
 <span id="cb190-2"><a href="#cb190-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[.1]}&quot;</span>, <span class="fl">1.2345</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 1 m</span></span>
 <span id="cb190-3"><a href="#cb190-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[.2]}&quot;</span>, <span class="fl">1.2345</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 1.2 m</span></span>
@@ -5677,8 +5622,8 @@ <h4 data-number="15.4.4.3" id="formatting-of-the-quantity-numerical-value"><span
 <span id="cb190-5"><a href="#cb190-5" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[.0f]}&quot;</span>, <span class="fl">1.2345</span> <span class="op">*</span> m<span class="op">)</span>;  <span class="co">// 1 m</span></span>
 <span id="cb190-6"><a href="#cb190-6" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[.1f]}&quot;</span>, <span class="fl">1.2345</span> <span class="op">*</span> m<span class="op">)</span>;  <span class="co">// 1.2 m</span></span>
 <span id="cb190-7"><a href="#cb190-7" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[.2f]}&quot;</span>, <span class="fl">1.2345</span> <span class="op">*</span> m<span class="op">)</span>;  <span class="co">// 1.23 m</span></span></code></pre></div>
-<p><code class="sourceCode default">type</code> specifies how a value of
-the representation type is being printed. For integral types:</p>
+<p><code class="sourceCode cpp">type</code> specifies how a value of the
+representation type is being printed. For integral types:</p>
 <div class="sourceCode" id="cb191"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb191-1"><a href="#cb191-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[b]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;    <span class="co">// 101010 m</span></span>
 <span id="cb191-2"><a href="#cb191-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[B]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;    <span class="co">// 101010 m</span></span>
 <span id="cb191-3"><a href="#cb191-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[d]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;    <span class="co">// 42 m</span></span>
@@ -5686,14 +5631,14 @@ <h4 data-number="15.4.4.3" id="formatting-of-the-quantity-numerical-value"><span
 <span id="cb191-5"><a href="#cb191-5" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[x]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;    <span class="co">// 2a m</span></span>
 <span id="cb191-6"><a href="#cb191-6" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[X]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;    <span class="co">// 2A m</span></span></code></pre></div>
 <p>The above can be printed in an alternate version thanks to the
-<code class="sourceCode default">#</code> token:</p>
+<code class="sourceCode cpp"><span class="er">#</span></code> token:</p>
 <div class="sourceCode" id="cb192"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb192-1"><a href="#cb192-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[#b]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 0b101010 m</span></span>
 <span id="cb192-2"><a href="#cb192-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[#B]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 0B101010 m</span></span>
 <span id="cb192-3"><a href="#cb192-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[#o]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 052 m</span></span>
 <span id="cb192-4"><a href="#cb192-4" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[#x]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 0x2a m</span></span>
 <span id="cb192-5"><a href="#cb192-5" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[#X]}&quot;</span>, <span class="dv">42</span> <span class="op">*</span> m<span class="op">)</span>;   <span class="co">// 0X2A m</span></span></code></pre></div>
 <p>For floating-point values, the
-<code class="sourceCode default">type</code> token works as follows:</p>
+<code class="sourceCode cpp">type</code> token works as follows:</p>
 <div class="sourceCode" id="cb193"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb193-1"><a href="#cb193-1" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[a]}&quot;</span>,   <span class="fl">1.2345678</span> <span class="op">*</span> m<span class="op">)</span>;      <span class="co">// 1.3c0ca2a5b1d5dp+0 m</span></span>
 <span id="cb193-2"><a href="#cb193-2" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[.3a]}&quot;</span>, <span class="fl">1.2345678</span> <span class="op">*</span> m<span class="op">)</span>;      <span class="co">// 1.3c1p+0 m</span></span>
 <span id="cb193-3"><a href="#cb193-3" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>println<span class="op">(</span><span class="st">&quot;{::N[A]}&quot;</span>,   <span class="fl">1.2345678</span> <span class="op">*</span> m<span class="op">)</span>;      <span class="co">// 1.3C0CA2A5B1D5DP+0 m</span></span>
@@ -5722,34 +5667,34 @@ <h2 data-number="15.5" id="quantity-point-text-output"><span class="header-secti
 many ways to do it. For example, should we prepend or append the origin
 part to the quantity text?</p>
 <p>For example, the text output of
-<code class="sourceCode default">42 m</code> for a quantity point may
-mean many things. It may be an offset from the mountain top, sea level,
-or maybe the center of Mars. Printing
-<code class="sourceCode default">42 m AMSL</code> for altitudes above
-mean sea level is a much better solution, but the library does not have
-enough information to print it that way by itself.</p>
+<code class="sourceCode cpp"><span class="dv">42</span> m</code> for a
+quantity point may mean many things. It may be an offset from the
+mountain top, sea level, or maybe the center of Mars. Printing
+<code class="sourceCode cpp"><span class="dv">42</span> m AMSL</code>
+for altitudes above mean sea level is a much better solution, but the
+library does not have enough information to print it that way by
+itself.</p>
 <h2 data-number="15.6" id="text-output-open-questions"><span class="header-section-number">15.6</span> Text output open questions<a href="#text-output-open-questions" class="self-link"></a></h2>
 <ol type="1">
 <li>Should we somehow provide text support for quantity points? What
 about temperatures?</li>
 <li>Are we OK with no text output support of quantity types?</li>
-<li>How to name a non-Unicode accessor member function (e.g.,
-<code class="sourceCode default">.ascii()</code>)? The same name
-should</li>
-<li>Should <code class="sourceCode default">unit_symbol()</code> and
-<code class="sourceCode default">dimension_symbol()</code> return
-<code class="sourceCode default">std::string_view</code> or
-<code class="sourceCode default">basic_fixed_string</code>?</li>
+<li>How to name a non-Unicode accessor member function (e.g., <code class="sourceCode cpp"><span class="op">.</span>ascii<span class="op">()</span></code>)?
+The same name should</li>
+<li>Should <code class="sourceCode cpp">unit_symbol<span class="op">()</span></code> and
+<code class="sourceCode cpp">dimension_symbol<span class="op">()</span></code>
+return <code class="sourceCode cpp">std<span class="op">::</span>string_view</code>
+or <code class="sourceCode cpp">basic_fixed_string</code>?</li>
 <li>What about the localization for units? Will we get something like
 ICU in the C++ standard? consistently be used in
-<code class="sourceCode default">text_encoding</code> and in the
-formatting grammar.</li>
+<code class="sourceCode cpp">text_encoding</code> and in the formatting
+grammar.</li>
 <li>Do we care about ostreams enough to introduce custom manipulators to
 format dimensions and units?</li>
-<li><code class="sourceCode default">std::chrono::duration</code> uses
-‘Q’ and ‘q’ for a number and a unit. In the grammar above, we proposed
-using ‘N’ and ‘U’ for them, respectively. We also introduced ‘D’ for
-dimensions. Are we OK with this?</li>
+<li><code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>
+uses ‘Q’ and ‘q’ for a number and a unit. In the grammar above, we
+proposed using ‘N’ and ‘U’ for them, respectively. We also introduced
+‘D’ for dimensions. Are we OK with this?</li>
 <li>Are we OK with the usage of ’_’ for denoting a subscript
 identifier?</li>
 </ol>
@@ -5760,12 +5705,10 @@ <h1 data-number="16" id="design-details-and-rationale"><span class="header-secti
 already.</em></p>
 <h2 data-number="16.1" id="conventions"><span class="header-section-number">16.1</span> Conventions<a href="#conventions" class="self-link"></a></h2>
 <h3 data-number="16.1.1" id="new-style-of-definitions"><span class="header-section-number">16.1.1</span> New style of definitions<a href="#new-style-of-definitions" class="self-link"></a></h3>
-<p>The <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library
-decided to use a rather unusual pattern to define entities, but it
-proved really successful, and we got great feedback from users so
-far.</p>
-<p>Here is how we define metre and second <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>
-base units:</p>
+<p>The <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library decided to use a
+rather unusual pattern to define entities, but it proved really
+successful, and we got great feedback from users so far.</p>
+<p>Here is how we define metre and second <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> base units:</p>
 <div class="sourceCode" id="cb194"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb194-1"><a href="#cb194-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> metre <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;m&quot;</span>, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;&gt;</span> <span class="op">{}</span> metre;</span>
 <span id="cb194-2"><a href="#cb194-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> second <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;s&quot;</span>, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>time<span class="op">&gt;&gt;</span> <span class="op">{}</span> second;</span></code></pre></div>
 <p>Please note that the above reuses the same identifier for a type and
@@ -5793,12 +5736,12 @@ <h3 data-number="16.1.2" id="strong-types-instead-of-aliases"><span class="heade
 <h3 data-number="16.1.3" id="entities-composability"><span class="header-section-number">16.1.3</span> Entities composability<a href="#entities-composability" class="self-link"></a></h3>
 <p>Many physical units libraries (in C++ or any other programming
 language) assign strong types to library entities (e.g., derived units).
-While <code class="sourceCode default">metre_per_second</code> as a type
-may not look too scary, consider, for example, units of angular
-momentum. If we followed this path, its coherent unit would look like
-<code class="sourceCode default">kilogram_metre_sq_per_second</code>.
-Now, consider how many scaled versions of this unit you would predefine
-in the library to ensure that all users are happy with your choice? How
+While <code class="sourceCode cpp">metre_per_second</code> as a type may
+not look too scary, consider, for example, units of angular momentum. If
+we followed this path, its coherent unit would look like
+<code class="sourceCode cpp">kilogram_metre_sq_per_second</code>. Now,
+consider how many scaled versions of this unit you would predefine in
+the library to ensure that all users are happy with your choice? How
 expensive would it be from the implementation point of view? How
 expensive would it be to standardize?</p>
 <p>This is why, in this library, we put a strong requirement to make
@@ -5816,9 +5759,8 @@ <h3 data-number="16.1.3" id="entities-composability"><span class="header-section
 <span id="cb197-2"><a href="#cb197-2" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> q <span class="op">=</span> la_vector<span class="op">{</span><span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">3</span><span class="op">}</span> <span class="op">*</span> isq<span class="op">::</span>angular_momentum<span class="op">[</span>kg <span class="op">*</span> m2 <span class="op">/</span> s<span class="op">]</span>;</span></code></pre></div>
 <p>It is a much better solution. It is terse and easy to understand.
 Please also notice how easy it is to obtain any scaled version of such a
-unit (e.g.,
-<code class="sourceCode default">mg * square(mm) / min</code>) without
-having to introduce hundreds of types to predefine them.</p>
+unit (e.g., <code class="sourceCode cpp">mg <span class="op">*</span> square<span class="op">(</span>mm<span class="op">)</span> <span class="op">/</span> min</code>)
+without having to introduce hundreds of types to predefine them.</p>
 <h3 data-number="16.1.4" id="value-based-equations"><span class="header-section-number">16.1.4</span> Value-based equations<a href="#value-based-equations" class="self-link"></a></h3>
 <p>This library is based on C++20, significantly improving user
 experience. One such improvement is the usage of value-based
@@ -5828,8 +5770,9 @@ <h3 data-number="16.1.4" id="value-based-equations"><span class="header-section-
 the library using such value-based equations. This is a considerable
 improvement compared to what we can find in other physical units
 libraries or what we have to deal with when we want to write some
-equations for <code class="sourceCode default">std::ratio</code>.</p>
-<p>For example, below are a few definitions of the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> derived units showing the power of
+equations for
+<code class="sourceCode cpp">std<span class="op">::</span>ratio</code>.</p>
+<p>For example, below are a few definitions of the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> derived units showing the power of
 C++20 extensions to Non-Type Template Parameters, which allow us to
 directly pass a result of the value-based unit equation to a class
 template definition:</p>
@@ -5843,7 +5786,7 @@ <h2 data-number="16.2" id="framework-entities"><span class="header-section-numbe
 <p>Some of the entities were already introduced in the <a href="#quick-domain-introduction">Quick domain introduction</a> chapter.
 Below we describe the remaining ones.</p>
 <h3 data-number="16.2.1" id="quantity-character"><span class="header-section-number">16.2.1</span> Quantity character<a href="#quantity-character" class="self-link"></a></h3>
-<p><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> explicitly states that
+<p><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> explicitly states that
 quantities (even of the same kind) may have different characters:</p>
 <ul>
 <li>scalar,</li>
@@ -5851,15 +5794,14 @@ <h3 data-number="16.2.1" id="quantity-character"><span class="header-section-num
 <li>tensor.</li>
 </ul>
 <p>The quantity character in the library is implemented with the
-<code class="sourceCode default">quantity_character</code>
-enumeration:</p>
+<code class="sourceCode cpp">quantity_character</code> enumeration:</p>
 <div class="sourceCode" id="cb199"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb199-1"><a href="#cb199-1" aria-hidden="true" tabindex="-1"></a><span class="kw">enum</span> <span class="kw">class</span> quantity_character <span class="op">{</span> scalar, vector, tensor <span class="op">}</span>;</span></code></pre></div>
 <p>More information on quantity characters can be found in the
 [Character of a quantity] chapter.</p>
 <h3 data-number="16.2.2" id="quantity-specification"><span class="header-section-number">16.2.2</span> Quantity specification<a href="#quantity-specification" class="self-link"></a></h3>
-<p>Dimension is not enough to describe a quantity. This is why <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides hundreds of
+<p>Dimension is not enough to describe a quantity. This is why <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides hundreds of
 named quantity types. It turns out that there are many more quantity
-types in the ISQ than the named units in the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>.</p>
+types in the ISQ than the named units in the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>.</p>
 <p>This is why the library introduces a quantity specification entity
 that stores:</p>
 <ul>
@@ -5871,23 +5813,24 @@ <h3 data-number="16.2.2" id="quantity-specification"><span class="header-section
 </ul>
 <p>For example:</p>
 <ul>
-<li><code class="sourceCode default">isq::length</code>,
-<code class="sourceCode default">isq::mass</code>,
-<code class="sourceCode default">isq::time</code>,
-<code class="sourceCode default">isq::electric_current</code>,
-<code class="sourceCode default">isq::thermodynamic_temperature</code>,
-<code class="sourceCode default">isq::amount_of_substance</code>, and
-<code class="sourceCode default">isq::luminous_intensity</code> are the
-specifications of base quantities in the ISQ.</li>
-<li><code class="sourceCode default">isq::width</code>,
-<code class="sourceCode default">isq::height</code>,
-<code class="sourceCode default">isq::radius</code>, and
-<code class="sourceCode default">isq::position_vector</code> are only a
-few of many quantities of a kind length specified in the ISQ.</li>
-<li><code class="sourceCode default">isq::area</code>,
-<code class="sourceCode default">isq::speed</code>,
-<code class="sourceCode default">isq::moment_of_force</code> are only a
-few of many derived quantities provided in the ISQ.</li>
+<li><code class="sourceCode cpp">isq<span class="op">::</span>length</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>mass</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>time</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>electric_current</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>thermodynamic_temperature</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>amount_of_substance</code>,
+and <code class="sourceCode cpp">isq<span class="op">::</span>luminous_intensity</code>
+are the specifications of base quantities in the ISQ.</li>
+<li><code class="sourceCode cpp">isq<span class="op">::</span>width</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>height</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>radius</code>,
+and <code class="sourceCode cpp">isq<span class="op">::</span>position_vector</code>
+are only a few of many quantities of a kind length specified in the
+ISQ.</li>
+<li><code class="sourceCode cpp">isq<span class="op">::</span>area</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>speed</code>,
+<code class="sourceCode cpp">isq<span class="op">::</span>moment_of_force</code>
+are only a few of many derived quantities provided in the ISQ.</li>
 </ul>
 <h3 data-number="16.2.3" id="unit"><span class="header-section-number">16.2.3</span> Unit<a href="#unit" class="self-link"></a></h3>
 <p>A unit is a concrete amount of a quantity that allows us to measure
@@ -5895,23 +5838,24 @@ <h3 data-number="16.2.3" id="unit"><span class="header-section-number">16.2.3</s
 number being the ratio of the two quantities.</p>
 <p>For example:</p>
 <ul>
-<li><code class="sourceCode default">si::second</code>,
-<code class="sourceCode default">si::metre</code>,
-<code class="sourceCode default">si::kilogram</code>,
-<code class="sourceCode default">si::ampere</code>,
-<code class="sourceCode default">si::kelvin</code>,
-<code class="sourceCode default">si::mole</code>, and
-<code class="sourceCode default">si::candela</code> are the base units
-of the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>.</li>
-<li><code class="sourceCode default">si::kilo&lt;si::metre&gt;</code> is
-a prefixed unit of length.</li>
-<li><code class="sourceCode default">si::radian</code>,
-<code class="sourceCode default">si::newton</code>, and
-<code class="sourceCode default">si::watt</code> are examples of named
-derived units within the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>.</li>
-<li><code class="sourceCode default">non_si::minute</code> is an example
-of a scaled unit of time.</li>
-<li><code class="sourceCode default">si::si2019::speed_of_light_in_vacuum</code>
+<li><code class="sourceCode cpp">si<span class="op">::</span>second</code>,
+<code class="sourceCode cpp">si<span class="op">::</span>metre</code>,
+<code class="sourceCode cpp">si<span class="op">::</span>kilogram</code>,
+<code class="sourceCode cpp">si<span class="op">::</span>ampere</code>,
+<code class="sourceCode cpp">si<span class="op">::</span>kelvin</code>,
+<code class="sourceCode cpp">si<span class="op">::</span>mole</code>,
+and
+<code class="sourceCode cpp">si<span class="op">::</span>candela</code>
+are the base units of the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>.</li>
+<li><code class="sourceCode cpp">si<span class="op">::</span>kilo<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">&gt;</span></code>
+is a prefixed unit of length.</li>
+<li><code class="sourceCode cpp">si<span class="op">::</span>radian</code>,
+<code class="sourceCode cpp">si<span class="op">::</span>newton</code>,
+and <code class="sourceCode cpp">si<span class="op">::</span>watt</code>
+are examples of named derived units within the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>.</li>
+<li><code class="sourceCode cpp">non_si<span class="op">::</span>minute</code> is
+an example of a scaled unit of time.</li>
+<li><code class="sourceCode cpp">si<span class="op">::</span>si2019<span class="op">::</span>speed_of_light_in_vacuum</code>
 is a physical constant standardized by the SI in 2019.</li>
 </ul>
 <p><em>Note: In this library, physical constants are also implemented as
@@ -5921,8 +5865,8 @@ <h3 data-number="16.2.4" id="quantity-representation"><span class="header-sectio
 value of a quantity. Such a type should be of a specific quantity
 character provided in the quantity specification.</p>
 <p><em>Note: By default, all floating-point and integral (besides
-<code class="sourceCode default">bool</code>) types are treated as
-scalars.</em></p>
+<code class="sourceCode cpp"><span class="dt">bool</span></code>) types
+are treated as scalars.</em></p>
 <h3 data-number="16.2.5" id="point-origin"><span class="header-section-number">16.2.5</span> Point origin<a href="#point-origin" class="self-link"></a></h3>
 <p>In the affine space theory, the point origin specifies where the
 “zero” of our measurement’s scale is.</p>
@@ -5948,61 +5892,57 @@ <h2 data-number="16.3" id="concepts"><span class="header-section-number">16.3</s
 and granularity of them, so to have a better idea about the scope and
 look and feel of the library.</em></p>
 <p><em>Note 2: Initially, C++20 was meant to use
-<code class="sourceCode default">CamelCase</code> for all the concept
+<code class="sourceCode cpp">CamelCase</code> for all the concept
 identifiers. Frustratingly,
-<code class="sourceCode default">CamelCase</code> concepts got dropped
-from the C++ standard at the last moment before releasing C++20. Now, we
-are facing the predictable consequences of running out of names. As long
-as some concepts in the library could be easily named with a
-<code class="sourceCode default">standard_case</code> there are some
-that are hard to distinguish from the corresponding type names, such as
-<code class="sourceCode default">Quantity</code>,
-<code class="sourceCode default">QuantityPoint</code>,
-<code class="sourceCode default">QuantitySpec</code>, or
-<code class="sourceCode default">Reference</code>. This is why we
-decided to use <code class="sourceCode default">CamelCase</code>
-consistently for all the concept identifiers to make it clear when we
-are talking about a type or concept identifier. However, we are aware
-that this might be a temporary solution. In case the library gets
-standardized, we can expect the LEWG to bikeshed/rename all of the
-concept identifiers to a
-<code class="sourceCode default">standard_case</code>, even if it will
+<code class="sourceCode cpp">CamelCase</code> concepts got dropped from
+the C++ standard at the last moment before releasing C++20. Now, we are
+facing the predictable consequences of running out of names. As long as
+some concepts in the library could be easily named with a
+<code class="sourceCode cpp">standard_case</code> there are some that
+are hard to distinguish from the corresponding type names, such as
+<code class="sourceCode cpp">Quantity</code>,
+<code class="sourceCode cpp">QuantityPoint</code>,
+<code class="sourceCode cpp">QuantitySpec</code>, or
+<code class="sourceCode cpp">Reference</code>. This is why we decided to
+use <code class="sourceCode cpp">CamelCase</code> consistently for all
+the concept identifiers to make it clear when we are talking about a
+type or concept identifier. However, we are aware that this might be a
+temporary solution. In case the library gets standardized, we can expect
+the LEWG to bikeshed/rename all of the concept identifiers to a
+<code class="sourceCode cpp">standard_case</code>, even if it will
 result in a harder to understand code.</em></p>
-<h3 data-number="16.3.1" id="Dimension-concept"><span class="header-section-number">16.3.1</span>
-<code class="sourceCode default">Dimension&lt;T&gt; concept</code><a href="#Dimension-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">Dimension</code> concept matches a
+<h3 data-number="16.3.1" id="Dimension-concept"><span class="header-section-number">16.3.1</span> <code class="sourceCode cpp">Dimension<span class="op">&lt;</span>T<span class="op">&gt;</span> <span class="kw">concept</span></code><a href="#Dimension-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">Dimension</code> concept matches a
 dimension of either a base or derived quantity:</p>
 <ul>
 <li>Base dimensions are explicitly defined by the user by inheriting
 from the instantiation of a
-<code class="sourceCode default">base_dimension</code> class template.
-It should be instantiated with a unique symbol identifier describing
-this dimension in a specific system of quantities.</li>
+<code class="sourceCode cpp">base_dimension</code> class template. It
+should be instantiated with a unique symbol identifier describing this
+dimension in a specific system of quantities.</li>
 <li>Derived dimensions are implicitly created by the library’s framework
 based on the quantity equation provided in the quantity
 specification.</li>
 </ul>
-<h4 data-number="16.3.1.1" id="DimensionOf-concept"><span class="header-section-number">16.3.1.1</span>
-<code class="sourceCode default">DimensionOf&lt;T, V&gt;</code>
+<h4 data-number="16.3.1.1" id="DimensionOf-concept"><span class="header-section-number">16.3.1.1</span> <code class="sourceCode cpp">DimensionOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<a href="#DimensionOf-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">DimensionOf</code> concept is
-satisfied when both arguments satisfy a <a href="#Dimension-concept"><code class="sourceCode default">Dimension</code></a>
+<p><code class="sourceCode cpp">DimensionOf</code> concept is satisfied
+when both arguments satisfy a <a href="#Dimension-concept"><code class="sourceCode cpp">Dimension</code></a>
 concept and when they compare equal.</p>
-<h3 data-number="16.3.2" id="QuantitySpec-concept"><span class="header-section-number">16.3.2</span>
-<code class="sourceCode default">QuantitySpec&lt;T&gt; concept</code><a href="#QuantitySpec-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">QuantitySpec</code> concept matches
-all the quantity specifications including:</p>
+<h3 data-number="16.3.2" id="QuantitySpec-concept"><span class="header-section-number">16.3.2</span> <code class="sourceCode cpp">QuantitySpec<span class="op">&lt;</span>T<span class="op">&gt;</span> <span class="kw">concept</span></code><a href="#QuantitySpec-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">QuantitySpec</code> concept matches all
+the quantity specifications including:</p>
 <ul>
 <li>Base quantities defined by a user by inheriting from the
-<code class="sourceCode default">quantity_spec</code> class template
+<code class="sourceCode cpp">quantity_spec</code> class template
 instantiated with a base dimension argument.</li>
 <li>Derived named quantities defined by a user by inheriting from the
-<code class="sourceCode default">quantity_spec</code> class template
+<code class="sourceCode cpp">quantity_spec</code> class template
 instantiated with a result of a quantity equation passed as an
 argument.</li>
 <li>Other named quantities forming a hierarchy of quantities of the same
 kind defined by a user by inheriting from the
-<code class="sourceCode default">quantity_spec</code> class template
+<code class="sourceCode cpp">quantity_spec</code> class template
 instantiated with another “parent” quantity specification passed as an
 argument.</li>
 <li>Quantity kinds describing a family of mutually comparable
@@ -6010,20 +5950,19 @@ <h3 data-number="16.3.2" id="QuantitySpec-concept"><span class="header-section-n
 <li>Intermediate derived quantity specifications being a result of a
 quantity equations on other specifications.</li>
 </ul>
-<h4 data-number="16.3.2.1" id="QuantitySpecOf-concept"><span class="header-section-number">16.3.2.1</span>
-<code class="sourceCode default">QuantitySpecOf&lt;T, V&gt;</code>
+<h4 data-number="16.3.2.1" id="QuantitySpecOf-concept"><span class="header-section-number">16.3.2.1</span> <code class="sourceCode cpp">QuantitySpecOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<a href="#QuantitySpecOf-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">QuantitySpecOf</code> concept is
-satisfied when both arguments satisfy a <a href="#QuantitySpec-concept"><code class="sourceCode default">QuantitySpec</code></a>
-concept and when <code class="sourceCode default">T</code> is implicitly
-convertible to <code class="sourceCode default">V</code>.</p>
+<p><code class="sourceCode cpp">QuantitySpecOf</code> concept is
+satisfied when both arguments satisfy a <a href="#QuantitySpec-concept"><code class="sourceCode cpp">QuantitySpec</code></a>
+concept and when <code class="sourceCode cpp">T</code> is implicitly
+convertible to <code class="sourceCode cpp">V</code>.</p>
 <p>Additionally:</p>
 <ul>
-<li><code class="sourceCode default">T</code> should not be a nested
-quantity specification of <code class="sourceCode default">V</code></li>
-<li>either <code class="sourceCode default">T</code> is quantity kind or
-<code class="sourceCode default">V</code> should not be a nested
-quantity specification of <code class="sourceCode default">T</code></li>
+<li><code class="sourceCode cpp">T</code> should not be a nested
+quantity specification of <code class="sourceCode cpp">V</code></li>
+<li>either <code class="sourceCode cpp">T</code> is quantity kind or
+<code class="sourceCode cpp">V</code> should not be a nested quantity
+specification of <code class="sourceCode cpp">T</code></li>
 </ul>
 <p>Those additional conditions are required to make the following
 work:</p>
@@ -6032,147 +5971,140 @@ <h4 data-number="16.3.2.1" id="QuantitySpecOf-concept"><span class="header-secti
 <span id="cb200-3"><a href="#cb200-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>ReferenceOf<span class="op">&lt;</span>isq<span class="op">::</span>angular_measure<span class="op">[</span>si<span class="op">::</span>radian<span class="op">]</span>, dimensionless<span class="op">&gt;)</span>;</span>
 <span id="cb200-4"><a href="#cb200-4" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>ReferenceOf<span class="op">&lt;</span>one, isq<span class="op">::</span>angular_measure<span class="op">&gt;)</span>;</span>
 <span id="cb200-5"><a href="#cb200-5" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(!</span>ReferenceOf<span class="op">&lt;</span>dimensionless<span class="op">[</span>one<span class="op">]</span>, isq<span class="op">::</span>angular_measure<span class="op">&gt;)</span>;</span></code></pre></div>
-<h3 data-number="16.3.3" id="Unit-concept"><span class="header-section-number">16.3.3</span>
-<code class="sourceCode default">Unit&lt;T&gt;</code> concept<a href="#Unit-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">Unit</code> concept matches all the
+<h3 data-number="16.3.3" id="Unit-concept"><span class="header-section-number">16.3.3</span> <code class="sourceCode cpp">Unit<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
+concept<a href="#Unit-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">Unit</code> concept matches all the
 units in the library including:</p>
 <ul>
 <li>Base units defined by a user by inheriting from the
-<code class="sourceCode default">named_unit</code> class template
+<code class="sourceCode cpp">named_unit</code> class template
 instantiated with a unique symbol identifier describing this unit in a
 specific system of units.</li>
 <li>Named scaled units defined by a user by inheriting from the
-<code class="sourceCode default">named_unit</code> class template
+<code class="sourceCode cpp">named_unit</code> class template
 instantiated with a unique symbol identifier and a product of
 multiplying another unit with some magnitude.</li>
 <li>Prefixed units defined by a user by inheriting from the
-<code class="sourceCode default">prefixed_unit</code> class template
+<code class="sourceCode cpp">prefixed_unit</code> class template
 instantiated with a prefix symbol, a magnitude, and a unit to be
 prefixed.</li>
 <li>Derived named units defined by a user by inheriting from the
-<code class="sourceCode default">named_unit</code> class template
+<code class="sourceCode cpp">named_unit</code> class template
 instantiated with a unique symbol identifier and a result of unit
 equation passed as an argument.</li>
 <li>Derived unnamed units being a result of a unit equations on other
 units.</li>
 </ul>
 <p><em>Note: Physical constants are also implemented as units.</em></p>
-<h4 data-number="16.3.3.1" id="AssociatedUnit-concept"><span class="header-section-number">16.3.3.1</span>
-<code class="sourceCode default">AssociatedUnit&lt;T&gt;</code>
+<h4 data-number="16.3.3.1" id="AssociatedUnit-concept"><span class="header-section-number">16.3.3.1</span> <code class="sourceCode cpp">AssociatedUnit<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<a href="#AssociatedUnit-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">AssociatedUnit</code> concept
-describes a unit with an associated quantity and is satisfied by:</p>
+<p><code class="sourceCode cpp">AssociatedUnit</code> concept describes
+a unit with an associated quantity and is satisfied by:</p>
 <ul>
 <li>All units derived from a
-<code class="sourceCode default">named_unit</code> class template
-instantiated with a unique symbol identifier and a <a href="#QuantitySpec-concept"><code class="sourceCode default">QuantitySpec</code></a>
+<code class="sourceCode cpp">named_unit</code> class template
+instantiated with a unique symbol identifier and a <a href="#QuantitySpec-concept"><code class="sourceCode cpp">QuantitySpec</code></a>
 of a quantity kind.</li>
 <li>All units being a result of unit equations on other associated
 units.</li>
 </ul>
-<p>All units in the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> have associated
-quantities. For example,
-<code class="sourceCode default">si::second</code> is specified to
-measure <code class="sourceCode default">isq::time</code>.</p>
+<p>All units in the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> have associated quantities. For
+example,
+<code class="sourceCode cpp">si<span class="op">::</span>second</code>
+is specified to measure
+<code class="sourceCode cpp">isq<span class="op">::</span>time</code>.</p>
 <p>Natural units typically do not have an associated quantity. For
-example, if we assume <code class="sourceCode default">c = 1</code>, a
-<code class="sourceCode default">natural::second</code> unit can be used
-to measure both <code class="sourceCode default">time</code> and
-<code class="sourceCode default">length</code>. In such case,
-<code class="sourceCode default">speed</code> would have a unit of
-<code class="sourceCode default">one</code>.</p>
-<h4 data-number="16.3.3.2" id="PrefixableUnit-concept"><span class="header-section-number">16.3.3.2</span>
-<code class="sourceCode default">PrefixableUnit&lt;T&gt;</code>
+example, if we assume <code class="sourceCode cpp">c <span class="op">=</span> <span class="dv">1</span></code>,
+a <code class="sourceCode cpp">natural<span class="op">::</span>second</code>
+unit can be used to measure both
+<code class="sourceCode cpp">time</code> and
+<code class="sourceCode cpp">length</code>. In such case,
+<code class="sourceCode cpp">speed</code> would have a unit of
+<code class="sourceCode cpp">one</code>.</p>
+<h4 data-number="16.3.3.2" id="PrefixableUnit-concept"><span class="header-section-number">16.3.3.2</span> <code class="sourceCode cpp">PrefixableUnit<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<a href="#PrefixableUnit-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">PrefixableUnit</code> concept is
+<p><code class="sourceCode cpp">PrefixableUnit</code> concept is
 satisfied by all units derived from a
-<code class="sourceCode default">named_unit</code> class template for
-which a customization point
-<code class="sourceCode default">unit_can_be_prefixed&lt;T{}&gt;</code>
-was not explicitly set to <code class="sourceCode default">false</code>.
-Such units can be passed as an argument to a
-<code class="sourceCode default">prefixed_unit</code> class
-template.</p>
-<p>All units in the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> can be prefixed with
-SI-defined prefixes.</p>
+<code class="sourceCode cpp">named_unit</code> class template for which
+a customization point <code class="sourceCode cpp">unit_can_be_prefixed<span class="op">&lt;</span>T<span class="op">{}&gt;</span></code>
+was not explicitly set to
+<code class="sourceCode cpp"><span class="kw">false</span></code>. Such
+units can be passed as an argument to a
+<code class="sourceCode cpp">prefixed_unit</code> class template.</p>
+<p>All units in the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> can be prefixed with SI-defined
+prefixes.</p>
 <p>Some off-system units like
-<code class="sourceCode default">non_si::day</code> can’t be prefixed.
-To enforce that, the following has to be provided:</p>
+<code class="sourceCode cpp">non_si<span class="op">::</span>day</code>
+can’t be prefixed. To enforce that, the following has to be
+provided:</p>
 <div class="sourceCode" id="cb201"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb201-1"><a href="#cb201-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;&gt;</span> <span class="kw">inline</span> <span class="kw">constexpr</span> <span class="dt">bool</span> unit_can_be_prefixed<span class="op">&lt;</span>non_si<span class="op">::</span>day<span class="op">&gt;</span> <span class="op">=</span> <span class="kw">false</span>;</span></code></pre></div>
-<h4 data-number="16.3.3.3" id="UnitOf-concept"><span class="header-section-number">16.3.3.3</span>
-<code class="sourceCode default">UnitOf&lt;T, V&gt;</code> concept<a href="#UnitOf-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">UnitOf</code> concept is satisfied
-for all units <code class="sourceCode default">T</code> matching an <a href="#AssociatedUnit-concept"><code class="sourceCode default">AssociatedUnit</code></a>
+<h4 data-number="16.3.3.3" id="UnitOf-concept"><span class="header-section-number">16.3.3.3</span> <code class="sourceCode cpp">UnitOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
+concept<a href="#UnitOf-concept" class="self-link"></a></h4>
+<p><code class="sourceCode cpp">UnitOf</code> concept is satisfied for
+all units <code class="sourceCode cpp">T</code> matching an <a href="#AssociatedUnit-concept"><code class="sourceCode cpp">AssociatedUnit</code></a>
 concept with an associated quantity type implicitly convertible to
-<code class="sourceCode default">V</code>.</p>
-<p>Additionally, the kind of <code class="sourceCode default">V</code>
-and the kind of quantity type associated with
-<code class="sourceCode default">T</code> must be the same, or the
-quantity type associated with <code class="sourceCode default">T</code>
-may not be derived from the kind of
-<code class="sourceCode default">V</code>.</p>
-<p>This condition is required to make
-<code class="sourceCode default">dimensionless[si::radian]</code>
-invalid as <code class="sourceCode default">si::radian</code> should be
-only used for
-<code class="sourceCode default">isq::angular_measure</code>, which is a
-nested quantity kind within the dimensionless quantities tree.</p>
-<h4 data-number="16.3.3.4" id="UnitCompatibleWith-concept"><span class="header-section-number">16.3.3.4</span> <code class="sourceCode default">UnitCompatibleWith&lt;T, V1, V2&gt;</code>
+<code class="sourceCode cpp">V</code>.</p>
+<p>Additionally, the kind of <code class="sourceCode cpp">V</code> and
+the kind of quantity type associated with
+<code class="sourceCode cpp">T</code> must be the same, or the quantity
+type associated with <code class="sourceCode cpp">T</code> may not be
+derived from the kind of <code class="sourceCode cpp">V</code>.</p>
+<p>This condition is required to make <code class="sourceCode cpp">dimensionless<span class="op">[</span>si<span class="op">::</span>radian<span class="op">]</span></code>
+invalid as
+<code class="sourceCode cpp">si<span class="op">::</span>radian</code>
+should be only used for <code class="sourceCode cpp">isq<span class="op">::</span>angular_measure</code>,
+which is a nested quantity kind within the dimensionless quantities
+tree.</p>
+<h4 data-number="16.3.3.4" id="UnitCompatibleWith-concept"><span class="header-section-number">16.3.3.4</span> <code class="sourceCode cpp">UnitCompatibleWith<span class="op">&lt;</span>T, V1, V2<span class="op">&gt;</span></code>
 concept<a href="#UnitCompatibleWith-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">UnitCompatibleWith</code> concept is
-satisfied for all units <code class="sourceCode default">T</code>
-when:</p>
-<ul>
-<li><code class="sourceCode default">V1</code> is a <a href="#Unit-concept"><code class="sourceCode default">Unit</code></a>,</li>
-<li><code class="sourceCode default">V2</code> is a <a href="#QuantitySpec-concept"><code class="sourceCode default">QuantitySpec</code></a>,</li>
-<li><code class="sourceCode default">T</code> and
-<code class="sourceCode default">V1</code> are defined in terms of the
-same reference unit,</li>
-<li>if <code class="sourceCode default">T</code> is an <a href="#AssociatedUnit-concept"><code class="sourceCode default">AssociatedUnit</code></a>
-it should satisfy <a href="#UnitOf-concept"><code class="sourceCode default">UnitOf&lt;V2&gt;</code></a>.</li>
+<p><code class="sourceCode cpp">UnitCompatibleWith</code> concept is
+satisfied for all units <code class="sourceCode cpp">T</code> when:</p>
+<ul>
+<li><code class="sourceCode cpp">V1</code> is a <a href="#Unit-concept"><code class="sourceCode cpp">Unit</code></a>,</li>
+<li><code class="sourceCode cpp">V2</code> is a <a href="#QuantitySpec-concept"><code class="sourceCode cpp">QuantitySpec</code></a>,</li>
+<li><code class="sourceCode cpp">T</code> and
+<code class="sourceCode cpp">V1</code> are defined in terms of the same
+reference unit,</li>
+<li>if <code class="sourceCode cpp">T</code> is an <a href="#AssociatedUnit-concept"><code class="sourceCode cpp">AssociatedUnit</code></a>
+it should satisfy <a href="#UnitOf-concept"><code class="sourceCode cpp">UnitOf<span class="op">&lt;</span>V2<span class="op">&gt;</span></code></a>.</li>
 </ul>
-<h3 data-number="16.3.4" id="Reference-concept"><span class="header-section-number">16.3.4</span>
-<code class="sourceCode default">Reference&lt;T&gt;</code> concept<a href="#Reference-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">Reference</code> concept is
-satisfied by all quantity reference types. Such types provide all the
-meta-information required to create a <a href="#Quantity-concept"><code class="sourceCode default">Quantity</code></a>.</p>
-<p>A <code class="sourceCode default">Reference</code> can either
-be:</p>
-<ul>
-<li>An <a href="#AssociatedUnit-concept"><code class="sourceCode default">AssociatedUnit</code></a>.</li>
-<li>The instantiation of a
-<code class="sourceCode default">reference</code> class template with a
-<a href="#QuantitySpec-concept"><code class="sourceCode default">QuantitySpec</code></a>
-passed as the first template argument and a <a href="#Unit-concept"><code class="sourceCode default">Unit</code></a>
-passed as the second one.</li>
+<h3 data-number="16.3.4" id="Reference-concept"><span class="header-section-number">16.3.4</span> <code class="sourceCode cpp">Reference<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
+concept<a href="#Reference-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">Reference</code> concept is satisfied by
+all quantity reference types. Such types provide all the
+meta-information required to create a <a href="#Quantity-concept"><code class="sourceCode cpp">Quantity</code></a>.</p>
+<p>A <code class="sourceCode cpp">Reference</code> can either be:</p>
+<ul>
+<li>An <a href="#AssociatedUnit-concept"><code class="sourceCode cpp">AssociatedUnit</code></a>.</li>
+<li>The instantiation of a <code class="sourceCode cpp">reference</code>
+class template with a <a href="#QuantitySpec-concept"><code class="sourceCode cpp">QuantitySpec</code></a>
+passed as the first template argument and a <a href="#Unit-concept"><code class="sourceCode cpp">Unit</code></a> passed
+as the second one.</li>
 </ul>
-<h4 data-number="16.3.4.1" id="ReferenceOf-concept"><span class="header-section-number">16.3.4.1</span>
-<code class="sourceCode default">ReferenceOf&lt;T, V&gt;</code>
+<h4 data-number="16.3.4.1" id="ReferenceOf-concept"><span class="header-section-number">16.3.4.1</span> <code class="sourceCode cpp">ReferenceOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<a href="#ReferenceOf-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">ReferenceOf</code> concept is
-satisfied by references <code class="sourceCode default">T</code> which
-have a quantity specification that satisfies <a href="#QuantitySpecOf-concept"><code class="sourceCode default">QuantitySpecOf&lt;V&gt;</code></a>
+<p><code class="sourceCode cpp">ReferenceOf</code> concept is satisfied
+by references <code class="sourceCode cpp">T</code> which have a
+quantity specification that satisfies <a href="#QuantitySpecOf-concept"><code class="sourceCode cpp">QuantitySpecOf<span class="op">&lt;</span>V<span class="op">&gt;</span></code></a>
 concept. |</p>
-<h3 data-number="16.3.5" id="Representation-concept"><span class="header-section-number">16.3.5</span>
-<code class="sourceCode default">Representation&lt;T&gt;</code>
+<h3 data-number="16.3.5" id="Representation-concept"><span class="header-section-number">16.3.5</span> <code class="sourceCode cpp">Representation<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<a href="#Representation-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">Representation</code> concept
+<p><code class="sourceCode cpp">Representation</code> concept
 constraints a type of a number that stores the value of a quantity.</p>
-<h4 data-number="16.3.5.1" id="RepresentationOf-concept"><span class="header-section-number">16.3.5.1</span>
-<code class="sourceCode default">RepresentationOf&lt;T, Ch&gt;</code>
+<h4 data-number="16.3.5.1" id="RepresentationOf-concept"><span class="header-section-number">16.3.5.1</span> <code class="sourceCode cpp">RepresentationOf<span class="op">&lt;</span>T, Ch<span class="op">&gt;</span></code>
 concept<a href="#RepresentationOf-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">RepresentationOf</code> concept is
-satisfied by all <a href="#Representation-concept"><code class="sourceCode default">Representation</code></a>
+<p><code class="sourceCode cpp">RepresentationOf</code> concept is
+satisfied by all <a href="#Representation-concept"><code class="sourceCode cpp">Representation</code></a>
 types that are of a specified quantity character
-<code class="sourceCode default">Ch</code>.</p>
+<code class="sourceCode cpp">Ch</code>.</p>
 <p>A user can declare a custom representation type to be of a specific
 character by providing the specialization with
-<code class="sourceCode default">true</code> for one or more of the
-following variable templates:</p>
+<code class="sourceCode cpp"><span class="kw">true</span></code> for one
+or more of the following variable templates:</p>
 <ul>
-<li><code class="sourceCode default">is_scalar&lt;T&gt;</code></li>
-<li><code class="sourceCode default">is_vector&lt;T&gt;</code></li>
-<li><code class="sourceCode default">is_tensor&lt;T&gt;</code></li>
+<li><code class="sourceCode cpp">is_scalar<span class="op">&lt;</span>T<span class="op">&gt;</span></code></li>
+<li><code class="sourceCode cpp">is_vector<span class="op">&lt;</span>T<span class="op">&gt;</span></code></li>
+<li><code class="sourceCode cpp">is_tensor<span class="op">&lt;</span>T<span class="op">&gt;</span></code></li>
 </ul>
 <p>If we want to use scalar types to also express vector quantities
 (e.g., ignoring the “direction” of the vector) the following definition
@@ -6180,69 +6112,63 @@ <h4 data-number="16.3.5.1" id="RepresentationOf-concept"><span class="header-sec
 <div class="sourceCode" id="cb202"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb202-1"><a href="#cb202-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
 <span id="cb202-2"><a href="#cb202-2" aria-hidden="true" tabindex="-1"></a>  <span class="kw">requires</span> is_scalar<span class="op">&lt;</span>T<span class="op">&gt;</span></span>
 <span id="cb202-3"><a href="#cb202-3" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_vector<span class="op">&lt;</span>T<span class="op">&gt;</span> <span class="op">=</span> <span class="kw">true</span>;</span></code></pre></div>
-<h3 data-number="16.3.6" id="Quantity-concept"><span class="header-section-number">16.3.6</span>
-<code class="sourceCode default">Quantity&lt;T&gt;</code> concept<a href="#Quantity-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">Quantity</code> concept matches
-every quantity in the library and is satisfied by all types being or
-deriving from an instantiation of a
-<code class="sourceCode default">quantity</code> class template.</p>
-<h4 data-number="16.3.6.1" id="QuantityOf-concept"><span class="header-section-number">16.3.6.1</span>
-<code class="sourceCode default">QuantityOf&lt;T, V&gt;</code> concept<a href="#QuantityOf-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">QuantityOf</code> concept is
-satisfied by all the quantities for which a <a href="#QuantitySpecOf-concept"><code class="sourceCode default">QuantitySpecOf&lt;V&gt;</code></a>
-is <code class="sourceCode default">true</code>.</p>
-<h3 data-number="16.3.7" id="PointOrigin-concept"><span class="header-section-number">16.3.7</span>
-<code class="sourceCode default">PointOrigin&lt;T&gt;</code> concept<a href="#PointOrigin-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">PointOrigin</code> concept matches
-all quantity point origins in the library. It is satisfied by
-either:</p>
+<h3 data-number="16.3.6" id="Quantity-concept"><span class="header-section-number">16.3.6</span> <code class="sourceCode cpp">Quantity<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
+concept<a href="#Quantity-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">Quantity</code> concept matches every
+quantity in the library and is satisfied by all types being or deriving
+from an instantiation of a <code class="sourceCode cpp">quantity</code>
+class template.</p>
+<h4 data-number="16.3.6.1" id="QuantityOf-concept"><span class="header-section-number">16.3.6.1</span> <code class="sourceCode cpp">QuantityOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
+concept<a href="#QuantityOf-concept" class="self-link"></a></h4>
+<p><code class="sourceCode cpp">QuantityOf</code> concept is satisfied
+by all the quantities for which a <a href="#QuantitySpecOf-concept"><code class="sourceCode cpp">QuantitySpecOf<span class="op">&lt;</span>V<span class="op">&gt;</span></code></a>
+is <code class="sourceCode cpp"><span class="kw">true</span></code>.</p>
+<h3 data-number="16.3.7" id="PointOrigin-concept"><span class="header-section-number">16.3.7</span> <code class="sourceCode cpp">PointOrigin<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
+concept<a href="#PointOrigin-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">PointOrigin</code> concept matches all
+quantity point origins in the library. It is satisfied by either:</p>
 <ul>
 <li>All types derived from an
-<code class="sourceCode default">absolute_point_origin</code> class
+<code class="sourceCode cpp">absolute_point_origin</code> class
 template.</li>
 <li>All types derived from a
-<code class="sourceCode default">relative_point_origin</code> class
+<code class="sourceCode cpp">relative_point_origin</code> class
 template.</li>
 </ul>
-<h4 data-number="16.3.7.1" id="PointOriginFor-concept"><span class="header-section-number">16.3.7.1</span>
-<code class="sourceCode default">PointOriginFor&lt;T, V&gt;</code>
+<h4 data-number="16.3.7.1" id="PointOriginFor-concept"><span class="header-section-number">16.3.7.1</span> <code class="sourceCode cpp">PointOriginFor<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<a href="#PointOriginFor-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">PointOriginFor</code> concept is
-satisfied by all <a href="#PointOrigin-concept"><code class="sourceCode default">PointOrigin</code></a>
+<p><code class="sourceCode cpp">PointOriginFor</code> concept is
+satisfied by all <a href="#PointOrigin-concept"><code class="sourceCode cpp">PointOrigin</code></a>
 types that have quantity type implicitly convertible from quantity
-specification <code class="sourceCode default">V</code>, which means
-that <code class="sourceCode default">V</code> must satisfy <a href="#QuantitySpecOf-concept"><code class="sourceCode default">QuantitySpecOf&lt;T::quantity_spec&gt;</code></a>.</p>
-<p>For example, <code class="sourceCode default">si::ice_point</code>
-can serve as a point origin for <em>points</em> of
-<code class="sourceCode default">isq::Celsius_temperature</code> because
-this quantity type implicitly converts to
-<code class="sourceCode default">isq::thermodynamic_temperature</code>.</p>
+specification <code class="sourceCode cpp">V</code>, which means that
+<code class="sourceCode cpp">V</code> must satisfy <a href="#QuantitySpecOf-concept"><code class="sourceCode cpp">QuantitySpecOf<span class="op">&lt;</span>T<span class="op">::</span>quantity_spec<span class="op">&gt;</span></code></a>.</p>
+<p>For example, <code class="sourceCode cpp">si<span class="op">::</span>ice_point</code> can
+serve as a point origin for <em>points</em> of <code class="sourceCode cpp">isq<span class="op">::</span>Celsius_temperature</code>
+because this quantity type implicitly converts to <code class="sourceCode cpp">isq<span class="op">::</span>thermodynamic_temperature</code>.</p>
 <p>However, if we define
-<code class="sourceCode default">mean_sea_level</code> in the following
+<code class="sourceCode cpp">mean_sea_level</code> in the following
 way:</p>
 <div class="sourceCode" id="cb203"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb203-1"><a href="#cb203-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> mean_sea_level <span class="op">:</span> absolute_point_origin<span class="op">&lt;</span>isq<span class="op">::</span>altitude<span class="op">&gt;</span> <span class="op">{}</span> mean_sea_level;</span></code></pre></div>
 <p>then it can’t be used as a point origin for <em>points</em> of
-<code class="sourceCode default">isq::length</code> or
-<code class="sourceCode default">isq::width</code> as none of them is
-implicitly convertible to
-<code class="sourceCode default">isq::altitude</code>:</p>
+<code class="sourceCode cpp">isq<span class="op">::</span>length</code>
+or
+<code class="sourceCode cpp">isq<span class="op">::</span>width</code>
+as none of them is implicitly convertible to <code class="sourceCode cpp">isq<span class="op">::</span>altitude</code>:</p>
 <ul>
 <li>not every <em>length</em> is an <em>altitude</em>,</li>
 <li><em>width</em> is not compatible with <em>altitude</em>.</li>
 </ul>
-<h3 data-number="16.3.8" id="QuantityPoint-concept"><span class="header-section-number">16.3.8</span>
-<code class="sourceCode default">QuantityPoint&lt;T&gt;</code> concept<a href="#QuantityPoint-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">QuantityPoint</code> concept is
+<h3 data-number="16.3.8" id="QuantityPoint-concept"><span class="header-section-number">16.3.8</span> <code class="sourceCode cpp">QuantityPoint<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
+concept<a href="#QuantityPoint-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">QuantityPoint</code> concept is
 satisfied by all types being either a specialization or derived from
-<code class="sourceCode default">quantity_point</code> class
-template.</p>
-<h4 data-number="16.3.8.1" id="QuantityPointOf-concept"><span class="header-section-number">16.3.8.1</span>
-<code class="sourceCode default">QuantityPointOf&lt;T, V&gt;</code>
+<code class="sourceCode cpp">quantity_point</code> class template.</p>
+<h4 data-number="16.3.8.1" id="QuantityPointOf-concept"><span class="header-section-number">16.3.8.1</span> <code class="sourceCode cpp">QuantityPointOf<span class="op">&lt;</span>T, V<span class="op">&gt;</span></code>
 concept<a href="#QuantityPointOf-concept" class="self-link"></a></h4>
-<p><code class="sourceCode default">QuantityPointOf</code> concept is
+<p><code class="sourceCode cpp">QuantityPointOf</code> concept is
 satisfied by all the quantity points
-<code class="sourceCode default">T</code> that match the following value
-<code class="sourceCode default">V</code>:</p>
+<code class="sourceCode cpp">T</code> that match the following value
+<code class="sourceCode cpp">V</code>:</p>
 <table>
 <colgroup>
 <col style="width: 12%" />
@@ -6251,7 +6177,7 @@ <h4 data-number="16.3.8.1" id="QuantityPointOf-concept"><span class="header-sect
 <thead>
 <tr class="header">
 <th><div style="text-align:center">
-<strong><code class="sourceCode default">V</code></strong>
+<strong><code class="sourceCode cpp">V</code></strong>
 </div></th>
 <th><div style="text-align:center">
 <strong>Condition</strong>
@@ -6260,46 +6186,44 @@ <h4 data-number="16.3.8.1" id="QuantityPointOf-concept"><span class="header-sect
 </thead>
 <tbody>
 <tr class="odd">
-<td><code class="sourceCode default">QuantitySpec</code></td>
-<td>The quantity point quantity specification satisfies <a href="#QuantitySpecOf-concept"><code class="sourceCode default">QuantitySpecOf&lt;V&gt;</code></a>
+<td><code class="sourceCode cpp">QuantitySpec</code></td>
+<td>The quantity point quantity specification satisfies <a href="#QuantitySpecOf-concept"><code class="sourceCode cpp">QuantitySpecOf<span class="op">&lt;</span>V<span class="op">&gt;</span></code></a>
 concept.</td>
 </tr>
 <tr class="even">
-<td><code class="sourceCode default">PointOrigin</code></td>
-<td>The <em>point</em> and <code class="sourceCode default">V</code>
-have the same absolute point origin.</td>
+<td><code class="sourceCode cpp">PointOrigin</code></td>
+<td>The <em>point</em> and <code class="sourceCode cpp">V</code> have
+the same absolute point origin.</td>
 </tr>
 </tbody>
 </table>
-<h3 data-number="16.3.9" id="QuantityLike-concept"><span class="header-section-number">16.3.9</span>
-<code class="sourceCode default">QuantityLike&lt;T&gt;</code> concept<a href="#QuantityLike-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">QuantityLike</code> concept provides
+<h3 data-number="16.3.9" id="QuantityLike-concept"><span class="header-section-number">16.3.9</span> <code class="sourceCode cpp">QuantityLike<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
+concept<a href="#QuantityLike-concept" class="self-link"></a></h3>
+<p><code class="sourceCode cpp">QuantityLike</code> concept provides
 interoperability with other libraries and is satisfied by a type
-<code class="sourceCode default">T</code> for which an instantiation of
-<code class="sourceCode default">quantity_like_traits</code> type trait
+<code class="sourceCode cpp">T</code> for which an instantiation of
+<code class="sourceCode cpp">quantity_like_traits</code> type trait
 yields a valid type that provides:</p>
 <ul>
-<li>Static data member <code class="sourceCode default">reference</code>
-that matches the <a href="#Reference-concept"><code class="sourceCode default">Reference</code></a>
+<li>Static data member <code class="sourceCode cpp">reference</code>
+that matches the <a href="#Reference-concept"><code class="sourceCode cpp">Reference</code></a>
 concept,</li>
-<li><code class="sourceCode default">rep</code> type that matches <a href="#RepresentationOf-concept"><code class="sourceCode default">RepresentationOf</code></a>
+<li><code class="sourceCode cpp">rep</code> type that matches <a href="#RepresentationOf-concept"><code class="sourceCode cpp">RepresentationOf</code></a>
 concept with the character provided in
-<code class="sourceCode default">reference</code>.</li>
-<li><code class="sourceCode default">to_numerical_value(T)</code> static
-member function returning a raw value of the quantity packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper that
+<code class="sourceCode cpp">reference</code>.</li>
+<li><code class="sourceCode cpp">to_numerical_value<span class="op">(</span>T<span class="op">)</span></code>
+static member function returning a raw value of the quantity packed in
+either <code class="sourceCode cpp">convert_explicitly</code> or
+<code class="sourceCode cpp">convert_implicitly</code> wrapper that
 enables implicit conversion in the latter case.</li>
-<li><code class="sourceCode default">from_numerical_value(rep)</code>
-static member function returning
-<code class="sourceCode default">T</code> packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper that
+<li><code class="sourceCode cpp">from_numerical_value<span class="op">(</span>rep<span class="op">)</span></code>
+static member function returning <code class="sourceCode cpp">T</code>
+packed in either <code class="sourceCode cpp">convert_explicitly</code>
+or <code class="sourceCode cpp">convert_implicitly</code> wrapper that
 enables implicit conversion in the latter case.</li>
 </ul>
-<p>For example, this is how support for
-<code class="sourceCode default">std::chrono::seconds</code> can be
-provided:</p>
+<p>For example, this is how support for <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>seconds</code>
+can be provided:</p>
 <div class="sourceCode" id="cb204"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb204-1"><a href="#cb204-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;&gt;</span></span>
 <span id="cb204-2"><a href="#cb204-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> quantity_like_traits<span class="op">&lt;</span>std<span class="op">::</span>chrono<span class="op">::</span>seconds<span class="op">&gt;</span> <span class="op">{</span></span>
 <span id="cb204-3"><a href="#cb204-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="kw">auto</span> reference <span class="op">=</span> si<span class="op">::</span>second;</span>
@@ -6318,42 +6242,39 @@ <h3 data-number="16.3.9" id="QuantityLike-concept"><span class="header-section-n
 <span id="cb204-16"><a href="#cb204-16" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb204-17"><a href="#cb204-17" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> <span class="dv">42</span><span class="bu">s</span>;</span>
 <span id="cb204-18"><a href="#cb204-18" aria-hidden="true" tabindex="-1"></a>std<span class="op">::</span>chrono<span class="op">::</span>seconds dur <span class="op">=</span> <span class="dv">42</span> <span class="op">*</span> s;</span></code></pre></div>
-<h3 data-number="16.3.10" id="QuantityPointLike-concept"><span class="header-section-number">16.3.10</span>
-<code class="sourceCode default">QuantityPointLike&lt;T&gt;</code>
+<h3 data-number="16.3.10" id="QuantityPointLike-concept"><span class="header-section-number">16.3.10</span> <code class="sourceCode cpp">QuantityPointLike<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 concept<a href="#QuantityPointLike-concept" class="self-link"></a></h3>
-<p><code class="sourceCode default">QuantityPointLike</code> concept
+<p><code class="sourceCode cpp">QuantityPointLike</code> concept
 provides interoperability with other libraries and is satisfied by a
-type <code class="sourceCode default">T</code> for which an
-instantiation of
-<code class="sourceCode default">quantity_point_like_traits</code> type
+type <code class="sourceCode cpp">T</code> for which an instantiation of
+<code class="sourceCode cpp">quantity_point_like_traits</code> type
 trait yields a valid type that provides:</p>
 <ul>
-<li>Static data member <code class="sourceCode default">reference</code>
-that matches the <a href="#Reference-concept"><code class="sourceCode default">Reference</code></a>
+<li>Static data member <code class="sourceCode cpp">reference</code>
+that matches the <a href="#Reference-concept"><code class="sourceCode cpp">Reference</code></a>
 concept.</li>
-<li>Static data member
-<code class="sourceCode default">point_origin</code> that matches the <a href="#PointOrigin-concept"><code class="sourceCode default">PointOrigin</code></a>
+<li>Static data member <code class="sourceCode cpp">point_origin</code>
+that matches the <a href="#PointOrigin-concept"><code class="sourceCode cpp">PointOrigin</code></a>
 concept.</li>
-<li><code class="sourceCode default">rep</code> type that matches <a href="#RepresentationOf-concept"><code class="sourceCode default">RepresentationOf</code></a>
+<li><code class="sourceCode cpp">rep</code> type that matches <a href="#RepresentationOf-concept"><code class="sourceCode cpp">RepresentationOf</code></a>
 concept with the character provided in
-<code class="sourceCode default">reference</code>.</li>
-<li><code class="sourceCode default">to_quantity(T)</code> static member
-function returning the <code class="sourceCode default">quantity</code>
-being the offset of the point from the origin packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper that
+<code class="sourceCode cpp">reference</code>.</li>
+<li><code class="sourceCode cpp">to_quantity<span class="op">(</span>T<span class="op">)</span></code>
+static member function returning the
+<code class="sourceCode cpp">quantity</code> being the offset of the
+point from the origin packed in either
+<code class="sourceCode cpp">convert_explicitly</code> or
+<code class="sourceCode cpp">convert_implicitly</code> wrapper that
 enables implicit conversion in the latter case.</li>
-<li><code class="sourceCode default">from_quantity(quantity&lt;reference, rep&gt;)</code>
-static member function returning
-<code class="sourceCode default">T</code> packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper that
+<li><code class="sourceCode cpp">from_quantity<span class="op">(</span>quantity<span class="op">&lt;</span>reference, rep<span class="op">&gt;)</span></code>
+static member function returning <code class="sourceCode cpp">T</code>
+packed in either <code class="sourceCode cpp">convert_explicitly</code>
+or <code class="sourceCode cpp">convert_implicitly</code> wrapper that
 enables implicit conversion in the latter case.</li>
 </ul>
-<p>For eample, this is how support for a
-<code class="sourceCode default">std::chrono::time_point</code> of
-<code class="sourceCode default">std::chrono::seconds</code> can be
-provided:</p>
+<p>For eample, this is how support for a <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>time_point</code>
+of <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>seconds</code>
+can be provided:</p>
 <div class="sourceCode" id="cb205"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb205-1"><a href="#cb205-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">typename</span> C<span class="op">&gt;</span></span>
 <span id="cb205-2"><a href="#cb205-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> quantity_point_like_traits<span class="op">&lt;</span>std<span class="op">::</span>chrono<span class="op">::</span>time_point<span class="op">&lt;</span>C, std<span class="op">::</span>chrono<span class="op">::</span>seconds<span class="op">&gt;&gt;</span> <span class="op">{</span></span>
 <span id="cb205-3"><a href="#cb205-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">using</span> T <span class="op">=</span> std<span class="op">::</span>chrono<span class="op">::</span>time_point<span class="op">&lt;</span>C, std<span class="op">::</span>chrono<span class="op">::</span>seconds<span class="op">&gt;</span>;</span>
@@ -6384,46 +6305,34 @@ <h2 data-number="16.4" id="operations-on-units-dimensions-and-quantity-types"><s
 get proper types as results of such operations.</p>
 <p>The operations exposed by such a library should include at least:</p>
 <ul>
-<li>multiplication
-(e.g. <code class="sourceCode default">newton * metre</code>),</li>
-<li>division
-(e.g. <code class="sourceCode default">metre / second</code>),</li>
-<li>power
-(e.g. <code class="sourceCode default">pow&lt;2&gt;(metre)</code> or
-<code class="sourceCode default">pow&lt;1, 2&gt;(metre * metre)</code>).</li>
+<li>multiplication (e.g. <code class="sourceCode cpp">newton <span class="op">*</span> metre</code>),</li>
+<li>division (e.g. <code class="sourceCode cpp">metre <span class="op">/</span> second</code>),</li>
+<li>power (e.g. <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>metre<span class="op">)</span></code>
+or <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;(</span>metre <span class="op">*</span> metre<span class="op">)</span></code>).</li>
 </ul>
 <p>To improve the usability of the library, we also recommend
 adding:</p>
 <ul>
-<li>square root
-(e.g. <code class="sourceCode default">sqrt(metre * metre)</code> as
-equivalent to
-<code class="sourceCode default">pow&lt;1, 2&gt;(metre * metre)</code>),</li>
-<li>cubic root
-(e.g. <code class="sourceCode default">cbrt(metre * metre * metre)</code>
-as equivalent to <code class="sourceCode default">pow&lt;1, 3&gt;(metre * metre * metre)</code>),</li>
-<li>inversion
-(e.g. <code class="sourceCode default">inverse(second)</code> as
-equivalent to
-<code class="sourceCode default">one / second</code>).</li>
+<li>square root (e.g. <code class="sourceCode cpp">sqrt<span class="op">(</span>metre <span class="op">*</span> metre<span class="op">)</span></code>
+as equivalent to <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;(</span>metre <span class="op">*</span> metre<span class="op">)</span></code>),</li>
+<li>cubic root (e.g. <code class="sourceCode cpp">cbrt<span class="op">(</span>metre <span class="op">*</span> metre <span class="op">*</span> metre<span class="op">)</span></code>
+as equivalent to <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">3</span><span class="op">&gt;(</span>metre <span class="op">*</span> metre <span class="op">*</span> metre<span class="op">)</span></code>),</li>
+<li>inversion (e.g. <code class="sourceCode cpp">inverse<span class="op">(</span>second<span class="op">)</span></code>
+as equivalent to
+<code class="sourceCode cpp">one <span class="op">/</span> second</code>).</li>
 </ul>
 <p>Additionally, for units only, to improve the readability of the code,
 it makes sense to expose the following:</p>
 <ul>
-<li>square power
-(e.g. <code class="sourceCode default">square(metre)</code> is
-equivalent to
-<code class="sourceCode default">pow&lt;2&gt;(metre)</code>),</li>
-<li>cubic power
-(e.g. <code class="sourceCode default">cubic(metre)</code> is equivalent
-to <code class="sourceCode default">pow&lt;3&gt;(metre)</code>).</li>
+<li>square power (e.g. <code class="sourceCode cpp">square<span class="op">(</span>metre<span class="op">)</span></code>
+is equivalent to <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>metre<span class="op">)</span></code>),</li>
+<li>cubic power (e.g. <code class="sourceCode cpp">cubic<span class="op">(</span>metre<span class="op">)</span></code>
+is equivalent to <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">3</span><span class="op">&gt;(</span>metre<span class="op">)</span></code>).</li>
 </ul>
 <p>The above two functions could also be considered for dimensions and
-quantity types. However,
-<code class="sourceCode default">cubic(length)</code> does not seem to
-make much sense, and probably
-<code class="sourceCode default">pow&lt;3&gt;(length)</code> should be
-preferred instead.</p>
+quantity types. However, <code class="sourceCode cpp">cubic<span class="op">(</span>length<span class="op">)</span></code>
+does not seem to make much sense, and probably <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">3</span><span class="op">&gt;(</span>length<span class="op">)</span></code>
+should be preferred instead.</p>
 <h2 data-number="16.5" id="expression-templates"><span class="header-section-number">16.5</span> Expression templates<a href="#expression-templates" class="self-link"></a></h2>
 <p>Modern C++ physical quantities and units libraries use opaque types
 to improve the user experience while analyzing compile-time errors or
@@ -6442,15 +6351,15 @@ <h3 data-number="16.5.1" id="derived-entities"><span class="header-section-numbe
 <p>Let’s assume that we want to represent the results of the following
 two unit equations:</p>
 <ul>
-<li><code class="sourceCode default">metre / second * second</code></li>
-<li><code class="sourceCode default">metre * metre / metre</code></li>
+<li><code class="sourceCode cpp">metre <span class="op">/</span> second <span class="op">*</span> second</code></li>
+<li><code class="sourceCode cpp">metre <span class="op">*</span> metre <span class="op">/</span> metre</code></li>
 </ul>
 <p>Both of them should result in a type equivalent to
-<code class="sourceCode default">metre</code>. A general-purpose library
+<code class="sourceCode cpp">metre</code>. A general-purpose library
 will probably result with the types similar to the below:</p>
 <ul>
-<li><code class="sourceCode default">mul&lt;div&lt;metre, second&gt;, second&gt;</code></li>
-<li><code class="sourceCode default">div&lt;mul&lt;metre, metre&gt;, metre&gt;</code></li>
+<li><code class="sourceCode cpp">mul<span class="op">&lt;</span>div<span class="op">&lt;</span>metre, second<span class="op">&gt;</span>, second<span class="op">&gt;</span></code></li>
+<li><code class="sourceCode cpp">div<span class="op">&lt;</span>mul<span class="op">&lt;</span>metre, metre<span class="op">&gt;</span>, metre<span class="op">&gt;</span></code></li>
 </ul>
 <p>Comparing such types for equivalence would not only be very expensive
 at compile-time but would also be really confusing to the users
@@ -6483,48 +6392,48 @@ <h3 data-number="16.5.1" id="derived-entities"><span class="header-section-numbe
 <strong>Unit</strong>
 </div></th>
 <th><div style="text-align:center">
-<strong><span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span></strong>
+<strong><span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span></strong>
 </div></th>
 <th><div style="text-align:center">
-<strong><span class="citation" data-cites="AU">[<a href="#ref-AU" role="doc-biblioref">Au</a>]</span></strong>
+<strong><span class="citation" data-cites="AU">[<a href="https://aurora-opensource.github.io/au" role="doc-biblioref">Au</a>]</span></strong>
 </div></th>
 </tr>
 </thead>
 <tbody>
 <tr class="odd">
-<td><code class="sourceCode default">N⋅m</code></td>
-<td><code class="sourceCode default">derived_unit&lt;metre, newton&gt;</code></td>
-<td><code class="sourceCode default">UnitProduct&lt;Meters, Newtons&gt;</code></td>
+<td><code class="sourceCode cpp">N⋅m</code></td>
+<td><code class="sourceCode cpp">derived_unit<span class="op">&lt;</span>metre, newton<span class="op">&gt;</span></code></td>
+<td><code class="sourceCode cpp">UnitProduct<span class="op">&lt;</span>Meters, Newtons<span class="op">&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td><code class="sourceCode default">1/s</code></td>
-<td><code class="sourceCode default">derived_unit&lt;one, per&lt;second&gt;&gt;</code></td>
-<td><code class="sourceCode default">Pow&lt;Seconds, -1&gt;</code></td>
+<td><code class="sourceCode cpp"><span class="dv">1</span><span class="op">/</span>s</code></td>
+<td><code class="sourceCode cpp">derived_unit<span class="op">&lt;</span>one, per<span class="op">&lt;</span>second<span class="op">&gt;&gt;</span></code></td>
+<td><code class="sourceCode cpp">Pow<span class="op">&lt;</span>Seconds, <span class="op">-</span><span class="dv">1</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td><code class="sourceCode default">km/h</code></td>
-<td><code class="sourceCode default">derived_unit&lt;kilo_&lt;metre&gt;, per&lt;hour&gt;&gt;</code></td>
-<td><code class="sourceCode default">UnitProduct&lt;Kilo&lt;Meters&gt;, Pow&lt;Hours, -1&gt;&gt;</code></td>
+<td><code class="sourceCode cpp">km<span class="op">/</span>h</code></td>
+<td><code class="sourceCode cpp">derived_unit<span class="op">&lt;</span>kilo_<span class="op">&lt;</span>metre<span class="op">&gt;</span>, per<span class="op">&lt;</span>hour<span class="op">&gt;&gt;</span></code></td>
+<td><code class="sourceCode cpp">UnitProduct<span class="op">&lt;</span>Kilo<span class="op">&lt;</span>Meters<span class="op">&gt;</span>, Pow<span class="op">&lt;</span>Hours, <span class="op">-</span><span class="dv">1</span><span class="op">&gt;&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td><code class="sourceCode default">kg⋅m²/(s³⋅K)</code></td>
-<td><code class="sourceCode default">derived_unit&lt;kilogram, pow&lt;metre, 2&gt;, per&lt;kelvin, power&lt;second, 3&gt;&gt;&gt;</code></td>
-<td><code class="sourceCode default">UnitProduct&lt;Pow&lt;Meters, 2&gt;, Kilo&lt;Grams&gt;, Pow&lt;Seconds, -3&gt;, Pow&lt;Kelvins, -1&gt;&gt;</code></td>
+<td><code class="sourceCode cpp">kg⋅m²<span class="op">/(</span>s³⋅K<span class="op">)</span></code></td>
+<td><code class="sourceCode cpp">derived_unit<span class="op">&lt;</span>kilogram, pow<span class="op">&lt;</span>metre, <span class="dv">2</span><span class="op">&gt;</span>, per<span class="op">&lt;</span>kelvin, power<span class="op">&lt;</span>second, <span class="dv">3</span><span class="op">&gt;&gt;&gt;</span></code></td>
+<td><code class="sourceCode cpp">UnitProduct<span class="op">&lt;</span>Pow<span class="op">&lt;</span>Meters, <span class="dv">2</span><span class="op">&gt;</span>, Kilo<span class="op">&lt;</span>Grams<span class="op">&gt;</span>, Pow<span class="op">&lt;</span>Seconds, <span class="op">-</span><span class="dv">3</span><span class="op">&gt;</span>, Pow<span class="op">&lt;</span>Kelvins, <span class="op">-</span><span class="dv">1</span><span class="op">&gt;&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td><code class="sourceCode default">m²/m</code></td>
-<td><code class="sourceCode default">metre</code></td>
-<td><code class="sourceCode default">Meters</code></td>
+<td><code class="sourceCode cpp">m²<span class="op">/</span>m</code></td>
+<td><code class="sourceCode cpp">metre</code></td>
+<td><code class="sourceCode cpp">Meters</code></td>
 </tr>
 <tr class="even">
-<td><code class="sourceCode default">km/m</code></td>
-<td><code class="sourceCode default">derived_unit&lt;kilo_&lt;metre&gt;, per&lt;metre&gt;&gt;</code></td>
-<td><code class="sourceCode default">UnitProduct&lt;Pow&lt;Meters, -1&gt;, Kilo&lt;Meters&gt;&gt;</code></td>
+<td><code class="sourceCode cpp">km<span class="op">/</span>m</code></td>
+<td><code class="sourceCode cpp">derived_unit<span class="op">&lt;</span>kilo_<span class="op">&lt;</span>metre<span class="op">&gt;</span>, per<span class="op">&lt;</span>metre<span class="op">&gt;&gt;</span></code></td>
+<td><code class="sourceCode cpp">UnitProduct<span class="op">&lt;</span>Pow<span class="op">&lt;</span>Meters, <span class="op">-</span><span class="dv">1</span><span class="op">&gt;</span>, Kilo<span class="op">&lt;</span>Meters<span class="op">&gt;&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td><code class="sourceCode default">m/m</code></td>
-<td><code class="sourceCode default">one</code></td>
-<td><code class="sourceCode default">UnitProduct&lt;&gt;</code></td>
+<td><code class="sourceCode cpp">m<span class="op">/</span>m</code></td>
+<td><code class="sourceCode cpp">one</code></td>
+<td><code class="sourceCode cpp">UnitProduct<span class="op">&lt;&gt;</span></code></td>
 </tr>
 </tbody>
 </table>
@@ -6533,11 +6442,11 @@ <h3 data-number="16.5.1" id="derived-entities"><span class="header-section-numbe
 the pros and cons here, we should remember that our users often do not
 have a scientific background. This is why we recommend to use syntax
 that is as similar to the correct English language as possible. It
-consistently uses the <code class="sourceCode default">derived_</code>
+consistently uses the <code class="sourceCode cpp">derived_</code>
 prefix for types representing derived units, dimensions, and quantity
 specifications. Those are instantiated first with the contents of the
 numerator followed by the entities of the denominator (if present)
-enclosed in the <code class="sourceCode default">per&lt;...&gt;</code>
+enclosed in the <code class="sourceCode cpp">per<span class="op">&lt;...&gt;</span></code>
 expression template.</p>
 <h3 data-number="16.5.2" id="identities"><span class="header-section-number">16.5.2</span> Identities<a href="#identities" class="self-link"></a></h3>
 <p>The arithmetics on units, dimensions, and quantity types require a
@@ -6546,14 +6455,13 @@ <h3 data-number="16.5.2" id="identities"><span class="header-section-number">16.
 expression template on multiplication.</p>
 <p>We chose the following names here:</p>
 <ul>
-<li><code class="sourceCode default">one</code> in the domain of
-units,</li>
-<li><code class="sourceCode default">dimension_one</code> in the domain
-of dimensions,</li>
-<li><code class="sourceCode default">dimensionless</code> in the domain
-of quantity types.</li>
+<li><code class="sourceCode cpp">one</code> in the domain of units,</li>
+<li><code class="sourceCode cpp">dimension_one</code> in the domain of
+dimensions,</li>
+<li><code class="sourceCode cpp">dimensionless</code> in the domain of
+quantity types.</li>
 </ul>
-<p>The above names were selected based on the following quote from <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>:</p>
+<p>The above names were selected based on the following quote from <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>:</p>
 <blockquote>
 <p>A quantity whose dimensional exponents are all equal to zero has the
 dimensional product denoted A<sup>0</sup>B<sup>0</sup>C<sup>0</sup>… =
@@ -6589,59 +6497,58 @@ <h3 data-number="16.5.3" id="supported-operations-and-their-results"><span class
 </thead>
 <tbody>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">A * B</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A, B</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A <span class="op">*</span> B</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, B</code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">B * A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A, B</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">B <span class="op">*</span> A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, B</code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">A * A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 2&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A <span class="op">*</span> A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">{identity} * A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span> <span class="op">*</span> A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A</code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">A * {identity}</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A <span class="op">*</span> <span class="op">{</span>identity<span class="op">}</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A</code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">A / B</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A, per&lt;B&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A <span class="op">/</span> B</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, per<span class="op">&lt;</span>B<span class="op">&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">A / A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A <span class="op">/</span> A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">A / {identity}</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A <span class="op">/</span> <span class="op">{</span>identity<span class="op">}</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A</code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">{identity} / A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}, per&lt;A&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span> <span class="op">/</span> A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span>, per<span class="op">&lt;</span>A<span class="op">&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">pow&lt;2&gt;(A)</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 2&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>A<span class="op">)</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">pow&lt;2&gt;({identity})</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;({</span>identity<span class="op">})</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">sqrt(A)</code>
-or <code class="sourceCode default">pow&lt;1, 2&gt;(A)</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 1, 2&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">sqrt<span class="op">(</span>A<span class="op">)</span></code>
+or <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;(</span>A<span class="op">)</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">sqrt({identity})</code>
-or
-<code class="sourceCode default">pow&lt;1, 2&gt;({identity})</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">sqrt<span class="op">({</span>identity<span class="op">})</span></code>
+or <code class="sourceCode cpp">pow<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;({</span>identity<span class="op">})</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span></code></td>
 </tr>
 </tbody>
 </table>
@@ -6658,7 +6565,7 @@ <h3 data-number="16.5.4" id="simplifying-the-resulting-expression-templates"><sp
 <p>This is probably the most important of all the steps, as it allows
 comparing types and enables the rest of the simplification rules.</p>
 <p>Units and dimensions have unique symbols, but ordering quantity types
-might not be that trivial. Although the ISQ defined in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides symbols for each
+might not be that trivial. Although the ISQ defined in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> provides symbols for each
 quantity, there is little use for them in the C++ code. This is caused
 by the fact that such symbols use a lot of characters that are not
 available with the Unicode encoding. Most of the limitations correspond
@@ -6695,20 +6602,20 @@ <h3 data-number="16.5.4" id="simplifying-the-resulting-expression-templates"><sp
 </thead>
 <tbody>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">A, A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 2&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">A, power&lt;A, 2&gt;</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 3&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">3</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 1, 2&gt;, power&lt;A, 2&gt;</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 5, 2&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;</span>, power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">5</span>, <span class="dv">2</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 1, 2&gt;, power&lt;A, 1, 2&gt;</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;</span>, power<span class="op">&lt;</span>A, <span class="dv">1</span>, <span class="dv">2</span><span class="op">&gt;</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A</code></td>
 </tr>
 </tbody>
 </table></li>
@@ -6729,34 +6636,35 @@ <h3 data-number="16.5.4" id="simplifying-the-resulting-expression-templates"><sp
 </thead>
 <tbody>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">A, per&lt;A&gt;</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, per<span class="op">&lt;</span>A<span class="op">&gt;</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 2&gt;, per&lt;A&gt;</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span>, per<span class="op">&lt;</span>A<span class="op">&gt;</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A</code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 3&gt;, per&lt;A&gt;</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 2&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">3</span><span class="op">&gt;</span>, per<span class="op">&lt;</span>A<span class="op">&gt;</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">A, per&lt;power&lt;A, 2&gt;&gt;</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}, per&lt;A&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, per<span class="op">&lt;</span>power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;&gt;</span></code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span>, per<span class="op">&lt;</span>A<span class="op">&gt;</span></code></td>
 </tr>
 </tbody>
 </table>
 <p>It is important to notice here that only the elements with exactly
 the same type are being simplified. This means that, for example,
-<code class="sourceCode default">m/m</code> results in
-<code class="sourceCode default">one</code>, but
-<code class="sourceCode default">km/m</code> will not be simplified. The
-resulting derived unit will preserve both symbols and their relative
-magnitude. This allows us to properly print symbols of some units or
-constants that require such behavior. For example, the Hubble constant
-is expressed in <code class="sourceCode default">km⋅s⁻¹⋅Mpc⁻¹</code>,
-where both <code class="sourceCode default">km</code> and
-<code class="sourceCode default">Mpc</code> are units of
+<code class="sourceCode cpp">m<span class="op">/</span>m</code> results
+in <code class="sourceCode cpp">one</code>, but
+<code class="sourceCode cpp">km<span class="op">/</span>m</code> will
+not be simplified. The resulting derived unit will preserve both symbols
+and their relative magnitude. This allows us to properly print symbols
+of some units or constants that require such behavior. For example, the
+Hubble constant is expressed in
+<code class="sourceCode cpp">km⋅s⁻¹⋅Mpc⁻¹</code>, where both
+<code class="sourceCode cpp">km</code> and
+<code class="sourceCode cpp">Mpc</code> are units of
 <em>length</em>.</p></li>
 <li><p><strong>Repacking</strong></p>
 <p>In case an expression uses two results of some other operations, the
@@ -6778,28 +6686,28 @@ <h3 data-number="16.5.4" id="simplifying-the-resulting-expression-templates"><sp
 </thead>
 <tbody>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">X * B</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">X <span class="op">*</span> B</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A</code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">X * A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 2&gt;, per&lt;B&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">X <span class="op">*</span> A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span>, per<span class="op">&lt;</span>B<span class="op">&gt;</span></code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">X * X</code></td>
-<td style="text-align: center;"><code class="sourceCode default">power&lt;A, 2&gt;, per&lt;power&lt;B, 2&gt;&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">X <span class="op">*</span> X</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">power<span class="op">&lt;</span>A, <span class="dv">2</span><span class="op">&gt;</span>, per<span class="op">&lt;</span>power<span class="op">&lt;</span>B, <span class="dv">2</span><span class="op">&gt;&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">X / X</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">X <span class="op">/</span> X</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span></code></td>
 </tr>
 <tr class="odd">
-<td style="text-align: center;"><code class="sourceCode default">X / A</code></td>
-<td style="text-align: center;"><code class="sourceCode default">{identity}, per&lt;B&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">X <span class="op">/</span> A</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp"><span class="op">{</span>identity<span class="op">}</span>, per<span class="op">&lt;</span>B<span class="op">&gt;</span></code></td>
 </tr>
 <tr class="even">
-<td style="text-align: center;"><code class="sourceCode default">X / B</code></td>
-<td style="text-align: center;"><code class="sourceCode default">A, per&lt;power&lt;B, 2&gt;&gt;</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">X <span class="op">/</span> B</code></td>
+<td style="text-align: center;"><code class="sourceCode cpp">A, per<span class="op">&lt;</span>power<span class="op">&lt;</span>B, <span class="dv">2</span><span class="op">&gt;&gt;</span></code></td>
 </tr>
 </tbody>
 </table></li>
@@ -6809,22 +6717,18 @@ <h3 data-number="16.5.4" id="simplifying-the-resulting-expression-templates"><sp
 benefit from those. They always use type identifiers to determine
 whether the operation should be performed.</p>
 <p>Unit symbols are not guaranteed to be unique in the project. For
-example, someone may use
-<code class="sourceCode default">&quot;s&quot;</code> as a symbol for a
-count of samples, which, when used in a unit expression with seconds,
-would cause fatal consequences (e.g.,
-<code class="sourceCode default">sample * second</code> would yield
-<code class="sourceCode default">s²</code>, or
-<code class="sourceCode default">sample / second</code> would result in
-<code class="sourceCode default">one</code>).</p>
+example, someone may use <code class="sourceCode cpp"><span class="st">&quot;s&quot;</span></code> as a
+symbol for a count of samples, which, when used in a unit expression
+with seconds, would cause fatal consequences (e.g., <code class="sourceCode cpp">sample <span class="op">*</span> second</code>
+would yield <code class="sourceCode cpp">s²</code>, or <code class="sourceCode cpp">sample <span class="op">/</span> second</code>
+would result in <code class="sourceCode cpp">one</code>).</p>
 <p>Some units would provide worse text output if the ordering step used
-type identifiers rather than unit symbols. For example, <code class="sourceCode default">si::metre * si::second * cgs::second</code>
-would result in <code class="sourceCode default">s m s</code>, or
-<code class="sourceCode default">newton * metre</code> would result in
-<code class="sourceCode default">m N</code>, which is not how we
-typically spell this unit. However, for the sake of consistency, we may
-also consider changing the algorithm used for ordering to be based on
-type identifiers.</p>
+type identifiers rather than unit symbols. For example, <code class="sourceCode cpp">si<span class="op">::</span>metre <span class="op">*</span> si<span class="op">::</span>second <span class="op">*</span> cgs<span class="op">::</span>second</code>
+would result in <code class="sourceCode cpp">s m s</code>, or <code class="sourceCode cpp">newton <span class="op">*</span> metre</code>
+would result in <code class="sourceCode cpp">m N</code>, which is not
+how we typically spell this unit. However, for the sake of consistency,
+we may also consider changing the algorithm used for ordering to be
+based on type identifiers.</p>
 <h3 data-number="16.5.5" id="expression-templates-in-action"><span class="header-section-number">16.5.5</span> Expression templates in
 action<a href="#expression-templates-in-action" class="self-link"></a></h3>
 <p>Thanks to all of the steps described above, a user may write the code
@@ -6840,20 +6744,21 @@ <h3 data-number="16.5.5" id="expression-templates-in-action"><span class="header
 <p>The above program will produce the following types for
 <em>acceleration</em> quantities:</p>
 <ul>
-<li><p><code class="sourceCode default">acceleration1</code></p>
+<li><p><code class="sourceCode cpp">acceleration1</code></p>
 <pre class="text"><code>quantity&lt;reference&lt;derived_quantity_spec&lt;isq::speed, per&lt;isq::time&gt;&gt;,
                    derived_unit&lt;si::kilo_&lt;si::metre&gt;, per&lt;non_si::hour, si::second&gt;&gt;&gt;{},
          double&gt;</code></pre></li>
-<li><p><code class="sourceCode default">acceleration2</code></p>
+<li><p><code class="sourceCode cpp">acceleration2</code></p>
 <pre class="text"><code>quantity&lt;reference&lt;isq::acceleration,
                    derived_unit&lt;si::metre, per&lt;power&lt;si::second, 2&gt;&gt;&gt;&gt;{},
          double&gt;&gt;</code></pre></li>
 </ul>
 <h2 data-number="16.6" id="physical-constants"><span class="header-section-number">16.6</span> Physical constants<a href="#physical-constants" class="self-link"></a></h2>
 <p>In most libraries, physical constants are implemented as constant
-(possibly <code class="sourceCode default">constexpr</code>) quantity
-values. Such an approach has some disadvantages, often resulting in
-longer compilation times and a loss of precision.</p>
+(possibly
+<code class="sourceCode cpp"><span class="kw">constexpr</span></code>)
+quantity values. Such an approach has some disadvantages, often
+resulting in longer compilation times and a loss of precision.</p>
 <h3 data-number="16.6.1" id="simplifying-constants-in-an-equation"><span class="header-section-number">16.6.1</span> Simplifying constants in an
 equation<a href="#simplifying-constants-in-an-equation" class="self-link"></a></h3>
 <p>When dealing with equations involving physical constants, they often
@@ -6911,9 +6816,10 @@ <h3 data-number="16.6.3" id="physical-constants-usage-examples"><span class="hea
 <pre class="text"><code>permittivity of vacuum = 1  μ₀⁻¹ c⁻² = 8.85419e-12 F/m</code></pre>
 <p>As we can clearly see, all the calculations above were just about
 multiplying and dividing the number
-<code class="sourceCode default">1</code> with the rest of the
-information provided as a compile-time type. Only when a user wants a
-specific SI unit as a result, the unit ratios are lazily resolved.</p>
+<code class="sourceCode cpp"><span class="dv">1</span></code> with the
+rest of the information provided as a compile-time type. Only when a
+user wants a specific SI unit as a result, the unit ratios are lazily
+resolved.</p>
 <p>Another similar example can be an equation for total energy:</p>
 <div class="sourceCode" id="cb211"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb211-1"><a href="#cb211-1" aria-hidden="true" tabindex="-1"></a>QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>mechanical_energy<span class="op">&gt;</span> <span class="kw">auto</span> total_energy<span class="op">(</span>QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>momentum<span class="op">&gt;</span> <span class="kw">auto</span> p,</span>
 <span id="cb211-2"><a href="#cb211-2" aria-hidden="true" tabindex="-1"></a>                                                     QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>mass<span class="op">&gt;</span> <span class="kw">auto</span> m,</span>
@@ -6970,10 +6876,8 @@ <h3 data-number="16.6.3" id="physical-constants-usage-examples"><span class="hea
 <h2 data-number="16.7" id="quantity-references"><span class="header-section-number">16.7</span> Quantity references<a href="#quantity-references" class="self-link"></a></h2>
 <p><em>Note: We know that probably the term “reference” will not survive
 too long in the Committee, but we couldn’t find a better name for it in
-the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library
-(<a href="https://github.com/mpusz/mp-units/issues/486" class="uri">https://github.com/mpusz/mp-units/issues/486</a>).</em></p>
-<p><span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span>
-says:</p>
+the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library (<a href="https://github.com/mpusz/mp-units/issues/486" class="uri">https://github.com/mpusz/mp-units/issues/486</a>).</em></p>
+<p><span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> says:</p>
 <blockquote>
 <p><strong>quantity</strong> - property of a phenomenon, body, or
 substance, where the property has a magnitude that can be expressed as a
@@ -6983,42 +6887,41 @@ <h2 data-number="16.7" id="quantity-references"><span class="header-section-numb
 </blockquote>
 <p>In the library a quantity reference represents all the
 domain-specific meta-data about the quantity besides its representation
-type and its value. A <a href="#Reference-concept"><code class="sourceCode default">Reference</code></a>
+type and its value. A <a href="#Reference-concept"><code class="sourceCode cpp">Reference</code></a>
 concept is satisfied by either of:</p>
 <ul>
 <li>an associated unit (e.g.,
-<code class="sourceCode default">si::metre</code>),</li>
-<li>an instantiation of the <code class="sourceCode default">reference&lt;QuantitySpec, Unit&gt;</code>
+<code class="sourceCode cpp">si<span class="op">::</span>metre</code>),</li>
+<li>an instantiation of the <code class="sourceCode cpp">reference<span class="op">&lt;</span>QuantitySpec, Unit<span class="op">&gt;</span></code>
 class template explicitly specifying the quantity type and its
 unit.</li>
 </ul>
 <p>A reference type is implicitly created as a result of the following
 expression:</p>
 <div class="sourceCode" id="cb213"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb213-1"><a href="#cb213-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> Reference <span class="kw">auto</span> distance <span class="op">=</span> isq<span class="op">::</span>distance<span class="op">[</span>m<span class="op">]</span>;</span></code></pre></div>
-<p>The above example defines a variable of type <code class="sourceCode default">reference&lt;isq::distance, si::metre&gt;</code>.</p>
-<p>The <code class="sourceCode default">reference</code> class template
-also exposes an arithmetic interface similar to the one that we have
-already discussed in case of units and quantity types. It simply
-forwards the operation to its quantity type and unit members.</p>
+<p>The above example defines a variable of type <code class="sourceCode cpp">reference<span class="op">&lt;</span>isq<span class="op">::</span>distance, si<span class="op">::</span>metre<span class="op">&gt;</span></code>.</p>
+<p>The <code class="sourceCode cpp">reference</code> class template also
+exposes an arithmetic interface similar to the one that we have already
+discussed in case of units and quantity types. It simply forwards the
+operation to its quantity type and unit members.</p>
 <div class="sourceCode" id="cb214"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb214-1"><a href="#cb214-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> ReferenceOf<span class="op">&lt;</span>isq<span class="op">::</span>speed<span class="op">&gt;</span> <span class="kw">auto</span> speed <span class="op">=</span> distance <span class="op">/</span> si<span class="op">::</span>second;</span></code></pre></div>
-<p>As a result we get a <code class="sourceCode default">reference&lt;derived_quantity_spec&lt;distance, per&lt;time&gt;&gt;, derived_unit&lt;metre, per&lt;second&gt;&gt;&gt;</code>
+<p>As a result we get a <code class="sourceCode cpp">reference<span class="op">&lt;</span>derived_quantity_spec<span class="op">&lt;</span>distance, per<span class="op">&lt;</span>time<span class="op">&gt;&gt;</span>, derived_unit<span class="op">&lt;</span>metre, per<span class="op">&lt;</span>second<span class="op">&gt;&gt;&gt;</span></code>
 type.</p>
-<p>Similarly to the <a href="#AssociatedUnit-concept"><code class="sourceCode default">AssociatedUnit</code></a>,
+<p>Similarly to the <a href="#AssociatedUnit-concept"><code class="sourceCode cpp">AssociatedUnit</code></a>,
 such a reference can be used to construct a quantity:</p>
 <div class="sourceCode" id="cb215"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb215-1"><a href="#cb215-1" aria-hidden="true" tabindex="-1"></a>QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>speed<span class="op">&gt;</span> <span class="kw">auto</span> s <span class="op">=</span> <span class="dv">60</span> <span class="op">*</span> speed;</span></code></pre></div>
 <h2 data-number="16.8" id="quantities"><span class="header-section-number">16.8</span> Quantities<a href="#quantities" class="self-link"></a></h2>
-<p>The <code class="sourceCode default">quantity</code> class template
-is a workhorse of the library. It can be considered a generalization of
-<code class="sourceCode default">std::chrono::duration</code>, but is
-not directly compatible with it.</p>
+<p>The <code class="sourceCode cpp">quantity</code> class template is a
+workhorse of the library. It can be considered a generalization of <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>,
+but is not directly compatible with it.</p>
 <p>Based on the ISO definition provided in the <a href="#quantity-references">Quantity references</a> chapter, the
-<code class="sourceCode default">quantity</code> class template has the
+<code class="sourceCode cpp">quantity</code> class template has the
 following signature:</p>
 <div class="sourceCode" id="cb216"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb216-1"><a href="#cb216-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span>Reference <span class="kw">auto</span> R, RepresentationOf<span class="op">&lt;</span>get_quantity_spec<span class="op">(</span>R<span class="op">).</span>character<span class="op">&gt;</span> Rep <span class="op">=</span> <span class="dt">double</span><span class="op">&gt;</span></span>
 <span id="cb216-2"><a href="#cb216-2" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> quantity;</span></code></pre></div>
 <p>It stores only one data member of
-<code class="sourceCode default">Rep</code> type. Unfortunately, this
-data member has to be publicly exposed to satisfy the C++ language
+<code class="sourceCode cpp">Rep</code> type. Unfortunately, this data
+member has to be publicly exposed to satisfy the C++ language
 requirements for <a href="https://eel.is/c++draft/temp.param#def:type,structural">structural
 types</a>. Hopefully, the language rules for structural types will
 improve with time before this library gets standardized.</p>
@@ -7028,7 +6931,9 @@ <h3 data-number="16.8.1" id="why-dont-we-use-udls-to-create-quantities"><span cl
 chapter describes and explains why we introduced the multiply syntax as
 a construction helper for quantities. Many people ask why we chose this
 approach over battle-proven User Defined Literals (UDLs) that work well
-for the <code class="sourceCode default">std::chrono</code> library.</p>
+for the
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
+library.</p>
 <p>It turns out that many reasons make UDLs a poor choice for a physical
 units library:</p>
 <ol type="1">
@@ -7038,9 +6943,8 @@ <h3 data-number="16.8.1" id="why-dont-we-use-udls-to-create-quantities"><span cl
 for <a href="#physical-constants">Physical constants</a>, we recommend
 using units rather than compile-time constants.</p></li>
 <li><p>Typical implementations of UDLs tend to always use the widest
-representation type available. In the case of
-<code class="sourceCode default">std::chrono::duration</code>, the
-following is true:</p>
+representation type available. In the case of <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>,
+the following is true:</p>
 <div class="sourceCode" id="cb217"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb217-1"><a href="#cb217-1" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> <span class="kw">namespace</span> std<span class="op">::</span>chrono_literals;</span>
 <span id="cb217-2"><a href="#cb217-2" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> d1 <span class="op">=</span> <span class="dv">42</span><span class="bu">s</span>;</span>
 <span id="cb217-3"><a href="#cb217-3" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> d2 <span class="op">=</span> <span class="fl">42.</span><span class="bu">s</span>;</span>
@@ -7050,38 +6954,38 @@ <h3 data-number="16.8.1" id="why-dont-we-use-udls-to-create-quantities"><span cl
 a shorter representation type, it will always expand it to the longest
 one. In other words, such long type spreads until all types use it
 everywhere.</p></li>
-<li><p>While increasing the coverage for the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library, we learned that many
+<li><p>While increasing the coverage for the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library, we learned that many
 unit symbols conflict with built-in types or numeric extensions. A few
-of those are: <code class="sourceCode default">F</code> (farad),
-<code class="sourceCode default">J</code> (joule),
-<code class="sourceCode default">W</code> (watt),
-<code class="sourceCode default">K</code> (kelvin),
-<code class="sourceCode default">d</code> (day),
-<code class="sourceCode default">l</code> or
-<code class="sourceCode default">L</code> (litre),
-<code class="sourceCode default">erg</code>,
-<code class="sourceCode default">ergps</code>. Using the
-<code class="sourceCode default">_</code> prefix would make it work for
-<span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span>, but if the library is
+of those are: <code class="sourceCode cpp">F</code> (farad),
+<code class="sourceCode cpp">J</code> (joule),
+<code class="sourceCode cpp">W</code> (watt),
+<code class="sourceCode cpp">K</code> (kelvin),
+<code class="sourceCode cpp">d</code> (day),
+<code class="sourceCode cpp">l</code> or
+<code class="sourceCode cpp">L</code> (litre),
+<code class="sourceCode cpp">erg</code>,
+<code class="sourceCode cpp">ergps</code>. Using the
+<code class="sourceCode cpp">_</code> prefix would make it work for
+<span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span>, but if the library is
 standardized, those naming collisions would be a big issue. This is why
-we came up with the <code class="sourceCode default">_q_</code> prefix
-that would become <code class="sourceCode default">q_</code> after
-standardization (e.g., <code class="sourceCode default">42q_s</code>),
+we came up with the <code class="sourceCode cpp">_q_</code> prefix that
+would become <code class="sourceCode cpp">q_</code> after
+standardization (e.g., <code class="sourceCode cpp"><span class="dv">42</span><span class="er">q_s</span></code>),
 which is not that nice anymore.</p></li>
 <li><p>UDLs with the same identifiers defined in different namespace
 can’t be disambiguated in the C++ language. If both SI and CGS systems
-define <code class="sourceCode default">q_s</code> UDL for a second
-unit, then it would not be possible to specify which one to use in case
-both namespaces are “imported” with using directives.</p></li>
+define <code class="sourceCode cpp">q_s</code> UDL for a second unit,
+then it would not be possible to specify which one to use in case both
+namespaces are “imported” with using directives.</p></li>
 <li><p>Another bad property of UDLs is that they do not compose. A
 coherent unit of angular momentum would have a UDL specified as
-<code class="sourceCode default">q_kg_m2_per_s</code>. Now imagine that
-we want to make every possible user happy. How many variations of that
-unit would we predefine for differently scaled versions of all unit
+<code class="sourceCode cpp">q_kg_m2_per_s</code>. Now imagine that we
+want to make every possible user happy. How many variations of that unit
+would we predefine for differently scaled versions of all unit
 ingredients?</p></li>
 <li><p>UDLs are also really expensive to define and specify. Typically,
 for each unit, we need two definitions. One for integral and another one
-for floating-point representation. In version 0.8.0 of the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library, the coherent unit of
+for floating-point representation. In version 0.8.0 of the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library, the coherent unit of
 angular momentum was defined as:</p>
 <div class="sourceCode" id="cb218"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb218-1"><a href="#cb218-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="kw">auto</span> <span class="kw">operator</span><span class="st">&quot;&quot;</span> _q_kg_m2_per_s<span class="op">(</span><span class="dt">unsigned</span> <span class="dt">long</span> <span class="dt">long</span> l<span class="op">)</span></span>
 <span id="cb218-2"><a href="#cb218-2" aria-hidden="true" tabindex="-1"></a><span class="op">{</span></span>
@@ -7098,81 +7002,80 @@ <h3 data-number="16.8.1" id="why-dont-we-use-udls-to-create-quantities"><span cl
 of those issues.</p>
 <h3 data-number="16.8.2" id="quantity-arithmetics"><span class="header-section-number">16.8.2</span> Quantity arithmetics<a href="#quantity-arithmetics" class="self-link"></a></h3>
 <h4 data-number="16.8.2.1" id="quantity-is-a-numeric-wrapper"><span class="header-section-number">16.8.2.1</span>
-<code class="sourceCode default">quantity</code> is a numeric wrapper<a href="#quantity-is-a-numeric-wrapper" class="self-link"></a></h4>
+<code class="sourceCode cpp">quantity</code> is a numeric wrapper<a href="#quantity-is-a-numeric-wrapper" class="self-link"></a></h4>
 <p>If we think about it, the
-<code class="sourceCode default">quantity</code> class template is just
-a “smart” numeric wrapper. It exposes properly constrained set of
+<code class="sourceCode cpp">quantity</code> class template is just a
+“smart” numeric wrapper. It exposes properly constrained set of
 arithmetic operations on one or two operands.</p>
 <p>Every single arithmetic operator is exposed by the
-<code class="sourceCode default">quantity</code> class template only if
-the underlying representation type provides it as well and its
+<code class="sourceCode cpp">quantity</code> class template only if the
+underlying representation type provides it as well and its
 implementation has proper semantics (e.g., returns a reasonable
 type).</p>
 <p>For example, in the following code,
-<code class="sourceCode default">-a</code> will compile only if
-<code class="sourceCode default">MyInt</code> exposes such an operation
-as well:</p>
+<code class="sourceCode cpp"><span class="op">-</span>a</code> will
+compile only if <code class="sourceCode cpp">MyInt</code> exposes such
+an operation as well:</p>
 <div class="sourceCode" id="cb219"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb219-1"><a href="#cb219-1" aria-hidden="true" tabindex="-1"></a>quantity a <span class="op">=</span> MyInt<span class="op">{</span><span class="dv">42</span><span class="op">}</span> <span class="op">*</span> m;</span>
 <span id="cb219-2"><a href="#cb219-2" aria-hidden="true" tabindex="-1"></a>quantity b <span class="op">=</span> <span class="op">-</span>a;</span></code></pre></div>
 <p>Assuming that:</p>
 <ul>
-<li><code class="sourceCode default">q</code> is our quantity,</li>
-<li><code class="sourceCode default">qq</code> is a quantity implicitly
-convertible to <code class="sourceCode default">q</code>,</li>
-<li><code class="sourceCode default">q2</code> is any other
-quantity,</li>
-<li><code class="sourceCode default">kind</code> is a quantity of the
-same kind as <code class="sourceCode default">q</code>,</li>
-<li><code class="sourceCode default">one</code> is a quantity of
-<code class="sourceCode default">dimension_one</code> with the unit
-<code class="sourceCode default">one</code>,</li>
-<li><code class="sourceCode default">number</code> is a value of a type
-“compatible” with <code class="sourceCode default">q</code>’s
-representation type,</li>
+<li><code class="sourceCode cpp">q</code> is our quantity,</li>
+<li><code class="sourceCode cpp">qq</code> is a quantity implicitly
+convertible to <code class="sourceCode cpp">q</code>,</li>
+<li><code class="sourceCode cpp">q2</code> is any other quantity,</li>
+<li><code class="sourceCode cpp">kind</code> is a quantity of the same
+kind as <code class="sourceCode cpp">q</code>,</li>
+<li><code class="sourceCode cpp">one</code> is a quantity of
+<code class="sourceCode cpp">dimension_one</code> with the unit
+<code class="sourceCode cpp">one</code>,</li>
+<li><code class="sourceCode cpp">number</code> is a value of a type
+“compatible” with <code class="sourceCode cpp">q</code>’s representation
+type,</li>
 </ul>
 <p>here is the list of all the supported operators:</p>
 <ul>
 <li>unary:
 <ul>
-<li><code class="sourceCode default">+q</code></li>
-<li><code class="sourceCode default">-q</code></li>
-<li><code class="sourceCode default">++q</code></li>
-<li><code class="sourceCode default">q++</code></li>
-<li><code class="sourceCode default">--q</code></li>
-<li><code class="sourceCode default">q--</code></li>
+<li><code class="sourceCode cpp"><span class="op">+</span>q</code></li>
+<li><code class="sourceCode cpp"><span class="op">-</span>q</code></li>
+<li><code class="sourceCode cpp"><span class="op">++</span>q</code></li>
+<li><code class="sourceCode cpp">q<span class="op">++</span></code></li>
+<li><code class="sourceCode cpp"><span class="op">--</span>q</code></li>
+<li><code class="sourceCode cpp">q<span class="op">--</span></code></li>
 </ul></li>
 <li>compound assignment:
 <ul>
-<li><code class="sourceCode default">q += qq</code></li>
-<li><code class="sourceCode default">q -= qq</code></li>
-<li><code class="sourceCode default">q %= qq</code></li>
-<li><code class="sourceCode default">q *= number</code></li>
-<li><code class="sourceCode default">q *= one</code></li>
-<li><code class="sourceCode default">q /= number</code></li>
-<li><code class="sourceCode default">q /= one</code></li>
+<li><code class="sourceCode cpp">q <span class="op">+=</span> qq</code></li>
+<li><code class="sourceCode cpp">q <span class="op">-=</span> qq</code></li>
+<li><code class="sourceCode cpp">q <span class="op">%=</span> qq</code></li>
+<li><code class="sourceCode cpp">q <span class="op">*=</span> number</code></li>
+<li><code class="sourceCode cpp">q <span class="op">*=</span> one</code></li>
+<li><code class="sourceCode cpp">q <span class="op">/=</span> number</code></li>
+<li><code class="sourceCode cpp">q <span class="op">/=</span> one</code></li>
 </ul></li>
 <li>binary:
 <ul>
-<li><code class="sourceCode default">q + kind</code></li>
-<li><code class="sourceCode default">q - kind</code></li>
-<li><code class="sourceCode default">q % kind</code></li>
-<li><code class="sourceCode default">q * q2</code></li>
-<li><code class="sourceCode default">q * number</code></li>
-<li><code class="sourceCode default">number * q</code></li>
-<li><code class="sourceCode default">q / q2</code></li>
-<li><code class="sourceCode default">q / number</code></li>
-<li><code class="sourceCode default">number / q</code></li>
+<li><code class="sourceCode cpp">q <span class="op">+</span> kind</code></li>
+<li><code class="sourceCode cpp">q <span class="op">-</span> kind</code></li>
+<li><code class="sourceCode cpp">q <span class="op">%</span> kind</code></li>
+<li><code class="sourceCode cpp">q <span class="op">*</span> q2</code></li>
+<li><code class="sourceCode cpp">q <span class="op">*</span> number</code></li>
+<li><code class="sourceCode cpp">number <span class="op">*</span> q</code></li>
+<li><code class="sourceCode cpp">q <span class="op">/</span> q2</code></li>
+<li><code class="sourceCode cpp">q <span class="op">/</span> number</code></li>
+<li><code class="sourceCode cpp">number <span class="op">/</span> q</code></li>
 </ul></li>
 <li>ordering and comparison:
 <ul>
-<li><code class="sourceCode default">q == kind</code></li>
-<li><code class="sourceCode default">q &lt;=&gt; kind</code></li>
+<li><code class="sourceCode cpp">q <span class="op">==</span> kind</code></li>
+<li><code class="sourceCode cpp">q <span class="op">&lt;=&gt;</span> kind</code></li>
 </ul></li>
 </ul>
 <p>As we can see, there are plenty of operations one can do on a value
-of a <code class="sourceCode default">quantity</code> type. As most of
-them are obvious, in the following chapters, we will discuss only the
-most important or non-trivial aspects of quantity arithmetics.</p>
+of a <code class="sourceCode cpp">quantity</code> type. As most of them
+are obvious, in the following chapters, we will discuss only the most
+important or non-trivial aspects of quantity arithmetics.</p>
 <h4 data-number="16.8.2.2" id="addition-and-subtraction"><span class="header-section-number">16.8.2.2</span> Addition and subtraction<a href="#addition-and-subtraction" class="self-link"></a></h4>
 <p>Quantities can easily be added or subtracted from each other:</p>
 <div class="sourceCode" id="cb220"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb220-1"><a href="#cb220-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span><span class="dv">1</span> <span class="op">*</span> m <span class="op">+</span> <span class="dv">1</span> <span class="op">*</span> m <span class="op">==</span> <span class="dv">2</span> <span class="op">*</span> m<span class="op">)</span>;</span>
@@ -7197,13 +7100,16 @@ <h4 data-number="16.8.2.2" id="addition-and-subtraction"><span class="header-sec
 <div class="sourceCode" id="cb223"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb223-1"><a href="#cb223-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">((</span><span class="dv">1</span> <span class="op">*</span> m <span class="op">-=</span> <span class="fl">0.5</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">==</span> <span class="fl">0.5</span> <span class="op">*</span> m<span class="op">)</span>;                       <span class="co">// Compile-time error (1)</span></span>
 <span id="cb223-2"><a href="#cb223-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">((</span><span class="dv">1</span> <span class="op">*</span> km <span class="op">+=</span> <span class="dv">1</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">==</span> <span class="dv">1001</span> <span class="op">*</span> m<span class="op">)</span>;                       <span class="co">// Compile-time error (2)</span></span>
 <span id="cb223-3"><a href="#cb223-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">((</span>isq<span class="op">::</span>height<span class="op">(</span><span class="dv">1</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">+=</span> isq<span class="op">::</span>length<span class="op">(</span><span class="dv">1</span> <span class="op">*</span> m<span class="op">))</span> <span class="op">==</span> <span class="dv">2</span> <span class="op">*</span> m<span class="op">)</span>; <span class="co">// Compile-time error (3)</span></span></code></pre></div>
-<p><code class="sourceCode default">(1)</code> Floating-point to
-integral representation type is considered narrowing.</p>
-<p><code class="sourceCode default">(2)</code> Conversion of quantity
-with integral representation type from a unit of a higher resolution to
-the one with a lower resolution is considered narrowing.</p>
-<p><code class="sourceCode default">(3)</code> Conversion from a more
-generic quantity type to a more specific one is considered unsafe.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">1</span><span class="op">)</span></code>
+Floating-point to integral representation type is considered
+narrowing.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">2</span><span class="op">)</span></code>
+Conversion of quantity with integral representation type from a unit of
+a higher resolution to the one with a lower resolution is considered
+narrowing.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">3</span><span class="op">)</span></code>
+Conversion from a more generic quantity type to a more specific one is
+considered unsafe.</p>
 <h4 data-number="16.8.2.3" id="multiplication-and-division"><span class="header-section-number">16.8.2.3</span> Multiplication and
 division<a href="#multiplication-and-division" class="self-link"></a></h4>
 <p>Multiplying or dividing a quantity by a number does not change its
@@ -7213,8 +7119,9 @@ <h4 data-number="16.8.2.3" id="multiplication-and-division"><span class="header-
 <p>Unless we use a compound assignment operator, in which case
 truncating operations are again not allowed:</p>
 <div class="sourceCode" id="cb225"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb225-1"><a href="#cb225-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">((</span>isq<span class="op">::</span>height<span class="op">(</span><span class="dv">3</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">*=</span> <span class="fl">0.5</span><span class="op">)</span> <span class="op">==</span> isq<span class="op">::</span>height<span class="op">(</span><span class="fl">1.5</span> <span class="op">*</span> m<span class="op">))</span>; <span class="co">// Compile-time error (1)</span></span></code></pre></div>
-<p><code class="sourceCode default">(1)</code> Floating-point to
-integral representation type is considered narrowing.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">1</span><span class="op">)</span></code>
+Floating-point to integral representation type is considered
+narrowing.</p>
 <p>However, suppose we multiply or divide quantities of the same or
 different types, or we divide a raw number by a quantity. In that case,
 we most probably will end up in a quantity of yet another type:</p>
@@ -7224,7 +7131,7 @@ <h4 data-number="16.8.2.3" id="multiplication-and-division"><span class="header-
 <p>An exception from the above rule happens when one of the arguments is
 a dimensionless quantity. If we multiply or divide by such a quantity,
 the quantity type will not change. If such a quantity has a unit
-<code class="sourceCode default">one</code>, also the unit of a quantity
+<code class="sourceCode cpp">one</code>, also the unit of a quantity
 will not change:</p>
 <div class="sourceCode" id="cb227"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb227-1"><a href="#cb227-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span><span class="dv">120</span> <span class="op">*</span> m <span class="op">/</span> <span class="op">(</span><span class="dv">2</span> <span class="op">*</span> one<span class="op">)</span> <span class="op">==</span> <span class="dv">60</span> <span class="op">*</span> m<span class="op">)</span>;</span></code></pre></div>
 <p>An interesting special case happens when we divide the same quantity
@@ -7233,28 +7140,25 @@ <h4 data-number="16.8.2.3" id="multiplication-and-division"><span class="header-
 <div class="sourceCode" id="cb228"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb228-1"><a href="#cb228-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>isq<span class="op">::</span>height<span class="op">(</span><span class="dv">4</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">/</span> isq<span class="op">::</span>width<span class="op">(</span><span class="dv">2</span> <span class="op">*</span> m<span class="op">)</span> <span class="op">==</span> <span class="dv">2</span> <span class="op">*</span> one<span class="op">)</span>; <span class="co">// (1)</span></span>
 <span id="cb228-2"><a href="#cb228-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span><span class="dv">5</span> <span class="op">*</span> h <span class="op">/</span> <span class="op">(</span><span class="dv">120</span> <span class="op">*</span> min<span class="op">)</span> <span class="op">==</span> <span class="dv">0</span> <span class="op">*</span> one<span class="op">)</span>;                    <span class="co">// (2)</span></span>
 <span id="cb228-3"><a href="#cb228-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span><span class="fl">5.</span> <span class="op">*</span> h <span class="op">/</span> <span class="op">(</span><span class="dv">120</span> <span class="op">*</span> min<span class="op">)</span> <span class="op">==</span> <span class="fl">2.5</span> <span class="op">*</span> one<span class="op">)</span>;</span></code></pre></div>
-<p><code class="sourceCode default">(1)</code> The resulting quantity
-type of the LHS is
-<code class="sourceCode default">isq::height / isq::width</code>, which
-is a quantity of the dimensionless kind.</p>
-<p><code class="sourceCode default">(2)</code> The resulting quantity of
-the LHS is
-<code class="sourceCode default">0 * dimensionless[h / min]</code>. To
-be consistent with the division of different quantity types, we do not
-convert quantity values to a common unit before the division.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">1</span><span class="op">)</span></code>
+The resulting quantity type of the LHS is <code class="sourceCode cpp">isq<span class="op">::</span>height <span class="op">/</span> isq<span class="op">::</span>width</code>,
+which is a quantity of the dimensionless kind.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">2</span><span class="op">)</span></code>
+The resulting quantity of the LHS is <code class="sourceCode cpp"><span class="dv">0</span> <span class="op">*</span> dimensionless<span class="op">[</span>h <span class="op">/</span> min<span class="op">]</span></code>.
+To be consistent with the division of different quantity types, we do
+not convert quantity values to a common unit before the division.</p>
 <h5 data-number="16.8.2.3.1" id="beware-of-integral-division"><span class="header-section-number">16.8.2.3.1</span> Beware of integral
 division<a href="#beware-of-integral-division" class="self-link"></a></h5>
 <p>The physical units library can’t do any runtime branching logic for
 the division operator. All logic has to be done at compile-time when the
 actual values are not known, and the quantity types can’t change at
 runtime.</p>
-<p>If we expect
-<code class="sourceCode default">120 * km / (2 * h)</code> to return
-<code class="sourceCode default">60 km/h</code>, we have to agree with
-the fact that <code class="sourceCode default">5 * km / (24 * h)</code>
-returns <code class="sourceCode default">0 km/h</code>. We can’t do a
-range check at runtime to dynamically adjust scales and types based on
-the values of provided function arguments.</p>
+<p>If we expect <code class="sourceCode cpp"><span class="dv">120</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">2</span> <span class="op">*</span> h<span class="op">)</span></code>
+to return <code class="sourceCode cpp"><span class="dv">60</span> km<span class="op">/</span>h</code>,
+we have to agree with the fact that <code class="sourceCode cpp"><span class="dv">5</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">24</span> <span class="op">*</span> h<span class="op">)</span></code>
+returns <code class="sourceCode cpp"><span class="dv">0</span> km<span class="op">/</span>h</code>.
+We can’t do a range check at runtime to dynamically adjust scales and
+types based on the values of provided function arguments.</p>
 <p>This is why we often prefer floating-point representation types when
 dealing with units. Some popular physical units libraries even <a href="https://aurora-opensource.github.io/au/main/troubleshooting/#integer-division-forbidden">forbid
 integer division at all</a>.</p>
@@ -7264,12 +7168,13 @@ <h4 data-number="16.8.2.4" id="modulo"><span class="header-section-number">16.8.
 be returned from the following quantity equation?</p>
 <div class="sourceCode" id="cb229"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb229-1"><a href="#cb229-1" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> q <span class="op">=</span> <span class="dv">5</span> <span class="op">*</span> h <span class="op">%</span> <span class="op">(</span><span class="dv">120</span> <span class="op">*</span> min<span class="op">)</span>;</span></code></pre></div>
 <p>Most of us would probably expect to see
-<code class="sourceCode default">1 h</code> or
-<code class="sourceCode default">60 min</code> as a result. And this is
-where the problems start.</p>
+<code class="sourceCode cpp"><span class="dv">1</span> h</code> or
+<code class="sourceCode cpp"><span class="dv">60</span> min</code> as a
+result. And this is where the problems start.</p>
 <p>The C++ language defines its
-<code class="sourceCode default">/</code> and
-<code class="sourceCode default">%</code> operators with the <a href="https://eel.is/c++draft/expr.mul#4">quotient-remainder
+<code class="sourceCode cpp"><span class="op">/</span></code> and
+<code class="sourceCode cpp"><span class="op">%</span></code> operators
+with the <a href="https://eel.is/c++draft/expr.mul#4">quotient-remainder
 theorem</a>:</p>
 <pre class="text"><code>q = a / b;
 r = a % b;
@@ -7279,9 +7184,9 @@ <h4 data-number="16.8.2.4" id="modulo"><span class="header-section-number">16.8.
 floating-point types means). However, as we saw in the previous chapter,
 integral types are tricky because they often truncate the value.</p>
 <p>From the quotient-remainder theorem, the result of modulo operation
-is <code class="sourceCode default">r = a - q * b</code>. Let’s see what
-we get from such a quantity equation on integral representation
-types:</p>
+is <code class="sourceCode cpp">r <span class="op">=</span> a <span class="op">-</span> q <span class="op">*</span> b</code>.
+Let’s see what we get from such a quantity equation on integral
+representation types:</p>
 <div class="sourceCode" id="cb230"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb230-1"><a href="#cb230-1" aria-hidden="true" tabindex="-1"></a>quantity a <span class="op">=</span> <span class="dv">5</span> <span class="op">*</span> h;</span>
 <span id="cb230-2"><a href="#cb230-2" aria-hidden="true" tabindex="-1"></a>quantity b <span class="op">=</span> <span class="dv">120</span> <span class="op">*</span> min;</span>
 <span id="cb230-3"><a href="#cb230-3" aria-hidden="true" tabindex="-1"></a>quantity q <span class="op">=</span> a <span class="op">/</span> b;</span>
@@ -7292,8 +7197,9 @@ <h4 data-number="16.8.2.4" id="modulo"><span class="header-section-number">16.8.
 <pre class="text"><code>reminder: 5 h</code></pre>
 <p>And now, a tough question needs an answer. Do we really want modulo
 operator on physical units to be consistent with the quotient-remainder
-theorem and return <code class="sourceCode default">5 h</code> for
-<code class="sourceCode default">5 * h % (120 * min)</code>?</p>
+theorem and return
+<code class="sourceCode cpp"><span class="dv">5</span> h</code> for
+<code class="sourceCode cpp"><span class="dv">5</span> <span class="op">*</span> h <span class="op">%</span> <span class="op">(</span><span class="dv">120</span> <span class="op">*</span> min<span class="op">)</span></code>?</p>
 <p>This is exactly why we decided not to follow this hugely surprising
 path in this library. The selected approach was also consistent with the
 feedback from C++ experts. For example, this is what Richard Smith said
@@ -7301,68 +7207,68 @@ <h4 data-number="16.8.2.4" id="modulo"><span class="header-section-number">16.8.
 <blockquote>
 <p>I think the quotient-remainder property is a less important
 motivation here than other factors – the constraints on
-<code class="sourceCode default">%</code> and
-<code class="sourceCode default">/</code> are quite different, so they
-lack the inherent connection they have for integers. In particular, I
-would expect that <code class="sourceCode default">A / B</code> works
-for all quantities <code class="sourceCode default">A</code> and
-<code class="sourceCode default">B</code>, whereas
-<code class="sourceCode default">A % B</code> is only meaningful when
-<code class="sourceCode default">A</code> and
-<code class="sourceCode default">B</code> have the same dimension. It
-seems like a nice-to-have for the property to apply in the case where
-both <code class="sourceCode default">/</code> and
-<code class="sourceCode default">%</code> are defined, but internal
-consistency of <code class="sourceCode default">/</code> across all
+<code class="sourceCode cpp"><span class="op">%</span></code> and
+<code class="sourceCode cpp"><span class="op">/</span></code> are quite
+different, so they lack the inherent connection they have for integers.
+In particular, I would expect that
+<code class="sourceCode cpp">A <span class="op">/</span> B</code> works
+for all quantities <code class="sourceCode cpp">A</code> and
+<code class="sourceCode cpp">B</code>, whereas
+<code class="sourceCode cpp">A <span class="op">%</span> B</code> is
+only meaningful when <code class="sourceCode cpp">A</code> and
+<code class="sourceCode cpp">B</code> have the same dimension. It seems
+like a nice-to-have for the property to apply in the case where both
+<code class="sourceCode cpp"><span class="op">/</span></code> and
+<code class="sourceCode cpp"><span class="op">%</span></code> are
+defined, but internal consistency of
+<code class="sourceCode cpp"><span class="op">/</span></code> across all
 cases seems much more important to me.</p>
-<p>I would expect <code class="sourceCode default">61 min % 1 h</code>
-to be <code class="sourceCode default">1 min</code>, and
-<code class="sourceCode default">1 h % 59 min</code> to also be
-<code class="sourceCode default">1 min</code>, so my intuition tells me
-that the result type of <code class="sourceCode default">A % B</code>,
-where <code class="sourceCode default">A</code> and
-<code class="sourceCode default">B</code> have the same dimension,
-should have the smaller unit of
-<code class="sourceCode default">A</code> and
-<code class="sourceCode default">B</code> (and if the smaller one
-doesn’t divide the larger one, we should either use the
-<code class="sourceCode default">gcd / std::common_type</code> of the
-units of <code class="sourceCode default">A</code> and
-<code class="sourceCode default">B</code> or perhaps just produce an
-error). I think any other behavior for
-<code class="sourceCode default">%</code> is hard to defend.</p>
+<p>I would expect <code class="sourceCode cpp"><span class="dv">61</span> min <span class="op">%</span> <span class="dv">1</span> h</code>
+to be <code class="sourceCode cpp"><span class="dv">1</span> min</code>,
+and <code class="sourceCode cpp"><span class="dv">1</span> h <span class="op">%</span> <span class="dv">59</span> min</code>
+to also be
+<code class="sourceCode cpp"><span class="dv">1</span> min</code>, so my
+intuition tells me that the result type of
+<code class="sourceCode cpp">A <span class="op">%</span> B</code>, where
+<code class="sourceCode cpp">A</code> and
+<code class="sourceCode cpp">B</code> have the same dimension, should
+have the smaller unit of <code class="sourceCode cpp">A</code> and
+<code class="sourceCode cpp">B</code> (and if the smaller one doesn’t
+divide the larger one, we should either use the <code class="sourceCode cpp">gcd <span class="op">/</span> std<span class="op">::</span>common_type</code>
+of the units of <code class="sourceCode cpp">A</code> and
+<code class="sourceCode cpp">B</code> or perhaps just produce an error).
+I think any other behavior for
+<code class="sourceCode cpp"><span class="op">%</span></code> is hard to
+defend.</p>
 <p>On the other hand, for division it seems to me that the choice of
-unit should probably not affect the result, and so if we want that
-<code class="sourceCode default">5 mm / 120 min = 0 mm/min</code>, then
-<code class="sourceCode default">5 h / 120 min == 0 hc</code> (where
-<code class="sourceCode default">hc</code> is a dimensionless
-“hexaconta”, or <code class="sourceCode default">60x</code>, unit). I
-don’t like the idea of taking SI base units into account; that seems
-arbitrary and like it would do the wrong thing as often as it does the
-right thing, especially when the units have a multiplier that is very
-large or small. We could special-case the situation of a dimensionless
-quantity, but that could lead to problematic overflow pretty easily: a
-calculation such as
-<code class="sourceCode default">10 s * 5 GHz * 2 uW</code> would
-overflow an <code class="sourceCode default">int</code> if it produces a
-dimensionless quantity for
-<code class="sourceCode default">10 s * 5 GHz</code>, but it could
-equally produce
-<code class="sourceCode default">50 G * 2 uW = 100 kW</code> without any
-overflow, and presumably would if the terms were merely reordered.</p>
+unit should probably not affect the result, and so if we want that <code class="sourceCode cpp"><span class="dv">5</span> mm <span class="op">/</span> <span class="dv">120</span> min <span class="op">=</span> <span class="dv">0</span> mm<span class="op">/</span>min</code>,
+then <code class="sourceCode cpp"><span class="dv">5</span> h <span class="op">/</span> <span class="dv">120</span> min <span class="op">==</span> <span class="dv">0</span> hc</code>
+(where <code class="sourceCode cpp">hc</code> is a dimensionless
+“hexaconta”, or <code class="sourceCode cpp"><span class="dv">60</span><span class="er">x</span></code>,
+unit). I don’t like the idea of taking SI base units into account; that
+seems arbitrary and like it would do the wrong thing as often as it does
+the right thing, especially when the units have a multiplier that is
+very large or small. We could special-case the situation of a
+dimensionless quantity, but that could lead to problematic overflow
+pretty easily: a calculation such as <code class="sourceCode cpp"><span class="dv">10</span> s <span class="op">*</span> <span class="dv">5</span> GHz <span class="op">*</span> <span class="dv">2</span> uW</code>
+would overflow an
+<code class="sourceCode cpp"><span class="dt">int</span></code> if it
+produces a dimensionless quantity for <code class="sourceCode cpp"><span class="dv">10</span> s <span class="op">*</span> <span class="dv">5</span> GHz</code>,
+but it could equally produce <code class="sourceCode cpp"><span class="dv">50</span> G <span class="op">*</span> <span class="dv">2</span> uW <span class="op">=</span> <span class="dv">100</span> kW</code>
+without any overflow, and presumably would if the terms were merely
+reordered.</p>
 <p>If people want to use integer-valued quantities, I think it’s
 fundamental that you need to know what the units of the result of an
 operation will be, and take that into account in how you express
 computations; the simplest rule for heterogeneous operators like
-<code class="sourceCode default">*</code> or
-<code class="sourceCode default">/</code> seems to be that the units of
-the result are determined by applying the operator to the units of the
-operands – and for homogeneous operators like
-<code class="sourceCode default">+</code> or
-<code class="sourceCode default">%</code>, it seems like the only
-reasonable option is that you get the
-<code class="sourceCode default">std::common_type</code> of the units of
-the operands.</p>
+<code class="sourceCode cpp"><span class="op">*</span></code> or
+<code class="sourceCode cpp"><span class="op">/</span></code> seems to
+be that the units of the result are determined by applying the operator
+to the units of the operands – and for homogeneous operators like
+<code class="sourceCode cpp"><span class="op">+</span></code> or
+<code class="sourceCode cpp"><span class="op">%</span></code>, it seems
+like the only reasonable option is that you get the <code class="sourceCode cpp">std<span class="op">::</span>common_type</code>
+of the units of the operands.</p>
 </blockquote>
 <p>To summarize, the modulo operator on physical units has more in
 common with addition and division operators than with the
@@ -7384,11 +7290,13 @@ <h4 data-number="16.8.2.5" id="comparison-against-zero"><span class="header-sect
 <span id="cb232-2"><a href="#cb232-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">// ...</span></span></code></pre></div>
 <p>The above would work (assuming we are dealing with the quantity of
 <em>speed</em>), but it’s not ideal. If the result of
-<code class="sourceCode default">q1 / q2</code> is not expressed in
-<code class="sourceCode default">m / s</code>, we’ll incur an extra unit
-conversion. Even if it is in
-<code class="sourceCode default">m / s</code>, it’s cumbersome to repeat
-the unit in a context where it makes no difference.</p>
+<code class="sourceCode cpp">q1 <span class="op">/</span> q2</code> is
+not expressed in
+<code class="sourceCode cpp">m <span class="op">/</span> s</code>, we’ll
+incur an extra unit conversion. Even if it is in
+<code class="sourceCode cpp">m <span class="op">/</span> s</code>, it’s
+cumbersome to repeat the unit in a context where it makes no
+difference.</p>
 <p>We could avoid repeating the unit, and guarantee there won’t be an
 extra conversion, by writing:</p>
 <div class="sourceCode" id="cb233"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb233-1"><a href="#cb233-1" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span><span class="op">(</span><span class="kw">auto</span> q <span class="op">=</span> q1 <span class="op">/</span> q2; q <span class="op">!=</span> q<span class="op">.</span>zero<span class="op">())</span></span>
@@ -7397,93 +7305,94 @@ <h4 data-number="16.8.2.5" id="comparison-against-zero"><span class="header-sect
 unaware of this technique and its rationale.</p>
 <h5 data-number="16.8.2.5.1" id="named-comparison-functions"><span class="header-section-number">16.8.2.5.1</span> Named comparison
 functions<a href="#named-comparison-functions" class="self-link"></a></h5>
-<p>For the above reasons, the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library provides dedicated
+<p>For the above reasons, the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library provides dedicated
 interfaces to compare against zero that follow the naming convention of
 <a href="https://en.cppreference.com/w/cpp/utility/compare/named_comparison_functions">named
 comparison functions</a> in the C++ Standard Library:</p>
 <ul>
-<li><code class="sourceCode default">is_eq_zero</code></li>
-<li><code class="sourceCode default">is_neq_zero</code></li>
-<li><code class="sourceCode default">is_lt_zero</code></li>
-<li><code class="sourceCode default">is_gt_zero</code></li>
-<li><code class="sourceCode default">is_lteq_zero</code></li>
-<li><code class="sourceCode default">is_gteq_zero</code></li>
+<li><code class="sourceCode cpp">is_eq_zero</code></li>
+<li><code class="sourceCode cpp">is_neq_zero</code></li>
+<li><code class="sourceCode cpp">is_lt_zero</code></li>
+<li><code class="sourceCode cpp">is_gt_zero</code></li>
+<li><code class="sourceCode cpp">is_lteq_zero</code></li>
+<li><code class="sourceCode cpp">is_gteq_zero</code></li>
 </ul>
 <p>Thanks to them, to save typing and not pay for unneeded conversions,
 our check could be implemented as follows:</p>
 <div class="sourceCode" id="cb234"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb234-1"><a href="#cb234-1" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>is_neq_zero<span class="op">(</span>q1 <span class="op">/</span> q2<span class="op">))</span></span>
 <span id="cb234-2"><a href="#cb234-2" aria-hidden="true" tabindex="-1"></a>  <span class="co">// ...</span></span></code></pre></div>
 <p>Those functions will work with any type
-<code class="sourceCode default">T</code> that exposes a
-<code class="sourceCode default">zero()</code> member function returning
-something comparable to <code class="sourceCode default">T</code>.
-Thanks to that, we can use them not only with quantities but also with
-<code class="sourceCode default">std::chrono::duration</code> or any
-other type that exposes such an interface.</p>
+<code class="sourceCode cpp">T</code> that exposes a
+<code class="sourceCode cpp">zero<span class="op">()</span></code>
+member function returning something comparable to
+<code class="sourceCode cpp">T</code>. Thanks to that, we can use them
+not only with quantities but also with <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>
+or any other type that exposes such an interface.</p>
 <p>This approach has a downside, though: it produces a set of new APIs
 which users must learn. Nor are these six the only such functions that
-will need to exist: for example,
-<code class="sourceCode default">max</code> and
-<code class="sourceCode default">min</code> are perfectly reasonable to
-use with <code class="sourceCode default">0</code> regardless of the
-units, but supporting them under this strategy would require adding a
-new utility function for each — and coming up with a name for those
-functions.</p>
+will need to exist: for example, <code class="sourceCode cpp">max</code>
+and <code class="sourceCode cpp">min</code> are perfectly reasonable to
+use with <code class="sourceCode cpp"><span class="dv">0</span></code>
+regardless of the units, but supporting them under this strategy would
+require adding a new utility function for each — and coming up with a
+name for those functions.</p>
 <p>It also introduces small opportunities for error and diffs that are
 harder to review, because we’re replacing a pattern that uses an
-operator (say, <code class="sourceCode default">a &gt; 0</code>) with a
-named function call (say,
-<code class="sourceCode default">is_gt_zero(a)</code>).</p>
+operator (say, <code class="sourceCode cpp">a <span class="op">&gt;</span> <span class="dv">0</span></code>)
+with a named function call (say, <code class="sourceCode cpp">is_gt_zero<span class="op">(</span>a<span class="op">)</span></code>).</p>
 <p>These pitfalls motivate us to consider other approaches as well.</p>
 <h5 data-number="16.8.2.5.2" id="zero-type"><span class="header-section-number">16.8.2.5.2</span>
-<code class="sourceCode default">Zero</code> type<a href="#zero-type" class="self-link"></a></h5>
-<p>The <span class="citation" data-cites="AU">[<a href="#ref-AU" role="doc-biblioref">Au</a>]</span> library takes a different approach
+<code class="sourceCode cpp">Zero</code> type<a href="#zero-type" class="self-link"></a></h5>
+<p>The <span class="citation" data-cites="AU">[<a href="https://aurora-opensource.github.io/au" role="doc-biblioref">Au</a>]</span> library takes a different approach
 to this problem. It provides an empty type,
-<code class="sourceCode default">Zero</code>, which represents a value
-of exactly <code class="sourceCode default">0</code> (in any units). It
-also provides an instance <code class="sourceCode default">ZERO</code>
-of this type. Every quantity is implicitly constructible from
-<code class="sourceCode default">Zero</code>.</p>
+<code class="sourceCode cpp">Zero</code>, which represents a value of
+exactly <code class="sourceCode cpp"><span class="dv">0</span></code>
+(in any units). It also provides an instance
+<code class="sourceCode cpp">ZERO</code> of this type. Every quantity is
+implicitly constructible from
+<code class="sourceCode cpp">Zero</code>.</p>
 <p>Consider this example legacy (i.e., pre-units-library) code:</p>
 <div class="sourceCode" id="cb235"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb235-1"><a href="#cb235-1" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>speed_squared_m2ps2 <span class="op">&gt;</span> <span class="dv">0</span><span class="op">)</span> <span class="op">{</span> <span class="co">/* ... */</span> <span class="op">}</span></span></code></pre></div>
 <p>When users upgrade to a units library, they will replace the raw
-number <code class="sourceCode default">speed_squared_m2ps2</code> with
-a strongly typed quantity
-<code class="sourceCode default">speed_squared</code>. Unfortunately,
-this replacement won’t compile, because quantities can’t be constructed
-from raw numeric values such as
-<code class="sourceCode default">0</code>. They can fix this problem by
-using the instance, <code class="sourceCode default">ZERO</code>, which
-encodes its value in the type:</p>
+number <code class="sourceCode cpp">speed_squared_m2ps2</code> with a
+strongly typed quantity
+<code class="sourceCode cpp">speed_squared</code>. Unfortunately, this
+replacement won’t compile, because quantities can’t be constructed from
+raw numeric values such as
+<code class="sourceCode cpp"><span class="dv">0</span></code>. They can
+fix this problem by using the instance,
+<code class="sourceCode cpp">ZERO</code>, which encodes its value in the
+type:</p>
 <div class="sourceCode" id="cb236"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb236-1"><a href="#cb236-1" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> <span class="op">(</span>speed_squared <span class="op">&gt;</span> ZERO<span class="op">)</span> <span class="op">{</span> <span class="co">/* ... */</span> <span class="op">}</span></span></code></pre></div>
 <p>This has significant advantages. It preserves the form of the code,
 making the transition less error prone than replacement with a function
-such as <code class="sourceCode default">is_gt_zero</code>. It also
-reduces the number of new comparison APIs a user must learn:
-<code class="sourceCode default">Zero</code> handles them all.</p>
-<p><code class="sourceCode default">Zero</code> has one downside: it
-will not work when passed across generic quantity interfaces.
-<code class="sourceCode default">Zero</code>’s value comes in situations
+such as <code class="sourceCode cpp">is_gt_zero</code>. It also reduces
+the number of new comparison APIs a user must learn:
+<code class="sourceCode cpp">Zero</code> handles them all.</p>
+<p><code class="sourceCode cpp">Zero</code> has one downside: it will
+not work when passed across generic quantity interfaces.
+<code class="sourceCode cpp">Zero</code>’s value comes in situations
 where the surrounding context makes it unambiguous which quantity type
 it should construct. While it converts to any specific quantity type, it
 is not itself a quantity. This could confuse users.</p>
 <p>This downside manifests in several different ways. Here are some
 examples:</p>
 <ol type="1">
-<li><p>While refactoring the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> code to try out this approach,
+<li><p>While refactoring the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> code to try out this approach,
 we found out a perfectly reasonable place where we could not replace the
-numerical value <code class="sourceCode default">0</code> with
-<code class="sourceCode default">ZERO</code>:</p>
+numerical value
+<code class="sourceCode cpp"><span class="dv">0</span></code> with
+<code class="sourceCode cpp">ZERO</code>:</p>
 <div class="sourceCode" id="cb237"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb237-1"><a href="#cb237-1" aria-hidden="true" tabindex="-1"></a>msl_altitude alt <span class="op">=</span> mean_sea_level <span class="op">+</span> <span class="dv">0</span> <span class="op">*</span> si<span class="op">::</span>metre;  <span class="co">// OK</span></span>
 <span id="cb237-2"><a href="#cb237-2" aria-hidden="true" tabindex="-1"></a>msl_altitude alt <span class="op">=</span> mean_sea_level <span class="op">+</span> ZERO;           <span class="co">// Compile-time error</span></span></code></pre></div>
 <p>This would not work because the
-<code class="sourceCode default">mean_sea_level</code> is an absolute
-point origin that stores the information about the quantity type but not
-its value or unit, which
-<code class="sourceCode default">msl_altitude</code> needs, but none of
-which <code class="sourceCode default">ZERO</code> has.</p></li>
-<li><p>Callsites passing <code class="sourceCode default">ZERO</code>
-can add friction when refactoring a concrete interface to be more
+<code class="sourceCode cpp">mean_sea_level</code> is an absolute point
+origin that stores the information about the quantity type but not its
+value or unit, which <code class="sourceCode cpp">msl_altitude</code>
+needs, but none of which <code class="sourceCode cpp">ZERO</code>
+has.</p></li>
+<li><p>Callsites passing <code class="sourceCode cpp">ZERO</code> can
+add friction when refactoring a concrete interface to be more
 generic.</p>
 <div class="sourceCode" id="cb238"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb238-1"><a href="#cb238-1" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> v1 <span class="op">{</span> <span class="dt">void</span> foo<span class="op">(</span>quantity<span class="op">&lt;</span>si<span class="op">::</span>metre<span class="op">&gt;</span> q<span class="op">)</span>; <span class="op">}</span></span>
 <span id="cb238-2"><a href="#cb238-2" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> v2 <span class="op">{</span> <span class="dt">void</span> foo<span class="op">(</span>QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>length<span class="op">&gt;</span> <span class="kw">auto</span> q<span class="op">)</span>; <span class="op">}</span></span>
@@ -7493,18 +7402,18 @@ <h5 data-number="16.8.2.5.2" id="zero-type"><span class="header-section-number">
 <p>In practice, this issue will be discovered at the point of
 refactoring, so it mainly affects library authors, not their clients.
 They can handle this by adding an overload for
-<code class="sourceCode default">Zero</code>, if appropriate. However,
-this wouldn’t scale well for APIs with multiple parameters where users
-would want to pass
-<code class="sourceCode default">Zero</code>.</p></li>
+<code class="sourceCode cpp">Zero</code>, if appropriate. However, this
+wouldn’t scale well for APIs with multiple parameters where users would
+want to pass <code class="sourceCode cpp">Zero</code>.</p></li>
 <li><p>For completeness, we mention that
-<code class="sourceCode default">Zero</code> works for addition but not
+<code class="sourceCode cpp">Zero</code> works for addition but not
 multiplication. When multiplying, we do not know what units (or even
 what dimension!) is desired for the result. However, this is not a
 problem in practice because users would not be motivated to write this
 in the first place, as simple multiplication with
-<code class="sourceCode default">0</code> (including any necessary
-units, if the result has a different dimension) would work.</p>
+<code class="sourceCode cpp"><span class="dv">0</span></code> (including
+any necessary units, if the result has a different dimension) would
+work.</p>
 <div class="sourceCode" id="cb239"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb239-1"><a href="#cb239-1" aria-hidden="true" tabindex="-1"></a>quantity q1 <span class="op">=</span> <span class="dv">1</span> <span class="op">*</span> m <span class="op">/</span> s;</span>
 <span id="cb239-2"><a href="#cb239-2" aria-hidden="true" tabindex="-1"></a>quantity q2 <span class="op">=</span> q1 <span class="op">+</span> <span class="dv">0</span> <span class="op">*</span> m <span class="op">/</span> s;   <span class="co">// OK</span></span>
 <span id="cb239-3"><a href="#cb239-3" aria-hidden="true" tabindex="-1"></a>quantity q3 <span class="op">=</span> q1 <span class="op">*</span> <span class="op">(</span><span class="dv">0</span> <span class="op">*</span> s<span class="op">)</span>;     <span class="co">// OK</span></span></code></pre></div>
@@ -7512,57 +7421,55 @@ <h5 data-number="16.8.2.5.2" id="zero-type"><span class="header-section-number">
 <span id="cb240-2"><a href="#cb240-2" aria-hidden="true" tabindex="-1"></a>quantity q2 <span class="op">=</span> q1 <span class="op">+</span> ZERO;        <span class="co">// OK</span></span>
 <span id="cb240-3"><a href="#cb240-3" aria-hidden="true" tabindex="-1"></a>quantity q3 <span class="op">=</span> q1 <span class="op">*</span> ZERO;        <span class="co">// Compile-time error</span></span></code></pre></div></li>
 </ol>
-<p>The main concern with the
-<code class="sourceCode default">Zero</code> feature is that novices
-might be tempted to replace every numeric value
-<code class="sourceCode default">0</code> with the instance
-<code class="sourceCode default">ZERO</code>, becoming confused when it
-doesn’t work. We could address this with easy-to-read documentation that
-clarifies its use cases and mental models.</p>
+<p>The main concern with the <code class="sourceCode cpp">Zero</code>
+feature is that novices might be tempted to replace every numeric value
+<code class="sourceCode cpp"><span class="dv">0</span></code> with the
+instance <code class="sourceCode cpp">ZERO</code>, becoming confused
+when it doesn’t work. We could address this with easy-to-read
+documentation that clarifies its use cases and mental models.</p>
 <h5 data-number="16.8.2.5.3" id="summary-comparison-against-zero"><span class="header-section-number">16.8.2.5.3</span> Summary (comparison
 against zero)<a href="#summary-comparison-against-zero" class="self-link"></a></h5>
 <p>Overall, these two approaches — special functions, and a
-<code class="sourceCode default">Zero</code> type — represent two local
+<code class="sourceCode cpp">Zero</code> type — represent two local
 optima in design space. Each has its strengths and weaknesses; each
 makes different tradeoffs. It’s currently an open question as to which
 approach would be best suited for a quantity type in the standard
 library.</p>
 <h4 data-number="16.8.2.6" id="other-maths"><span class="header-section-number">16.8.2.6</span> Other maths<a href="#other-maths" class="self-link"></a></h4>
 <p>This chapter scoped only on the
-<code class="sourceCode default">quantity</code> type’s operators.
-However, there are many named math functions provided in the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library. Among others, we can
+<code class="sourceCode cpp">quantity</code> type’s operators. However,
+there are many named math functions provided in the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library. Among others, we can
 find there the following:</p>
 <ul>
-<li><code class="sourceCode default">pow()</code>,
-<code class="sourceCode default">sqrt()</code>, and
-<code class="sourceCode default">cbrt()</code>,</li>
-<li><code class="sourceCode default">exp()</code>,</li>
-<li><code class="sourceCode default">abs()</code>,</li>
-<li><code class="sourceCode default">epsilon()</code>,</li>
-<li><code class="sourceCode default">fma()</code>,
-<code class="sourceCode default">fmod()</code>,</li>
-<li><code class="sourceCode default">floor()</code>,
-<code class="sourceCode default">ceil()</code>,
-<code class="sourceCode default">round()</code>,</li>
-<li><code class="sourceCode default">inverse()</code>,</li>
-<li><code class="sourceCode default">hypot()</code>,</li>
-<li><code class="sourceCode default">sin()</code>,
-<code class="sourceCode default">cos()</code>,
-<code class="sourceCode default">tan()</code>,</li>
-<li><code class="sourceCode default">asin()</code>,
-<code class="sourceCode default">acos()</code>,
-<code class="sourceCode default">atan()</code>,
-<code class="sourceCode default">atan2()</code>.</li>
+<li><code class="sourceCode cpp">pow<span class="op">()</span></code>,
+<code class="sourceCode cpp">sqrt<span class="op">()</span></code>, and
+<code class="sourceCode cpp">cbrt<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">exp<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">abs<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">epsilon<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">fma<span class="op">()</span></code>,
+<code class="sourceCode cpp">fmod<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">floor<span class="op">()</span></code>,
+<code class="sourceCode cpp">ceil<span class="op">()</span></code>,
+<code class="sourceCode cpp">round<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">inverse<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">hypot<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">sin<span class="op">()</span></code>,
+<code class="sourceCode cpp">cos<span class="op">()</span></code>,
+<code class="sourceCode cpp">tan<span class="op">()</span></code>,</li>
+<li><code class="sourceCode cpp">asin<span class="op">()</span></code>,
+<code class="sourceCode cpp">acos<span class="op">()</span></code>,
+<code class="sourceCode cpp">atan<span class="op">()</span></code>,
+<code class="sourceCode cpp">atan2<span class="op">()</span></code>.</li>
 </ul>
-<p>In the library, we can also find the
-<code class="sourceCode default">&lt;mp-units/random.h&gt;</code> header
-file with all the pseudo-random number generators.</p>
+<p>In the library, we can also find the <code class="sourceCode cpp"><span class="op">&lt;</span>mp<span class="op">-</span>units<span class="op">/</span>random<span class="op">.</span>h<span class="op">&gt;</span></code>
+header file with all the pseudo-random number generators.</p>
 <p>We plan to provide a separate paper on those in the future.</p>
 <h3 data-number="16.8.3" id="dimensionless-quantities"><span class="header-section-number">16.8.3</span> Dimensionless quantities<a href="#dimensionless-quantities" class="self-link"></a></h3>
 <p>The quantities we discussed so far always had some specific type and
 physical dimension. However, this is not always the case. While
 performing various computations, we sometimes end up with so-called
-“dimensionless” quantities, which <span class="citation" data-cites="ISO-GUIDE">[<a href="#ref-ISO-GUIDE" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> correctly defines as
+“dimensionless” quantities, which <span class="citation" data-cites="ISO-GUIDE">[<a href="https://www.iso.org/obp/ui#iso:std:iso-iec:guide:99" role="doc-biblioref">ISO/IEC Guide 99</a>]</span> correctly defines as
 quantities of dimension one:</p>
 <blockquote>
 <ul>
@@ -7583,34 +7490,35 @@ <h4 data-number="16.8.3.1" id="dividing-two-quantities-of-the-same-kind"><span c
 types.</p>
 <p>Dividing two quantities of the same dimension always results in a
 quantity with the dimension being
-<code class="sourceCode default">dimension_one</code>. This is often
+<code class="sourceCode cpp">dimension_one</code>. This is often
 different for other physical units libraries, which may return a raw
 representation type for such cases. A raw value is also always returned
-from the division of two
-<code class="sourceCode default">std::chrono::duration</code>
+from the division of two <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>
 values.</p>
-<p>In the initial design of the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library, the resulting type of
+<p>In the initial design of the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library, the resulting type of
 division of two quantities was their common representation type (just
-like <code class="sourceCode default">std::chrono::duration</code>):</p>
+like <code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code>):</p>
 <div class="sourceCode" id="cb241"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb241-1"><a href="#cb241-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>std<span class="op">::</span>is_same_v<span class="op">&lt;</span><span class="kw">decltype</span><span class="op">(</span><span class="dv">10</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">5</span> <span class="op">*</span> km<span class="op">))</span>, <span class="dt">int</span><span class="op">&gt;)</span>;</span></code></pre></div>
 <p>The reasoning behind it was not providing a false impression of a
-strong <code class="sourceCode default">quantity</code> type for
-something that looks and feels like a regular number. Also, all of the
-mathematic and trigonometric functions were working fine out of the box
-with such representation types, so we did not have to rewrite
-<code class="sourceCode default">sin()</code>,
-<code class="sourceCode default">cos()</code>,
-<code class="sourceCode default">exp()</code>, and others.</p>
+strong <code class="sourceCode cpp">quantity</code> type for something
+that looks and feels like a regular number. Also, all of the mathematic
+and trigonometric functions were working fine out of the box with such
+representation types, so we did not have to rewrite
+<code class="sourceCode cpp">sin<span class="op">()</span></code>,
+<code class="sourceCode cpp">cos<span class="op">()</span></code>,
+<code class="sourceCode cpp">exp<span class="op">()</span></code>, and
+others.</p>
 <p>However, the feedback we got from the production usage was that such
 an approach is really bad for generic programming. It is hard to handle
 the result of the two quantities’ division (or multiplication) as it
 might be either a quantity or a fundamental type. If we want to raise
 such a result to some power, we must use
-<code class="sourceCode default">units::pow</code> or
-<code class="sourceCode default">std::pow</code> depending on the
-resulting type (<code class="sourceCode default">units::pow</code> takes
-the power as template arguments). Those are only a few issues related to
-such an approach.</p>
+<code class="sourceCode cpp">units<span class="op">::</span>pow</code>
+or <code class="sourceCode cpp">std<span class="op">::</span>pow</code>
+depending on the resulting type
+(<code class="sourceCode cpp">units<span class="op">::</span>pow</code>
+takes the power as template arguments). Those are only a few issues
+related to such an approach.</p>
 <p>Moreover, suppose we divide quantities of the same dimension, but
 with units of significantly different magnitudes. In such case, we may
 end up with a really small or a huge floating-point value, which may
@@ -7628,30 +7536,28 @@ <h5 data-number="16.8.3.1.1" id="dividing-quantities-of-the-same-type"><span cla
 <span id="cb243-2"><a href="#cb243-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>q<span class="op">.</span>dimension <span class="op">==</span> dimension_one<span class="op">)</span>;</span>
 <span id="cb243-3"><a href="#cb243-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>q<span class="op">.</span>unit <span class="op">==</span> one<span class="op">)</span>;</span></code></pre></div>
 <p>In case we would like to print its value, we would see a raw value of
-<code class="sourceCode default">4</code> in the output with no unit
-being printed.</p>
+<code class="sourceCode cpp"><span class="dv">4</span></code> in the
+output with no unit being printed.</p>
 <h5 data-number="16.8.3.1.2" id="dividing-quantities-of-different-types"><span class="header-section-number">16.8.3.1.2</span> Dividing quantities of
 different types<a href="#dividing-quantities-of-different-types" class="self-link"></a></h5>
 <p>We can divide quantities of the same dimension and unit but of
 different quantity types:</p>
 <div class="sourceCode" id="cb244"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb244-1"><a href="#cb244-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> QuantityOf<span class="op">&lt;</span>dimensionless<span class="op">&gt;</span> <span class="kw">auto</span> q <span class="op">=</span> isq<span class="op">::</span>work<span class="op">(</span><span class="dv">200</span> <span class="op">*</span> J<span class="op">)</span> <span class="op">/</span> isq<span class="op">::</span>heat<span class="op">(</span><span class="dv">50</span> <span class="op">*</span> J<span class="op">)</span>;</span></code></pre></div>
 <p>Again we end up with
-<code class="sourceCode default">dimension_one</code> and
-<code class="sourceCode default">one</code>, but this time:</p>
+<code class="sourceCode cpp">dimension_one</code> and
+<code class="sourceCode cpp">one</code>, but this time:</p>
 <div class="sourceCode" id="cb245"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb245-1"><a href="#cb245-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>q<span class="op">.</span>quantity_spec <span class="op">==</span> isq<span class="op">::</span>work <span class="op">/</span> isq<span class="op">::</span>heat<span class="op">)</span>;</span></code></pre></div>
 <p>As shown above, the result is not of a
-<code class="sourceCode default">dimensionless</code> type anymore.
-Instead, we get a quantity type derived from the performed quantity
-equation. According to the <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>, <em>work</em> divided by
+<code class="sourceCode cpp">dimensionless</code> type anymore. Instead,
+we get a quantity type derived from the performed quantity equation.
+According to the <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>, <em>work</em> divided by
 <em>heat</em> is the recipe for the <em>thermodynamic efficiency</em>
 quantity, thus:</p>
 <div class="sourceCode" id="cb246"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb246-1"><a href="#cb246-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>implicitly_convertible<span class="op">(</span>q<span class="op">.</span>quantity_spec, isq<span class="op">::</span>efficiency_thermodynamics<span class="op">))</span>;</span></code></pre></div>
-<p>Please note that the quantity of
-<code class="sourceCode default">isq::efficiency_thermodynamics</code>
-is of a kind <code class="sourceCode default">dimensionless</code>, so
-it is implicitly convertible to
-<code class="sourceCode default">dimensionless</code> and satisfies the
-<a href="#QuantityOf-concept"><code class="sourceCode default">QuantityOf&lt;dimensionless&gt;</code></a>
+<p>Please note that the quantity of <code class="sourceCode cpp">isq<span class="op">::</span>efficiency_thermodynamics</code>
+is of a kind <code class="sourceCode cpp">dimensionless</code>, so it is
+implicitly convertible to
+<code class="sourceCode cpp">dimensionless</code> and satisfies the <a href="#QuantityOf-concept"><code class="sourceCode cpp">QuantityOf<span class="op">&lt;</span>dimensionless<span class="op">&gt;</span></code></a>
 concept.</p>
 <h5 data-number="16.8.3.1.3" id="dividing-quantities-of-different-units"><span class="header-section-number">16.8.3.1.3</span> Dividing quantities of
 different units<a href="#dividing-quantities-of-different-units" class="self-link"></a></h5>
@@ -7659,22 +7565,23 @@ <h5 data-number="16.8.3.1.3" id="dividing-quantities-of-different-units"><span c
 type but different units:</p>
 <div class="sourceCode" id="cb247"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb247-1"><a href="#cb247-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> QuantityOf<span class="op">&lt;</span>dimensionless<span class="op">&gt;</span> <span class="kw">auto</span> q <span class="op">=</span> isq<span class="op">::</span>height<span class="op">(</span><span class="dv">4</span> <span class="op">*</span> km<span class="op">)</span> <span class="op">/</span> isq<span class="op">::</span>height<span class="op">(</span><span class="dv">2</span> <span class="op">*</span> m<span class="op">)</span>;</span></code></pre></div>
 <p>This time we get a quantity of
-<code class="sourceCode default">dimensionless</code> type with a
-<code class="sourceCode default">dimension_one</code> as its dimension.
+<code class="sourceCode cpp">dimensionless</code> type with a
+<code class="sourceCode cpp">dimension_one</code> as its dimension.
 However, the resulting unit is not
-<code class="sourceCode default">one</code> anymore:</p>
+<code class="sourceCode cpp">one</code> anymore:</p>
 <div class="sourceCode" id="cb248"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb248-1"><a href="#cb248-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>q<span class="op">.</span>unit <span class="op">==</span> mag_power<span class="op">&lt;</span><span class="dv">10</span>, <span class="dv">3</span><span class="op">&gt;</span> <span class="op">*</span> one<span class="op">)</span>;</span></code></pre></div>
 <p>In case we would print the text output of this quantity, we would not
-see a raw value of <code class="sourceCode default">2000</code>, but
-<code class="sourceCode default">2 km/m</code>.</p>
+see a raw value of
+<code class="sourceCode cpp"><span class="dv">2000</span></code>, but
+<code class="sourceCode cpp"><span class="dv">2</span> km<span class="op">/</span>m</code>.</p>
 <p>First, it may look surprising, but this is actually consistent with
 the division of quantities of different dimensions. For example, if we
-divide <code class="sourceCode default">4 * km / (2 * s)</code>, we do
-not expect <code class="sourceCode default">km</code> to be “expanded”
-to <code class="sourceCode default">m</code> before the division, right?
-We would expect the result of
-<code class="sourceCode default">2 * (km / s)</code>, which is exactly
-what we get when we divide quantities of the same kind.</p>
+divide <code class="sourceCode cpp"><span class="dv">4</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">2</span> <span class="op">*</span> s<span class="op">)</span></code>,
+we do not expect <code class="sourceCode cpp">km</code> to be “expanded”
+to <code class="sourceCode cpp">m</code> before the division, right? We
+would expect the result of <code class="sourceCode cpp"><span class="dv">2</span> <span class="op">*</span> <span class="op">(</span>km <span class="op">/</span> s<span class="op">)</span></code>,
+which is exactly what we get when we divide quantities of the same
+kind.</p>
 <p>This is a compelling feature that allows us to express huge or tiny
 ratios without the need for big and expensive representation types. With
 this, we can easily define things like a <a href="https://en.wikipedia.org/wiki/Hubble%27s_law#Dimensionless_Hubble_constant">Hubble’s
@@ -7687,57 +7594,54 @@ <h4 data-number="16.8.3.2" id="counts-of-things"><span class="header-section-num
 <p>Another important use case for dimensionless quantities is to provide
 strong types for counts of things. For example:</p>
 <ul>
-<li><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-(part 3) provides a <em>rotation</em> quantity defined as the number of
-revolutions,</li>
-<li><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-(part 6) provides a <em>number of turns in a winding</em> quantity,</li>
-<li><span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-(part 13) provides a <em>Hamming distance</em> quantity defined as the
-number of digit positions in which the corresponding digits of two words
-of the same length are different.</li>
+<li><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 3) provides a
+<em>rotation</em> quantity defined as the number of revolutions,</li>
+<li><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 6) provides a
+<em>number of turns in a winding</em> quantity,</li>
+<li><span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 13) provides a
+<em>Hamming distance</em> quantity defined as the number of digit
+positions in which the corresponding digits of two words of the same
+length are different.</li>
 </ul>
 <p>Thanks to assigning strong names to such quantities, they can be used
 in the quantity equation of other quantities. For example,
-<em>rotational frequency</em> is defined by
-<code class="sourceCode default">rotation / duration</code>.</p>
+<em>rotational frequency</em> is defined by <code class="sourceCode cpp">rotation <span class="op">/</span> duration</code>.</p>
 <h4 data-number="16.8.3.3" id="lack-of-convertibility-from-fundamental-types"><span class="header-section-number">16.8.3.3</span> Lack of convertibility
 from fundamental types<a href="#lack-of-convertibility-from-fundamental-types" class="self-link"></a></h4>
 <p>As stated before, the division of two quantities of the same kind
 results in a quantity of dimension one. Even though it does not have a
 specific physical dimension it still uses units with various ratios such
-as <code class="sourceCode default">one</code>,
-<code class="sourceCode default">percent</code>,
-<code class="sourceCode default">radian</code>,
-<code class="sourceCode default">degree</code>, etc. It is essential to
-be explicit about which unit we want to use for such a quantity.</p>
+as <code class="sourceCode cpp">one</code>,
+<code class="sourceCode cpp">percent</code>,
+<code class="sourceCode cpp">radian</code>,
+<code class="sourceCode cpp">degree</code>, etc. It is essential to be
+explicit about which unit we want to use for such a quantity.</p>
 <p>However, in some cases, this might look like an overkill. In the <a href="#basic-quantity-equations">Basic quantity equations</a> chapter
 one of the lines looks as follows:</p>
 <div class="sourceCode" id="cb250"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb250-1"><a href="#cb250-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span><span class="dv">10</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">5</span> <span class="op">*</span> km<span class="op">)</span> <span class="op">==</span> <span class="dv">2</span> <span class="op">*</span> one<span class="op">)</span>;</span></code></pre></div>
 <p>Another example could be subtracting a value
-<code class="sourceCode default">1</code> from the dimensionless
-quantity that we can find in <a href="#storage-tank">Storage tank</a>
-example:</p>
+<code class="sourceCode cpp"><span class="dv">1</span></code> from the
+dimensionless quantity that we can find in <a href="#storage-tank">Storage tank</a> example:</p>
 <div class="sourceCode" id="cb251"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb251-1"><a href="#cb251-1" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>time<span class="op">&gt;</span> <span class="kw">auto</span> fill_time_left <span class="op">=</span> <span class="op">(</span>height <span class="op">/</span> fill_level <span class="op">-</span> <span class="dv">1</span> <span class="op">*</span> one<span class="op">)</span> <span class="op">*</span> fill_time;</span></code></pre></div>
-<p>Some physical quantities and units libraries (e.g. <span class="citation" data-cites="BOOST-UNITS">[<a href="#ref-BOOST-UNITS" role="doc-biblioref">Boost.Units</a>]</span>) provide <a href="https://www.boost.org/doc/libs/1_83_0/doc/html/boost_units/Quantities.html#boost_units.Quantities.Quantity_Construction_and_Conversion">implicit
+<p>Some physical quantities and units libraries (e.g. <span class="citation" data-cites="BOOST-UNITS">[<a href="https://www.boost.org/doc/libs/1_83_0/doc/html/boost_units.html" role="doc-biblioref">Boost.Units</a>]</span>) provide <a href="https://www.boost.org/doc/libs/1_83_0/doc/html/boost_units/Quantities.html#boost_units.Quantities.Quantity_Construction_and_Conversion">implicit
 conversions from the values of representation types to such
 quantities</a>.</p>
 <p>With such support, the above examples would look in the following
 way:</p>
 <div class="sourceCode" id="cb252"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb252-1"><a href="#cb252-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span><span class="dv">10</span> <span class="op">*</span> km <span class="op">/</span> <span class="op">(</span><span class="dv">5</span> <span class="op">*</span> km<span class="op">)</span> <span class="op">==</span> <span class="dv">2</span><span class="op">)</span>;</span></code></pre></div>
 <div class="sourceCode" id="cb253"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb253-1"><a href="#cb253-1" aria-hidden="true" tabindex="-1"></a><span class="kw">const</span> QuantityOf<span class="op">&lt;</span>isq<span class="op">::</span>time<span class="op">&gt;</span> <span class="kw">auto</span> fill_time_left <span class="op">=</span> <span class="op">(</span>height <span class="op">/</span> fill_level <span class="op">-</span> <span class="dv">1</span><span class="op">)</span> <span class="op">*</span> fill_time;</span></code></pre></div>
-<p>Such simplification might look tempting, and the <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> initially provided a special
+<p>Such simplification might look tempting, and the <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> initially provided a special
 support that allowed the above to compile. However, in the V2 version of
 the library, it was removed. There are a few reasons for that:</p>
 <ul>
 <li><p>Such support has sense only for quantities of dimension one with
-a unit <code class="sourceCode default">one</code>. In the case of all
-the other units, the specific unit should still be provided.</p></li>
+a unit <code class="sourceCode cpp">one</code>. In the case of all the
+other units, the specific unit should still be provided.</p></li>
 <li><p>If we provide implicit conversions from the representation type
 to a quantity of dimension one with a unit
-<code class="sourceCode default">one</code> and we start depending on
-such a feature, we might end up with compile-time errors after
-refactoring the unit in a type of such a quantity. For example:</p></li>
+<code class="sourceCode cpp">one</code> and we start depending on such a
+feature, we might end up with compile-time errors after refactoring the
+unit in a type of such a quantity. For example:</p></li>
 </ul>
 <table>
 <thead>
@@ -7782,18 +7686,18 @@ <h4 data-number="16.8.3.3" id="lack-of-convertibility-from-fundamental-types"><s
 </ul>
 <p>Please also note that we will still need to use explicit units to
 create a quantity for some cases. For example, in the following code,
-<code class="sourceCode default">asin(-1)</code> would use the overload
-from the <code class="sourceCode default">&lt;math&gt;</code> header of
-the C++ standard library rather than the one for quantities provided in
-<code class="sourceCode default">&lt;mp-units/math.h&gt;</code> header
-file:</p>
+<code class="sourceCode cpp">asin<span class="op">(-</span><span class="dv">1</span><span class="op">)</span></code>
+would use the overload from the <code class="sourceCode cpp"><span class="op">&lt;</span>math<span class="op">&gt;</span></code>
+header of the C++ standard library rather than the one for quantities
+provided in <code class="sourceCode cpp"><span class="op">&lt;</span>mp<span class="op">-</span>units<span class="op">/</span>math<span class="op">.</span>h<span class="op">&gt;</span></code>
+header file:</p>
 <div class="sourceCode" id="cb256"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb256-1"><a href="#cb256-1" aria-hidden="true" tabindex="-1"></a>REQUIRE_THAT<span class="op">(</span>asin<span class="op">(-</span><span class="dv">1</span> <span class="op">*</span> one<span class="op">)</span>, AlmostEquals<span class="op">(-</span><span class="fl">90.</span> <span class="op">*</span> deg<span class="op">))</span>;</span></code></pre></div>
 <p>The authors of this paper are not opposed to providing support for
 conversions from the raw value to the dimensionless quantity of a unit
-<code class="sourceCode default">one</code>. If WG21 groups decide that
-is a good direction, we will provide additional interfaces to the
-library to support such a scenario. If we choose to go this path, two
-questions should be answered first:</p>
+<code class="sourceCode cpp">one</code>. If WG21 groups decide that is a
+good direction, we will provide additional interfaces to the library to
+support such a scenario. If we choose to go this path, two questions
+should be answered first:</p>
 <ol type="1">
 <li><p>Should such a conversion be explicit or implicit?</p>
 <p>We may be tempted to stay on the safe side and choose explicit
@@ -7803,8 +7707,8 @@ <h4 data-number="16.8.3.3" id="lack-of-convertibility-from-fundamental-types"><s
 <p>It would be strange to support arithmetics against the raw value if
 the quantity type can’t be implicitly constructed from it.</p></li>
 <li><p>Should we support converting from the dimensionless quantity with
-unit <code class="sourceCode default">one</code> to the raw value? And
-if yes, should it be implicit or explicit?</p>
+unit <code class="sourceCode cpp">one</code> to the raw value? And if
+yes, should it be implicit or explicit?</p>
 <p>It could probably be better to allow implicit conversions to work
 with legacy interfaces or to benefit from regular math-related functions
 that work on fundamental types. Otherwise, we will need to type
@@ -7816,10 +7720,10 @@ <h4 data-number="16.8.3.3" id="lack-of-convertibility-from-fundamental-types"><s
 <h4 data-number="16.8.3.4" id="predefined-units-of-the-dimensionless-quantity"><span class="header-section-number">16.8.3.4</span> Predefined units of the
 dimensionless quantity<a href="#predefined-units-of-the-dimensionless-quantity" class="self-link"></a></h4>
 <p>As we observed above, the most common unit for dimensionless
-quantities is <code class="sourceCode default">one</code>. It has the
-ratio of <code class="sourceCode default">1</code> and does not output
-any textual symbol.</p>
-<p>A unit <code class="sourceCode default">one</code> is special in the
+quantities is <code class="sourceCode cpp">one</code>. It has the ratio
+of <code class="sourceCode cpp"><span class="dv">1</span></code> and
+does not output any textual symbol.</p>
+<p>A unit <code class="sourceCode cpp">one</code> is special in the
 entire type system of units as it is considered to be an identity
 operand in the unit expression templates. This means that, for
 example:</p>
@@ -7827,11 +7731,11 @@ <h4 data-number="16.8.3.4" id="predefined-units-of-the-dimensionless-quantity"><
 <span id="cb260-2"><a href="#cb260-2" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>one <span class="op">*</span> si<span class="op">::</span>metre <span class="op">==</span> si<span class="op">::</span>metre<span class="op">)</span>;</span>
 <span id="cb260-3"><a href="#cb260-3" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>si<span class="op">::</span>metre <span class="op">/</span> si<span class="op">::</span>metre <span class="op">==</span> one<span class="op">)</span>;</span></code></pre></div>
 <p>The same is also true for
-<code class="sourceCode default">dimension_one</code> and
-<code class="sourceCode default">dimensionless</code> in the domains of
+<code class="sourceCode cpp">dimension_one</code> and
+<code class="sourceCode cpp">dimensionless</code> in the domains of
 dimensions and quantity specifications, respectively.</p>
-<p>Besides the unit <code class="sourceCode default">one</code>, there
-are a few other scaled units predefined in the library for usage with
+<p>Besides the unit <code class="sourceCode cpp">one</code>, there are a
+few other scaled units predefined in the library for usage with
 dimensionless quantities:</p>
 <div class="sourceCode" id="cb261"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb261-1"><a href="#cb261-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> percent <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;%&quot;</span>, mag_ratio<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">100</span><span class="op">&gt;</span> <span class="op">*</span> one<span class="op">&gt;</span> <span class="op">{}</span> percent;</span>
 <span id="cb261-2"><a href="#cb261-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> per_mille <span class="op">:</span> named_unit<span class="op">&lt;{</span><span class="st">u8&quot;‰&quot;</span>, <span class="st">&quot;</span><span class="sc">%o</span><span class="st">&quot;</span><span class="op">}</span>, mag_ratio<span class="op">&lt;</span><span class="dv">1</span>, <span class="dv">1000</span><span class="op">&gt;</span> <span class="op">*</span> one<span class="op">&gt;</span> <span class="op">{}</span> per_mille;</span>
@@ -7840,80 +7744,73 @@ <h4 data-number="16.8.3.4" id="predefined-units-of-the-dimensionless-quantity"><
 <h4 data-number="16.8.3.5" id="angular-quantities"><span class="header-section-number">16.8.3.5</span> Angular quantities<a href="#angular-quantities" class="self-link"></a></h4>
 <p>Special, often controversial, examples of dimensionless quantities
 are the <em>angular measure</em> and <em>solid angular measure</em>
-quantities that are defined in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 3) to be the result
-of a division of
-<code class="sourceCode default">arc_length / radius</code> and
-<code class="sourceCode default">area / pow&lt;2&gt;(radius)</code>
-respectively. Moreover, <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> also
-explicitly states that both can be expressed in the unit
-<code class="sourceCode default">one</code>. This means that both
-<code class="sourceCode default">isq::angular_measure</code> and
-<code class="sourceCode default">isq::solid_angular_measure</code>
+quantities that are defined in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 3) to be the result
+of a division of <code class="sourceCode cpp">arc_length <span class="op">/</span> radius</code>
+and <code class="sourceCode cpp">area <span class="op">/</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>radius<span class="op">)</span></code>
+respectively. Moreover, <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> also explicitly states
+that both can be expressed in the unit
+<code class="sourceCode cpp">one</code>. This means that both <code class="sourceCode cpp">isq<span class="op">::</span>angular_measure</code>
+and <code class="sourceCode cpp">isq<span class="op">::</span>solid_angular_measure</code>
 should be of a kind of
-<code class="sourceCode default">dimensionless</code>.</p>
-<p>On the other hand, <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> also
-specifies that the unit <code class="sourceCode default">radian</code>
-can be used for <em>angular measure</em>, and the unit
-<code class="sourceCode default">steradian</code> can be used for
-<em>solid angular measure</em>. Those should not be mixed or used to
-express other types of dimensionless quantities. We should not be able
-to measure:</p>
+<code class="sourceCode cpp">dimensionless</code>.</p>
+<p>On the other hand, <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> also specifies that the
+unit <code class="sourceCode cpp">radian</code> can be used for
+<em>angular measure</em>, and the unit
+<code class="sourceCode cpp">steradian</code> can be used for <em>solid
+angular measure</em>. Those should not be mixed or used to express other
+types of dimensionless quantities. We should not be able to measure:</p>
 <ul>
 <li>basic dimensionless quantity in radians or steradians,</li>
 <li><em>angular measure</em> in steradians,</li>
 <li><em>solid angular measure</em> in radians.</li>
 </ul>
-<p>This means that both
-<code class="sourceCode default">isq::angular_measure</code> and
-<code class="sourceCode default">isq::solid_angular_measure</code>
+<p>This means that both <code class="sourceCode cpp">isq<span class="op">::</span>angular_measure</code>
+and <code class="sourceCode cpp">isq<span class="op">::</span>solid_angular_measure</code>
 should also be quantity kinds by themselves.</p>
 <p><em>Note: Many people claim that angle being a dimensionless quantity
 is a bad idea. There are proposals submitted to make an angle a base
-quantity and <code class="sourceCode default">rad</code> to become a
-base unit in both <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span> and <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>.</em></p>
+quantity and <code class="sourceCode cpp">rad</code> to become a base
+unit in both <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span> and <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span>.</em></p>
 <h4 data-number="16.8.3.6" id="nested-quantity-kinds"><span class="header-section-number">16.8.3.6</span> Nested quantity kinds<a href="#nested-quantity-kinds" class="self-link"></a></h4>
 <p>Angular quantities are not the only ones with such a “strange”
 behavior. A similar case is the <em>storage capacity</em> quantity
-specified in <span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span>
-(part 13) that again allows expressing it in both
-<code class="sourceCode default">one</code> and
-<code class="sourceCode default">bit</code> units.</p>
+specified in <span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (part 13) that again
+allows expressing it in both <code class="sourceCode cpp">one</code> and
+<code class="sourceCode cpp">bit</code> units.</p>
 <p>Those cases make dimensionless quantities an exceptional tree in the
 library. This is the only quantity hierarchy that contains more than one
 quantity kind in its tree:</p>
 <p><img src="data:image/svg+xml;base64,<svg aria-roledescription="flowchart-v2" role="graphics-document document" viewBox="-8 -8 1058.34375 281" style="max-width: 100%;" xmlns="http://www.w3.org/2000/svg" width="100%" id="graph-div" height="100%" xmlns:xlink="http://www.w3.org/1999/xlink"><style>@import url("https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.2/css/all.min.css");'</style><style>#graph-div{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#graph-div .error-icon{fill:#552222;}#graph-div .error-text{fill:#552222;stroke:#552222;}#graph-div .edge-thickness-normal{stroke-width:2px;}#graph-div .edge-thickness-thick{stroke-width:3.5px;}#graph-div .edge-pattern-solid{stroke-dasharray:0;}#graph-div .edge-pattern-dashed{stroke-dasharray:3;}#graph-div .edge-pattern-dotted{stroke-dasharray:2;}#graph-div .marker{fill:#333333;stroke:#333333;}#graph-div .marker.cross{stroke:#333333;}#graph-div svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#graph-div .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#graph-div .cluster-label text{fill:#333;}#graph-div .cluster-label span,#graph-div p{color:#333;}#graph-div .label text,#graph-div span,#graph-div p{fill:#333;color:#333;}#graph-div .node rect,#graph-div .node circle,#graph-div .node ellipse,#graph-div .node polygon,#graph-div .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#graph-div .flowchart-label text{text-anchor:middle;}#graph-div .node .label{text-align:center;}#graph-div .node.clickable{cursor:pointer;}#graph-div .arrowheadPath{fill:#333333;}#graph-div .edgePath .path{stroke:#333333;stroke-width:2.0px;}#graph-div .flowchart-link{stroke:#333333;fill:none;}#graph-div .edgeLabel{background-color:#e8e8e8;text-align:center;}#graph-div .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#graph-div .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#graph-div .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#graph-div .cluster text{fill:#333;}#graph-div .cluster span,#graph-div p{color:#333;}#graph-div div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#graph-div .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#graph-div :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g><marker orient="auto" markerHeight="12" markerWidth="12" markerUnits="userSpaceOnUse" refY="5" refX="6" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-pointEnd"><path style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 0 0 L 10 5 L 0 10 z"></path></marker><marker orient="auto" markerHeight="12" markerWidth="12" markerUnits="userSpaceOnUse" refY="5" refX="4.5" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-pointStart"><path style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 0 5 L 10 10 L 10 0 z"></path></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5" refX="11" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-circleEnd"><circle style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" r="5" cy="5" cx="5"></circle></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5" refX="-1" viewBox="0 0 10 10" class="marker flowchart" id="graph-div_flowchart-circleStart"><circle style="stroke-width: 1; stroke-dasharray: 1, 0;" class="arrowMarkerPath" r="5" cy="5" cx="5"></circle></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5.2" refX="12" viewBox="0 0 11 11" class="marker cross flowchart" id="graph-div_flowchart-crossEnd"><path style="stroke-width: 2; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 1,1 l 9,9 M 10,1 l -9,9"></path></marker><marker orient="auto" markerHeight="11" markerWidth="11" markerUnits="userSpaceOnUse" refY="5.2" refX="-1" viewBox="0 0 11 11" class="marker cross flowchart" id="graph-div_flowchart-crossStart"><path style="stroke-width: 2; stroke-dasharray: 1, 0;" class="arrowMarkerPath" d="M 1,1 l 9,9 M 10,1 l -9,9"></path></marker><g class="root"><g class="clusters"></g><g class="edgePaths"><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-dimensionless LE-rotation" id="L-dimensionless-rotation-0" d="M478.367,37.954L404.706,46.295C331.044,54.636,183.721,71.318,110.06,85.826C36.398,100.333,36.398,112.667,36.398,118.833L36.398,125"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-dimensionless LE-efficiency" id="L-dimensionless-efficiency-0" d="M478.367,40.213L426.263,48.177C374.159,56.142,269.951,72.071,217.846,86.202C165.742,100.333,165.742,112.667,165.742,118.833L165.742,125"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-dimensionless LE-angular_measure" id="L-dimensionless-angular_measure-0" d="M478.367,46.979L453.19,53.815C428.013,60.652,377.659,74.326,352.482,85.33C327.305,96.333,327.305,104.667,327.305,108.833L327.305,113"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-angular_measure LE-rotational_displacement" id="L-angular_measure-rotational_displacement-0" d="M272.482,176L265.231,180.167C257.979,184.333,243.476,192.667,236.224,201C228.973,209.333,228.973,217.667,228.973,221.833L228.973,226"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-angular_measure LE-phase_angle" id="L-angular_measure-phase_angle-0" d="M395.922,168.313L411.62,173.761C427.318,179.209,458.714,190.104,474.411,199.719C490.109,209.333,490.109,217.667,490.109,221.833L490.109,226"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-dimensionless LE-solid_angular_measure" id="L-dimensionless-solid_angular_measure-0" d="M535.367,63L535.367,67.167C535.367,71.333,535.367,79.667,535.367,88C535.367,96.333,535.367,104.667,535.367,108.833L535.367,113"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-dimensionless LE-drag_factor" id="L-dimensionless-drag_factor-0" d="M592.367,48.574L614.305,55.145C636.242,61.716,680.117,74.858,702.055,87.596C723.992,100.333,723.992,112.667,723.992,118.833L723.992,125"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-dimensionless LE-storage_capacity" id="L-dimensionless-storage_capacity-0" d="M592.367,40.544L642.214,48.454C692.06,56.363,791.753,72.181,841.599,84.257C891.445,96.333,891.445,104.667,891.445,108.833L891.445,113"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-storage_capacity LE-equivalent_binary_storage_capacity" id="L-storage_capacity-equivalent_binary_storage_capacity-0" d="M891.445,176L891.445,180.167C891.445,184.333,891.445,192.667,891.445,201C891.445,209.333,891.445,217.667,891.445,221.833L891.445,226"></path><path style="fill:none;" class="edge-thickness-normal edge-pattern-solid flowchart-link LS-dimensionless LE-..." id="L-dimensionless-...-0" d="M592.367,38.064L664.645,46.386C736.922,54.709,881.477,71.355,953.754,85.844C1026.031,100.333,1026.031,112.667,1026.031,118.833L1026.031,125"></path></g><g class="edgeLabels"><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g><g class="edgeLabel"><g transform="translate(0, 0)" class="label"><foreignObject height="0" width="0"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="edgeLabel"></span></div></foreignObject></g></g></g><g class="nodes"><g transform="translate(535.3671875, 31.5)" id="flowchart-dimensionless-358" class="node default default flowchart-label"><rect height="63" width="114" y="-31.5" x="-57" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-49.5, -24)" style="" class="label"><rect></rect><foreignObject height="48" width="99"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">dimensionless<br/>[one]</span></div></foreignObject></g></g><g transform="translate(36.3984375, 144.5)" id="flowchart-rotation-360" class="node default default flowchart-label"><rect height="39" width="72.796875" y="-19.5" x="-36.3984375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-28.8984375, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="57.796875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">rotation</span></div></foreignObject></g></g><g transform="translate(165.7421875, 144.5)" id="flowchart-efficiency-362" class="node default default flowchart-label"><rect height="39" width="85.890625" y="-19.5" x="-42.9453125" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-35.4453125, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="70.890625"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">efficiency</span></div></foreignObject></g></g><g transform="translate(327.3046875, 144.5)" id="flowchart-angular_measure-364" class="node default default flowchart-label"><rect height="63" width="137.234375" y="-31.5" x="-68.6171875" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-61.1171875, -24)" style="" class="label"><rect></rect><foreignObject height="48" width="122.234375"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">angular_measure<br/>[rad]</span></div></foreignObject></g></g><g transform="translate(228.97265625, 245.5)" id="flowchart-rotational_displacement-366" class="node default default flowchart-label"><rect height="39" width="190.046875" y="-19.5" x="-95.0234375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-87.5234375, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="175.046875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">rotational_displacement</span></div></foreignObject></g></g><g transform="translate(490.109375, 245.5)" id="flowchart-phase_angle-368" class="node default default flowchart-label"><rect height="39" width="103.28125" y="-19.5" x="-51.640625" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-44.140625, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="88.28125"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">phase_angle</span></div></foreignObject></g></g><g transform="translate(535.3671875, 144.5)" id="flowchart-solid_angular_measure-370" class="node default default flowchart-label"><rect height="63" width="178.890625" y="-31.5" x="-89.4453125" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-81.9453125, -24)" style="" class="label"><rect></rect><foreignObject height="48" width="163.890625"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">solid_angular_measure<br/>[sr]</span></div></foreignObject></g></g><g transform="translate(723.9921875, 144.5)" id="flowchart-drag_factor-372" class="node default default flowchart-label"><rect height="39" width="98.359375" y="-19.5" x="-49.1796875" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-41.6796875, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="83.359375"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">drag_factor</span></div></foreignObject></g></g><g transform="translate(891.4453125, 144.5)" id="flowchart-storage_capacity-374" class="node default default flowchart-label"><rect height="63" width="136.546875" y="-31.5" x="-68.2734375" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-60.7734375, -24)" style="" class="label"><rect></rect><foreignObject height="48" width="121.546875"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">storage_capacity<br/>[bit]</span></div></foreignObject></g></g><g transform="translate(891.4453125, 245.5)" id="flowchart-equivalent_binary_storage_capacity-375" class="node default default flowchart-label"><rect height="39" width="273.78125" y="-19.5" x="-136.890625" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-129.390625, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="258.78125"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">equivalent_binary_storage_capacity</span></div></foreignObject></g></g><g transform="translate(1026.03125, 144.5)" id="flowchart-...-377" class="node default default flowchart-label"><rect height="39" width="32.625" y="-19.5" x="-16.3125" ry="0" rx="0" style="" class="basic label-container"></rect><g transform="translate(-8.8125, -12)" style="" class="label"><rect></rect><foreignObject height="24" width="17.625"><div style="display: inline-block; white-space: nowrap;" xmlns="http://www.w3.org/1999/xhtml"><span class="nodeLabel">...</span></div></foreignObject></g></g></g></g></g></svg>" /></p>
 <p>To provide such support in the library, we provided an
-<code class="sourceCode default">is_kind</code> specifier that can be
+<code class="sourceCode cpp">is_kind</code> specifier that can be
 appended to the quantity specification:</p>
 <div class="sourceCode" id="cb262"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb262-1"><a href="#cb262-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> angular_measure <span class="op">:</span> quantity_spec<span class="op">&lt;</span>dimensionless, arc_length <span class="op">/</span> radius, is_kind<span class="op">&gt;</span> <span class="op">{}</span> angular_measure;</span>
 <span id="cb262-2"><a href="#cb262-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> solid_angular_measure <span class="op">:</span> quantity_spec<span class="op">&lt;</span>dimensionless, area <span class="op">/</span> pow<span class="op">&lt;</span><span class="dv">2</span><span class="op">&gt;(</span>radius<span class="op">)</span>, is_kind<span class="op">&gt;</span> <span class="op">{}</span> solid_angular_measure;</span>
 <span id="cb262-3"><a href="#cb262-3" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> storage_capacity <span class="op">:</span> quantity_spec<span class="op">&lt;</span>dimensionless, is_kind<span class="op">&gt;</span> <span class="op">{}</span> storage_capacity;</span></code></pre></div>
 <p>With the above, we can constrain
-<code class="sourceCode default">radian</code>,
-<code class="sourceCode default">steradian</code>, and
-<code class="sourceCode default">bit</code> to be allowed for usage with
+<code class="sourceCode cpp">radian</code>,
+<code class="sourceCode cpp">steradian</code>, and
+<code class="sourceCode cpp">bit</code> to be allowed for usage with
 specific quantity kinds only:</p>
 <div class="sourceCode" id="cb263"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb263-1"><a href="#cb263-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> radian <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;rad&quot;</span>, metre <span class="op">/</span> metre, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>angular_measure<span class="op">&gt;&gt;</span> <span class="op">{}</span> radian;</span>
 <span id="cb263-2"><a href="#cb263-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> steradian <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;sr&quot;</span>, square<span class="op">(</span>metre<span class="op">)</span> <span class="op">/</span> square<span class="op">(</span>metre<span class="op">)</span>, kind_of<span class="op">&lt;</span>isq<span class="op">::</span>solid_angular_measure<span class="op">&gt;&gt;</span> <span class="op">{}</span> steradian;</span>
 <span id="cb263-3"><a href="#cb263-3" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> bit <span class="op">:</span> named_unit<span class="op">&lt;</span><span class="st">&quot;bit&quot;</span>, one, kind_of<span class="op">&lt;</span>storage_capacity<span class="op">&gt;&gt;</span> <span class="op">{}</span> bit;</span></code></pre></div>
 <p>This still allows the usage of
-<code class="sourceCode default">one</code> (possibly scaled) for such
+<code class="sourceCode cpp">one</code> (possibly scaled) for such
 quantities which is exactly what we wanted to achieve.</p>
 <h2 data-number="16.9" id="interoperability-with-other-libraries"><span class="header-section-number">16.9</span> Interoperability with other
 libraries<a href="#interoperability-with-other-libraries" class="self-link"></a></h2>
 <p>It is easy to cooperate with similar entities of other libraries. No
 matter if we want to provide interoperability with a simple home-grown
 strongly typed wrapper type (e.g.,
-<code class="sourceCode default">Meter</code>,
-<code class="sourceCode default">Timestamp</code>, …) or with a
-feature-rich quantities and units library, we have to provide
-specializations of:</p>
-<ul>
-<li>a <code class="sourceCode default">quantity_like_traits</code> for
-external <code class="sourceCode default">quantity</code>-like
-type,</li>
-<li>a <code class="sourceCode default">quantity_point_like_traits</code>
-for external <code class="sourceCode default">quantity_point</code>-like
+<code class="sourceCode cpp">Meter</code>,
+<code class="sourceCode cpp">Timestamp</code>, …) or with a feature-rich
+quantities and units library, we have to provide specializations of:</p>
+<ul>
+<li>a <code class="sourceCode cpp">quantity_like_traits</code> for
+external <code class="sourceCode cpp">quantity</code>-like type,</li>
+<li>a <code class="sourceCode cpp">quantity_point_like_traits</code> for
+external <code class="sourceCode cpp">quantity_point</code>-like
 type.</li>
 </ul>
 <h3 data-number="16.9.1" id="specifying-a-conversion-kind"><span class="header-section-number">16.9.1</span> Specifying a conversion
@@ -7945,50 +7842,44 @@ <h3 data-number="16.9.1" id="specifying-a-conversion-kind"><span class="header-s
 <p>The kinds of inter-library conversions can be easily configured in
 partial specializations of conversion traits. To require an explicit
 conversion, the return type of the conversion function should be wrapped
-in <code class="sourceCode default">convert_explicitly&lt;T&gt;</code>.
-Otherwise,
-<code class="sourceCode default">convert_implicitly&lt;T&gt;</code>
+in <code class="sourceCode cpp">convert_explicitly<span class="op">&lt;</span>T<span class="op">&gt;</span></code>.
+Otherwise, <code class="sourceCode cpp">convert_implicitly<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 should be used.</p>
 <h3 data-number="16.9.2" id="quantities-conversions"><span class="header-section-number">16.9.2</span> Quantities conversions<a href="#quantities-conversions" class="self-link"></a></h3>
 <p>For example, let’s assume that some company has its own
-<code class="sourceCode default">Meter</code> strong-type wrapper:</p>
+<code class="sourceCode cpp">Meter</code> strong-type wrapper:</p>
 <div class="sourceCode" id="cb264"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb264-1"><a href="#cb264-1" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> Meter <span class="op">{</span></span>
 <span id="cb264-2"><a href="#cb264-2" aria-hidden="true" tabindex="-1"></a>  <span class="dt">int</span> value;</span>
 <span id="cb264-3"><a href="#cb264-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
-<p>As every usage of <code class="sourceCode default">Meter</code> is at
-least as good and safe as the usage of
-<code class="sourceCode default">quantity&lt;si::metre, int&gt;</code>,
+<p>As every usage of <code class="sourceCode cpp">Meter</code> is at
+least as good and safe as the usage of <code class="sourceCode cpp">quantity<span class="op">&lt;</span>si<span class="op">::</span>metre, <span class="dt">int</span><span class="op">&gt;</span></code>,
 and as there is no significant runtime performance penalty, we would
-like to allow the conversion to
-<code class="sourceCode default">mp_units::quantity</code> to happen
-implicitly.</p>
-<p>On the other hand, the
-<code class="sourceCode default">quantity</code> type is much safer than
-the <code class="sourceCode default">Meter</code>, and that is why we
-would prefer to see the opposite conversions stated explicitly in our
-code.</p>
+like to allow the conversion to <code class="sourceCode cpp">mp_units<span class="op">::</span>quantity</code>
+to happen implicitly.</p>
+<p>On the other hand, the <code class="sourceCode cpp">quantity</code>
+type is much safer than the <code class="sourceCode cpp">Meter</code>,
+and that is why we would prefer to see the opposite conversions stated
+explicitly in our code.</p>
 <p>To enable such interoperability, we must define a partial
-specialization of the
-<code class="sourceCode default">quantity_like_traits&lt;T&gt;</code>
+specialization of the <code class="sourceCode cpp">quantity_like_traits<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 type trait. Such specialization should provide:</p>
 <ul>
-<li>static data member <code class="sourceCode default">reference</code>
+<li>static data member <code class="sourceCode cpp">reference</code>
 that provides the quantity reference (e.g., unit),</li>
-<li><code class="sourceCode default">rep</code> type that specifies the
+<li><code class="sourceCode cpp">rep</code> type that specifies the
 underlying storage type,</li>
-<li><code class="sourceCode default">to_numerical_value(T)</code> static
-member function returning a quantity’s raw value of
-<code class="sourceCode default">rep</code> type packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper.</li>
-<li><code class="sourceCode default">from_numerical_value(rep)</code>
-static member function returning
-<code class="sourceCode default">T</code> packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper.</li>
+<li><code class="sourceCode cpp">to_numerical_value<span class="op">(</span>T<span class="op">)</span></code>
+static member function returning a quantity’s raw value of
+<code class="sourceCode cpp">rep</code> type packed in either
+<code class="sourceCode cpp">convert_explicitly</code> or
+<code class="sourceCode cpp">convert_implicitly</code> wrapper.</li>
+<li><code class="sourceCode cpp">from_numerical_value<span class="op">(</span>rep<span class="op">)</span></code>
+static member function returning <code class="sourceCode cpp">T</code>
+packed in either <code class="sourceCode cpp">convert_explicitly</code>
+or <code class="sourceCode cpp">convert_implicitly</code> wrapper.</li>
 </ul>
-<p>For example, for our <code class="sourceCode default">Meter</code>
-type, we could provide the following:</p>
+<p>For example, for our <code class="sourceCode cpp">Meter</code> type,
+we could provide the following:</p>
 <div class="sourceCode" id="cb265"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb265-1"><a href="#cb265-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;&gt;</span></span>
 <span id="cb265-2"><a href="#cb265-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> std<span class="op">::</span>quantity_like_traits<span class="op">&lt;</span>Meter<span class="op">&gt;</span> <span class="op">{</span></span>
 <span id="cb265-3"><a href="#cb265-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="kw">auto</span> reference <span class="op">=</span> si<span class="op">::</span>metre;</span>
@@ -7996,7 +7887,7 @@ <h3 data-number="16.9.2" id="quantities-conversions"><span class="header-section
 <span id="cb265-5"><a href="#cb265-5" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> convert_implicitly<span class="op">&lt;</span>rep<span class="op">&gt;</span> to_numerical_value<span class="op">(</span>Meter m<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> m<span class="op">.</span>value; <span class="op">}</span></span>
 <span id="cb265-6"><a href="#cb265-6" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> convert_explicitly<span class="op">&lt;</span>Meter<span class="op">&gt;</span> from_numerical_value<span class="op">(</span>rep v<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> Meter<span class="op">{</span>v<span class="op">}</span>; <span class="op">}</span></span>
 <span id="cb265-7"><a href="#cb265-7" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
-<p>After that, we can check that the <a href="#QuantityLike-concept"><code class="sourceCode default">QuantityLike</code></a>
+<p>After that, we can check that the <a href="#QuantityLike-concept"><code class="sourceCode cpp">QuantityLike</code></a>
 concept is satisfied:</p>
 <div class="sourceCode" id="cb266"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb266-1"><a href="#cb266-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>QuantityLike<span class="op">&lt;</span>Meter<span class="op">&gt;)</span>;</span></code></pre></div>
 <p>and we can write the following:</p>
@@ -8070,17 +7961,19 @@ <h3 data-number="16.9.2" id="quantities-conversions"><span class="header-section
 </tr>
 </tbody>
 </table>
-<p><code class="sourceCode default">(1)</code> Truncation of value while
-converting from meters to kilometers.</p>
-<p><code class="sourceCode default">(2)</code> Conversion of
-<code class="sourceCode default">double</code> to
-<code class="sourceCode default">int</code> is not value-preserving.</p>
-<p><code class="sourceCode default">(3)</code> Truncation of value while
-converting from millimeters to meters.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">1</span><span class="op">)</span></code>
+Truncation of value while converting from meters to kilometers.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">2</span><span class="op">)</span></code>
+Conversion of
+<code class="sourceCode cpp"><span class="dt">double</span></code> to
+<code class="sourceCode cpp"><span class="dt">int</span></code> is not
+value-preserving.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">3</span><span class="op">)</span></code>
+Truncation of value while converting from millimeters to meters.</p>
 <h3 data-number="16.9.3" id="quantity-points-conversions"><span class="header-section-number">16.9.3</span> Quantity points
 conversions<a href="#quantity-points-conversions" class="self-link"></a></h3>
 <p>To play with quantity point conversions, let’s assume that we have a
-<code class="sourceCode default">Timestamp</code> strong type in our
+<code class="sourceCode cpp">Timestamp</code> strong type in our
 codebase, and we would like to start using this library to work with
 this abstraction.</p>
 <div class="sourceCode" id="cb270"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb270-1"><a href="#cb270-1" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> Timestamp <span class="op">{</span></span>
@@ -8090,33 +7983,31 @@ <h3 data-number="16.9.3" id="quantity-points-conversions"><span class="header-se
 chapter, timestamps should be modeled as quantity points rather than
 regular quantities.</p>
 <p>To allow the conversion between our custom
-<code class="sourceCode default">Timestamp</code> type and the
-<code class="sourceCode default">quantity_point</code> class template we
-need to provide the following in the partial specialization of the <code class="sourceCode default">quantity_point_like_traits&lt;T&gt;</code>
+<code class="sourceCode cpp">Timestamp</code> type and the
+<code class="sourceCode cpp">quantity_point</code> class template we
+need to provide the following in the partial specialization of the <code class="sourceCode cpp">quantity_point_like_traits<span class="op">&lt;</span>T<span class="op">&gt;</span></code>
 type trait:</p>
 <ul>
-<li>static data member <code class="sourceCode default">reference</code>
+<li>static data member <code class="sourceCode cpp">reference</code>
 that provides the quantity point reference (e.g., unit),</li>
-<li>static data member
-<code class="sourceCode default">point_origin</code> that specifies the
-absolute point, which is the beginning of our measurement scale for our
-points,</li>
-<li><code class="sourceCode default">rep</code> type that specifies the
+<li>static data member <code class="sourceCode cpp">point_origin</code>
+that specifies the absolute point, which is the beginning of our
+measurement scale for our points,</li>
+<li><code class="sourceCode cpp">rep</code> type that specifies the
 underlying storage type,</li>
-<li><code class="sourceCode default">to_quantity(T)</code> static member
-function returning the <code class="sourceCode default">quantity</code>
-being the offset of the point from the origin packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper,</li>
-<li><code class="sourceCode default">from_quantity(quantity&lt;reference, rep&gt;)</code>
-static member function returning
-<code class="sourceCode default">T</code> packed in either
-<code class="sourceCode default">convert_explicitly</code> or
-<code class="sourceCode default">convert_implicitly</code> wrapper.</li>
+<li><code class="sourceCode cpp">to_quantity<span class="op">(</span>T<span class="op">)</span></code>
+static member function returning the
+<code class="sourceCode cpp">quantity</code> being the offset of the
+point from the origin packed in either
+<code class="sourceCode cpp">convert_explicitly</code> or
+<code class="sourceCode cpp">convert_implicitly</code> wrapper,</li>
+<li><code class="sourceCode cpp">from_quantity<span class="op">(</span>quantity<span class="op">&lt;</span>reference, rep<span class="op">&gt;)</span></code>
+static member function returning <code class="sourceCode cpp">T</code>
+packed in either <code class="sourceCode cpp">convert_explicitly</code>
+or <code class="sourceCode cpp">convert_implicitly</code> wrapper.</li>
 </ul>
-<p>For example, for our
-<code class="sourceCode default">Timestamp</code> type, we could provide
-the following:</p>
+<p>For example, for our <code class="sourceCode cpp">Timestamp</code>
+type, we could provide the following:</p>
 <div class="sourceCode" id="cb271"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb271-1"><a href="#cb271-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;&gt;</span></span>
 <span id="cb271-2"><a href="#cb271-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> std<span class="op">::</span>quantity_point_like_traits<span class="op">&lt;</span>Timestamp<span class="op">&gt;</span> <span class="op">{</span></span>
 <span id="cb271-3"><a href="#cb271-3" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static</span> <span class="kw">constexpr</span> <span class="kw">auto</span> reference <span class="op">=</span> si<span class="op">::</span>second;</span>
@@ -8133,7 +8024,7 @@ <h3 data-number="16.9.3" id="quantity-points-conversions"><span class="header-se
 <span id="cb271-14"><a href="#cb271-14" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Timestamp<span class="op">(</span>q<span class="op">.</span>numerical_value_ref_in<span class="op">(</span>si<span class="op">::</span>second<span class="op">))</span>;</span>
 <span id="cb271-15"><a href="#cb271-15" aria-hidden="true" tabindex="-1"></a>  <span class="op">}</span></span>
 <span id="cb271-16"><a href="#cb271-16" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
-<p>After that, we can check that the <a href="#QuantityPointLike-concept"><code class="sourceCode default">QuantityPointLike</code></a>
+<p>After that, we can check that the <a href="#QuantityPointLike-concept"><code class="sourceCode cpp">QuantityPointLike</code></a>
 concept is satisfied:</p>
 <div class="sourceCode" id="cb272"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb272-1"><a href="#cb272-1" aria-hidden="true" tabindex="-1"></a><span class="kw">static_assert</span><span class="op">(</span>mp_units<span class="op">::</span>QuantityPointLike<span class="op">&lt;</span>Timestamp<span class="op">&gt;)</span>;</span></code></pre></div>
 <p>and we can write the following:</p>
@@ -8155,36 +8046,36 @@ <h3 data-number="16.9.3" id="quantity-points-conversions"><span class="header-se
 <span id="cb273-16"><a href="#cb273-16" aria-hidden="true" tabindex="-1"></a>  print<span class="op">(</span>Timestamp<span class="op">(</span>qp<span class="op">))</span>;</span>
 <span id="cb273-17"><a href="#cb273-17" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
 <h3 data-number="16.9.4" id="interoperability-with-the-stdchrono-abstractions"><span class="header-section-number">16.9.4</span> Interoperability with the
-<code class="sourceCode default">std::chrono</code> abstractions<a href="#interoperability-with-the-stdchrono-abstractions" class="self-link"></a></h3>
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
+abstractions<a href="#interoperability-with-the-stdchrono-abstractions" class="self-link"></a></h3>
 <p>In the C++ standard library, we have two types that handle quantities
 and model the affine space. Those are:</p>
 <ul>
-<li><a href="https://en.cppreference.com/w/cpp/chrono/duration"><code class="sourceCode default">std::chrono::duration</code></a>
+<li><a href="https://en.cppreference.com/w/cpp/chrono/duration"><code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>duration</code></a>
 - specifies quantities of time,</li>
-<li><a href="https://en.cppreference.com/w/cpp/chrono/time_point"><code class="sourceCode default">std::chrono::time_point</code></a>
+<li><a href="https://en.cppreference.com/w/cpp/chrono/time_point"><code class="sourceCode cpp">std<span class="op">::</span>chrono<span class="op">::</span>time_point</code></a>
 - specifies quantity points of time.</li>
 </ul>
 <p>This library comes with built-in interoperability with those types
 thanks to:</p>
 <ul>
 <li>partial specializations of
-<code class="sourceCode default">quantity_like_traits</code> and
-<code class="sourceCode default">quantity_point_like_traits</code> that
+<code class="sourceCode cpp">quantity_like_traits</code> and
+<code class="sourceCode cpp">quantity_point_like_traits</code> that
 provide support for implicit conversions between types in both
 directions,</li>
-<li><code class="sourceCode default">chrono_point_origin&lt;Clock&gt;</code>
-point origin for <code class="sourceCode default">std</code>
-clocks,</li>
-<li><code class="sourceCode default">to_chrono_duration</code> and
-<code class="sourceCode default">to_chrono_time_point</code> dedicated
+<li><code class="sourceCode cpp">chrono_point_origin<span class="op">&lt;</span>Clock<span class="op">&gt;</span></code>
+point origin for <code class="sourceCode cpp">std</code> clocks,</li>
+<li><code class="sourceCode cpp">to_chrono_duration</code> and
+<code class="sourceCode cpp">to_chrono_time_point</code> dedicated
 conversion functions that result in types exactly representing this
 library’s abstractions.</li>
 </ul>
 <p>It is important to note here that only a
-<code class="sourceCode default">quantity_point</code> that uses
-<code class="sourceCode default">chrono_point_origin&lt;Clock&gt;</code>
+<code class="sourceCode cpp">quantity_point</code> that uses <code class="sourceCode cpp">chrono_point_origin<span class="op">&lt;</span>Clock<span class="op">&gt;</span></code>
 as its origin can be converted to the
-<code class="sourceCode default">std::chrono</code> abstractions:</p>
+<code class="sourceCode cpp">std<span class="op">::</span>chrono</code>
+abstractions:</p>
 <div class="sourceCode" id="cb274"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb274-1"><a href="#cb274-1" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> ts_origin <span class="op">:</span> relative_point_origin<span class="op">&lt;</span>chrono_point_origin<span class="op">&lt;</span>system_clock<span class="op">&gt;</span> <span class="op">+</span> <span class="dv">1</span> <span class="op">*</span> h<span class="op">&gt;</span> <span class="op">{}</span> ts_origin;</span>
 <span id="cb274-2"><a href="#cb274-2" aria-hidden="true" tabindex="-1"></a><span class="kw">inline</span> <span class="kw">constexpr</span> <span class="kw">struct</span> my_origin <span class="op">:</span> absolute_point_origin<span class="op">&lt;</span>my_origin, isq<span class="op">::</span>time<span class="op">&gt;</span> <span class="op">{}</span> my_origin;</span>
 <span id="cb274-3"><a href="#cb274-3" aria-hidden="true" tabindex="-1"></a></span>
@@ -8202,14 +8093,12 @@ <h3 data-number="16.9.4" id="interoperability-with-the-stdchrono-abstractions"><
 <span id="cb274-15"><a href="#cb274-15" aria-hidden="true" tabindex="-1"></a></span>
 <span id="cb274-16"><a href="#cb274-16" aria-hidden="true" tabindex="-1"></a>quantity_point qp5<span class="op">{</span><span class="dv">1</span> <span class="op">*</span> s<span class="op">}</span>;</span>
 <span id="cb274-17"><a href="#cb274-17" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> tp5 <span class="op">=</span> to_chrono_time_point<span class="op">(</span>qp5<span class="op">)</span>;  <span class="co">// Compile-time Error (2)</span></span></code></pre></div>
-<p><code class="sourceCode default">(1)</code>
-<code class="sourceCode default">my_origin</code> is not defined in
-terms of
-<code class="sourceCode default">chrono_point_origin&lt;Clock&gt;</code>.</p>
-<p><code class="sourceCode default">(2)</code>
-<code class="sourceCode default">zeroth_point_origin</code> is not
-defined in terms of
-<code class="sourceCode default">chrono_point_origin&lt;Clock&gt;</code>.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">1</span><span class="op">)</span></code>
+<code class="sourceCode cpp">my_origin</code> is not defined in terms of
+<code class="sourceCode cpp">chrono_point_origin<span class="op">&lt;</span>Clock<span class="op">&gt;</span></code>.</p>
+<p><code class="sourceCode cpp"><span class="op">(</span><span class="dv">2</span><span class="op">)</span></code>
+<code class="sourceCode cpp">zeroth_point_origin</code> is not defined
+in terms of <code class="sourceCode cpp">chrono_point_origin<span class="op">&lt;</span>Clock<span class="op">&gt;</span></code>.</p>
 <p>Here is an example of how interoperability described in this chapter
 can be used in practice:</p>
 <div class="sourceCode" id="cb275"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb275-1"><a href="#cb275-1" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> <span class="kw">namespace</span> std<span class="op">::</span>chrono;</span>
@@ -8233,13 +8122,13 @@ <h3 data-number="16.9.4" id="interoperability-with-the-stdchrono-abstractions"><
 <div class="sourceCode" id="cb276"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb276-1"><a href="#cb276-1" aria-hidden="true" tabindex="-1"></a>Takeoff<span class="op">:</span> <span class="dv">2023</span><span class="op">-</span><span class="dv">11</span><span class="op">-</span><span class="dv">18</span> <span class="dv">13</span><span class="op">:</span><span class="dv">20</span><span class="op">:</span><span class="dv">54</span> UTC</span>
 <span id="cb276-2"><a href="#cb276-2" aria-hidden="true" tabindex="-1"></a>Landing<span class="op">:</span> <span class="dv">2023</span><span class="op">-</span><span class="dv">11</span><span class="op">-</span><span class="dv">18</span> <span class="dv">15</span><span class="op">:</span><span class="bn">07</span><span class="op">:</span><span class="bn">01</span> MST</span></code></pre></div>
 <h1 data-number="17" id="teachability"><span class="header-section-number">17</span> Teachability<a href="#teachability" class="self-link"></a></h1>
-<p>Through the last years <span class="citation" data-cites="MP-UNITS">[<a href="#ref-MP-UNITS" role="doc-biblioref">mp-units</a>]</span> library proved to be very
+<p>Through the last years <span class="citation" data-cites="MP-UNITS">[<a href="https://mpusz.github.io/mp-units" role="doc-biblioref">mp-units</a>]</span> library proved to be very
 intuitive to both novices in the domain and non-C++ experts. Thanks to
 the user-friendly multiply syntax, support for CTAD, excellent
 readability of generated types in compiler error messages, and
 simplicity of systems definitions, this library makes it easy to do the
 first steps in the dimensional analysis domain.</p>
-<p>If someone is new to the domain, a concise introduction of <a href="#systems-of-units">Systems of units</a>, the <span class="citation" data-cites="SI">[<a href="#ref-SI" role="doc-biblioref">SI</a>]</span>, and the US Customary System (and
+<p>If someone is new to the domain, a concise introduction of <a href="#systems-of-units">Systems of units</a>, the <span class="citation" data-cites="SI">[<a href="https://www.bipm.org/en/publications/si-brochure" role="doc-biblioref">SI</a>]</span>, and the US Customary System (and
 how it relates to SI) might be needed.</p>
 <p>After that, every new user, even a C++ newbie, should have no
 problems with understanding the topics of the <a href="#unit-based-quantities-simple-mode">Unit-based quantities (simple
@@ -8283,7 +8172,7 @@ <h1 data-number="17" id="teachability"><span class="header-section-number">17</s
 quantities is not only about kinds</a>.</p>
 <p>According to our experience, the most common pitfall in using
 quantity types might be related to the names chosen for them by the
-<span class="citation" data-cites="ISO80000">[<a href="#ref-ISO80000" role="doc-biblioref">ISO/IEC 80000</a>]</span> (e.g., <em>length</em>).
+<span class="citation" data-cites="ISO80000">[<a href="https://www.iso.org/standard/76921.html" role="doc-biblioref">ISO/IEC 80000</a>]</span> (e.g., <em>length</em>).
 It might be good to describe what <em>length</em> means when we say
 “every <em>height</em> is a <em>length</em>” and what it means when we
 describe a box of <em>length</em>, <em>width</em>, and <em>height</em>
@@ -8303,7 +8192,7 @@ <h1 data-number="18" id="acknowledgements"><span class="header-section-number">1
 confusing passages.</p>
 <!-- markdownlint-disable -->
 <h1 data-number="19" id="bibliography"><span class="header-section-number">19</span> References<a href="#bibliography" class="self-link"></a></h1>
-<div id="refs" class="references csl-bib-body hanging-indent" role="doc-bibliography">
+<div id="refs" class="references csl-bib-body hanging-indent" data-entry-spacing="1" role="doc-bibliography">
 <div id="ref-ARIANE" class="csl-entry" role="doc-biblioentry">
 [Ariane flight V88] Ariane flight V88. <a href="https://en.wikipedia.org/wiki/Ariane_flight_V88"><div class="csl-block">https://en.wikipedia.org/wiki/Ariane_flight_V88</div></a>
 </div>
@@ -8388,6 +8277,9 @@ <h1 data-number="19" id="bibliography"><span class="header-section-number">19</s
 <div id="ref-P1045R1" class="csl-entry" role="doc-biblioentry">
 [P1045R1] David Stone. 2019-09-27. constexpr Function Parameters. <a href="https://wg21.link/p1045r1"><div class="csl-block">https://wg21.link/p1045r1</div></a>
 </div>
+<div id="ref-P1729R3" class="csl-entry" role="doc-biblioentry">
+[P1729R3] Elias Kosunen, Victor Zverovich. 2023-10-12. Text Parsing. <a href="https://wg21.link/p1729r3"><div class="csl-block">https://wg21.link/p1729r3</div></a>
+</div>
 <div id="ref-P1930R0" class="csl-entry" role="doc-biblioentry">
 [P1930R0] Vincent Reverdy. 2019-10-07. Towards a standard unit systems
 library. <a href="https://wg21.link/p1930r0"><div class="csl-block">https://wg21.link/p1930r0</div></a>
@@ -8399,6 +8291,39 @@ <h1 data-number="19" id="bibliography"><span class="header-section-number">19</s
 [P2509R0] Giuseppe D’Angelo. 2021-12-17. A proposal for a type trait to
 detect value-preserving conversions. <a href="https://wg21.link/p2509r0"><div class="csl-block">https://wg21.link/p2509r0</div></a>
 </div>
+<div id="ref-P2980R1" class="csl-entry" role="doc-biblioentry">
+[P2980R1] Mateusz Pusz, Dominik Berner, Johel Ernesto Guerrero Peña,
+Charles Hogg, Nicolas Holthaus, Roth Michaels, Vincent Reverdy.
+2023-11-28. A motivation, scope, and plan for a quantities and units
+library. <a href="https://wg21.link/p2980r1"><div class="csl-block">https://wg21.link/p2980r1</div></a>
+</div>
+<div id="ref-P2981R1" class="csl-entry" role="doc-biblioentry">
+[P2981R1] Mateusz Pusz, Dominik Berner, Johel Ernesto Guerrero Peña.
+2023-11-09. Improving our safety with a physical quantities and units
+library. <a href="https://wg21.link/p2981r1"><div class="csl-block">https://wg21.link/p2981r1</div></a>
+</div>
+<div id="ref-P2982R1" class="csl-entry" role="doc-biblioentry">
+[P2982R1] Mateusz Pusz, Chip Hogg. 2023-11-09. `std::quantity` as a
+numeric type. <a href="https://wg21.link/p2982r1"><div class="csl-block">https://wg21.link/p2982r1</div></a>
+</div>
+<div id="ref-P2993R0" class="csl-entry" role="doc-biblioentry">
+[P2993R0] Luke Valenty. 2024-03-21. Constrained Numbers. <a href="https://wg21.link/p2993r0"><div class="csl-block">https://wg21.link/p2993r0</div></a>
+</div>
+<div id="ref-P3003R0" class="csl-entry" role="doc-biblioentry">
+[P3003R0] Johel Ernesto Guerrero Peña. 2023-10-14. The design of a
+library of number concepts. <a href="https://wg21.link/p3003r0"><div class="csl-block">https://wg21.link/p3003r0</div></a>
+</div>
+<div id="ref-P3045R0" class="csl-entry" role="doc-biblioentry">
+[P3045R0] Mateusz Pusz, Dominik Berner, Johel Ernesto Guerrero Peña,
+Charles Hogg, Nicolas Holthaus, Roth Michaels, Vincent Reverdy.
+2024-02-15. Quantities and units library. <a href="https://wg21.link/p3045r0"><div class="csl-block">https://wg21.link/p3045r0</div></a>
+</div>
+<div id="ref-P3094R0" class="csl-entry" role="doc-biblioentry">
+[P3094R0] Mateusz Pusz. 2024-02-05. std::basic_fixed_string. <a href="https://wg21.link/p3094r0"><div class="csl-block">https://wg21.link/p3094r0</div></a>
+</div>
+<div id="ref-P3133R0" class="csl-entry" role="doc-biblioentry">
+[P3133R0] Chip Hogg. 2024-02-14. Fast first-factor finding function. <a href="https://wg21.link/p3133r0"><div class="csl-block">https://wg21.link/p3133r0</div></a>
+</div>
 <div id="ref-PINT" class="csl-entry" role="doc-biblioentry">
 [Pint] Pint: makes units easy. <a href="https://pint.readthedocs.io/en/stable/index.html"><div class="csl-block">https://pint.readthedocs.io/en/stable/index.html</div></a>
 </div>