diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 18b4b82ec2..ac21ae7eda 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -40,7 +40,7 @@ jobs:
           - name: msrv
             os: ubuntu-22.04
             # sync MSRV with docs: guide/src/guide/installation.md and Cargo.toml
-            rust: 1.85.0
+            rust: 1.88.0
             target: x86_64-unknown-linux-gnu
     name: ${{ matrix.name }}
     steps:
diff --git a/Cargo.lock b/Cargo.lock
index b32495c33f..e913aa3040 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,19 +26,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "ammonia"
-version = "4.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6b346764dd0814805de8abf899fe03065bcee69bb1a4771c785817e39f3978f"
-dependencies = [
- "cssparser",
- "html5ever 0.35.0",
- "maplit",
- "tendril",
- "url",
-]
-
 [[package]]
 name = "anstream"
 version = "0.6.19"
@@ -356,29 +343,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "cssparser"
-version = "0.35.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e901edd733a1472f944a45116df3f846f54d37e67e68640ac8bb69689aca2aa"
-dependencies = [
- "cssparser-macros",
- "dtoa-short",
- "itoa",
- "phf 0.11.3",
- "smallvec",
-]
-
-[[package]]
-name = "cssparser-macros"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
-dependencies = [
- "quote",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "darling"
 version = "0.20.11"
@@ -451,12 +415,6 @@ dependencies = [
  "syn 2.0.104",
 ]
 
-[[package]]
-name = "diff"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
-
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -467,38 +425,18 @@ dependencies = [
  "crypto-common",
 ]
 
-[[package]]
-name = "displaydoc"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
-[[package]]
-name = "dtoa"
-version = "1.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6add3b8cff394282be81f3fc1a0605db594ed69890078ca6e2cab1c408bcf04"
-
-[[package]]
-name = "dtoa-short"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87"
-dependencies = [
- "dtoa",
-]
-
 [[package]]
 name = "dunce"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
 
+[[package]]
+name = "ego-tree"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2972feb8dffe7bc8c5463b1dacda1b0dfbed3710e50f977d965429692d74cd8"
+
 [[package]]
 name = "elasticlunr-rs"
 version = "3.0.2"
@@ -855,119 +793,12 @@ dependencies = [
  "tower-service",
 ]
 
-[[package]]
-name = "icu_collections"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "200072f5d0e3614556f94a9930d5dc3e0662a652823904c3a75dc3b0af7fee47"
-dependencies = [
- "displaydoc",
- "potential_utf",
- "yoke",
- "zerofrom",
- "zerovec",
-]
-
-[[package]]
-name = "icu_locale_core"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cde2700ccaed3872079a65fb1a78f6c0a36c91570f28755dda67bc8f7d9f00a"
-dependencies = [
- "displaydoc",
- "litemap",
- "tinystr",
- "writeable",
- "zerovec",
-]
-
-[[package]]
-name = "icu_normalizer"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "436880e8e18df4d7bbc06d58432329d6458cc84531f7ac5f024e93deadb37979"
-dependencies = [
- "displaydoc",
- "icu_collections",
- "icu_normalizer_data",
- "icu_properties",
- "icu_provider",
- "smallvec",
- "zerovec",
-]
-
-[[package]]
-name = "icu_normalizer_data"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00210d6893afc98edb752b664b8890f0ef174c8adbb8d0be9710fa66fbbf72d3"
-
-[[package]]
-name = "icu_properties"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "016c619c1eeb94efb86809b015c58f479963de65bdb6253345c1a1276f22e32b"
-dependencies = [
- "displaydoc",
- "icu_collections",
- "icu_locale_core",
- "icu_properties_data",
- "icu_provider",
- "potential_utf",
- "zerotrie",
- "zerovec",
-]
-
-[[package]]
-name = "icu_properties_data"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "298459143998310acd25ffe6810ed544932242d3f07083eee1084d83a71bd632"
-
-[[package]]
-name = "icu_provider"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03c80da27b5f4187909049ee2d72f276f0d9f99a42c306bd0131ecfe04d8e5af"
-dependencies = [
- "displaydoc",
- "icu_locale_core",
- "stable_deref_trait",
- "tinystr",
- "writeable",
- "yoke",
- "zerofrom",
- "zerotrie",
- "zerovec",
-]
-
 [[package]]
 name = "ident_case"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 
-[[package]]
-name = "idna"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
-dependencies = [
- "idna_adapter",
- "smallvec",
- "utf8_iter",
-]
-
-[[package]]
-name = "idna_adapter"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
-dependencies = [
- "icu_normalizer",
- "icu_properties",
-]
-
 [[package]]
 name = "ignore"
 version = "0.4.23"
@@ -1086,12 +917,6 @@ version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
 
-[[package]]
-name = "litemap"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "241eaef5fd12c88705a01fc1066c48c4b36e0dd4377dcdc7ec3942cea7a69956"
-
 [[package]]
 name = "lock_api"
 version = "0.4.13"
@@ -1114,12 +939,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 
-[[package]]
-name = "maplit"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
-
 [[package]]
 name = "markup5ever"
 version = "0.11.0"
@@ -1262,16 +1081,17 @@ dependencies = [
 name = "mdbook-html"
 version = "0.5.0-alpha.1"
 dependencies = [
- "ammonia",
  "anyhow",
+ "ego-tree",
  "elasticlunr-rs",
  "font-awesome-as-a-crate",
  "handlebars",
  "hex",
+ "html5ever 0.35.0",
+ "indexmap",
  "mdbook-core",
  "mdbook-markdown",
  "mdbook-renderer",
- "pretty_assertions",
  "pulldown-cmark",
  "regex",
  "serde",
@@ -1583,7 +1403,6 @@ version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
 dependencies = [
- "phf_macros",
  "phf_shared 0.11.3",
 ]
 
@@ -1627,19 +1446,6 @@ dependencies = [
  "rand 0.8.5",
 ]
 
-[[package]]
-name = "phf_macros"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
-dependencies = [
- "phf_generator 0.11.3",
- "phf_shared 0.11.3",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "phf_shared"
 version = "0.10.0"
@@ -1670,15 +1476,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
-[[package]]
-name = "potential_utf"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585"
-dependencies = [
- "zerovec",
-]
-
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -1694,16 +1491,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
 
-[[package]]
-name = "pretty_assertions"
-version = "1.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
-dependencies = [
- "diff",
- "yansi",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
@@ -2086,12 +1873,6 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
-[[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
-
 [[package]]
 name = "string_cache"
 version = "0.8.9"
@@ -2151,17 +1932,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
 
-[[package]]
-name = "synstructure"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "tempfile"
 version = "3.20.0"
@@ -2225,16 +1995,6 @@ dependencies = [
  "cfg-if",
 ]
 
-[[package]]
-name = "tinystr"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d4f6d1145dcb577acf783d4e601bc1d76a13337bb54e6233add580b07344c8b"
-dependencies = [
- "displaydoc",
- "zerovec",
-]
-
 [[package]]
 name = "tokio"
 version = "1.46.1"
@@ -2497,17 +2257,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c"
 
-[[package]]
-name = "url"
-version = "2.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
-dependencies = [
- "form_urlencoded",
- "idna",
- "percent-encoding",
-]
-
 [[package]]
 name = "utf-8"
 version = "0.7.6"
@@ -2520,12 +2269,6 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86bd8d4e895da8537e5315b8254664e6b769c4ff3db18321b297a1e7004392e3"
 
-[[package]]
-name = "utf8_iter"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
-
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -2760,12 +2503,6 @@ dependencies = [
  "bitflags 2.9.1",
 ]
 
-[[package]]
-name = "writeable"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea2f10b9bb0928dfb1b42b65e1f9e36f7f54dbdf08457afefb38afcdec4fa2bb"
-
 [[package]]
 name = "xml5ever"
 version = "0.17.0"
@@ -2777,36 +2514,6 @@ dependencies = [
  "markup5ever 0.11.0",
 ]
 
-[[package]]
-name = "yansi"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
-
-[[package]]
-name = "yoke"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f41bb01b8226ef4bfd589436a297c53d118f65921786300e427be8d487695cc"
-dependencies = [
- "serde",
- "stable_deref_trait",
- "yoke-derive",
- "zerofrom",
-]
-
-[[package]]
-name = "yoke-derive"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38da3c9736e16c5d3c8c597a9aaa5d1fa565d0532ae05e27c24aa62fb32c0ab6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
- "synstructure",
-]
-
 [[package]]
 name = "zerocopy"
 version = "0.8.26"
@@ -2826,57 +2533,3 @@ dependencies = [
  "quote",
  "syn 2.0.104",
 ]
-
-[[package]]
-name = "zerofrom"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
-dependencies = [
- "zerofrom-derive",
-]
-
-[[package]]
-name = "zerofrom-derive"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
- "synstructure",
-]
-
-[[package]]
-name = "zerotrie"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36f0bbd478583f79edad978b407914f61b2972f5af6fa089686016be8f9af595"
-dependencies = [
- "displaydoc",
- "yoke",
- "zerofrom",
-]
-
-[[package]]
-name = "zerovec"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a05eb080e015ba39cc9e23bbe5e7fb04d5fb040350f99f34e338d5fdd294428"
-dependencies = [
- "yoke",
- "zerofrom",
- "zerovec-derive",
-]
-
-[[package]]
-name = "zerovec-derive"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b96237efa0c878c64bd89c436f661be4e46b2f3eff1ebb976f7ef2321d2f58f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
diff --git a/Cargo.toml b/Cargo.toml
index d36bc3be70..4804376fd3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,20 +22,21 @@ unreachable_pub = "warn"
 edition = "2024"
 license = "MPL-2.0"
 repository = "https://github.com/rust-lang/mdBook"
-rust-version = "1.85.0" # Keep in sync with installation.md and .github/workflows/main.yml
+rust-version = "1.88.0" # Keep in sync with installation.md and .github/workflows/main.yml
 
 [workspace.dependencies]
-ammonia = "4.1.1"
 anyhow = "1.0.98"
 axum = "0.8.4"
 clap = { version = "4.5.41", features = ["cargo", "wrap_help"] }
 clap_complete = "4.5.55"
+ego-tree = "0.10.0"
 elasticlunr-rs = "3.0.2"
 font-awesome-as-a-crate = "0.3.0"
 futures-util = "0.3.31"
 glob = "0.3.3"
 handlebars = "6.3.2"
 hex = "0.4.3"
+html5ever = "0.35.0"
 indexmap = "2.10.0"
 ignore = "0.4.23"
 mdbook-core = { path = "crates/mdbook-core" }
@@ -50,7 +51,6 @@ notify = "8.1.0"
 notify-debouncer-mini = "0.6.0"
 opener = "0.8.2"
 pathdiff = "0.2.3"
-pretty_assertions = "1.4.1"
 pulldown-cmark = { version = "0.13.0", default-features = false, features = ["html"] } # Do not update, part of the public api.
 regex = "1.11.1"
 select = "0.6.1"
diff --git a/crates/mdbook-core/src/config.rs b/crates/mdbook-core/src/config.rs
index 98ca169dd5..a452702254 100644
--- a/crates/mdbook-core/src/config.rs
+++ b/crates/mdbook-core/src/config.rs
@@ -1135,4 +1135,11 @@ mod tests {
         assert!(html_config.print.enable);
         assert!(!html_config.print.page_break);
     }
+
+    #[test]
+    fn test_json_direction() {
+        use serde_json::json;
+        assert_eq!(json!(TextDirection::RightToLeft), json!("rtl"));
+        assert_eq!(json!(TextDirection::LeftToRight), json!("ltr"));
+    }
 }
diff --git a/crates/mdbook-core/src/utils/html.rs b/crates/mdbook-core/src/utils/html.rs
new file mode 100644
index 0000000000..0bbeffb5aa
--- /dev/null
+++ b/crates/mdbook-core/src/utils/html.rs
@@ -0,0 +1,78 @@
+//! Utilities for dealing with HTML.
+
+use std::borrow::Cow;
+
+/// Escape characters to make it safe for an HTML string.
+pub fn escape_html_attribute(text: &str) -> Cow<'_, str> {
+    let needs_escape: &[char] = &['<', '>', '\'', '"', '\\', '&'];
+    let mut s = text;
+    let mut output = String::new();
+    while let Some(next) = s.find(needs_escape) {
+        output.push_str(&s[..next]);
+        match s.as_bytes()[next] {
+            b'<' => output.push_str("&lt;"),
+            b'>' => output.push_str("&gt;"),
+            b'\'' => output.push_str("&#39;"),
+            b'"' => output.push_str("&quot;"),
+            b'\\' => output.push_str("&#92;"),
+            b'&' => output.push_str("&amp;"),
+            _ => unreachable!(),
+        }
+        s = &s[next + 1..];
+    }
+    if output.is_empty() {
+        Cow::Borrowed(text)
+    } else {
+        output.push_str(s);
+        Cow::Owned(output)
+    }
+}
+
+/// Escape `<`, `>`, and '&' for HTML.
+pub fn escape_html(text: &str) -> Cow<'_, str> {
+    let needs_escape: &[char] = &['<', '>', '&'];
+    let mut s = text;
+    let mut output = String::new();
+    while let Some(next) = s.find(needs_escape) {
+        output.push_str(&s[..next]);
+        match s.as_bytes()[next] {
+            b'<' => output.push_str("&lt;"),
+            b'>' => output.push_str("&gt;"),
+            b'&' => output.push_str("&amp;"),
+            _ => unreachable!(),
+        }
+        s = &s[next + 1..];
+    }
+    if output.is_empty() {
+        Cow::Borrowed(text)
+    } else {
+        output.push_str(s);
+        Cow::Owned(output)
+    }
+}
+
+#[test]
+fn attributes_are_escaped() {
+    assert_eq!(escape_html_attribute(""), "");
+    assert_eq!(escape_html_attribute("<"), "&lt;");
+    assert_eq!(escape_html_attribute(">"), "&gt;");
+    assert_eq!(escape_html_attribute("<>"), "&lt;&gt;");
+    assert_eq!(escape_html_attribute("<test>"), "&lt;test&gt;");
+    assert_eq!(escape_html_attribute("a<test>b"), "a&lt;test&gt;b");
+    assert_eq!(escape_html_attribute("'"), "&#39;");
+    assert_eq!(escape_html_attribute("\\"), "&#92;");
+    assert_eq!(escape_html_attribute("&"), "&amp;");
+}
+
+#[test]
+fn html_is_escaped() {
+    assert_eq!(escape_html(""), "");
+    assert_eq!(escape_html("<"), "&lt;");
+    assert_eq!(escape_html(">"), "&gt;");
+    assert_eq!(escape_html("&"), "&amp;");
+    assert_eq!(escape_html("<>"), "&lt;&gt;");
+    assert_eq!(escape_html("<test>"), "&lt;test&gt;");
+    assert_eq!(escape_html("a<test>b"), "a&lt;test&gt;b");
+    assert_eq!(escape_html("'"), "'");
+    assert_eq!(escape_html("\\"), "\\");
+}
diff --git a/crates/mdbook-core/src/utils/mod.rs b/crates/mdbook-core/src/utils/mod.rs
index a6ab262726..5e78d5e3f0 100644
--- a/crates/mdbook-core/src/utils/mod.rs
+++ b/crates/mdbook-core/src/utils/mod.rs
@@ -1,17 +1,17 @@
 //! Various helpers and utilities.
 
 use anyhow::Error;
-use std::borrow::Cow;
-use std::collections::HashMap;
 use std::fmt::Write;
 use tracing::error;
 
 pub mod fs;
+mod html;
 mod string;
 mod toml_ext;
 
 pub(crate) use self::toml_ext::TomlExt;
 
+pub use self::html::{escape_html, escape_html_attribute};
 pub use self::string::{
     take_anchored_lines, take_lines, take_rustdoc_include_anchored_lines,
     take_rustdoc_include_lines,
@@ -30,65 +30,6 @@ macro_rules! static_regex {
     };
 }
 
-/// Replaces multiple consecutive whitespace characters with a single space character.
-pub fn collapse_whitespace(text: &str) -> Cow<'_, str> {
-    static_regex!(WS, r"\s\s+");
-    WS.replace_all(text, " ")
-}
-
-/// Convert the given string to a valid HTML element ID.
-/// The only restriction is that the ID must not contain any ASCII whitespace.
-pub fn normalize_id(content: &str) -> String {
-    content
-        .chars()
-        .filter_map(|ch| {
-            if ch.is_alphanumeric() || ch == '_' || ch == '-' {
-                Some(ch.to_ascii_lowercase())
-            } else if ch.is_whitespace() {
-                Some('-')
-            } else {
-                None
-            }
-        })
-        .collect::<String>()
-}
-
-/// Generate an ID for use with anchors which is derived from a "normalised"
-/// string.
-fn id_from_content(content: &str) -> String {
-    let mut content = content.to_string();
-
-    // Skip any tags or html-encoded stuff
-    static_regex!(HTML, r"(<.*?>)");
-    content = HTML.replace_all(&content, "").into();
-    const REPL_SUB: &[&str] = &["&lt;", "&gt;", "&amp;", "&#39;", "&quot;"];
-    for sub in REPL_SUB {
-        content = content.replace(sub, "");
-    }
-
-    // Remove spaces and hashes indicating a header
-    let trimmed = content.trim().trim_start_matches('#').trim();
-    normalize_id(trimmed)
-}
-
-/// Generate an ID for use with anchors which is derived from a "normalised"
-/// string.
-///
-/// Each ID returned will be unique, if the same `id_counter` is provided on
-/// each call.
-pub fn unique_id_from_content(content: &str, id_counter: &mut HashMap<String, usize>) -> String {
-    let id = id_from_content(content);
-
-    // If we have headers with the same normalized id, append an incrementing counter
-    let id_count = id_counter.entry(id.clone()).or_insert(0);
-    let unique_id = match *id_count {
-        0 => id,
-        id_count => format!("{id}-{id_count}"),
-    };
-    *id_count += 1;
-    unique_id
-}
-
 /// Prints a "backtrace" of some `Error`.
 pub fn log_backtrace(e: &Error) {
     let mut message = format!("{e}");
@@ -99,114 +40,3 @@ pub fn log_backtrace(e: &Error) {
 
     error!("{message}");
 }
-
-/// Escape `<` and `>` for HTML.
-pub fn bracket_escape(mut s: &str) -> String {
-    let mut escaped = String::with_capacity(s.len());
-    let needs_escape: &[char] = &['<', '>'];
-    while let Some(next) = s.find(needs_escape) {
-        escaped.push_str(&s[..next]);
-        match s.as_bytes()[next] {
-            b'<' => escaped.push_str("&lt;"),
-            b'>' => escaped.push_str("&gt;"),
-            _ => unreachable!(),
-        }
-        s = &s[next + 1..];
-    }
-    escaped.push_str(s);
-    escaped
-}
-
-#[cfg(test)]
-mod tests {
-    use super::bracket_escape;
-
-    #[allow(deprecated)]
-    mod id_from_content {
-        use super::super::id_from_content;
-
-        #[test]
-        fn it_generates_anchors() {
-            assert_eq!(
-                id_from_content("## Method-call expressions"),
-                "method-call-expressions"
-            );
-            assert_eq!(id_from_content("## **Bold** title"), "bold-title");
-            assert_eq!(id_from_content("## `Code` title"), "code-title");
-            assert_eq!(
-                id_from_content("## title <span dir=rtl>foo</span>"),
-                "title-foo"
-            );
-        }
-
-        #[test]
-        fn it_generates_anchors_from_non_ascii_initial() {
-            assert_eq!(
-                id_from_content("## `--passes`: add more rustdoc passes"),
-                "--passes-add-more-rustdoc-passes"
-            );
-            assert_eq!(
-                id_from_content("## 中文標題 CJK title"),
-                "中文標題-cjk-title"
-            );
-            assert_eq!(id_from_content("## Über"), "Über");
-        }
-    }
-
-    mod html_munging {
-        use super::super::{normalize_id, unique_id_from_content};
-
-        #[test]
-        fn it_normalizes_ids() {
-            assert_eq!(
-                normalize_id("`--passes`: add more rustdoc passes"),
-                "--passes-add-more-rustdoc-passes"
-            );
-            assert_eq!(
-                normalize_id("Method-call 🐙 expressions \u{1f47c}"),
-                "method-call--expressions-"
-            );
-            assert_eq!(normalize_id("_-_12345"), "_-_12345");
-            assert_eq!(normalize_id("12345"), "12345");
-            assert_eq!(normalize_id("中文"), "中文");
-            assert_eq!(normalize_id("にほんご"), "にほんご");
-            assert_eq!(normalize_id("한국어"), "한국어");
-            assert_eq!(normalize_id(""), "");
-        }
-
-        #[test]
-        fn it_generates_unique_ids_from_content() {
-            // Same id if not given shared state
-            assert_eq!(
-                unique_id_from_content("## 中文標題 CJK title", &mut Default::default()),
-                "中文標題-cjk-title"
-            );
-            assert_eq!(
-                unique_id_from_content("## 中文標題 CJK title", &mut Default::default()),
-                "中文標題-cjk-title"
-            );
-
-            // Different id if given shared state
-            let mut id_counter = Default::default();
-            assert_eq!(unique_id_from_content("## Über", &mut id_counter), "Über");
-            assert_eq!(
-                unique_id_from_content("## 中文標題 CJK title", &mut id_counter),
-                "中文標題-cjk-title"
-            );
-            assert_eq!(unique_id_from_content("## Über", &mut id_counter), "Über-1");
-            assert_eq!(unique_id_from_content("## Über", &mut id_counter), "Über-2");
-        }
-    }
-
-    #[test]
-    fn escaped_brackets() {
-        assert_eq!(bracket_escape(""), "");
-        assert_eq!(bracket_escape("<"), "&lt;");
-        assert_eq!(bracket_escape(">"), "&gt;");
-        assert_eq!(bracket_escape("<>"), "&lt;&gt;");
-        assert_eq!(bracket_escape("<test>"), "&lt;test&gt;");
-        assert_eq!(bracket_escape("a<test>b"), "a&lt;test&gt;b");
-        assert_eq!(bracket_escape("'"), "'");
-        assert_eq!(bracket_escape("\\"), "\\");
-    }
-}
diff --git a/crates/mdbook-driver/src/load.rs b/crates/mdbook-driver/src/load.rs
index ab7b13b49e..9a69579cea 100644
--- a/crates/mdbook-driver/src/load.rs
+++ b/crates/mdbook-driver/src/load.rs
@@ -1,7 +1,7 @@
 use anyhow::{Context, Result};
 use mdbook_core::book::{Book, BookItem, Chapter};
 use mdbook_core::config::BuildConfig;
-use mdbook_core::utils::bracket_escape;
+use mdbook_core::utils::escape_html;
 use mdbook_summary::{Link, Summary, SummaryItem, parse_summary};
 use std::fs::{self, File};
 use std::io::{Read, Write};
@@ -51,7 +51,8 @@ fn create_missing(src_dir: &Path, summary: &Summary) -> Result<()> {
                     let mut f = File::create(&filename).with_context(|| {
                         format!("Unable to create missing file: {}", filename.display())
                     })?;
-                    writeln!(f, "# {}", bracket_escape(&link.name))?;
+                    let title = escape_html(&link.name);
+                    writeln!(f, "# {title}")?;
                 }
             }
 
diff --git a/crates/mdbook-html/Cargo.toml b/crates/mdbook-html/Cargo.toml
index 0b5e5fcb1a..fef26bbfa9 100644
--- a/crates/mdbook-html/Cargo.toml
+++ b/crates/mdbook-html/Cargo.toml
@@ -8,12 +8,14 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-ammonia = { workspace = true, optional = true }
 anyhow.workspace = true
+ego-tree.workspace = true
 elasticlunr-rs = { workspace = true, optional = true }
 font-awesome-as-a-crate.workspace = true
 handlebars.workspace = true
 hex.workspace = true
+html5ever.workspace = true
+indexmap.workspace = true
 mdbook-core.workspace = true
 mdbook-markdown.workspace = true
 mdbook-renderer.workspace = true
@@ -25,7 +27,6 @@ sha2.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]
-pretty_assertions.workspace = true
 tempfile.workspace = true
 toml.workspace = true
 
@@ -33,4 +34,4 @@ toml.workspace = true
 workspace = true
 
 [features]
-search = ["dep:ammonia", "dep:elasticlunr-rs"]
+search = ["dep:elasticlunr-rs"]
diff --git a/crates/mdbook-html/src/html/hide_lines.rs b/crates/mdbook-html/src/html/hide_lines.rs
new file mode 100644
index 0000000000..6852b6c4c5
--- /dev/null
+++ b/crates/mdbook-html/src/html/hide_lines.rs
@@ -0,0 +1,182 @@
+//! Support for hiding code lines.
+
+use crate::html::{Element, Node};
+use ego_tree::{NodeId, Tree};
+use html5ever::tendril::StrTendril;
+use mdbook_core::static_regex;
+use std::collections::HashMap;
+
+/// Wraps hidden lines in a `<span>` for the given code block.
+pub(crate) fn hide_lines(
+    tree: &mut Tree<Node>,
+    code_id: NodeId,
+    hidelines: &HashMap<String, String>,
+) {
+    let mut node = tree.get_mut(code_id).unwrap();
+    let el = node.value().as_element().unwrap();
+
+    let classes: Vec<_> = el.attr("class").unwrap_or_default().split(' ').collect();
+    let language = classes
+        .iter()
+        .filter_map(|cls| cls.strip_prefix("language-"))
+        .next()
+        .unwrap_or_default()
+        .to_string();
+    let hideline_info = classes
+        .iter()
+        .filter_map(|cls| cls.strip_prefix("hidelines="))
+        .map(|prefix| prefix.to_string())
+        .next();
+
+    if let Some(mut child) = node.first_child()
+        && let Node::Text(text) = child.value()
+    {
+        if language == "rust" {
+            let new_nodes = hide_lines_rust(text);
+            child.detach();
+            let root = tree.extend_tree(new_nodes);
+            let root_id = root.id();
+            let mut node = tree.get_mut(code_id).unwrap();
+            node.reparent_from_id_append(root_id);
+        } else {
+            // Use the prefix from the code block, else the prefix from config.
+            let hidelines_prefix = hideline_info
+                .as_deref()
+                .or_else(|| hidelines.get(&language).map(|p| p.as_str()));
+            if let Some(prefix) = hidelines_prefix {
+                let new_nodes = hide_lines_with_prefix(text, prefix);
+                child.detach();
+                let root = tree.extend_tree(new_nodes);
+                let root_id = root.id();
+                let mut node = tree.get_mut(code_id).unwrap();
+                node.reparent_from_id_append(root_id);
+            }
+        }
+    }
+}
+
+/// Wraps hidden lines in a `<span>` specifically for Rust code blocks.
+fn hide_lines_rust(text: &StrTendril) -> Tree<Node> {
+    static_regex!(BORING_LINES_REGEX, r"^(\s*)#(.?)(.*)$");
+
+    let mut tree = Tree::new(Node::Fragment);
+    let mut root = tree.root_mut();
+    let mut lines = text.lines().peekable();
+    while let Some(line) = lines.next() {
+        // Don't include newline on the last line.
+        let newline = if lines.peek().is_none() { "" } else { "\n" };
+        if let Some(caps) = BORING_LINES_REGEX.captures(line) {
+            if &caps[2] == "#" {
+                root.append(Node::Text(
+                    format!("{}{}{}{newline}", &caps[1], &caps[2], &caps[3]).into(),
+                ));
+                continue;
+            } else if matches!(&caps[2], "" | " ") {
+                let mut span = Element::new("span");
+                span.insert_attr("class", "boring".into());
+                let mut span = root.append(Node::Element(span));
+                span.append(Node::Text(
+                    format!("{}{}{newline}", &caps[1], &caps[3]).into(),
+                ));
+                continue;
+            }
+        }
+        root.append(Node::Text(format!("{line}{newline}").into()));
+    }
+    tree
+}
+
+/// Wraps hidden lines in a `<span>` tag for lines starting with the given prefix.
+fn hide_lines_with_prefix(content: &str, prefix: &str) -> Tree<Node> {
+    let mut tree = Tree::new(Node::Fragment);
+    let mut root = tree.root_mut();
+    for line in content.lines() {
+        if line.trim_start().starts_with(prefix) {
+            let pos = line.find(prefix).unwrap();
+            let (ws, rest) = (&line[..pos], &line[pos + prefix.len()..]);
+            let mut span = Element::new("span");
+            span.insert_attr("class", "boring".into());
+            let mut span = root.append(Node::Element(span));
+            span.append(Node::Text(format!("{ws}{rest}\n").into()));
+        } else {
+            root.append(Node::Text(format!("{line}\n").into()));
+        }
+    }
+    tree
+}
+
+/// If this code text is missing an `fn main`, the wrap it with `fn main` in a
+/// fashion similar to rustdoc, with the wrapper hidden.
+pub(crate) fn wrap_rust_main(text: &str) -> Option<String> {
+    if !text.contains("fn main") && !text.contains("quick_main!") {
+        let (attrs, code) = partition_rust_source(text);
+        let newline = if code.is_empty() || code.ends_with('\n') {
+            ""
+        } else {
+            "\n"
+        };
+        Some(format!(
+            "# #![allow(unused)]\n{attrs}# fn main() {{\n{code}{newline}# }}"
+        ))
+    } else {
+        None
+    }
+}
+
+/// Splits Rust inner attributes from the given source string.
+///
+/// Returns `(inner_attrs, rest_of_code)`.
+fn partition_rust_source(s: &str) -> (&str, &str) {
+    static_regex!(
+        HEADER_RE,
+        r"^(?mx)
+        (
+            (?:
+                ^[ \t]*\#!\[.* (?:\r?\n)?
+                |
+                ^\s* (?:\r?\n)?
+            )*
+        )"
+    );
+    let split_idx = match HEADER_RE.captures(s) {
+        Some(caps) => {
+            let attributes = &caps[1];
+            attributes.len()
+        }
+        None => 0,
+    };
+    s.split_at(split_idx)
+}
+
+#[test]
+fn it_partitions_rust_source() {
+    assert_eq!(partition_rust_source(""), ("", ""));
+    assert_eq!(partition_rust_source("let x = 1;"), ("", "let x = 1;"));
+    assert_eq!(
+        partition_rust_source("fn main()\n{ let x = 1; }\n"),
+        ("", "fn main()\n{ let x = 1; }\n")
+    );
+    assert_eq!(
+        partition_rust_source("#![allow(foo)]"),
+        ("#![allow(foo)]", "")
+    );
+    assert_eq!(
+        partition_rust_source("#![allow(foo)]\n"),
+        ("#![allow(foo)]\n", "")
+    );
+    assert_eq!(
+        partition_rust_source("#![allow(foo)]\nlet x = 1;"),
+        ("#![allow(foo)]\n", "let x = 1;")
+    );
+    assert_eq!(
+        partition_rust_source(
+            "\n\
+        #![allow(foo)]\n\
+        \n\
+        #![allow(bar)]\n\
+        \n\
+        let x = 1;"
+        ),
+        ("\n#![allow(foo)]\n\n#![allow(bar)]\n\n", "let x = 1;")
+    );
+}
diff --git a/crates/mdbook-html/src/html/mod.rs b/crates/mdbook-html/src/html/mod.rs
new file mode 100644
index 0000000000..65f28fa102
--- /dev/null
+++ b/crates/mdbook-html/src/html/mod.rs
@@ -0,0 +1,105 @@
+//! HTML rendering support.
+//!
+//! This module's primary entry point is [`render_markdown`] which will take
+//! markdown text and render it to HTML. In summary, the general procedure of
+//! that function is:
+//!
+//! 1. Use [`pulldown_cmark`] to parse the markdown and generate events.
+//! 2. [`tree`] converts those events to a tree data structure.
+//!      1. Parse HTML inside the markdown using [`tokenizer`].
+//!      2. Apply various transformations to the tree data structure, such as adding header links.
+//! 3. Serialize the tree to HTML in [`serialize()`].
+
+use ego_tree::Tree;
+use mdbook_core::book::{Book, Chapter};
+use mdbook_core::config::{HtmlConfig, RustEdition};
+use mdbook_markdown::{MarkdownOptions, new_cmark_parser};
+use std::path::{Path, PathBuf};
+
+mod hide_lines;
+mod print;
+mod serialize;
+#[cfg(test)]
+mod tests;
+mod tokenizer;
+mod tree;
+
+pub(crate) use hide_lines::{hide_lines, wrap_rust_main};
+pub(crate) use print::render_print_page;
+pub(crate) use serialize::serialize;
+pub(crate) use tree::{Element, Node};
+
+/// Options for converting a single chapter's markdown to HTML.
+pub(crate) struct HtmlRenderOptions<'a> {
+    /// Options for parsing markdown.
+    pub markdown_options: MarkdownOptions,
+    /// The chapter's location, relative to the `SUMMARY.md` file.
+    pub path: &'a Path,
+    /// The default Rust edition, used to set the proper class on the code blocks.
+    pub edition: Option<RustEdition>,
+    /// The [`HtmlConfig`], whose options affect how the HTML is generated.
+    pub config: &'a HtmlConfig,
+}
+
+impl<'a> HtmlRenderOptions<'a> {
+    /// Creates a new [`HtmlRenderOptions`].
+    pub(crate) fn new(
+        path: &'a Path,
+        config: &'a HtmlConfig,
+        edition: Option<RustEdition>,
+    ) -> HtmlRenderOptions<'a> {
+        let mut markdown_options = MarkdownOptions::default();
+        markdown_options.smart_punctuation = config.smart_punctuation;
+        HtmlRenderOptions {
+            markdown_options,
+            path,
+            edition,
+            config,
+        }
+    }
+}
+
+/// Renders markdown to HTML.
+pub(crate) fn render_markdown(text: &str, options: &HtmlRenderOptions<'_>) -> String {
+    let tree = build_tree(text, options);
+    let mut output = String::new();
+    serialize::serialize(&tree, &mut output);
+    output
+}
+
+/// Renders markdown to a [`Tree`].
+fn build_tree(text: &str, options: &HtmlRenderOptions<'_>) -> Tree<Node> {
+    let events = new_cmark_parser(text, &options.markdown_options);
+    tree::MarkdownTreeBuilder::build(options, events)
+}
+
+/// The parsed chapter, and some information about the chapter.
+pub(crate) struct ChapterTree<'book> {
+    pub(crate) chapter: &'book Chapter,
+    /// The path to the chapter relative to the root with the `.html` extension.
+    pub(crate) html_path: PathBuf,
+    /// The chapter tree.
+    pub(crate) tree: Tree<Node>,
+}
+
+/// Creates all of the [`ChapterTree`]s for the book.
+pub(crate) fn build_trees<'book>(
+    book: &'book Book,
+    html_config: &HtmlConfig,
+    edition: Option<RustEdition>,
+) -> Vec<ChapterTree<'book>> {
+    book.chapters()
+        .map(|ch| {
+            let path = ch.path.as_ref().unwrap();
+            let html_path = ch.path.as_ref().unwrap().with_extension("html");
+            let options = HtmlRenderOptions::new(path, html_config, edition);
+            let tree = build_tree(&ch.content, &options);
+
+            ChapterTree {
+                chapter: ch,
+                html_path,
+                tree,
+            }
+        })
+        .collect()
+}
diff --git a/crates/mdbook-html/src/html/print.rs b/crates/mdbook-html/src/html/print.rs
new file mode 100644
index 0000000000..5996ef2b19
--- /dev/null
+++ b/crates/mdbook-html/src/html/print.rs
@@ -0,0 +1,217 @@
+//! Support for generating the print page.
+//!
+//! The print page takes all the individual chapters (as `Tree<Node>`
+//! elements) and modifies the chapters so that they work on a consolidated
+//! print page, and then serializes it all as one HTML page.
+
+use super::Node;
+use crate::html::{ChapterTree, Element, serialize};
+use crate::utils::{ToUrlPath, id_from_content, normalize_path, unique_id};
+use mdbook_core::static_regex;
+use std::collections::HashMap;
+use std::path::{Component, PathBuf};
+
+/// Takes all the chapter trees, modifies them to be suitable to render for
+/// the print page, and returns an string of all the chapters rendered to a
+/// single HTML page.
+pub(crate) fn render_print_page(mut chapter_trees: Vec<ChapterTree<'_>>) -> String {
+    let (id_remap, mut id_counter) = make_ids_unique(&mut chapter_trees);
+    let path_to_root_id = make_root_id_map(&mut chapter_trees, &mut id_counter);
+    rewrite_links(&mut chapter_trees, &id_remap, &path_to_root_id);
+
+    let mut print_content = String::new();
+    for ChapterTree { tree, .. } in chapter_trees {
+        if !print_content.is_empty() {
+            // Add page break between chapters
+            // See https://developer.mozilla.org/en-US/docs/Web/CSS/break-before and https://developer.mozilla.org/en-US/docs/Web/CSS/page-break-before
+            // Add both two CSS properties because of the compatibility issue
+            print_content
+                .push_str(r#"<div style="break-before: page; page-break-before: always;"></div>"#);
+        }
+        serialize(&tree, &mut print_content);
+    }
+    print_content
+}
+
+/// Make all IDs unique, and create a map from old to new IDs.
+///
+/// The first map is a map of the chapter path to the IDs that were rewritten
+/// in that chapter (old ID to new ID).
+///
+/// The second map is a map of every ID seen to the number of times it has
+/// been seen. This is used to generate unique IDs.
+fn make_ids_unique(
+    chapter_trees: &mut [ChapterTree<'_>],
+) -> (
+    HashMap<PathBuf, HashMap<String, String>>,
+    HashMap<String, u32>,
+) {
+    let mut id_remap = HashMap::new();
+    let mut id_counter = HashMap::new();
+    for ChapterTree {
+        html_path, tree, ..
+    } in chapter_trees
+    {
+        for value in tree.values_mut() {
+            if let Node::Element(el) = value
+                && let Some(id) = el.attr("id")
+            {
+                let new_id = unique_id(id, &mut id_counter);
+                if new_id != id {
+                    let id = id.to_string();
+                    el.insert_attr("id", new_id.clone().into());
+
+                    let map: &mut HashMap<_, _> = id_remap.entry(html_path.clone()).or_default();
+                    map.insert(id, new_id);
+                }
+            }
+        }
+    }
+    (id_remap, id_counter)
+}
+
+/// Generates a map of a chapter path to the ID of the top of the chapter.
+///
+/// If a chapter is missing an `h1` tag, then one is synthesized so that the
+/// print output has something to link to.
+fn make_root_id_map(
+    chapter_trees: &mut [ChapterTree<'_>],
+    id_counter: &mut HashMap<String, u32>,
+) -> HashMap<PathBuf, String> {
+    let mut path_to_root_id = HashMap::new();
+    for ChapterTree {
+        chapter,
+        html_path,
+        tree,
+        ..
+    } in chapter_trees
+    {
+        let mut h1_found = false;
+        for value in tree.values_mut() {
+            if let Node::Element(el) = value {
+                if el.name() == "h1" {
+                    if let Some(id) = el.attr("id") {
+                        h1_found = true;
+                        path_to_root_id.insert(html_path.clone(), id.to_string());
+                    }
+                    break;
+                } else if matches!(el.name(), "h2" | "h3" | "h4" | "h5" | "h6") {
+                    // h1 not found.
+                    break;
+                }
+            }
+        }
+        if !h1_found {
+            // Synthesize a root id to be able to link to the start of the page.
+            // TODO: This might want to be a warning? Chapters generally
+            // should start with an h1.
+            let mut h1 = Element::new("h1");
+            let id = id_from_content(&chapter.name);
+            let id = unique_id(&id, id_counter);
+            h1.insert_attr("id", id.clone().into());
+            let mut root = tree.root_mut();
+            let mut h1 = root.prepend(Node::Element(h1));
+            let mut a = Element::new("a");
+            a.insert_attr("href", format!("#{id}").into());
+            a.insert_attr("class", "header".into());
+            let mut a = h1.append(Node::Element(a));
+            a.append(Node::Text(chapter.name.clone().into()));
+            path_to_root_id.insert(html_path.clone(), id);
+        }
+    }
+
+    path_to_root_id
+}
+
+/// Rewrite links so that they point to IDs on the print page.
+fn rewrite_links(
+    chapter_trees: &mut [ChapterTree<'_>],
+    id_remap: &HashMap<PathBuf, HashMap<String, String>>,
+    path_to_root_id: &HashMap<PathBuf, String>,
+) {
+    static_regex!(
+        LINK,
+        r"(?x)
+            (?P<scheme>^[a-z][a-z0-9+.-]*:)?
+            (?P<path>[^\#]+)?
+            (?:\#(?P<anchor>.*))?"
+    );
+
+    // Rewrite path links to go to the appropriate place.
+    for ChapterTree {
+        html_path, tree, ..
+    } in chapter_trees
+    {
+        let base = html_path.parent().expect("path can't be empty");
+
+        for value in tree.values_mut() {
+            let Node::Element(el) = value else {
+                continue;
+            };
+            if !matches!(el.name(), "a" | "img") {
+                continue;
+            }
+            for attr in ["href", "src", "xlink:href"] {
+                let Some(dest) = el.attr(attr) else {
+                    continue;
+                };
+                let Some(caps) = LINK.captures(&dest) else {
+                    continue;
+                };
+                if caps.name("scheme").is_some() {
+                    continue;
+                }
+                // The lookup_key is the key to look up in the remap table.
+                let mut lookup_key = html_path.clone();
+                if let Some(href_path) = caps.name("path")
+                    && let href_path = href_path.as_str()
+                    && !href_path.is_empty()
+                {
+                    lookup_key.pop();
+                    lookup_key.push(href_path);
+                    let normalized = normalize_path(&lookup_key);
+                    // If this points outside of the book, don't modify it.
+                    let is_outside = matches!(
+                        normalized.components().next(),
+                        Some(Component::ParentDir | Component::RootDir)
+                    );
+                    if is_outside || !href_path.ends_with(".html") {
+                        // Make the link relative to the print page location.
+                        let mut rel_path = normalize_path(&base.join(href_path)).to_url_path();
+                        if let Some(anchor) = caps.name("anchor") {
+                            rel_path.push('#');
+                            rel_path.push_str(anchor.as_str());
+                        }
+                        el.insert_attr(attr, rel_path.into());
+                        continue;
+                    }
+                }
+
+                let lookup_key = normalize_path(&lookup_key);
+
+                let anchor = caps.name("anchor");
+                let id = match anchor {
+                    Some(anchor_id) => {
+                        let anchor_id = anchor_id.as_str().to_string();
+                        match id_remap.get(&lookup_key) {
+                            Some(id_map) => match id_map.get(&anchor_id) {
+                                Some(new_id) => new_id.clone(),
+                                None => anchor_id,
+                            },
+                            None => {
+                                // Assume the anchor goes to some non-remapped
+                                // ID that already exists.
+                                anchor_id
+                            }
+                        }
+                    }
+                    None => match path_to_root_id.get(&lookup_key) {
+                        Some(id) => id.to_string(),
+                        None => continue,
+                    },
+                };
+                el.insert_attr(attr, format!("#{id}").into());
+            }
+        }
+    }
+}
diff --git a/crates/mdbook-html/src/html/serialize.rs b/crates/mdbook-html/src/html/serialize.rs
new file mode 100644
index 0000000000..3917585465
--- /dev/null
+++ b/crates/mdbook-html/src/html/serialize.rs
@@ -0,0 +1,112 @@
+//! Serializes the [`Node`] tree to an HTML string.
+
+use super::tree::is_void_element;
+use super::tree::{Element, Node};
+use ego_tree::{Tree, iter::Edge};
+use html5ever::{local_name, ns};
+use mdbook_core::utils::{escape_html, escape_html_attribute};
+use std::ops::Deref;
+
+/// Serializes the given tree of [`Node`] elements to an HTML string.
+pub(crate) fn serialize(tree: &Tree<Node>, output: &mut String) {
+    for edge in tree.root().traverse() {
+        match edge {
+            Edge::Open(node) => match node.value() {
+                Node::Element(el) => serialize_start(el, output),
+                Node::Text(text) => {
+                    output.push_str(&escape_html(text));
+                }
+                Node::Comment(comment) => {
+                    output.push_str("<!--");
+                    output.push_str(comment);
+                    output.push_str("-->");
+                }
+                Node::Fragment => {}
+                Node::RawData(html) => {
+                    output.push_str(html);
+                }
+            },
+            Edge::Close(node) => {
+                if let Node::Element(el) = node.value() {
+                    serialize_end(el, output);
+                }
+            }
+        }
+    }
+}
+
+/// Returns true if this HTML element wants a newline to keep the emitted
+/// output more readable.
+fn wants_pretty_html_newline(name: &str) -> bool {
+    matches!(name, |"blockquote"| "dd"
+        | "div"
+        | "dl"
+        | "dt"
+        | "h1"
+        | "h2"
+        | "h3"
+        | "h4"
+        | "h5"
+        | "h6"
+        | "hr"
+        | "li"
+        | "ol"
+        | "p"
+        | "pre"
+        | "table"
+        | "tbody"
+        | "thead"
+        | "tr"
+        | "ul")
+}
+
+/// Emit the start tag of an element.
+fn serialize_start(el: &Element, output: &mut String) {
+    let el_name = el.name();
+    if wants_pretty_html_newline(el_name) {
+        if !output.is_empty() {
+            if !output.ends_with('\n') {
+                output.push('\n');
+            }
+        }
+    }
+    output.push('<');
+    output.push_str(el_name);
+    for (attr_name, value) in &el.attrs {
+        output.push(' ');
+        match attr_name.ns {
+            ns!() => (),
+            ns!(xml) => output.push_str("xml:"),
+            ns!(xmlns) => {
+                if el.name.local != local_name!("xmlns") {
+                    output.push_str("xmlns:");
+                }
+            }
+            ns!(xlink) => output.push_str("xlink:"),
+            _ => (), // TODO what should it do here?
+        }
+        output.push_str(attr_name.local.deref());
+        output.push_str("=\"");
+        output.push_str(&escape_html_attribute(&value));
+        output.push('"');
+    }
+    if el.self_closing {
+        output.push_str(" /");
+    }
+    output.push('>');
+}
+
+/// Emit the end tag of an element.
+fn serialize_end(el: &Element, output: &mut String) {
+    // Void elements do not have an end tag.
+    if el.self_closing || is_void_element(el.name()) {
+        return;
+    }
+    let name = el.name();
+    output.push_str("</");
+    output.push_str(name);
+    output.push('>');
+    if wants_pretty_html_newline(name) {
+        output.push('\n');
+    }
+}
diff --git a/crates/mdbook-html/src/html/tests.rs b/crates/mdbook-html/src/html/tests.rs
new file mode 100644
index 0000000000..58825c9c81
--- /dev/null
+++ b/crates/mdbook-html/src/html/tests.rs
@@ -0,0 +1,53 @@
+use crate::html::tokenizer::parse_html;
+use html5ever::tokenizer::{Tag, TagKind, Token};
+
+// Basic tokenizer behavior of a script.
+#[test]
+fn parse_html_script() {
+    let script = r#"
+if (3 < 5 > 10)
+{
+    alert("The sky is falling!");
+}
+"#;
+    let t = format!("<script>{script}</script>");
+    let ts = parse_html(&t);
+    eprintln!("{ts:#?}",);
+    let mut output = String::new();
+    let mut in_script = false;
+    for t in ts {
+        match t {
+            Token::ParseError(e) => panic!("{e:?}"),
+            Token::CharacterTokens(s) => {
+                if in_script {
+                    output.push_str(&s)
+                }
+            }
+            Token::TagToken(Tag {
+                kind: TagKind::StartTag,
+                ..
+            }) => in_script = true,
+            Token::TagToken(Tag {
+                kind: TagKind::EndTag,
+                ..
+            }) => in_script = false,
+            _ => {}
+        }
+    }
+    assert_eq!(output, script);
+}
+
+// What happens if a script doesn't end.
+#[test]
+fn parse_html_script_unclosed() {
+    let t = r#"<script>
+// Test
+"#;
+    let ts = parse_html(t);
+    eprintln!("{ts:#?}",);
+    for t in ts {
+        if let Token::ParseError(e) = t {
+            panic!("{e:?}",);
+        }
+    }
+}
diff --git a/crates/mdbook-html/src/html/tokenizer.rs b/crates/mdbook-html/src/html/tokenizer.rs
new file mode 100644
index 0000000000..e3d8e44f86
--- /dev/null
+++ b/crates/mdbook-html/src/html/tokenizer.rs
@@ -0,0 +1,83 @@
+//! Support for parsing HTML.
+//!
+//! The primary entry point is [`parse_html`] which uses [`html5ever`] to
+//! tokenize the input.
+
+use html5ever::TokenizerResult;
+use html5ever::tendril::ByteTendril;
+use html5ever::tokenizer::states::RawKind;
+use html5ever::tokenizer::{
+    BufferQueue, TagKind, Token, TokenSink, TokenSinkResult, Tokenizer, TokenizerOpts,
+};
+use std::cell::RefCell;
+
+/// Collector for HTML tokens.
+#[derive(Default)]
+struct TokenCollector {
+    /// Parsed HTML tokens.
+    tokens: RefCell<Vec<Token>>,
+}
+
+impl TokenSink for TokenCollector {
+    type Handle = ();
+
+    fn process_token(&self, token: Token, _line_number: u64) -> TokenSinkResult<()> {
+        match &token {
+            Token::DoctypeToken(_) => {}
+            Token::TagToken(tag) => {
+                let tag_name = tag.name.as_bytes();
+                // TODO: This could probably use special support for SVG and MathML.
+                if tag_name == b"script" {
+                    match tag.kind {
+                        TagKind::StartTag => {
+                            self.tokens.borrow_mut().push(token);
+                            return TokenSinkResult::RawData(RawKind::ScriptData);
+                        }
+                        TagKind::EndTag => {}
+                    }
+                }
+                if tag_name == b"style" {
+                    match tag.kind {
+                        TagKind::StartTag => {
+                            self.tokens.borrow_mut().push(token);
+                            return TokenSinkResult::RawData(RawKind::Rawtext);
+                        }
+                        TagKind::EndTag => {}
+                    }
+                }
+                self.tokens.borrow_mut().push(token);
+            }
+            Token::CommentToken(_) => {
+                self.tokens.borrow_mut().push(token);
+            }
+            Token::CharacterTokens(_) => {
+                self.tokens.borrow_mut().push(token);
+            }
+            Token::NullCharacterToken => {}
+            Token::EOFToken => {}
+            Token::ParseError(_) => {
+                self.tokens.borrow_mut().push(token);
+            }
+        }
+        TokenSinkResult::Continue
+    }
+}
+
+/// Parse HTML into tokens.
+pub(crate) fn parse_html(html: &str) -> Vec<Token> {
+    let tendril: ByteTendril = html.as_bytes().into();
+    let mut queue = BufferQueue::default();
+    queue.push_back(tendril.try_reinterpret().unwrap());
+
+    let collector = TokenCollector::default();
+    let tok = Tokenizer::new(collector, TokenizerOpts::default());
+    let result = tok.feed(&mut queue);
+    assert_eq!(result, TokenizerResult::Done);
+    assert!(
+        queue.is_empty(),
+        "queue wasn't empty: {:?}",
+        queue.pop_front()
+    );
+    tok.end();
+    tok.sink.tokens.take()
+}
diff --git a/crates/mdbook-html/src/html/tree.rs b/crates/mdbook-html/src/html/tree.rs
new file mode 100644
index 0000000000..802a215eac
--- /dev/null
+++ b/crates/mdbook-html/src/html/tree.rs
@@ -0,0 +1,1054 @@
+//! Tree data structure for representing a markdown document.
+//!
+//! [`MarkdownTreeBuilder::build`] is the primary entry point of this module.
+//! It takes events from [`pulldown_cmark`], and generates a [`Tree`]
+//! structure of [`Node`] elements. It also handles all the various
+//! transformations that mdbook performs, such as creating header links.
+
+use super::tokenizer::parse_html;
+use super::{HtmlRenderOptions, hide_lines, wrap_rust_main};
+use crate::utils::{id_from_content, unique_id};
+use ego_tree::{NodeId, NodeRef, Tree};
+use html5ever::tendril::StrTendril;
+use html5ever::tokenizer::{TagKind, Token};
+use html5ever::{LocalName, QualName};
+use indexmap::IndexMap;
+use mdbook_core::config::RustEdition;
+use mdbook_core::static_regex;
+use pulldown_cmark::{
+    Alignment, BlockQuoteKind, CodeBlockKind, CowStr, Event, LinkType, Tag, TagEnd,
+};
+use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
+use std::ops::Deref;
+use tracing::{error, warn};
+
+/// Helper to create a [`QualName`].
+macro_rules! attr_qual_name {
+    ($name:expr) => {
+        QualName::new(None, html5ever::ns!(), LocalName::from($name))
+    };
+}
+
+/// A node in the [`Tree`].
+#[derive(Debug)]
+pub(crate) enum Node {
+    /// An HTML [`Element`].
+    Element(Element),
+    /// Plain text.
+    ///
+    /// This will be escaped when serialized.
+    Text(StrTendril),
+    /// An HTML comment.
+    Comment(StrTendril),
+    /// Root node of a tree fragment.
+    ///
+    /// This is a general purpose node whenever it is convenient to have a
+    /// container of other nodes.
+    Fragment,
+    /// Raw data that should be copied into the output as-is without escaping.
+    RawData(StrTendril),
+}
+
+impl Node {
+    /// If this is an [`Element`], return it.
+    pub(crate) fn as_element(&self) -> Option<&Element> {
+        if let Node::Element(el) = self {
+            Some(el)
+        } else {
+            None
+        }
+    }
+
+    /// If this is an [`Element`], return it (mutable).
+    fn as_element_mut(&mut self) -> Option<&mut Element> {
+        if let Node::Element(el) = self {
+            Some(el)
+        } else {
+            None
+        }
+    }
+}
+
+/// An HTML element.
+#[derive(Debug)]
+pub(crate) struct Element {
+    /// The tag name.
+    pub(crate) name: QualName,
+    /// Element attributes.
+    pub(crate) attrs: Attributes,
+    /// True if this tag ends with `/>`.
+    pub(crate) self_closing: bool,
+}
+
+impl Element {
+    /// Creates a new HTML element.
+    pub(crate) fn new(tag_name: &str) -> Element {
+        let name = QualName::new(None, html5ever::ns!(html), LocalName::from(tag_name));
+        Element {
+            name,
+            attrs: Attributes::new(),
+            self_closing: false,
+        }
+    }
+
+    /// The name of this element.
+    pub(crate) fn name(&self) -> &str {
+        self.name.local.deref()
+    }
+
+    /// If this is a heading element, returns the level of the heading.
+    #[allow(dead_code, reason = "currently only used in search")]
+    pub(crate) fn heading_level(&self) -> Option<u8> {
+        let name = self.name();
+        if matches!(name, "h1" | "h2" | "h3" | "h4" | "h5" | "h6") {
+            Some(name.as_bytes()[1] - b'0')
+        } else {
+            None
+        }
+    }
+
+    /// Returns the value of an attribute.
+    pub(crate) fn attr(&self, name: &str) -> Option<&str> {
+        let qname = attr_qual_name!(name);
+        self.attrs.get(&qname).map(Deref::deref)
+    }
+
+    /// Inserts an attribute.
+    pub(crate) fn insert_attr(&mut self, name: &str, value: StrTendril) {
+        let name = attr_qual_name!(name);
+        self.attrs.insert(name, value);
+    }
+}
+
+/// A map of attributes on an [`Element`].
+type Attributes = IndexMap<QualName, StrTendril>;
+
+/// Helper to convert [`CowStr`] to a [`StrTendril`].
+trait ToTendril {
+    /// Converts self to a [`StrTendril`].
+    fn into_tendril(self) -> StrTendril;
+}
+
+impl ToTendril for CowStr<'_> {
+    fn into_tendril(self) -> StrTendril {
+        match self {
+            CowStr::Boxed(s) => {
+                let s: String = s.into();
+                StrTendril::from(s)
+            }
+            CowStr::Borrowed(s) => StrTendril::from(s),
+            CowStr::Inlined(s) => StrTendril::from(s.as_ref()),
+        }
+    }
+}
+
+/// Tracks the current state of parsing a table.
+///
+/// This is used to determine if it should generate `<th>` or `<td>` tags.
+enum TableState {
+    /// Currently in the table head.
+    Head,
+    /// Currently in the table body.
+    Body,
+}
+
+/// A builder used to create a [`Tree`] of [`Node`] elements.
+///
+/// Parts of this are based on pulldown-cmark's serializer (like table handling).
+pub(crate) struct MarkdownTreeBuilder<'opts, 'event, EventIter> {
+    /// [`pulldown_cmark`] iterator of [`pulldown_cmark::Event`] elements.
+    events: EventIter,
+    /// Options for how to generate the HTML.
+    options: &'opts HtmlRenderOptions<'opts>,
+    /// The tree that is being built.
+    tree: Tree<Node>,
+    /// The ID of the current [`Node`].
+    current_node: NodeId,
+    /// The tag stack.
+    ///
+    /// This is used to set the `current_node` as the parser enters and leaves
+    /// a tag.
+    tag_stack: Vec<NodeId>,
+    /// When parsing a table, whether or not we are currently in the head or
+    /// the body.
+    table_state: TableState,
+    /// When parsing a table, the alignments of the columns.
+    ///
+    /// The count should match the number of columns.
+    table_alignments: Vec<Alignment>,
+    /// What parsing a table, the index of the current column.
+    table_cell_index: usize,
+    /// Mapping of footnote numbers.
+    ///
+    /// This is used for generating linkbacks in the definitions.
+    ///
+    /// This is a map of `name -> (number, count)`.
+    ///
+    /// - `name` is the name of the footnote.
+    /// - `number` is the footnote number displayed in the output.
+    /// - `count` is the number of references to this footnote (used for multiple
+    ///   linkbacks, and checking for unused footnotes).
+    footnote_numbers: HashMap<CowStr<'event>, (usize, u32)>,
+    /// Footnote definitions.
+    ///
+    /// This is a map of `name -> NodeId` of each footnote definition. When
+    /// parsing footnotes, they are initially left in the position where they
+    /// were defined as an `<li>` tag. The [`NodeId`] here is the id of that
+    /// tag. After the document has been parsed, all the definitions are moved
+    /// to the end of the document.
+    footnote_defs: HashMap<CowStr<'event>, NodeId>,
+}
+
+impl<'opts, 'event, EventIter> MarkdownTreeBuilder<'opts, 'event, EventIter>
+where
+    EventIter: Iterator<Item = Event<'event>>,
+{
+    /// Processes a [`pulldown_cmark`] iterator of [`pulldown_cmark::Event`]
+    /// values, and generates a tree of [`Node`] values.
+    pub(crate) fn build(options: &'opts HtmlRenderOptions<'opts>, events: EventIter) -> Tree<Node> {
+        let tree = Tree::new(Node::Fragment);
+        let root = tree.root().id();
+
+        let mut builder = Self {
+            events,
+            options,
+            tree,
+            current_node: root,
+            tag_stack: vec![root],
+            table_state: TableState::Head,
+            table_alignments: Vec::new(),
+            table_cell_index: 0,
+            footnote_numbers: HashMap::new(),
+            footnote_defs: HashMap::new(),
+        };
+        builder.process_events();
+        builder.add_header_links();
+        builder.update_code_blocks();
+        builder.convert_fontawesome();
+        builder.tree
+    }
+
+    /// Append a new child to the current node.
+    ///
+    /// Returns the [`NodeId`] of the new node.
+    fn append(&mut self, node: Node) -> NodeId {
+        self.tree
+            .get_mut(self.current_node)
+            .unwrap()
+            .append(node)
+            .id()
+    }
+
+    /// Appends text to the current node.
+    ///
+    /// If the previous sibling is a text node, then it merges with that node.
+    /// This makes some processing more convenient.
+    fn append_text(&mut self, text: StrTendril) {
+        let mut current = self.tree.get_mut(self.current_node).unwrap();
+        if let Some(mut prev) = current.last_child()
+            && let Node::Text(prev_text) = prev.value()
+        {
+            prev_text.push_slice(&text);
+        } else {
+            self.append(Node::Text(text));
+        }
+    }
+
+    /// Append a new child to the current node, and make the new node the current node.
+    ///
+    /// This should only be used if you expect `pop` to be called.
+    fn push(&mut self, node: Node) {
+        let new_node = self.append(node);
+        self.tag_stack.push(new_node);
+        self.current_node = new_node;
+    }
+
+    /// Append a new child to the current node, and make the new node the current node.
+    ///
+    /// As compared to `push`, it is *not* expected that there will be a `pop` called
+    /// for this node. The next call to `pop` will unwind the stack past this node.
+    fn push_no_stack(&mut self, node: Node) {
+        let new_node = self.append(node);
+        self.current_node = new_node;
+    }
+
+    /// Switch the current node to the current node's parent.
+    fn pop(&mut self) {
+        self.tag_stack.pop();
+        if let Some(&parent) = self.tag_stack.last() {
+            self.current_node = parent;
+        } else {
+            panic!("pop too far processing `{}`", self.options.path.display());
+        }
+    }
+
+    /// Returns all of the [`NodeId`]s, filtering out just the [`Element`]
+    /// nodes where the given callback returns `true` based on the element
+    /// name.
+    fn node_ids_for_tag(&self, filter: &dyn Fn(&str) -> bool) -> Vec<NodeId> {
+        self.tree
+            .nodes()
+            .filter(|node| {
+                let Node::Element(el) = node.value() else {
+                    return false;
+                };
+                filter(el.name())
+            })
+            .map(|node| node.id())
+            .collect()
+    }
+
+    /// The main processing loop. Processes all events until the end.
+    fn process_events(&mut self) {
+        while let Some(event) = self.events.next() {
+            match event {
+                Event::Start(tag) => self.start_tag(tag),
+                Event::End(tag) => {
+                    self.pop();
+                    match tag {
+                        TagEnd::TableHead => {
+                            self.table_state = TableState::Body;
+                            self.push(Node::Element(Element::new("tbody")));
+                        }
+                        TagEnd::TableCell => {
+                            self.table_cell_index += 1;
+                        }
+                        TagEnd::Table => {
+                            // Pop tbody or thead
+                            self.pop();
+                        }
+                        _ => {}
+                    }
+                }
+                Event::Text(text) => {
+                    self.append_text(text.into_tendril());
+                }
+                Event::Code(code) => {
+                    self.push(Node::Element(Element::new("code")));
+                    self.append(Node::Text(code.into_tendril()));
+                    self.pop();
+                }
+                Event::InlineMath(text) => {
+                    let mut span = Element::new("span");
+                    span.insert_attr("class", "math math-inline".into());
+                    self.push(Node::Element(span));
+                    self.append(Node::Text(text.into_tendril()));
+                    self.pop();
+                }
+                Event::DisplayMath(text) => {
+                    let mut span = Element::new("span");
+                    span.insert_attr("class", "math math-display".into());
+                    self.push(Node::Element(span));
+                    self.append(Node::Text(text.into_tendril()));
+                    self.pop();
+                }
+                Event::Html(html) => {
+                    // The loop in Tag::HtmlBlock should have consumed all
+                    // Html events.
+                    panic!(
+                        "`{}` unexpected Html event: {html}",
+                        self.options.path.display()
+                    );
+                }
+                Event::InlineHtml(html) => self.append_html(&html),
+                Event::FootnoteReference(name) => self.footnote_reference(name),
+                Event::SoftBreak => {
+                    self.append_text("\n".into());
+                }
+                Event::HardBreak => {
+                    self.append(Node::Element(Element::new("br")));
+                }
+                Event::Rule => {
+                    self.append(Node::Element(Element::new("hr")));
+                }
+                Event::TaskListMarker(checked) => {
+                    let mut input = Element::new("input");
+                    input.insert_attr("disabled", "".into());
+                    input.insert_attr("type", "checkbox".into());
+                    if checked {
+                        input.insert_attr("checked", "".into());
+                    }
+                    self.push(Node::Element(input));
+                    // Add some space before whatever follows.
+                    self.append(Node::Text(" ".into()));
+                    self.pop();
+                }
+            }
+        }
+        self.collect_footnote_defs();
+    }
+
+    fn start_tag(&mut self, tag: Tag<'event>) {
+        let element = match tag {
+            Tag::Paragraph => Element::new("p"),
+            Tag::Heading {
+                level,
+                id,
+                classes,
+                attrs,
+            } => {
+                let mut el = Element::new(&level.to_string());
+                for (name, value) in attrs {
+                    let name =
+                        QualName::new(None, html5ever::ns!(), LocalName::from(Cow::from(name)));
+                    let value = value.unwrap_or_else(|| CowStr::from(""));
+                    el.attrs.insert(name, value.into_tendril());
+                }
+                if let Some(id) = id {
+                    el.insert_attr("id", id.into_tendril());
+                }
+                if !classes.is_empty() {
+                    let classes = classes.join(" ");
+                    el.insert_attr("class", classes.into());
+                }
+                el
+            }
+            Tag::BlockQuote(kind) => {
+                let mut b = Element::new("blockquote");
+                if let Some(kind) = kind {
+                    let class = match kind {
+                        BlockQuoteKind::Note => "markdown-alert-note",
+                        BlockQuoteKind::Tip => "markdown-alert-tip",
+                        BlockQuoteKind::Important => "markdown-alert-important",
+                        BlockQuoteKind::Warning => "markdown-alert-warning",
+                        BlockQuoteKind::Caution => "markdown-alert-caution",
+                    };
+                    b.insert_attr("class", class.into());
+                }
+                b
+            }
+            Tag::CodeBlock(kind) => {
+                let mut code = Element::new("code");
+                match kind {
+                    CodeBlockKind::Fenced(info) => {
+                        let mut infos =
+                            info.split([' ', '\t', ',']).filter(|info| !info.is_empty());
+                        if let Some(lang) = infos.next() {
+                            let mut classes = String::with_capacity(info.len() + 10);
+                            // The first element in the infostring is treated as the language.
+                            classes.push_str("language-");
+                            classes.push_str(lang);
+                            // The rest are just added as classes.
+                            while let Some(info) = infos.next() {
+                                classes.push(' ');
+                                classes.push_str(info);
+                            }
+                            code.insert_attr("class", classes.into());
+                        }
+                    }
+                    CodeBlockKind::Indented => {}
+                }
+                self.push_no_stack(Node::Element(Element::new("pre")));
+                code
+            }
+            Tag::HtmlBlock => {
+                // To process the HTML correctly, this needs to
+                // collect it all into a single string.
+                let mut html = String::new();
+                while let Some(event) = self.events.next() {
+                    match event {
+                        Event::Html(text) | Event::Text(text) => html.push_str(&text),
+                        Event::End(TagEnd::HtmlBlock) => break,
+                        _ => panic!(
+                            "`{}` unexpected event in html block {event:?}",
+                            self.options.path.display()
+                        ),
+                    }
+                }
+                self.append_html(&html);
+                // TagEnd::HtmlBlock must not pop.
+                return;
+            }
+            Tag::List(Some(start)) => {
+                let mut ol = Element::new("ol");
+                if start != 1 {
+                    ol.insert_attr("start", format!("{start}").into());
+                }
+                ol
+            }
+            Tag::List(None) => Element::new("ul"),
+            Tag::Item => Element::new("li"),
+            Tag::FootnoteDefinition(name) => {
+                if self.footnote_defs.contains_key(&name) {
+                    warn!(
+                        "footnote `{name}` in {} defined multiple times - \
+                                     not updating to new definition",
+                        self.options.path.display()
+                    );
+                    self.eat_till_end();
+                    return;
+                } else {
+                    let mut el = Element::new("li");
+                    el.insert_attr("id", format!("footnote-{name}").into());
+                    self.push(Node::Element(el));
+                    self.footnote_defs.insert(name, self.current_node);
+                    return;
+                }
+            }
+            Tag::DefinitionList => Element::new("dl"),
+            Tag::DefinitionListTitle => Element::new("dt"),
+            Tag::DefinitionListDefinition => Element::new("dd"),
+            Tag::Table(alignments) => {
+                self.table_alignments = alignments.clone();
+                // This div wrapper around the table is used to apply
+                // `overflow-x: auto` so that wide tables can be scrolled
+                // horizontally, rather than overflowing or scrolling the
+                // entire page. See
+                // https://github.com/rust-lang/mdBook/pull/1617
+                let mut div = Element::new("div");
+                div.insert_attr("class", "table-wrapper".into());
+                self.push_no_stack(Node::Element(div));
+                Element::new("table")
+            }
+            Tag::TableHead => {
+                self.table_state = TableState::Head;
+                self.table_cell_index = 0;
+                let thead = Element::new("thead");
+                self.push_no_stack(Node::Element(thead));
+                Element::new("tr")
+            }
+            Tag::TableRow => {
+                self.table_cell_index = 0;
+                Element::new("tr")
+            }
+            Tag::TableCell => {
+                let mut cell = match self.table_state {
+                    TableState::Head => Element::new("th"),
+                    TableState::Body => Element::new("td"),
+                };
+                let style = match self.table_alignments.get(self.table_cell_index) {
+                    Some(&Alignment::Left) => "text-align: left",
+                    Some(&Alignment::Center) => "text-align: center",
+                    Some(&Alignment::Right) => "text-align: right",
+                    Some(&Alignment::None) | None => "",
+                };
+                if !style.is_empty() {
+                    cell.insert_attr("style", style.into());
+                }
+                cell
+            }
+            Tag::Emphasis => Element::new("em"),
+            Tag::Strong => Element::new("strong"),
+            Tag::Strikethrough => Element::new("del"),
+            Tag::Superscript => Element::new("sup"),
+            Tag::Subscript => Element::new("sub"),
+            Tag::Link {
+                link_type,
+                dest_url,
+                title,
+                id: _,
+            } => {
+                let href: StrTendril = if matches!(link_type, LinkType::Email) {
+                    format!("mailto:{dest_url}").into()
+                } else {
+                    fix_link(dest_url).into_tendril()
+                };
+                let mut a = Element::new("a");
+                a.insert_attr("href", href);
+                if !title.is_empty() {
+                    a.insert_attr("title", title.into_tendril());
+                }
+                a
+            }
+            Tag::Image {
+                link_type: _,
+                dest_url,
+                title,
+                id: _,
+            } => {
+                let mut img = Element::new("img");
+                let src = fix_link(dest_url).into_tendril();
+                img.insert_attr("src", src);
+                if !title.is_empty() {
+                    img.insert_attr("title", title.into_tendril());
+                }
+                // This will eat TagEnd::Image
+                let alt = self.text_for_img_alt();
+                img.insert_attr("alt", alt.into());
+                self.append(Node::Element(img));
+                return;
+            }
+            Tag::MetadataBlock(_) => {
+                // Eat all events till the end of MetadataBlock.
+                while let Some(event) = self.events.next() {
+                    if matches!(event, Event::End(TagEnd::MetadataBlock(_))) {
+                        break;
+                    }
+                }
+                return;
+            }
+        };
+        self.push(Node::Element(element));
+    }
+
+    /// Given some HTML, parse it into [`Node`] elements and append them to
+    /// the current node.
+    fn append_html(&mut self, html: &str) {
+        let tokens = parse_html(&html);
+        let mut is_raw = false;
+        for token in tokens {
+            match token {
+                Token::DoctypeToken(_) => {}
+                Token::TagToken(tag) => {
+                    match tag.kind {
+                        TagKind::StartTag => {
+                            let is_closed = is_void_element(&tag.name) || tag.self_closing;
+                            is_raw = matches!(&*tag.name, "script" | "style");
+                            let name = QualName::new(None, html5ever::ns!(html), tag.name);
+                            let attrs = tag
+                                .attrs
+                                .into_iter()
+                                .map(|attr| (attr.name, attr.value))
+                                .collect();
+                            let mut el = Element {
+                                name,
+                                attrs,
+                                self_closing: tag.self_closing,
+                            };
+                            fix_html_link(&mut el);
+                            self.push(Node::Element(el));
+                            if is_closed {
+                                // No end element.
+                                self.pop();
+                            }
+                        }
+                        TagKind::EndTag => {
+                            if self.is_html_tag_matching(&tag.name) {
+                                self.pop();
+                            }
+                            // else the stack is corrupt. I'm not really sure
+                            // what to do here...
+                        }
+                    }
+                }
+                Token::CommentToken(comment) => {
+                    self.append(Node::Comment(comment));
+                }
+                Token::CharacterTokens(chars) => {
+                    if is_raw {
+                        self.append(Node::RawData(chars));
+                    } else {
+                        self.append_text(chars);
+                    }
+                }
+                Token::NullCharacterToken => {}
+                Token::EOFToken => {}
+                Token::ParseError(error) => {
+                    warn!(
+                        "html parse error in `{}`: {error}\n\
+                         Html text was:\n\
+                         {html}",
+                        self.options.path.display()
+                    );
+                }
+            }
+        }
+    }
+
+    /// This is used to verify HTML parsing keeps the stack of tags in sync.
+    fn is_html_tag_matching(&self, name: &str) -> bool {
+        let current = self.tree.get(self.current_node).unwrap().value();
+        if let Node::Element(el) = current
+            && el.name() == name
+        {
+            return true;
+        }
+        error!(
+            "internal error: HTML tag stack out of sync.\n
+             path: `{}`\n\
+             current={current:?}\n\
+             pop name: {name}",
+            self.options.path.display()
+        );
+        false
+    }
+
+    /// Eats all pulldown-cmark events until the next `End` matching the
+    /// current nesting level.
+    fn eat_till_end(&mut self) {
+        let mut nest = 0;
+        while let Some(event) = self.events.next() {
+            match event {
+                Event::Start(_) => nest += 1,
+                Event::End(_) => {
+                    if nest == 0 {
+                        break;
+                    }
+                    nest -= 1;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    /// Eats events generating a plain text string, stripping out any
+    /// formatting elements.
+    fn text_for_img_alt(&mut self) -> String {
+        let mut nest = 0;
+        let mut output = String::new();
+        while let Some(event) = self.events.next() {
+            match event {
+                Event::Start(_) => nest += 1,
+                Event::End(_) => {
+                    if nest == 0 {
+                        break;
+                    }
+                    nest -= 1;
+                }
+                Event::Html(_) => {}
+                Event::InlineHtml(text) | Event::Code(text) | Event::Text(text) => {
+                    output.push_str(&text);
+                }
+                Event::InlineMath(text) => {
+                    output.push('$');
+                    output.push_str(&text);
+                    output.push('$');
+                }
+                Event::DisplayMath(text) => {
+                    output.push_str("$$");
+                    output.push_str(&text);
+                    output.push_str("$$");
+                }
+                Event::SoftBreak | Event::HardBreak | Event::Rule => output.push(' '),
+                Event::FootnoteReference(_) => {}
+                Event::TaskListMarker(_) => {}
+            }
+        }
+        output
+    }
+
+    /// Appends a new footnote reference.
+    fn footnote_reference(&mut self, name: CowStr<'event>) {
+        let len = self.footnote_numbers.len() + 1;
+        let (n, count) = self
+            .footnote_numbers
+            .entry(name.clone())
+            .or_insert((len, 0));
+        *count += 1;
+        let (n, count) = (*n, *count);
+
+        let current = self.tree.get(self.current_node).unwrap();
+        if let Some(last) = current.last_child()
+            && let Node::Element(el) = last.value()
+        {
+            if el.attr("class") == Some("footnote-reference") {
+                self.append(Node::Text(" ".into()));
+            }
+        }
+        let mut sup = Element::new("sup");
+        sup.insert_attr("class", "footnote-reference".into());
+        let id = format!("fr-{name}-{count}");
+        sup.insert_attr("id", id.into());
+        self.push(Node::Element(sup));
+        let mut a = Element::new("a");
+        a.insert_attr("href", format!("#footnote-{name}").into());
+        self.push(Node::Element(a));
+        self.append(Node::Text(format!("{n}").into()));
+        self.pop(); // a
+        self.pop(); // sup
+    }
+
+    /// This is used after parsing is complete to move the footnote
+    /// definitions to the end of the document.
+    fn collect_footnote_defs(&mut self) {
+        if self.footnote_defs.is_empty() {
+            return;
+        }
+        let defs = std::mem::take(&mut self.footnote_defs);
+        let mut defs: Vec<_> = defs.into_iter().collect();
+        // Detach nodes and remove unused.
+        defs.retain(|(name, def_id)| {
+            let mut node = self.tree.get_mut(*def_id).unwrap();
+            node.detach();
+
+            if !self.footnote_numbers.contains_key(name) {
+                warn!(
+                    "footnote `{name}` in `{}` is defined but not referenced",
+                    self.options.path.display()
+                );
+                false
+            } else {
+                true
+            }
+        });
+        defs.sort_by_cached_key(|(name, _)| self.footnote_numbers[name].0);
+
+        // Move defs to the end of the chapter.
+        self.append(Node::Element(Element::new("hr")));
+        let mut ol = Element::new("ol");
+        ol.insert_attr("class", "footnote-definition".into());
+        let ol_id = self.append(Node::Element(ol));
+        for (name, def_id) in defs {
+            // Generate the linkbacks.
+            let count = self.footnote_numbers[&name].1;
+            for usage in 1..=count {
+                let nth = if usage == 1 {
+                    String::new()
+                } else {
+                    usage.to_string()
+                };
+                let space = self.tree.orphan(Node::Text(" ".into())).id();
+                let mut backlink = Element::new("a");
+                backlink.insert_attr("href", format!("#fr-{name}-{usage}").into());
+                let mut backlink = self.tree.orphan(Node::Element(backlink));
+                backlink.append(Node::Text(format!("↩{nth}").into()));
+                let backlink = backlink.id();
+                let mut def = self.tree.get_mut(def_id).unwrap();
+                if let Some(mut last_child) = def.last_child()
+                    && let value = last_child.value()
+                    && let Node::Element(last_el) = value
+                    && last_el.name() == "p"
+                {
+                    // Put the linkback at the end of the last paragraph instead
+                    // of on a line by itself.
+                    last_child.append_id(space);
+                    last_child.append_id(backlink);
+                } else {
+                    // Not a clear place to put it in this circumstance, so put it
+                    // at the end.
+                    def.append_id(space);
+                    def.append_id(backlink);
+                };
+            }
+            let mut ol = self.tree.get_mut(ol_id).unwrap();
+            ol.append_id(def_id);
+        }
+    }
+
+    /// This is used after parsing is complete to add a unique `id` attribute
+    /// to all header elements, and to also add an `<a>` tag so that clicking
+    /// the header will set the current URL to that header's fragment.
+    fn add_header_links(&mut self) {
+        let mut id_counter = HashMap::new();
+        let headings =
+            self.node_ids_for_tag(&|name| matches!(name, "h1" | "h2" | "h3" | "h4" | "h5" | "h6"));
+        for heading in headings {
+            let node = self.tree.get(heading).unwrap();
+            let el = node.value().as_element().unwrap();
+            let href = if let Some(id) = el.attr("id") {
+                format!("#{id}")
+            } else {
+                let mut id = String::new();
+                let node_id = node.id();
+                let node_ref = self.tree.get(node_id).unwrap();
+                text_in_node(node_ref, &mut id);
+                let id = id_from_content(&id);
+                let id = unique_id(&id, &mut id_counter);
+                let mut node = self.tree.get_mut(heading).unwrap();
+                let el = node.value().as_element_mut().unwrap();
+                let href = format!("#{id}");
+                el.insert_attr("id", id.into());
+                href
+            };
+            // Insert an <a> element between the heading and its children.
+            let mut a = Element::new("a");
+            a.insert_attr("class", "header".into());
+            a.insert_attr("href", href.into());
+            let mut a = self.tree.orphan(Node::Element(a));
+            a.reparent_from_id_append(heading);
+            let a_id = a.id();
+            let mut node = self.tree.get_mut(heading).unwrap();
+            node.append_id(a_id);
+        }
+    }
+
+    /// This is used after parsing is complete to set the appropriate classes
+    /// on a code block, to wrap hidden lines in `<span>` tags, and to add an
+    /// `fn main() {}` wrapper for Rust code blocks.
+    fn update_code_blocks(&mut self) {
+        let mut code_ids = self.node_ids_for_tag(&|name| name == "code");
+        // The processing below assumes the code block is in a contiguous
+        // chunk. The text nodes should have been merged during event
+        // processing. I don't know exactly what this should do if it
+        // encounters code blocks with non-text nodes.
+        code_ids.retain(|id| {
+            let code = self.tree.get(*id).unwrap();
+            code.children().count() == 1
+        });
+
+        for code_id in code_ids.iter().copied() {
+            let mut node = self.tree.get_mut(code_id).unwrap();
+            let parent_id = node.parent().unwrap().id();
+            let code_el = node.value().as_element_mut().unwrap();
+            let class = code_el.attr("class").unwrap_or_default();
+            let class_set: HashSet<_> = class.split(' ').collect();
+            let is_editable = class_set.contains("editable");
+            let is_playground = class_set.contains("language-rust")
+                && ((!class_set.contains("ignore")
+                    && !class_set.contains("noplayground")
+                    && !class_set.contains("noplaypen")
+                    && self.options.config.playground.runnable)
+                    || class_set.contains("mdbook-runnable"));
+            if !is_playground {
+                continue;
+            }
+            let add_edition = if class_set.iter().any(|cls| cls.starts_with("edition")) {
+                None
+            } else {
+                self.options.edition.map(|edition| match edition {
+                    RustEdition::E2015 => "edition2015",
+                    RustEdition::E2018 => "edition2018",
+                    RustEdition::E2021 => "edition2021",
+                    RustEdition::E2024 => "edition2024",
+                    _ => panic!("edition {edition:?} not covered"),
+                })
+            };
+            if let Some(edition) = add_edition {
+                code_el.insert_attr("class", format!("{class} {edition}").into());
+            }
+
+            let mut node = self.tree.get_mut(code_id).unwrap();
+            if !self.options.config.playground.editable || !is_editable {
+                if let Some(mut child) = node.first_child()
+                    && let Node::Text(text) = child.value()
+                {
+                    if let Some(new_text) = wrap_rust_main(text) {
+                        *text = new_text.into();
+                    }
+                }
+            }
+
+            let mut pre = self.tree.get_mut(parent_id).unwrap();
+            let pre = pre.value().as_element_mut().unwrap();
+            assert_eq!(pre.name(), "pre");
+            pre.insert_attr("class", "playground".into());
+        }
+
+        for code_id in code_ids {
+            hide_lines(&mut self.tree, code_id, &self.options.config.code.hidelines);
+        }
+    }
+
+    /// This is used after parsing is complete to replace `<i>` tags with a
+    /// `<span>` that includes the corresponding SVG code.
+    fn convert_fontawesome(&mut self) {
+        use font_awesome_as_a_crate as fa;
+
+        let is = self.node_ids_for_tag(&|name| name == "i");
+        for i_id in is {
+            let mut icon = String::new();
+            let mut type_ = fa::Type::Regular;
+            let mut new_classes = String::from("fa-svg");
+
+            let mut node = self.tree.get_mut(i_id).unwrap();
+            if node.first_child().is_some() {
+                // Just to be safe, only translate <i></i>.
+                continue;
+            }
+            let i_el = node.value().as_element().unwrap();
+            let classes = i_el.attr("class").unwrap_or_default();
+            for class in classes.split(" ") {
+                if let Some(class) = class.strip_prefix("fa-") {
+                    icon = class.to_owned();
+                } else if class == "fa" {
+                    type_ = fa::Type::Regular;
+                } else if class == "fas" {
+                    type_ = fa::Type::Solid;
+                } else if class == "fab" {
+                    type_ = fa::Type::Brands;
+                } else {
+                    new_classes += " ";
+                    new_classes += class;
+                }
+            }
+
+            if !icon.is_empty()
+                && let Ok(svg) = fa::svg(type_, &icon)
+            {
+                let mut span = Element::new("span");
+                span.insert_attr("class", new_classes.into());
+                for (name, value) in &i_el.attrs {
+                    if *name != attr_qual_name!("class") {
+                        span.attrs.insert(name.clone(), value.clone());
+                    }
+                }
+                *node.value() = Node::Element(span);
+                node.append(Node::RawData(svg.into()));
+            }
+        }
+    }
+}
+
+/// Traverse the given node, emitting any plain text into the output.
+///
+/// This is used to generate the `id` of a header.
+fn text_in_node(node: NodeRef<'_, Node>, output: &mut String) {
+    for child in node.children() {
+        match child.value() {
+            Node::Element(_) => {}
+            Node::Text(text) => output.push_str(text),
+            Node::Comment(_) => {}
+            Node::Fragment => {}
+            Node::RawData(_) => {}
+        }
+        text_in_node(child, output);
+    }
+}
+
+/// Modifies links to work with HTML.
+///
+/// For local paths, this changes the `.md` extension to `.html`.
+fn fix_link<'a>(link: CowStr<'a>) -> CowStr<'a> {
+    static_regex!(SCHEME_LINK, r"^[a-z][a-z0-9+.-]*:");
+    static_regex!(MD_LINK, r"(?P<link>.*)\.md(?P<anchor>#.*)?");
+
+    if link.starts_with('#') {
+        // Fragment-only link.
+        return link;
+    }
+    // Don't modify links with schemes like `https`.
+    if SCHEME_LINK.is_match(&link) {
+        return link;
+    }
+
+    // This is a relative link, adjust it as necessary.
+    if let Some(caps) = MD_LINK.captures(&link) {
+        let mut fixed_link = String::from(&caps["link"]);
+        fixed_link.push_str(".html");
+        if let Some(anchor) = caps.name("anchor") {
+            fixed_link.push_str(anchor.as_str());
+        }
+        CowStr::from(fixed_link)
+    } else {
+        link
+    }
+}
+
+/// Calls [`fix_link`] for HTML elements.
+fn fix_html_link(el: &mut Element) {
+    if el.name() != "a" {
+        return;
+    }
+    for attr in ["href", "xlink:href"] {
+        if let Some(value) = el.attr(attr) {
+            let fixed = fix_link(value.into());
+            el.insert_attr(attr, fixed.into_tendril());
+        }
+    }
+}
+
+/// Whether or not this element name is a [void element].
+///
+/// This is used to know whether or not to expect a `</>` end tag.
+///
+/// [void element]: https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+pub(crate) fn is_void_element(name: &str) -> bool {
+    matches!(
+        name,
+        "area"
+            | "base"
+            | "br"
+            | "col"
+            | "embed"
+            | "hr"
+            | "img"
+            | "input"
+            | "link"
+            | "meta"
+            | "param"
+            | "source"
+            | "track"
+            | "wbr"
+    )
+}
diff --git a/crates/mdbook-html/src/html_handlebars/hbs_renderer.rs b/crates/mdbook-html/src/html_handlebars/hbs_renderer.rs
index 3bc576e050..073e9c861d 100644
--- a/crates/mdbook-html/src/html_handlebars/hbs_renderer.rs
+++ b/crates/mdbook-html/src/html_handlebars/hbs_renderer.rs
@@ -1,20 +1,17 @@
 use super::helpers;
 use super::static_files::StaticFiles;
+use crate::html::ChapterTree;
+use crate::html::{build_trees, render_markdown, serialize};
 use crate::theme::Theme;
 use crate::utils::ToUrlPath;
 use anyhow::{Context, Result, bail};
 use handlebars::Handlebars;
 use mdbook_core::book::{Book, BookItem, Chapter};
-use mdbook_core::config::{BookConfig, Code, Config, HtmlConfig, Playground, RustEdition};
-use mdbook_core::utils::fs::get_404_output_file;
-use mdbook_core::{static_regex, utils};
-use mdbook_markdown::render_markdown;
+use mdbook_core::config::{BookConfig, Config, HtmlConfig};
+use mdbook_core::utils;
 use mdbook_renderer::{RenderContext, Renderer};
-use regex::Captures;
 use serde_json::json;
-use std::borrow::Cow;
-use std::collections::BTreeMap;
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::fs::{self, File};
 use std::path::{Path, PathBuf};
 use tracing::error;
@@ -33,15 +30,19 @@ impl HtmlHandlebars {
 
     fn render_chapter(
         &self,
-        ch: &Chapter,
+        chapter_tree: &ChapterTree<'_>,
         prev_ch: Option<&Chapter>,
         next_ch: Option<&Chapter>,
         mut ctx: RenderChapterContext<'_>,
-        print_content: &mut String,
     ) -> Result<()> {
         // FIXME: This should be made DRY-er and rely less on mutable state
+        let ch = chapter_tree.chapter;
 
         let path = ch.path.as_ref().unwrap();
+        // "print.html" is used for the print page.
+        if path == Path::new("print.md") {
+            bail!("{} is reserved for internal use", path.display());
+        };
 
         if let Some(ref edit_url_template) = ctx.html_config.edit_url_template {
             let full_path = ctx.book_config.src.to_str().unwrap_or_default().to_owned()
@@ -57,30 +58,14 @@ impl HtmlHandlebars {
                 .insert("git_repository_edit_url".to_owned(), json!(edit_url));
         }
 
-        let mut options = crate::html_render_options_from_config(path, &ctx.html_config);
-        let content = render_markdown(&ch.content, &options);
-        options.for_print = true;
-        let fixed_content = render_markdown(&ch.content, &options);
-        if prev_ch.is_some() && ctx.html_config.print.page_break {
-            // Add page break between chapters
-            // See https://developer.mozilla.org/en-US/docs/Web/CSS/break-before and https://developer.mozilla.org/en-US/docs/Web/CSS/page-break-before
-            // Add both two CSS properties because of the compatibility issue
-            print_content
-                .push_str(r#"<div style="break-before: page; page-break-before: always;"></div>"#);
-        }
-        print_content.push_str(&fixed_content);
+        let mut content = String::new();
+        serialize(&chapter_tree.tree, &mut content);
 
-        // Update the context with data for this file
         let ctx_path = path
             .to_str()
             .with_context(|| "Could not convert path to str")?;
         let filepath = Path::new(&ctx_path).with_extension("html");
 
-        // "print.html" is used for the print page.
-        if path == Path::new("print.md") {
-            bail!("{} is reserved for internal use", path.display());
-        };
-
         let book_title = ctx
             .data
             .get("book_title")
@@ -137,13 +122,6 @@ impl HtmlHandlebars {
         debug!("Render template");
         let rendered = ctx.handlebars.render("index", &ctx.data)?;
 
-        let rendered = self.post_process(
-            rendered,
-            &ctx.html_config.playground,
-            &ctx.html_config.code,
-            ctx.edition,
-        );
-
         // Write to file
         debug!("Creating {}", filepath.display());
         utils::fs::write_file(&ctx.destination, &filepath, rendered.as_bytes())?;
@@ -153,12 +131,6 @@ impl HtmlHandlebars {
             ctx.data.insert("path_to_root".to_owned(), json!(""));
             ctx.data.insert("is_index".to_owned(), json!(true));
             let rendered_index = ctx.handlebars.render("index", &ctx.data)?;
-            let rendered_index = self.post_process(
-                rendered_index,
-                &ctx.html_config.playground,
-                &ctx.html_config.code,
-                ctx.edition,
-            );
             debug!("Creating index.html from {}", ctx_path);
             utils::fs::write_file(&ctx.destination, "index.html", rendered_index.as_bytes())?;
         }
@@ -192,7 +164,11 @@ impl HtmlHandlebars {
                     .to_string()
             }
         };
-        let options = crate::html_render_options_from_config(Path::new("404.md"), html_config);
+        let options = crate::html::HtmlRenderOptions::new(
+            Path::new("404.md"),
+            html_config,
+            ctx.config.rust.edition,
+        );
         let html_content_404 = render_markdown(&content_404, &options);
 
         let mut data_404 = data.clone();
@@ -219,43 +195,28 @@ impl HtmlHandlebars {
         data_404.insert("title".to_owned(), json!(title));
         let rendered = handlebars.render("index", &data_404)?;
 
-        let rendered = self.post_process(
-            rendered,
-            &html_config.playground,
-            &html_config.code,
-            ctx.config.rust.edition,
-        );
-        let output_file = get_404_output_file(&html_config.input_404);
+        let output_file = utils::fs::get_404_output_file(&html_config.input_404);
         utils::fs::write_file(destination, output_file, rendered.as_bytes())?;
         debug!("Creating 404.html ✓");
         Ok(())
     }
 
-    fn post_process(
-        &self,
-        rendered: String,
-        playground_config: &Playground,
-        code_config: &Code,
-        edition: Option<RustEdition>,
-    ) -> String {
-        let rendered = build_header_links(&rendered);
-        let rendered = fix_code_blocks(&rendered);
-        let rendered = add_playground_pre(&rendered, playground_config, edition);
-        let rendered = hide_lines(&rendered, code_config);
-        let rendered = convert_fontawesome(&rendered);
-
-        rendered
-    }
-
-    /// Update the context with data for this file
-    fn configure_print_version(
+    fn render_print_page(
         &self,
+        ctx: &RenderContext,
+        handlebars: &Handlebars<'_>,
         data: &mut serde_json::Map<String, serde_json::Value>,
-        print_content: &str,
-    ) {
-        // Make sure that the Print chapter does not display the title from
-        // the last rendered chapter by removing it from its context
-        data.remove("title");
+        chapter_trees: Vec<ChapterTree<'_>>,
+    ) -> Result<String> {
+        let print_content = crate::html::render_print_page(chapter_trees);
+
+        if let Some(ref title) = ctx.config.book.title {
+            data.insert("title".to_owned(), json!(title));
+        } else {
+            // Make sure that the Print chapter does not display the title from
+            // the last rendered chapter by removing it from its context
+            data.remove("title");
+        }
         data.insert("is_print".to_owned(), json!(true));
         data.insert("path".to_owned(), json!("print.md"));
         data.insert("content".to_owned(), json!(print_content));
@@ -263,6 +224,10 @@ impl HtmlHandlebars {
             "path_to_root".to_owned(),
             json!(utils::fs::path_to_root(Path::new("print.md"))),
         );
+
+        debug!("Render template");
+        let rendered = handlebars.render("index", &data)?;
+        Ok(rendered)
     }
 
     fn register_hbs_helpers(&self, handlebars: &mut Handlebars<'_>, html_config: &HtmlConfig) {
@@ -401,8 +366,7 @@ impl Renderer for HtmlHandlebars {
 
         let mut data = make_data(&ctx.root, book, &ctx.config, &html_config, &theme)?;
 
-        // Print version
-        let mut print_content = String::new();
+        let chapter_trees = build_trees(book, &html_config, ctx.config.rust.edition);
 
         fs::create_dir_all(destination)
             .with_context(|| "Unexpected error when constructing destination path")?;
@@ -415,7 +379,7 @@ impl Renderer for HtmlHandlebars {
             let default = mdbook_core::config::Search::default();
             let search = html_config.search.as_ref().unwrap_or(&default);
             if search.enable {
-                super::search::create_files(&search, &mut static_files, &book)?;
+                super::search::create_files(&search, &mut static_files, &chapter_trees)?;
             }
         }
 
@@ -458,20 +422,18 @@ impl Renderer for HtmlHandlebars {
             utils::fs::write_file(destination, "CNAME", format!("{cname}\n").as_bytes())?;
         }
 
-        let chapters: Vec<_> = book.chapters().collect();
-        for (i, ch) in chapters.iter().enumerate() {
-            let previous = (i != 0).then(|| chapters[i - 1]);
-            let next = (i != chapters.len() - 1).then(|| chapters[i + 1]);
+        for (i, chapter_tree) in chapter_trees.iter().enumerate() {
+            let previous = (i != 0).then(|| chapter_trees[i - 1].chapter);
+            let next = (i != chapter_trees.len() - 1).then(|| chapter_trees[i + 1].chapter);
             let ctx = RenderChapterContext {
                 handlebars: &handlebars,
                 destination: destination.to_path_buf(),
                 data: data.clone(),
                 book_config: book_config.clone(),
                 html_config: html_config.clone(),
-                edition: ctx.config.rust.edition,
                 chapter_titles: &ctx.chapter_titles,
             };
-            self.render_chapter(ch, previous, next, ctx, &mut print_content)?;
+            self.render_chapter(chapter_tree, previous, next, ctx)?;
         }
 
         // Render 404 page
@@ -479,25 +441,12 @@ impl Renderer for HtmlHandlebars {
             self.render_404(ctx, &html_config, &src_dir, &mut handlebars, &mut data)?;
         }
 
-        // Print version
-        self.configure_print_version(&mut data, &print_content);
-        if let Some(ref title) = ctx.config.book.title {
-            data.insert("title".to_owned(), json!(title));
-        }
-
-        // Render the handlebars template with the data
+        // Render the print version.
         if html_config.print.enable {
-            debug!("Render template");
-            let rendered = handlebars.render("index", &data)?;
-
-            let rendered = self.post_process(
-                rendered,
-                &html_config.playground,
-                &html_config.code,
-                ctx.config.rust.edition,
-            );
+            let print_rendered =
+                self.render_print_page(ctx, &handlebars, &mut data, chapter_trees)?;
 
-            utils::fs::write_file(destination, "print.html", rendered.as_bytes())?;
+            utils::fs::write_file(destination, "print.html", print_rendered.as_bytes())?;
             debug!("Creating print.html ✓");
         }
 
@@ -691,331 +640,12 @@ fn make_data(
     Ok(data)
 }
 
-/// Goes through the rendered HTML, making sure all header tags have
-/// an anchor respectively so people can link to sections directly.
-fn build_header_links(html: &str) -> String {
-    static_regex!(
-        BUILD_HEADER_LINKS,
-        r#"<h(\d)(?: id="([^"]+)")?(?: class="([^"]+)")?>(.*?)</h\d>"#
-    );
-    static IGNORE_CLASS: &[&str] = &["menu-title", "mdbook-help-title"];
-
-    let mut id_counter = HashMap::new();
-
-    BUILD_HEADER_LINKS
-        .replace_all(html, |caps: &Captures<'_>| {
-            let level = caps[1]
-                .parse()
-                .expect("Regex should ensure we only ever get numbers here");
-
-            // Ignore .menu-title because now it's getting detected by the regex.
-            if let Some(classes) = caps.get(3) {
-                for class in classes.as_str().split(" ") {
-                    if IGNORE_CLASS.contains(&class) {
-                        return caps[0].to_string();
-                    }
-                }
-            }
-
-            insert_link_into_header(
-                level,
-                &caps[4],
-                caps.get(2).map(|x| x.as_str().to_string()),
-                caps.get(3).map(|x| x.as_str().to_string()),
-                &mut id_counter,
-            )
-        })
-        .into_owned()
-}
-
-/// Insert a single link into a header, making sure each link gets its own
-/// unique ID by appending an auto-incremented number (if necessary).
-fn insert_link_into_header(
-    level: usize,
-    content: &str,
-    id: Option<String>,
-    classes: Option<String>,
-    id_counter: &mut HashMap<String, usize>,
-) -> String {
-    let id = id.unwrap_or_else(|| utils::unique_id_from_content(content, id_counter));
-    let classes = classes
-        .map(|s| format!(" class=\"{s}\""))
-        .unwrap_or_default();
-
-    format!(
-        r##"<h{level} id="{id}"{classes}><a class="header" href="#{id}">{content}</a></h{level}>"##
-    )
-}
-
-// Convert fontawesome `<i>` tags to inline SVG
-fn convert_fontawesome(html: &str) -> String {
-    use font_awesome_as_a_crate as fa;
-
-    static_regex!(FA_RE, r#"<i([^>]+)class="([^"]+)"([^>]*)></i>"#);
-    FA_RE
-        .replace_all(html, |caps: &Captures<'_>| {
-            let text = &caps[0];
-            let before = &caps[1];
-            let classes = &caps[2];
-            let after = &caps[3];
-
-            let mut icon = String::new();
-            let mut type_ = fa::Type::Regular;
-            let mut other_classes = String::new();
-
-            for class in classes.split(" ") {
-                if let Some(class) = class.strip_prefix("fa-") {
-                    icon = class.to_owned();
-                } else if class == "fa" {
-                    type_ = fa::Type::Regular;
-                } else if class == "fas" {
-                    type_ = fa::Type::Solid;
-                } else if class == "fab" {
-                    type_ = fa::Type::Brands;
-                } else {
-                    other_classes += " ";
-                    other_classes += class;
-                }
-            }
-
-            if icon.is_empty() {
-                text.to_owned()
-            } else if let Ok(svg) = fa::svg(type_, &icon) {
-                format!(
-                    r#"<span{before}class="fa-svg{other_classes}"{after}>{svg}</span>"#,
-                    before = before,
-                    other_classes = other_classes,
-                    after = after,
-                    svg = svg
-                )
-            } else {
-                text.to_owned()
-            }
-        })
-        .into_owned()
-}
-
-// The rust book uses annotations for rustdoc to test code snippets,
-// like the following:
-// ```rust,should_panic
-// fn main() {
-//     // Code here
-// }
-// ```
-// This function replaces all commas by spaces in the code block classes
-fn fix_code_blocks(html: &str) -> String {
-    static_regex!(FIX_CODE_BLOCKS, r#"<code([^>]+)class="([^"]+)"([^>]*)>"#);
-
-    FIX_CODE_BLOCKS
-        .replace_all(html, |caps: &Captures<'_>| {
-            let before = &caps[1];
-            let classes = &caps[2].replace(',', " ");
-            let after = &caps[3];
-
-            format!(r#"<code{before}class="{classes}"{after}>"#)
-        })
-        .into_owned()
-}
-
-static_regex!(
-    CODE_BLOCK_RE,
-    r#"((?s)<code[^>]?class="([^"]+)".*?>(.*?)</code>)"#
-);
-
-fn add_playground_pre(
-    html: &str,
-    playground_config: &Playground,
-    edition: Option<RustEdition>,
-) -> String {
-    CODE_BLOCK_RE
-        .replace_all(html, |caps: &Captures<'_>| {
-            let text = &caps[1];
-            let classes = &caps[2];
-            let code = &caps[3];
-
-            if classes.contains("language-rust")
-                && ((!classes.contains("ignore")
-                    && !classes.contains("noplayground")
-                    && !classes.contains("noplaypen")
-                    && playground_config.runnable)
-                    || classes.contains("mdbook-runnable"))
-            {
-                let contains_e2015 = classes.contains("edition2015");
-                let contains_e2018 = classes.contains("edition2018");
-                let contains_e2021 = classes.contains("edition2021");
-                let edition_class = if contains_e2015 || contains_e2018 || contains_e2021 {
-                    // the user forced edition, we should not overwrite it
-                    ""
-                } else {
-                    match edition {
-                        Some(RustEdition::E2015) => " edition2015",
-                        Some(RustEdition::E2018) => " edition2018",
-                        Some(RustEdition::E2021) => " edition2021",
-                        Some(RustEdition::E2024) => " edition2024",
-                        Some(_) => panic!("edition {edition:?} not covered"),
-                        None => "",
-                    }
-                };
-
-                // wrap the contents in an external pre block
-                format!(
-                    "<pre class=\"playground\"><code class=\"{}{}\">{}</code></pre>",
-                    classes,
-                    edition_class,
-                    {
-                        let content: Cow<'_, str> = if playground_config.editable
-                            && classes.contains("editable")
-                            || text.contains("fn main")
-                            || text.contains("quick_main!")
-                        {
-                            code.into()
-                        } else {
-                            // we need to inject our own main
-                            let (attrs, code) = partition_rust_source(code);
-                            let newline = if code.is_empty() || code.ends_with('\n') {
-                                ""
-                            } else {
-                                "\n"
-                            };
-                            format!(
-                                "# #![allow(unused)]\n{attrs}# fn main() {{\n{code}{newline}# }}"
-                            )
-                            .into()
-                        };
-                        content
-                    }
-                )
-            } else {
-                // not language-rust, so no-op
-                text.to_owned()
-            }
-        })
-        .into_owned()
-}
-
-/// Modifies all `<code>` blocks to convert "hidden" lines and to wrap them in
-/// a `<span class="boring">`.
-fn hide_lines(html: &str, code_config: &Code) -> String {
-    static_regex!(LANGUAGE_REGEX, r"\blanguage-(\w+)\b");
-    static_regex!(HIDELINES_REGEX, r"\bhidelines=(\S+)");
-
-    CODE_BLOCK_RE
-        .replace_all(html, |caps: &Captures<'_>| {
-            let text = &caps[1];
-            let classes = &caps[2];
-            let code = &caps[3];
-
-            if classes.contains("language-rust") {
-                format!(
-                    "<code class=\"{}\">{}</code>",
-                    classes,
-                    hide_lines_rust(code)
-                )
-            } else {
-                // First try to get the prefix from the code block
-                let hidelines_capture = HIDELINES_REGEX.captures(classes);
-                let hidelines_prefix = match &hidelines_capture {
-                    Some(capture) => Some(&capture[1]),
-                    None => {
-                        // Then look up the prefix by language
-                        LANGUAGE_REGEX.captures(classes).and_then(|capture| {
-                            code_config.hidelines.get(&capture[1]).map(|p| p.as_str())
-                        })
-                    }
-                };
-
-                match hidelines_prefix {
-                    Some(prefix) => format!(
-                        "<code class=\"{}\">{}</code>",
-                        classes,
-                        hide_lines_with_prefix(code, prefix)
-                    ),
-                    None => text.to_owned(),
-                }
-            }
-        })
-        .into_owned()
-}
-
-fn hide_lines_rust(content: &str) -> String {
-    static_regex!(BORING_LINES_REGEX, r"^(\s*)#(.?)(.*)$");
-
-    let mut result = String::with_capacity(content.len());
-    let mut lines = content.lines().peekable();
-    while let Some(line) = lines.next() {
-        // Don't include newline on the last line.
-        let newline = if lines.peek().is_none() { "" } else { "\n" };
-        if let Some(caps) = BORING_LINES_REGEX.captures(line) {
-            if &caps[2] == "#" {
-                result += &caps[1];
-                result += &caps[2];
-                result += &caps[3];
-                result += newline;
-                continue;
-            } else if matches!(&caps[2], "" | " ") {
-                result += "<span class=\"boring\">";
-                result += &caps[1];
-                result += &caps[3];
-                result += newline;
-                result += "</span>";
-                continue;
-            }
-        }
-        result += line;
-        result += newline;
-    }
-    result
-}
-
-fn hide_lines_with_prefix(content: &str, prefix: &str) -> String {
-    let mut result = String::with_capacity(content.len());
-    for line in content.lines() {
-        if line.trim_start().starts_with(prefix) {
-            let pos = line.find(prefix).unwrap();
-            let (ws, rest) = (&line[..pos], &line[pos + prefix.len()..]);
-
-            result += "<span class=\"boring\">";
-            result += ws;
-            result += rest;
-            result += "\n";
-            result += "</span>";
-            continue;
-        }
-        result += line;
-        result += "\n";
-    }
-    result
-}
-
-/// Splits Rust inner attributes from the given source string.
-///
-/// Returns `(inner_attrs, rest_of_code)`.
-fn partition_rust_source(s: &str) -> (&str, &str) {
-    static_regex!(
-        HEADER_RE,
-        r"^(?mx)
-        (
-            (?:
-                ^[ \t]*\#!\[.* (?:\r?\n)?
-                |
-                ^\s* (?:\r?\n)?
-            )*
-        )"
-    );
-    let split_idx = match HEADER_RE.captures(s) {
-        Some(caps) => caps[1].len(),
-        None => 0,
-    };
-    s.split_at(split_idx)
-}
-
 struct RenderChapterContext<'a> {
     handlebars: &'a Handlebars<'a>,
     destination: PathBuf,
     data: serde_json::Map<String, serde_json::Value>,
     book_config: BookConfig,
     html_config: HtmlConfig,
-    edition: Option<RustEdition>,
     chapter_titles: &'a HashMap<PathBuf, String>,
 }
 
@@ -1074,283 +704,3 @@ fn collect_redirects_for_path(
         .collect();
     Ok(map)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use mdbook_core::config::TextDirection;
-    use pretty_assertions::assert_eq;
-
-    #[test]
-    fn original_build_header_links() {
-        let inputs = vec![
-            (
-                "blah blah <h1>Foo</h1>",
-                r##"blah blah <h1 id="foo"><a class="header" href="#foo">Foo</a></h1>"##,
-            ),
-            (
-                "<h1>Foo</h1>",
-                r##"<h1 id="foo"><a class="header" href="#foo">Foo</a></h1>"##,
-            ),
-            (
-                "<h3>Foo^bar</h3>",
-                r##"<h3 id="foobar"><a class="header" href="#foobar">Foo^bar</a></h3>"##,
-            ),
-            (
-                "<h4></h4>",
-                r##"<h4 id=""><a class="header" href="#"></a></h4>"##,
-            ),
-            (
-                "<h4><em>Hï</em></h4>",
-                r##"<h4 id="hï"><a class="header" href="#hï"><em>Hï</em></a></h4>"##,
-            ),
-            (
-                "<h1>Foo</h1><h3>Foo</h3>",
-                r##"<h1 id="foo"><a class="header" href="#foo">Foo</a></h1><h3 id="foo-1"><a class="header" href="#foo-1">Foo</a></h3>"##,
-            ),
-            // id only
-            (
-                r##"<h1 id="foobar">Foo</h1>"##,
-                r##"<h1 id="foobar"><a class="header" href="#foobar">Foo</a></h1>"##,
-            ),
-            // class only
-            (
-                r##"<h1 class="class1 class2">Foo</h1>"##,
-                r##"<h1 id="foo" class="class1 class2"><a class="header" href="#foo">Foo</a></h1>"##,
-            ),
-            // both id and class
-            (
-                r##"<h1 id="foobar" class="class1 class2">Foo</h1>"##,
-                r##"<h1 id="foobar" class="class1 class2"><a class="header" href="#foobar">Foo</a></h1>"##,
-            ),
-        ];
-
-        for (src, should_be) in inputs {
-            let got = build_header_links(src);
-            assert_eq!(got, should_be);
-        }
-    }
-
-    #[test]
-    fn add_playground() {
-        let inputs = [
-            (
-                "<code class=\"language-rust\">x()</code>",
-                "<pre class=\"playground\"><code class=\"language-rust\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>",
-                "<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>",
-            ),
-            (
-                "<code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>",
-            ),
-        ];
-        for (src, should_be) in &inputs {
-            let mut p = Playground::default();
-            p.editable = true;
-            let got = add_playground_pre(src, &p, None);
-            assert_eq!(&*got, *should_be);
-        }
-    }
-    #[test]
-    fn add_playground_edition2015() {
-        let inputs = [
-            (
-                "<code class=\"language-rust\">x()</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2015\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust edition2015\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust edition2018\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
-            ),
-        ];
-        for (src, should_be) in &inputs {
-            let mut p = Playground::default();
-            p.editable = true;
-            let got = add_playground_pre(src, &p, Some(RustEdition::E2015));
-            assert_eq!(&*got, *should_be);
-        }
-    }
-    #[test]
-    fn add_playground_edition2018() {
-        let inputs = [
-            (
-                "<code class=\"language-rust\">x()</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2018\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust edition2015\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust edition2018\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
-            ),
-        ];
-        for (src, should_be) in &inputs {
-            let mut p = Playground::default();
-            p.editable = true;
-            let got = add_playground_pre(src, &p, Some(RustEdition::E2018));
-            assert_eq!(&*got, *should_be);
-        }
-    }
-    #[test]
-    fn add_playground_edition2021() {
-        let inputs = [
-            (
-                "<code class=\"language-rust\">x()</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2021\"># #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2021\">fn main() {}</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust edition2015\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2015\">fn main() {}</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust edition2018\">fn main() {}</code>",
-                "<pre class=\"playground\"><code class=\"language-rust edition2018\">fn main() {}</code></pre>",
-            ),
-        ];
-        for (src, should_be) in &inputs {
-            let mut p = Playground::default();
-            p.editable = true;
-            let got = add_playground_pre(src, &p, Some(RustEdition::E2021));
-            assert_eq!(&*got, *should_be);
-        }
-    }
-
-    #[test]
-    fn hide_lines_language_rust() {
-        let inputs = [
-            (
-                "<pre class=\"playground\"><code class=\"language-rust\">\n# #![allow(unused)]\n# fn main() {\nx()\n# }</code></pre>",
-                "<pre class=\"playground\"><code class=\"language-rust\">\n<span class=\"boring\">#![allow(unused)]\n</span><span class=\"boring\">fn main() {\n</span>x()\n<span class=\"boring\">}</span></code></pre>",
-            ),
-            // # must be followed by a space for a line to be hidden
-            (
-                "<pre class=\"playground\"><code class=\"language-rust\">\n#fn main() {\nx()\n#}</code></pre>",
-                "<pre class=\"playground\"><code class=\"language-rust\">\n#fn main() {\nx()\n#}</code></pre>",
-            ),
-            (
-                "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>",
-                "<pre class=\"playground\"><code class=\"language-rust\">fn main() {}</code></pre>",
-            ),
-            (
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span>\";</code></pre>",
-            ),
-            (
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n ## bar\n\";</code></pre>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n\";</code></pre>",
-            ),
-            (
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n # bar\n#\n\";</code></pre>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">let s = \"foo\n<span class=\"boring\"> bar\n</span><span class=\"boring\">\n</span>\";</code></pre>",
-            ),
-            (
-                "<code class=\"language-rust ignore\">let s = \"foo\n # bar\n\";</code>",
-                "<code class=\"language-rust ignore\">let s = \"foo\n<span class=\"boring\"> bar\n</span>\";</code>",
-            ),
-            (
-                "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>",
-                "<pre class=\"playground\"><code class=\"language-rust editable\">#![no_std]\nlet s = \"foo\";\n #[some_attr]</code></pre>",
-            ),
-        ];
-        for (src, should_be) in &inputs {
-            let got = hide_lines(src, &Code::default());
-            assert_eq!(&*got, *should_be);
-        }
-    }
-
-    #[test]
-    fn hide_lines_language_other() {
-        let inputs = [
-            (
-                "<code class=\"language-python\">~hidden()\nnothidden():\n~    hidden()\n    ~hidden()\n    nothidden()</code>",
-                "<code class=\"language-python\"><span class=\"boring\">hidden()\n</span>nothidden():\n<span class=\"boring\">    hidden()\n</span><span class=\"boring\">    hidden()\n</span>    nothidden()\n</code>",
-            ),
-            (
-                "<code class=\"language-python hidelines=!!!\">!!!hidden()\nnothidden():\n!!!    hidden()\n    !!!hidden()\n    nothidden()</code>",
-                "<code class=\"language-python hidelines=!!!\"><span class=\"boring\">hidden()\n</span>nothidden():\n<span class=\"boring\">    hidden()\n</span><span class=\"boring\">    hidden()\n</span>    nothidden()\n</code>",
-            ),
-        ];
-        let mut code = Code::default();
-        code.hidelines.insert("python".to_string(), "~".to_string());
-        for (src, should_be) in &inputs {
-            let got = hide_lines(src, &code);
-            assert_eq!(&*got, *should_be);
-        }
-    }
-
-    #[test]
-    fn test_json_direction() {
-        assert_eq!(json!(TextDirection::RightToLeft), json!("rtl"));
-        assert_eq!(json!(TextDirection::LeftToRight), json!("ltr"));
-    }
-
-    #[test]
-    fn it_partitions_rust_source() {
-        assert_eq!(partition_rust_source(""), ("", ""));
-        assert_eq!(partition_rust_source("let x = 1;"), ("", "let x = 1;"));
-        assert_eq!(
-            partition_rust_source("fn main()\n{ let x = 1; }\n"),
-            ("", "fn main()\n{ let x = 1; }\n")
-        );
-        assert_eq!(
-            partition_rust_source("#![allow(foo)]"),
-            ("#![allow(foo)]", "")
-        );
-        assert_eq!(
-            partition_rust_source("#![allow(foo)]\n"),
-            ("#![allow(foo)]\n", "")
-        );
-        assert_eq!(
-            partition_rust_source("#![allow(foo)]\nlet x = 1;"),
-            ("#![allow(foo)]\n", "let x = 1;")
-        );
-        assert_eq!(
-            partition_rust_source(
-                "\n\
-                #![allow(foo)]\n\
-                \n\
-                #![allow(bar)]\n\
-                \n\
-                let x = 1;"
-            ),
-            ("\n#![allow(foo)]\n\n#![allow(bar)]\n\n", "let x = 1;")
-        );
-    }
-}
diff --git a/crates/mdbook-html/src/html_handlebars/helpers/toc.rs b/crates/mdbook-html/src/html_handlebars/helpers/toc.rs
index d299803d36..36972d24c6 100644
--- a/crates/mdbook-html/src/html_handlebars/helpers/toc.rs
+++ b/crates/mdbook-html/src/html_handlebars/helpers/toc.rs
@@ -1,11 +1,10 @@
 use crate::utils::ToUrlPath;
-use std::path::Path;
-use std::{cmp::Ordering, collections::BTreeMap};
-
 use handlebars::{
     Context, Handlebars, Helper, HelperDef, Output, RenderContext, RenderError, RenderErrorReason,
 };
-use mdbook_markdown::special_escape;
+use mdbook_core::utils::escape_html_attribute;
+use std::path::Path;
+use std::{cmp::Ordering, collections::BTreeMap};
 
 // Handlebars helper to construct TOC
 #[derive(Clone, Copy)]
@@ -101,7 +100,7 @@ impl HelperDef for RenderToc {
             // Part title
             if let Some(title) = item.get("part") {
                 out.write("<li class=\"part-title\">")?;
-                out.write(&special_escape(title))?;
+                out.write(&escape_html_attribute(title))?;
                 out.write("</li>")?;
                 continue;
             }
@@ -137,7 +136,7 @@ impl HelperDef for RenderToc {
             }
 
             if let Some(name) = item.get("name") {
-                out.write(&special_escape(name))?
+                out.write(&escape_html_attribute(name))?;
             }
 
             if path_exists {
diff --git a/crates/mdbook-html/src/html_handlebars/search.rs b/crates/mdbook-html/src/html_handlebars/search.rs
index f4f73e4193..09920d76d2 100644
--- a/crates/mdbook-html/src/html_handlebars/search.rs
+++ b/crates/mdbook-html/src/html_handlebars/search.rs
@@ -1,19 +1,17 @@
 use super::static_files::StaticFiles;
+use crate::html::{ChapterTree, Node};
 use crate::theme::searcher;
 use crate::utils::ToUrlPath;
 use anyhow::{Result, bail};
+use ego_tree::iter::Edge;
 use elasticlunr::{Index, IndexBuilder};
-use mdbook_core::book::{Book, Chapter};
+use mdbook_core::book::Chapter;
 use mdbook_core::config::{Search, SearchChapterSettings};
-use mdbook_core::utils;
-use mdbook_markdown::HtmlRenderOptions;
-use mdbook_markdown::new_cmark_parser;
-use pulldown_cmark::*;
+use mdbook_core::static_regex;
 use serde::Serialize;
 use std::borrow::Cow;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-use std::sync::LazyLock;
 use tracing::{debug, warn};
 
 const MAX_WORD_LENGTH_TO_INDEX: usize = 80;
@@ -31,7 +29,7 @@ fn tokenize(text: &str) -> Vec<String> {
 pub(super) fn create_files(
     search_config: &Search,
     static_files: &mut StaticFiles,
-    book: &Book,
+    chapter_trees: &[ChapterTree<'_>],
 ) -> Result<()> {
     let mut index = IndexBuilder::new()
         .add_field_with_tokenizer("title", Box::new(&tokenize))
@@ -39,19 +37,19 @@ pub(super) fn create_files(
         .add_field_with_tokenizer("breadcrumbs", Box::new(&tokenize))
         .build();
 
-    let mut doc_urls = Vec::with_capacity(book.items.len());
+    // These are links to all of the headings in all of the chapters.
+    let mut doc_urls = Vec::new();
 
     let chapter_configs = sort_search_config(&search_config.chapter);
-    validate_chapter_config(&chapter_configs, book)?;
+    validate_chapter_config(&chapter_configs, chapter_trees)?;
 
-    for chapter in book.chapters() {
-        if let Some(path) = settings_path(chapter) {
-            let chapter_settings = get_chapter_settings(&chapter_configs, path);
-            if !chapter_settings.enable.unwrap_or(true) {
-                continue;
-            }
+    for ct in chapter_trees {
+        let path = settings_path(ct.chapter);
+        let chapter_settings = get_chapter_settings(&chapter_configs, path);
+        if !chapter_settings.enable.unwrap_or(true) {
+            continue;
         }
-        render_item(&mut index, search_config, &mut doc_urls, chapter)?;
+        index_chapter(&mut index, search_config, &mut doc_urls, ct)?;
     }
 
     let index = write_to_json(index, search_config, doc_urls)?;
@@ -85,151 +83,110 @@ fn add_doc(
     index: &mut Index,
     doc_urls: &mut Vec<String>,
     anchor_base: &str,
-    heading: &str,
-    id_counter: &mut HashMap<String, usize>,
-    section_id: &Option<CowStr<'_>>,
+    heading_id: &str,
     items: &[&str],
 ) {
-    // Either use the explicit section id the user specified, or generate one
-    // from the heading content.
-    let section_id = section_id.as_ref().map(|id| id.to_string()).or_else(|| {
-        if heading.is_empty() {
-            // In the case where a chapter has no heading, don't set a section id.
-            None
-        } else {
-            Some(utils::unique_id_from_content(heading, id_counter))
-        }
-    });
+    let mut url = anchor_base.to_string();
+    if !heading_id.is_empty() {
+        url.push('#');
+        url.push_str(heading_id);
+    }
 
-    let url = if let Some(id) = section_id {
-        Cow::Owned(format!("{anchor_base}#{id}"))
-    } else {
-        Cow::Borrowed(anchor_base)
-    };
-    let url = utils::collapse_whitespace(url.trim());
     let doc_ref = doc_urls.len().to_string();
-    doc_urls.push(url.into());
+    doc_urls.push(url);
 
-    let items = items.iter().map(|&x| utils::collapse_whitespace(x.trim()));
+    let items = items.iter().map(|&x| collapse_whitespace(x.trim()));
     index.add_doc(&doc_ref, items);
 }
 
-/// Renders markdown into flat unformatted text and adds it to the search index.
-fn render_item(
+/// Adds the chapter to the search index.
+fn index_chapter(
     index: &mut Index,
     search_config: &Search,
     doc_urls: &mut Vec<String>,
-    chapter: &Chapter,
+    chapter_tree: &ChapterTree<'_>,
 ) -> Result<()> {
-    let chapter_path = chapter
-        .path
-        .as_ref()
-        .expect("Checked that path exists above");
-    let anchor_base = Path::new(&chapter_path)
-        .with_extension("html")
-        .to_url_path();
-
-    let options = HtmlRenderOptions::new(&chapter_path);
-    let mut p = new_cmark_parser(&chapter.content, &options.markdown_options).peekable();
+    let anchor_base = chapter_tree.html_path.to_url_path();
 
     let mut in_heading = false;
-    let max_section_depth = u32::from(search_config.heading_split_level);
+    let max_section_depth = search_config.heading_split_level;
     let mut section_id = None;
     let mut heading = String::new();
     let mut body = String::new();
-    let mut breadcrumbs = chapter.parent_names.clone();
-    let mut footnote_numbers = HashMap::new();
-
-    breadcrumbs.push(chapter.name.clone());
-
-    let mut id_counter = HashMap::new();
-    while let Some(event) = p.next() {
-        match event {
-            Event::Start(Tag::Heading { level, id, .. }) if level as u32 <= max_section_depth => {
-                if !heading.is_empty() {
-                    // Section finished, the next heading is following now
-                    // Write the data to the index, and clear it for the next section
-                    add_doc(
-                        index,
-                        doc_urls,
-                        &anchor_base,
-                        &heading,
-                        &mut id_counter,
-                        &section_id,
-                        &[&heading, &body, &breadcrumbs.join(" » ")],
-                    );
-                    heading.clear();
-                    body.clear();
-                    breadcrumbs.pop();
-                }
-
-                section_id = id;
-                in_heading = true;
-            }
-            Event::End(TagEnd::Heading(level)) if level as u32 <= max_section_depth => {
-                in_heading = false;
-                breadcrumbs.push(heading.clone());
-            }
-            Event::Start(Tag::FootnoteDefinition(name)) => {
-                let number = footnote_numbers.len() + 1;
-                footnote_numbers.entry(name).or_insert(number);
-            }
-            Event::Html(html) => {
-                let mut html_block = html.into_string();
-
-                // As of pulldown_cmark 0.6, html events are no longer contained
-                // in an HtmlBlock tag. We must collect consecutive Html events
-                // into a block ourselves.
-                while let Some(Event::Html(html)) = p.peek() {
-                    html_block.push_str(html);
-                    p.next();
-                }
-                body.push_str(&clean_html(&html_block));
-            }
-            Event::InlineHtml(html) => {
-                // This is not capable of cleaning inline tags like
-                // `foo <script>…</script>`. The `<script>` tags show up as
-                // individual InlineHtml events, and the content inside is
-                // just a regular Text event. There isn't a very good way to
-                // know how to collect all the content in-between. I'm not
-                // sure if this is easily fixable. It should be extremely
-                // rare, since script and style tags should almost always be
-                // blocks, and worse case you have some noise in the index.
-                body.push_str(&clean_html(&html));
-            }
-            Event::InlineMath(text) | Event::DisplayMath(text) => {
-                if in_heading {
-                    heading.push_str(&text);
-                } else {
-                    body.push_str(&text);
+    let mut breadcrumbs = chapter_tree.chapter.parent_names.clone();
+
+    breadcrumbs.push(chapter_tree.chapter.name.clone());
+
+    let mut traverse = chapter_tree.tree.root().traverse();
+
+    while let Some(edge) = traverse.next() {
+        match edge {
+            Edge::Open(node) => match node.value() {
+                Node::Element(el) => {
+                    if let Some(level) = el.heading_level()
+                        && level <= max_section_depth
+                        && let Some(heading_id) = el.attr("id")
+                    {
+                        if !heading.is_empty() {
+                            // Section finished, the next heading is following now
+                            // Write the data to the index, and clear it for the next section
+                            add_doc(
+                                index,
+                                doc_urls,
+                                &anchor_base,
+                                section_id.unwrap(),
+                                &[&heading, &body, &breadcrumbs.join(" » ")],
+                            );
+                            heading.clear();
+                            body.clear();
+                            breadcrumbs.pop();
+                        }
+                        section_id = Some(heading_id);
+                        in_heading = true;
+                    } else if matches!(el.name(), "script" | "style") {
+                        // Skip this node.
+                        while let Some(edge) = traverse.next() {
+                            if let Edge::Close(close) = edge
+                                && close == node
+                            {
+                                break;
+                            }
+                        }
+                    // Insert spaces where HTML output would usually separate text
+                    // to ensure words don't get merged together
+                    } else if in_heading {
+                        heading.push(' ');
+                    } else {
+                        body.push(' ');
+                    }
                 }
-            }
-            Event::Start(_) | Event::End(_) | Event::Rule | Event::SoftBreak | Event::HardBreak => {
-                // Insert spaces where HTML output would usually separate text
-                // to ensure words don't get merged together
-                if in_heading {
-                    heading.push(' ');
-                } else {
-                    body.push(' ');
+                Node::Text(text) => {
+                    if in_heading {
+                        heading.push_str(text);
+                    } else {
+                        body.push_str(text);
+                    }
                 }
-            }
-            Event::Text(text) | Event::Code(text) => {
-                if in_heading {
-                    heading.push_str(&text);
-                } else {
-                    body.push_str(&text);
+                Node::Comment(_) => {}
+                Node::Fragment => {}
+                Node::RawData(_) => {}
+            },
+            Edge::Close(node) => match node.value() {
+                Node::Element(el) => {
+                    if let Some(level) = el.heading_level()
+                        && level <= max_section_depth
+                    {
+                        in_heading = false;
+                        breadcrumbs.push(heading.clone());
+                    }
                 }
-            }
-            Event::FootnoteReference(name) => {
-                let len = footnote_numbers.len() + 1;
-                let number = footnote_numbers.entry(name).or_insert(len);
-                body.push_str(&format!(" [{number}] "));
-            }
-            Event::TaskListMarker(_checked) => {}
+                _ => {}
+            },
         }
     }
 
     if !body.is_empty() || !heading.is_empty() {
+        // Make sure the last section is added to the index
         let title = if heading.is_empty() {
             if let Some(chapter) = breadcrumbs.first() {
                 chapter
@@ -239,14 +196,11 @@ fn render_item(
         } else {
             &heading
         };
-        // Make sure the last section is added to the index
         add_doc(
             index,
             doc_urls,
             &anchor_base,
-            &heading,
-            &mut id_counter,
-            &section_id,
+            section_id.unwrap_or_default(),
             &[title, &body, &breadcrumbs.join(" » ")],
         );
     }
@@ -316,37 +270,20 @@ fn write_to_json(index: Index, search_config: &Search, doc_urls: Vec<String>) ->
     Ok(json_contents)
 }
 
-fn clean_html(html: &str) -> String {
-    static AMMONIA: LazyLock<ammonia::Builder<'static>> = LazyLock::new(|| {
-        let mut clean_content = HashSet::new();
-        clean_content.insert("script");
-        clean_content.insert("style");
-        let mut builder = ammonia::Builder::new();
-        builder
-            .tags(HashSet::new())
-            .tag_attributes(HashMap::new())
-            .generic_attributes(HashSet::new())
-            .link_rel(None)
-            .allowed_classes(HashMap::new())
-            .clean_content_tags(clean_content);
-        builder
-    });
-    AMMONIA.clean(html).to_string()
-}
-
-fn settings_path(ch: &Chapter) -> Option<&Path> {
-    ch.source_path.as_deref().or_else(|| ch.path.as_deref())
+fn settings_path(ch: &Chapter) -> &Path {
+    ch.source_path
+        .as_deref()
+        .unwrap_or_else(|| ch.path.as_deref().unwrap())
 }
 
 fn validate_chapter_config(
     chapter_configs: &[(PathBuf, SearchChapterSettings)],
-    book: &Book,
+    chapter_trees: &[ChapterTree<'_>],
 ) -> Result<()> {
     for (path, _) in chapter_configs {
-        let found = book
-            .chapters()
-            .filter_map(|ch| settings_path(ch))
-            .any(|source_path| source_path.starts_with(path));
+        let found = chapter_trees
+            .iter()
+            .any(|ct| settings_path(ct.chapter).starts_with(path));
         if !found {
             bail!(
                 "[output.html.search.chapter] key `{}` does not match any chapter paths",
@@ -383,6 +320,12 @@ fn get_chapter_settings(
     result
 }
 
+/// Replaces multiple consecutive whitespace characters with a single space character.
+fn collapse_whitespace(text: &str) -> Cow<'_, str> {
+    static_regex!(WS, r"\s\s+");
+    WS.replace_all(text, " ")
+}
+
 #[test]
 fn chapter_settings_priority() {
     let cfg = r#"
diff --git a/crates/mdbook-html/src/lib.rs b/crates/mdbook-html/src/lib.rs
index 796202c844..9bb7f00851 100644
--- a/crates/mdbook-html/src/lib.rs
+++ b/crates/mdbook-html/src/lib.rs
@@ -1,20 +1,8 @@
 //! mdBook HTML renderer.
 
+mod html;
 mod html_handlebars;
 pub mod theme;
 pub(crate) mod utils;
 
 pub use html_handlebars::HtmlHandlebars;
-use mdbook_core::config::HtmlConfig;
-use mdbook_markdown::HtmlRenderOptions;
-use std::path::Path;
-
-/// Creates an [`HtmlRenderOptions`] from the given config.
-pub fn html_render_options_from_config<'a>(
-    path: &'a Path,
-    config: &HtmlConfig,
-) -> HtmlRenderOptions<'a> {
-    let mut options = HtmlRenderOptions::new(path);
-    options.markdown_options.smart_punctuation = config.smart_punctuation;
-    options
-}
diff --git a/crates/mdbook-html/src/utils.rs b/crates/mdbook-html/src/utils.rs
index 75f3e4b5cd..0fb54613f9 100644
--- a/crates/mdbook-html/src/utils.rs
+++ b/crates/mdbook-html/src/utils.rs
@@ -1,6 +1,43 @@
 //! Utilities for processing HTML.
 
-use std::path::Path;
+use std::collections::HashMap;
+use std::fmt::Write;
+use std::path::{Component, Path, PathBuf};
+
+/// Utility function to normalize path elements like `..`.
+pub(crate) fn normalize_path(path: &Path) -> PathBuf {
+    let mut components = path.components().peekable();
+    let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() {
+        components.next();
+        PathBuf::from(c.as_os_str())
+    } else {
+        PathBuf::new()
+    };
+
+    for component in components {
+        match component {
+            Component::Prefix(..) => unreachable!(),
+            Component::RootDir => {
+                ret.push(Component::RootDir);
+            }
+            Component::CurDir => {}
+            Component::ParentDir => {
+                if ret.ends_with(Component::ParentDir) {
+                    ret.push(Component::ParentDir);
+                } else {
+                    let popped = ret.pop();
+                    if !popped && !ret.has_root() {
+                        ret.push(Component::ParentDir);
+                    }
+                }
+            }
+            Component::Normal(c) => {
+                ret.push(c);
+            }
+        }
+    }
+    ret
+}
 
 /// Helper trait for converting a [`Path`] to a string suitable for an HTML path.
 pub(crate) trait ToUrlPath {
@@ -14,3 +51,71 @@ impl ToUrlPath for Path {
         self.to_str().unwrap().replace('\\', "/")
     }
 }
+
+/// Make sure an HTML id is unique.
+///
+/// The `id_counter` map is used to ensure the ID is globally unique. If the
+/// same id appears more than once, then it will have a number added to make
+/// it unique.
+pub(crate) fn unique_id(id: &str, id_counter: &mut HashMap<String, u32>) -> String {
+    let mut id = id.to_string();
+    let id_count = id_counter.entry(id.to_string()).or_insert(0);
+    if *id_count != 0 {
+        // FIXME: This should be a loop to ensure that the new ID is also unique.
+        write!(id, "-{id_count}").unwrap();
+    }
+    *id_count += 1;
+    id
+}
+
+/// Generates an HTML id from the given text.
+pub(crate) fn id_from_content(content: &str) -> String {
+    content
+        .trim()
+        .chars()
+        .filter_map(|ch| {
+            if ch.is_alphanumeric() || ch == '_' || ch == '-' {
+                Some(ch.to_ascii_lowercase())
+            } else if ch.is_whitespace() {
+                Some('-')
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_generates_unique_ids() {
+        let mut id_counter = Default::default();
+
+        assert_eq!(unique_id("", &mut id_counter), "");
+        assert_eq!(unique_id("Über", &mut id_counter), "Über");
+        assert_eq!(unique_id("Über", &mut id_counter), "Über-1");
+        assert_eq!(unique_id("Über", &mut id_counter), "Über-2");
+    }
+
+    #[test]
+    fn it_normalizes_ids() {
+        assert_eq!(
+            id_from_content("`--passes`: add more rustdoc passes"),
+            "--passes-add-more-rustdoc-passes"
+        );
+        assert_eq!(
+            id_from_content("Method-call 🐙 expressions \u{1f47c}"),
+            "method-call--expressions-"
+        );
+        assert_eq!(id_from_content("_-_12345"), "_-_12345");
+        assert_eq!(id_from_content("12345"), "12345");
+        assert_eq!(id_from_content("中文"), "中文");
+        assert_eq!(id_from_content("にほんご"), "にほんご");
+        assert_eq!(id_from_content("한국어"), "한국어");
+        assert_eq!(id_from_content(""), "");
+        assert_eq!(id_from_content("中文標題 CJK title"), "中文標題-cjk-title");
+        assert_eq!(id_from_content("Über"), "Über");
+    }
+}
diff --git a/crates/mdbook-markdown/src/lib.rs b/crates/mdbook-markdown/src/lib.rs
index 22c11f8a03..0b63b8d1b7 100644
--- a/crates/mdbook-markdown/src/lib.rs
+++ b/crates/mdbook-markdown/src/lib.rs
@@ -9,20 +9,11 @@
 //! [`pulldown_cmark`] event stream. For example, it adjusts some links,
 //! modifies the behavior of footnotes, and adds various HTML wrappers.
 
-use pulldown_cmark::{CodeBlockKind, CowStr, Event, Options, Parser, Tag, TagEnd, html};
-use regex::Regex;
-use std::collections::HashMap;
-use std::fmt::Write;
-use std::path::Path;
-use std::sync::LazyLock;
-use tracing::warn;
+use pulldown_cmark::{Options, Parser};
 
 #[doc(inline)]
 pub use pulldown_cmark;
 
-#[cfg(test)]
-mod tests;
-
 /// Options for parsing markdown.
 #[non_exhaustive]
 pub struct MarkdownOptions {
@@ -43,28 +34,6 @@ impl Default for MarkdownOptions {
     }
 }
 
-/// Options for converting markdown to HTML.
-#[non_exhaustive]
-pub struct HtmlRenderOptions<'a> {
-    /// Options for parsing markdown.
-    pub markdown_options: MarkdownOptions,
-    /// The chapter's location, relative to the `SUMMARY.md` file.
-    pub path: &'a Path,
-    /// If true, render for the print page.
-    pub for_print: bool,
-}
-
-impl<'a> HtmlRenderOptions<'a> {
-    /// Creates a new [`HtmlRenderOptions`].
-    pub fn new(path: &'a Path) -> HtmlRenderOptions<'a> {
-        HtmlRenderOptions {
-            markdown_options: MarkdownOptions::default(),
-            path,
-            for_print: false,
-        }
-    }
-}
-
 /// Creates a new pulldown-cmark parser of the given text.
 pub fn new_cmark_parser<'text>(text: &'text str, options: &MarkdownOptions) -> Parser<'text> {
     let mut opts = Options::empty();
@@ -78,346 +47,3 @@ pub fn new_cmark_parser<'text>(text: &'text str, options: &MarkdownOptions) -> P
     }
     Parser::new_ext(text, opts)
 }
-
-/// Renders markdown to HTML.
-pub fn render_markdown(text: &str, options: &HtmlRenderOptions<'_>) -> String {
-    let mut body = String::with_capacity(text.len() * 3 / 2);
-
-    // Based on
-    // https://github.com/pulldown-cmark/pulldown-cmark/blob/master/pulldown-cmark/examples/footnote-rewrite.rs
-
-    // This handling of footnotes is a two-pass process. This is done to
-    // support linkbacks, little arrows that allow you to jump back to the
-    // footnote reference. The first pass collects the footnote definitions.
-    // The second pass modifies those definitions to include the linkbacks,
-    // and inserts the definitions back into the `events` list.
-
-    // This is a map of name -> (number, count)
-    // `name` is the name of the footnote.
-    // `number` is the footnote number displayed in the output.
-    // `count` is the number of references to this footnote (used for multiple
-    // linkbacks, and checking for unused footnotes).
-    let mut footnote_numbers = HashMap::new();
-    // This is a map of name -> Vec<Event>
-    // `name` is the name of the footnote.
-    // The events list is the list of events needed to build the footnote definition.
-    let mut footnote_defs = HashMap::new();
-
-    // The following are used when currently processing a footnote definition.
-    //
-    // This is the name of the footnote (escaped).
-    let mut in_footnote_name = String::new();
-    // This is the list of events to build the footnote definition.
-    let mut in_footnote = Vec::new();
-    // This is used to add space between consecutive footnotes. I was unable
-    // to figure out a way to do this just with pure CSS.
-    let mut prev_was_footnote = false;
-
-    let events = new_cmark_parser(text, &options.markdown_options)
-        .map(clean_codeblock_headers)
-        .map(|event| adjust_links(event, options))
-        .flat_map(|event| {
-            let (a, b) = wrap_tables(event);
-            a.into_iter().chain(b)
-        })
-        // Footnote rewriting must go last to ensure inner definition contents
-        // are processed (since they get pulled out of the initial stream).
-        .filter_map(|event| {
-            match event {
-                Event::Start(Tag::FootnoteDefinition(name)) => {
-                    prev_was_footnote = false;
-                    if !in_footnote.is_empty() {
-                        warn!(
-                            "internal bug: nested footnote not expected in {:?}",
-                            options.path
-                        );
-                    }
-                    in_footnote_name = special_escape(&name);
-                    None
-                }
-                Event::End(TagEnd::FootnoteDefinition) => {
-                    let def_events = std::mem::take(&mut in_footnote);
-                    let name = std::mem::take(&mut in_footnote_name);
-
-                    if footnote_defs.contains_key(&name) {
-                        warn!(
-                            "footnote `{name}` in {} defined multiple times - \
-                             not updating to new definition",
-                            options.path.display()
-                        );
-                    } else {
-                        footnote_defs.insert(name, def_events);
-                    }
-                    None
-                }
-                Event::FootnoteReference(name) => {
-                    let name = special_escape(&name);
-                    let len = footnote_numbers.len() + 1;
-                    let (n, count) = footnote_numbers.entry(name.clone()).or_insert((len, 0));
-                    *count += 1;
-                    let mut html = String::new();
-                    if prev_was_footnote {
-                        write!(html, " ").unwrap();
-                    }
-                    prev_was_footnote = true;
-                    write!(
-                        html,
-                        "<sup class=\"footnote-reference\" id=\"fr-{name}-{count}\">\
-                            <a href=\"#footnote-{name}\">{n}</a>\
-                         </sup>"
-                    )
-                    .unwrap();
-                    let html = Event::Html(html.into());
-                    if in_footnote_name.is_empty() {
-                        Some(html)
-                    } else {
-                        // While inside a footnote, we need to accumulate.
-                        in_footnote.push(html);
-                        None
-                    }
-                }
-                // While inside a footnote, accumulate all events into a local.
-                _ if !in_footnote_name.is_empty() => {
-                    in_footnote.push(event);
-                    prev_was_footnote = false;
-                    None
-                }
-                _ => {
-                    prev_was_footnote = false;
-                    Some(event)
-                }
-            }
-        });
-
-    html::push_html(&mut body, events);
-
-    if !footnote_defs.is_empty() {
-        add_footnote_defs(
-            &mut body,
-            options,
-            footnote_defs.into_iter().collect(),
-            &footnote_numbers,
-        );
-    }
-
-    body
-}
-
-/// Adds all footnote definitions into `body`.
-fn add_footnote_defs(
-    body: &mut String,
-    options: &HtmlRenderOptions<'_>,
-    mut defs: Vec<(String, Vec<Event<'_>>)>,
-    numbers: &HashMap<String, (usize, u32)>,
-) {
-    // Remove unused.
-    defs.retain(|(name, _)| {
-        if !numbers.contains_key(name) {
-            warn!(
-                "footnote `{name}` in `{}` is defined but not referenced",
-                options.path.display()
-            );
-            false
-        } else {
-            true
-        }
-    });
-
-    defs.sort_by_cached_key(|(name, _)| numbers[name].0);
-
-    body.push_str(
-        "<hr>\n\
-         <ol class=\"footnote-definition\">",
-    );
-
-    // Insert the backrefs to the definition, and put the definitions in the output.
-    for (name, mut fn_events) in defs {
-        let count = numbers[&name].1;
-        fn_events.insert(
-            0,
-            Event::Html(format!("<li id=\"footnote-{name}\">").into()),
-        );
-        // Generate the linkbacks.
-        for usage in 1..=count {
-            let nth = if usage == 1 {
-                String::new()
-            } else {
-                usage.to_string()
-            };
-            let backlink =
-                Event::Html(format!(" <a href=\"#fr-{name}-{usage}\">↩{nth}</a>").into());
-            if matches!(fn_events.last(), Some(Event::End(TagEnd::Paragraph))) {
-                // Put the linkback at the end of the last paragraph instead
-                // of on a line by itself.
-                fn_events.insert(fn_events.len() - 1, backlink);
-            } else {
-                // Not a clear place to put it in this circumstance, so put it
-                // at the end.
-                fn_events.push(backlink);
-            }
-        }
-        fn_events.push(Event::Html("</li>\n".into()));
-        html::push_html(body, fn_events.into_iter());
-    }
-
-    body.push_str("</ol>");
-}
-
-/// Wraps tables in a `.table-wrapper` class to apply overflow-x rules to.
-fn wrap_tables(event: Event<'_>) -> (Option<Event<'_>>, Option<Event<'_>>) {
-    match event {
-        Event::Start(Tag::Table(_)) => (
-            Some(Event::Html(r#"<div class="table-wrapper">"#.into())),
-            Some(event),
-        ),
-        Event::End(TagEnd::Table) => (Some(event), Some(Event::Html(r#"</div>"#.into()))),
-        _ => (Some(event), None),
-    }
-}
-
-fn clean_codeblock_headers(event: Event<'_>) -> Event<'_> {
-    match event {
-        Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(ref info))) => {
-            let info: String = info
-                .chars()
-                .map(|x| match x {
-                    ' ' | '\t' => ',',
-                    _ => x,
-                })
-                .filter(|ch| !ch.is_whitespace())
-                .collect();
-
-            Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(CowStr::from(info))))
-        }
-        _ => event,
-    }
-}
-
-/// Fix links to the correct location.
-///
-/// This adjusts links, such as turning `.md` extensions to `.html`.
-///
-/// `path` is the path to the page being rendered relative to the root of the
-/// book. This is used for the `print.html` page so that links on the print
-/// page go to the original location. Normal page rendering sets `path` to
-/// None. Ideally, print page links would link to anchors on the print page,
-/// but that is very difficult.
-fn adjust_links<'a>(event: Event<'a>, options: &HtmlRenderOptions<'_>) -> Event<'a> {
-    static SCHEME_LINK: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"^[a-z][a-z0-9+.-]*:").unwrap());
-    static MD_LINK: LazyLock<Regex> =
-        LazyLock::new(|| Regex::new(r"(?P<link>.*)\.md(?P<anchor>#.*)?").unwrap());
-
-    fn fix<'a>(dest: CowStr<'a>, options: &HtmlRenderOptions<'_>) -> CowStr<'a> {
-        if dest.starts_with('#') {
-            // Fragment-only link.
-            if options.for_print {
-                let mut base = options.path.display().to_string();
-                if base.ends_with(".md") {
-                    base.replace_range(base.len() - 3.., ".html");
-                }
-                return format!("{base}{dest}").into();
-            } else {
-                return dest;
-            }
-        }
-        // Don't modify links with schemes like `https`.
-        if !SCHEME_LINK.is_match(&dest) {
-            // This is a relative link, adjust it as necessary.
-            let mut fixed_link = String::new();
-            if options.for_print {
-                let base = options
-                    .path
-                    .parent()
-                    .expect("path can't be empty")
-                    .to_str()
-                    .expect("utf-8 paths only");
-                if !base.is_empty() {
-                    write!(fixed_link, "{base}/").unwrap();
-                }
-            }
-
-            if let Some(caps) = MD_LINK.captures(&dest) {
-                fixed_link.push_str(&caps["link"]);
-                fixed_link.push_str(".html");
-                if let Some(anchor) = caps.name("anchor") {
-                    fixed_link.push_str(anchor.as_str());
-                }
-            } else {
-                fixed_link.push_str(&dest);
-            };
-            return CowStr::from(fixed_link);
-        }
-        dest
-    }
-
-    fn fix_html<'a>(html: CowStr<'a>, options: &HtmlRenderOptions<'_>) -> CowStr<'a> {
-        // This is a terrible hack, but should be reasonably reliable. Nobody
-        // should ever parse a tag with a regex. However, there isn't anything
-        // in Rust that I know of that is suitable for handling partial html
-        // fragments like those generated by pulldown_cmark.
-        //
-        // There are dozens of HTML tags/attributes that contain paths, so
-        // feel free to add more tags if desired; these are the only ones I
-        // care about right now.
-        static HTML_LINK: LazyLock<Regex> =
-            LazyLock::new(|| Regex::new(r#"(<(?:a|img) [^>]*?(?:src|href)=")([^"]+?)""#).unwrap());
-
-        HTML_LINK
-            .replace_all(&html, |caps: &regex::Captures<'_>| {
-                let fixed = fix(caps[2].into(), options);
-                format!("{}{}\"", &caps[1], fixed)
-            })
-            .into_owned()
-            .into()
-    }
-
-    match event {
-        Event::Start(Tag::Link {
-            link_type,
-            dest_url,
-            title,
-            id,
-        }) => Event::Start(Tag::Link {
-            link_type,
-            dest_url: fix(dest_url, options),
-            title,
-            id,
-        }),
-        Event::Start(Tag::Image {
-            link_type,
-            dest_url,
-            title,
-            id,
-        }) => Event::Start(Tag::Image {
-            link_type,
-            dest_url: fix(dest_url, options),
-            title,
-            id,
-        }),
-        Event::Html(html) => Event::Html(fix_html(html, options)),
-        Event::InlineHtml(html) => Event::InlineHtml(fix_html(html, options)),
-        _ => event,
-    }
-}
-
-/// Escape characters to make it safe for an HTML string.
-pub fn special_escape(mut s: &str) -> String {
-    let mut escaped = String::with_capacity(s.len());
-    let needs_escape: &[char] = &['<', '>', '\'', '"', '\\', '&'];
-    while let Some(next) = s.find(needs_escape) {
-        escaped.push_str(&s[..next]);
-        match s.as_bytes()[next] {
-            b'<' => escaped.push_str("&lt;"),
-            b'>' => escaped.push_str("&gt;"),
-            b'\'' => escaped.push_str("&#39;"),
-            b'"' => escaped.push_str("&quot;"),
-            b'\\' => escaped.push_str("&#92;"),
-            b'&' => escaped.push_str("&amp;"),
-            _ => unreachable!(),
-        }
-        s = &s[next + 1..];
-    }
-    escaped.push_str(s);
-    escaped
-}
diff --git a/crates/mdbook-markdown/src/tests.rs b/crates/mdbook-markdown/src/tests.rs
deleted file mode 100644
index 223eade311..0000000000
--- a/crates/mdbook-markdown/src/tests.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-use super::render_markdown;
-use super::*;
-
-#[test]
-fn escaped_special() {
-    assert_eq!(special_escape(""), "");
-    assert_eq!(special_escape("<"), "&lt;");
-    assert_eq!(special_escape(">"), "&gt;");
-    assert_eq!(special_escape("<>"), "&lt;&gt;");
-    assert_eq!(special_escape("<test>"), "&lt;test&gt;");
-    assert_eq!(special_escape("a<test>b"), "a&lt;test&gt;b");
-    assert_eq!(special_escape("'"), "&#39;");
-    assert_eq!(special_escape("\\"), "&#92;");
-    assert_eq!(special_escape("&"), "&amp;");
-}
-
-#[test]
-fn preserves_external_links() {
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(
-        render_markdown("[example](https://www.rust-lang.org/)", &options),
-        "<p><a href=\"https://www.rust-lang.org/\">example</a></p>\n"
-    );
-}
-
-#[test]
-fn it_can_adjust_markdown_links() {
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(
-        render_markdown("[example](example.md)", &options),
-        "<p><a href=\"example.html\">example</a></p>\n"
-    );
-    assert_eq!(
-        render_markdown("[example_anchor](example.md#anchor)", &options),
-        "<p><a href=\"example.html#anchor\">example_anchor</a></p>\n"
-    );
-
-    // this anchor contains 'md' inside of it
-    assert_eq!(
-        render_markdown("[phantom data](foo.html#phantomdata)", &options),
-        "<p><a href=\"foo.html#phantomdata\">phantom data</a></p>\n"
-    );
-}
-
-#[test]
-fn it_can_wrap_tables() {
-    let src = r#"
-| Original        | Punycode        | Punycode + Encoding |
-|-----------------|-----------------|---------------------|
-| føø             | f-5gaa          | f_5gaa              |
-"#;
-    let out = r#"
-<div class="table-wrapper"><table><thead><tr><th>Original</th><th>Punycode</th><th>Punycode + Encoding</th></tr></thead><tbody>
-<tr><td>føø</td><td>f-5gaa</td><td>f_5gaa</td></tr>
-</tbody></table>
-</div>
-"#.trim();
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(render_markdown(src, &options), out);
-}
-
-#[test]
-fn it_can_keep_quotes_straight() {
-    let mut options = HtmlRenderOptions::new(&Path::new(""));
-    options.markdown_options.smart_punctuation = false;
-    assert_eq!(render_markdown("'one'", &options), "<p>'one'</p>\n");
-}
-
-#[test]
-fn it_can_make_quotes_curly_except_when_they_are_in_code() {
-    let input = r#"
-'one'
-```
-'two'
-```
-`'three'` 'four'"#;
-    let expected = r#"<p>‘one’</p>
-<pre><code>'two'
-</code></pre>
-<p><code>'three'</code> ‘four’</p>
-"#;
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(render_markdown(input, &options), expected);
-}
-
-#[test]
-fn whitespace_outside_of_codeblock_header_is_preserved() {
-    let input = r#"
-some text with spaces
-```rust
-fn main() {
-// code inside is unchanged
-}
-```
-more text with spaces
-"#;
-
-    let expected = r#"<p>some text with spaces</p>
-<pre><code class="language-rust">fn main() {
-// code inside is unchanged
-}
-</code></pre>
-<p>more text with spaces</p>
-"#;
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(render_markdown(input, &options), expected);
-}
-
-#[test]
-fn rust_code_block_properties_are_passed_as_space_delimited_class() {
-    let input = r#"
-```rust,no_run,should_panic,property_3
-```
-"#;
-
-    let expected = r#"<pre><code class="language-rust,no_run,should_panic,property_3"></code></pre>
-"#;
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(render_markdown(input, &options), expected);
-}
-
-#[test]
-fn rust_code_block_properties_with_whitespace_are_passed_as_space_delimited_class() {
-    let input = r#"
-```rust,    no_run,,,should_panic , ,property_3
-```
-"#;
-
-    let expected = r#"<pre><code class="language-rust,,,,,no_run,,,should_panic,,,,property_3"></code></pre>
-"#;
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(render_markdown(input, &options), expected);
-}
-
-#[test]
-fn rust_code_block_without_properties_has_proper_html_class() {
-    let input = r#"
-```rust
-```
-"#;
-
-    let expected = r#"<pre><code class="language-rust"></code></pre>
-"#;
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(render_markdown(input, &options), expected);
-
-    let input = r#"
-```rust
-```
-"#;
-    let options = HtmlRenderOptions::new(&Path::new(""));
-    assert_eq!(render_markdown(input, &options), expected);
-}
diff --git a/guide/src/guide/installation.md b/guide/src/guide/installation.md
index 72beb50f5e..0aa27960a8 100644
--- a/guide/src/guide/installation.md
+++ b/guide/src/guide/installation.md
@@ -20,7 +20,7 @@ To make it easier to run, put the path to the binary into your `PATH`.
 
 To build the `mdbook` executable from source, you will first need to install Rust and Cargo.
 Follow the instructions on the [Rust installation page].
-mdBook currently requires at least Rust version 1.85.
+mdBook currently requires at least Rust version 1.88.
 
 Once you have installed Rust, the following command can be used to build and install mdBook:
 
diff --git a/tests/testsuite/includes.rs b/tests/testsuite/includes.rs
index 7bf9480885..42d71ddcbe 100644
--- a/tests/testsuite/includes.rs
+++ b/tests/testsuite/includes.rs
@@ -31,10 +31,10 @@ fn anchored_include() {
         "book/anchors.html",
         str![[r##"
 <h1 id="include-anchors"><a class="header" href="#include-anchors">Include Anchors</a></h1>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>let x = 1;
-<span class="boring">}</span></code></pre></pre>
+<span class="boring">}</span></code></pre>
 "##]],
     );
 }
@@ -77,12 +77,12 @@ fn playground_include() {
         .check_main_file("book/playground.html",
             str![[r##"
 <h1 id="playground-includes"><a class="header" href="#playground-includes">Playground Includes</a></h1>
-<pre><pre class="playground"><code class="language-rust">fn main() {
+<pre class="playground"><code class="language-rust">fn main() {
     println!("Hello World!");
 <span class="boring">
 </span><span class="boring">   // You can even hide lines! :D
 </span><span class="boring">  println!("I am hidden! Expand the code snippet to see me");
-</span>}</code></pre></pre>
+</span>}</code></pre>
 "##]]);
 }
 
@@ -94,20 +94,20 @@ fn rustdoc_include() {
             str![[r##"
 <h1 id="rustdoc-includes"><a class="header" href="#rustdoc-includes">Rustdoc Includes</a></h1>
 <h2 id="rustdoc-include-adds-the-rest-of-the-file-as-hidden"><a class="header" href="#rustdoc-include-adds-the-rest-of-the-file-as-hidden">Rustdoc include adds the rest of the file as hidden</a></h2>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">fn some_function() {
+<pre class="playground"><code class="language-rust"><span class="boring">fn some_function() {
 </span><span class="boring">    println!("some function");
 </span><span class="boring">}
 </span><span class="boring">
 </span>fn main() {
     some_function();
-}</code></pre></pre>
+}</code></pre>
 <h2 id="rustdoc-include-works-with-anchors-too"><a class="header" href="#rustdoc-include-works-with-anchors-too">Rustdoc include works with anchors too</a></h2>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">fn some_other_function() {
+<pre class="playground"><code class="language-rust"><span class="boring">fn some_other_function() {
 </span><span class="boring">    println!("unused anchor");
 </span><span class="boring">}
 </span><span class="boring">
 </span>fn main() {
     some_other_function();
-}</code></pre></pre>
+}</code></pre>
 "##]]);
 }
diff --git a/tests/testsuite/markdown.rs b/tests/testsuite/markdown.rs
index 8237215c90..7369c4577d 100644
--- a/tests/testsuite/markdown.rs
+++ b/tests/testsuite/markdown.rs
@@ -9,9 +9,9 @@ fn custom_header_attributes() {
     BookTest::from_dir("markdown/custom_header_attributes")
         .check_main_file("book/custom_header_attributes.html", str![[r##"
 <h1 id="attrs"><a class="header" href="#attrs">Heading Attributes</a></h1>
-<h2 id="heading-with-classes" class="class1 class2"><a class="header" href="#heading-with-classes">Heading with classes</a></h2>
+<h2 class="class1 class2" id="heading-with-classes"><a class="header" href="#heading-with-classes">Heading with classes</a></h2>
 <h2 id="both" class="class1 class2"><a class="header" href="#both">Heading with id and classes</a></h2>
-<h2 id="myh3" class="myclass1 myclass2" myattr="" otherattr="value">Heading with attribute</h2>
+<h2 myattr="" otherattr="value" id="myh3" class="myclass1 myclass2"><a class="header" href="#myh3">Heading with attribute</a></h2>
 "##]]);
 }
 
@@ -25,8 +25,6 @@ fn footnotes() {
  INFO Running the html backend
  WARN footnote `multiple-definitions` in footnotes.md defined multiple times - not updating to new definition
  WARN footnote `unused` in `footnotes.md` is defined but not referenced
- WARN footnote `multiple-definitions` in footnotes.md defined multiple times - not updating to new definition
- WARN footnote `unused` in `footnotes.md` is defined but not referenced
  INFO HTML book written to `[ROOT]/book`
 
 "#]]);
@@ -44,16 +42,29 @@ fn tables() {
         "book/tables.html",
         str![[r##"
 <h1 id="tables"><a class="header" href="#tables">Tables</a></h1>
-<div class="table-wrapper"><table><thead><tr><th>foo</th><th>bar</th></tr></thead><tbody>
+<div class="table-wrapper">
+<table>
+<thead>
+<tr><th>foo</th><th>bar</th></tr>
+</thead>
+<tbody>
 <tr><td>baz</td><td>bim</td></tr>
 <tr><td>Backslash in code</td><td><code>/</code></td></tr>
 <tr><td>Double back in code</td><td><code>//</code></td></tr>
 <tr><td>Pipe in code</td><td><code>|</code></td></tr>
 <tr><td>Pipe in code2</td><td><code>test | inside</code></td></tr>
-</tbody></table>
-</div><div class="table-wrapper"><table><thead><tr><th>Neither</th><th style="text-align: left">Left</th><th style="text-align: center">Center</th><th style="text-align: right">Right</th></tr></thead><tbody>
+</tbody>
+</table>
+</div>
+<div class="table-wrapper">
+<table>
+<thead>
+<tr><th>Neither</th><th style="text-align: left">Left</th><th style="text-align: center">Center</th><th style="text-align: right">Right</th></tr>
+</thead>
+<tbody>
 <tr><td>one</td><td style="text-align: left">two</td><td style="text-align: center">three</td><td style="text-align: right">four</td></tr>
-</tbody></table>
+</tbody>
+</table>
 </div>
 "##]],
     );
@@ -79,12 +90,9 @@ fn tasklists() {
         str![[r##"
 <h2 id="tasklisks"><a class="header" href="#tasklisks">Tasklisks</a></h2>
 <ul>
-<li><input disabled="" type="checkbox" checked=""/>
-Apples</li>
-<li><input disabled="" type="checkbox" checked=""/>
-Broccoli</li>
-<li><input disabled="" type="checkbox"/>
-Carrots</li>
+<li><input disabled="" type="checkbox" checked=""> Apples</li>
+<li><input disabled="" type="checkbox" checked=""> Broccoli</li>
+<li><input disabled="" type="checkbox"> Carrots</li>
 </ul>
 "##]],
     );
diff --git a/tests/testsuite/markdown/basic_markdown/expected/blockquotes.html b/tests/testsuite/markdown/basic_markdown/expected/blockquotes.html
index 3be37bed4e..8347490c33 100644
--- a/tests/testsuite/markdown/basic_markdown/expected/blockquotes.html
+++ b/tests/testsuite/markdown/basic_markdown/expected/blockquotes.html
@@ -1,7 +1,6 @@
 <h1 id="blockquotes"><a class="header" href="#blockquotes">Blockquotes</a></h1>
 <p>Empty:</p>
-<blockquote>
-</blockquote>
+<blockquote></blockquote>
 <p>Normal:</p>
 <blockquote>
 <p>foo
@@ -9,10 +8,10 @@ <h1 id="blockquotes"><a class="header" href="#blockquotes">Blockquotes</a></h1>
 </blockquote>
 <p>Contains code block:</p>
 <blockquote>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>let x = 1;
-<span class="boring">}</span></code></pre></pre>
+<span class="boring">}</span></code></pre>
 </blockquote>
 <p>Random stuff:</p>
 <blockquote>
diff --git a/tests/testsuite/markdown/basic_markdown/expected/code-blocks.html b/tests/testsuite/markdown/basic_markdown/expected/code-blocks.html
index 09b7b2baf9..47976806cd 100644
--- a/tests/testsuite/markdown/basic_markdown/expected/code-blocks.html
+++ b/tests/testsuite/markdown/basic_markdown/expected/code-blocks.html
@@ -1,22 +1,22 @@
 <h1 id="code-blocks"><a class="header" href="#code-blocks">Code blocks</a></h1>
 <pre><code>This is a codeblock
 </code></pre>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>// This links to a playpen
-<span class="boring">}</span></code></pre></pre>
+<span class="boring">}</span></code></pre>
 <pre><code class="language-bash editable"># This is an editable codeblock
 </code></pre>
-<pre><code class="language-text cls1  cls2 cls3">Text with different classes.
+<pre><code class="language-text cls1 cls2 cls3">Text with different classes.
 </code></pre>
 <pre><code>Indented
 code
 block.
 </code></pre>
-<pre><pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>let x = 1;
-<span class="boring">}</span></code></pre></pre>
-<pre><pre class="playground"><code class="language-rust">fn main() {
+<span class="boring">}</span></code></pre>
+<pre class="playground"><code class="language-rust">fn main() {
     println!("hello");
-}</code></pre></pre>
\ No newline at end of file
+}</code></pre>
\ No newline at end of file
diff --git a/tests/testsuite/markdown/basic_markdown/expected/html.html b/tests/testsuite/markdown/basic_markdown/expected/html.html
index ac7aa2c2b9..7213939f8b 100644
--- a/tests/testsuite/markdown/basic_markdown/expected/html.html
+++ b/tests/testsuite/markdown/basic_markdown/expected/html.html
@@ -20,18 +20,14 @@ <h2 id="void-elements"><a class="header" href="#void-elements">Void elements</a>
     <col span="2" class="a">
   </colgroup>
 </table>
-<p><embed
-  type="image/jpeg"
-  src="/image.jpg"
-  width="100"
-  height="200"></p>
+
+<p><embed type="image/jpeg" src="/image.jpg" width="100" height="200"></p>
 <p>Rule:</p>
 <hr>
 <img src="example.jpg">
 <input type="text">
 <link href="example.css" rel="stylesheet">
-<p><meta name="example"
-  content="Example content"></p>
+<p><meta name="example" content="Example content"></p>
 <video>
   <source src="video.webm" type="video/webm">
   <track kind="captions" src="captions.vtt" srclang="en">
@@ -40,12 +36,14 @@ <h2 id="blocks"><a class="header" href="#blocks">Blocks</a></h2>
 <div>
 A block HTML element trying to do *markup*.
 </div>
+
 <div>
 <p>A block HTML with spaces that <strong>cause</strong> it to be interleaved with markdown.</p>
 </div>
+
 <h2 id="scripts"><a class="header" href="#scripts">Scripts</a></h2>
 <script></script>
-<script async src="foo.js"></script>
+<script async="" src="foo.js"></script>
 <script>
 const x = 'some *text* inside';
 
@@ -62,6 +60,6 @@ <h2 id="style"><a class="header" href="#style">Style</a></h2>
 */
 
 </style>
-<style media="(width < 500px)">
+<style media="(width &lt; 500px)">
 .bar { background-color: green }
 </style>
\ No newline at end of file
diff --git a/tests/testsuite/markdown/basic_markdown/expected/images.html b/tests/testsuite/markdown/basic_markdown/expected/images.html
index be7e41528d..4dfdf1657a 100644
--- a/tests/testsuite/markdown/basic_markdown/expected/images.html
+++ b/tests/testsuite/markdown/basic_markdown/expected/images.html
@@ -1,3 +1,3 @@
 <h1 id="images"><a class="header" href="#images">Images</a></h1>
-<p><img src="https://rust-lang.org/logos/rust-logo-256x256.png" alt="Image “alt” &amp; &quot; &quot;text&quot; &amp; &lt;stuff&gt; url &lt;em&gt;html&lt;/em&gt; — hard break " /></p>
-<p><img src="https://rust-lang.org/logos/rust-logo-256x256.png" alt="Image with title" title="Some title" /></p>
\ No newline at end of file
+<p><img src="https://rust-lang.org/logos/rust-logo-256x256.png" alt="Image “alt” &amp; &quot; &quot;text&quot; &amp; &lt;stuff&gt; url &lt;em&gt;html&lt;/em&gt; — hard break "></p>
+<p><img src="https://rust-lang.org/logos/rust-logo-256x256.png" title="Some title" alt="Image with title"></p>
\ No newline at end of file
diff --git a/tests/testsuite/markdown/basic_markdown/expected/inlines.html b/tests/testsuite/markdown/basic_markdown/expected/inlines.html
index 306e1221d0..c2e061a333 100644
--- a/tests/testsuite/markdown/basic_markdown/expected/inlines.html
+++ b/tests/testsuite/markdown/basic_markdown/expected/inlines.html
@@ -1,8 +1,6 @@
 <h1 id="inlines"><a class="header" href="#inlines">Inlines</a></h1>
 <p><em>emphasis</em> <strong>bold</strong> <strong><em>bold emphasis</em></strong></p>
 <p>Some <code>inline code</code>.</p>
-<p>Hard<br />
-break</p>
-<p>Invisible hard<br />
-break</p>
+<p>Hard<br>break</p>
+<p>Invisible hard<br>break</p>
 <p>[escaped] &lt;html&gt; *here*</p>
\ No newline at end of file
diff --git a/tests/testsuite/markdown/basic_markdown/expected/lists.html b/tests/testsuite/markdown/basic_markdown/expected/lists.html
index 94dbe9bcf6..ae4b533592 100644
--- a/tests/testsuite/markdown/basic_markdown/expected/lists.html
+++ b/tests/testsuite/markdown/basic_markdown/expected/lists.html
@@ -5,7 +5,7 @@ <h1 id="lists"><a class="header" href="#lists">Lists</a></h1>
 <li>Ordered</li>
 <li>List</li>
 </ol>
-<hr />
+<hr>
 <ol>
 <li>A
 <ol>
@@ -17,19 +17,19 @@ <h1 id="lists"><a class="header" href="#lists">Lists</a></h1>
 <li>Still</li>
 <li>Normal</li>
 </ol>
-<hr />
+<hr>
 <ol start="7">
 <li>Start list</li>
 <li>with a different number.</li>
 </ol>
-<hr />
+<hr>
 <ul>
 <li>An</li>
 <li>Unordered</li>
 <li>Normal</li>
 <li>List</li>
 </ul>
-<hr />
+<hr>
 <ul>
 <li>Nested
 <ul>
@@ -38,7 +38,7 @@ <h1 id="lists"><a class="header" href="#lists">Lists</a></h1>
 </li>
 <li>List</li>
 </ul>
-<hr />
+<hr>
 <ul>
 <li>This
 <ol>
diff --git a/tests/testsuite/markdown/footnotes/expected/footnotes.html b/tests/testsuite/markdown/footnotes/expected/footnotes.html
index 69faf6e00d..385e522d31 100644
--- a/tests/testsuite/markdown/footnotes/expected/footnotes.html
+++ b/tests/testsuite/markdown/footnotes/expected/footnotes.html
@@ -9,7 +9,8 @@ <h1 id="footnote-tests"><a class="header" href="#footnote-tests">Footnote tests<
 <p>And another<sup class="footnote-reference" id="fr-in-between-1"><a href="#footnote-in-between">8</a></sup> that references the duplicate again.<sup class="footnote-reference" id="fr-multiple-definitions-2"><a href="#footnote-multiple-definitions">7</a></sup></p>
 <p>Multiple footnotes in a row.<sup class="footnote-reference" id="fr-a-1"><a href="#footnote-a">9</a></sup> <sup class="footnote-reference" id="fr-b-1"><a href="#footnote-b">10</a></sup> <sup class="footnote-reference" id="fr-c-1"><a href="#footnote-c">11</a></sup></p>
 <hr>
-<ol class="footnote-definition"><li id="footnote-1">
+<ol class="footnote-definition">
+<li id="footnote-1">
 <p>This is a footnote. <a href="#fr-1-1">↩</a> <a href="#fr-1-2">↩2</a></p>
 </li>
 <li id="footnote-word">
diff --git a/tests/testsuite/playground.rs b/tests/testsuite/playground.rs
index 1983757dfe..d0aeb69981 100644
--- a/tests/testsuite/playground.rs
+++ b/tests/testsuite/playground.rs
@@ -9,10 +9,10 @@ fn playground_on_rust_code() {
         "book/index.html",
         str![[r##"
 <h1 id="rust-sample"><a class="header" href="#rust-sample">Rust Sample</a></h1>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>let x = 1;
-<span class="boring">}</span></code></pre></pre>
+<span class="boring">}</span></code></pre>
 "##]],
     );
 }
diff --git a/tests/testsuite/print/chapter_no_h1/expected/print.html b/tests/testsuite/print/chapter_no_h1/expected/print.html
index 90b64f0f1b..6220dcb130 100644
--- a/tests/testsuite/print/chapter_no_h1/expected/print.html
+++ b/tests/testsuite/print/chapter_no_h1/expected/print.html
@@ -1,5 +1,9 @@
 <h1 id="chapter-1"><a class="header" href="#chapter-1">Chapter 1</a></h1>
-<p>See <a href="chapter_2.html">chapter 2</a>.</p>
-<div style="break-before: page; page-break-before: always;"></div><p>See <a href="./chapter_2.html">this</a>.</p>
-<div style="break-before: page; page-break-before: always;"></div><h2 id="h2-instead"><a class="header" href="#h2-instead">H2 instead</a></h2>
+<p>See <a href="#chapter-2">chapter 2</a>.</p>
+<div style="break-before: page; page-break-before: always;"></div>
+<h1 id="chapter-2"><a href="#chapter-2" class="header">Chapter 2</a></h1>
+<p>See <a href="#chapter-2">this</a>.</p>
+<div style="break-before: page; page-break-before: always;"></div>
+<h1 id="h2-instead-1"><a href="#h2-instead-1" class="header">H2 instead</a></h1>
+<h2 id="h2-instead"><a class="header" href="#h2-instead">H2 instead</a></h2>
 <p>This has H2 instead of H1.</p>
\ No newline at end of file
diff --git a/tests/testsuite/print/duplicate_ids/expected/print.html b/tests/testsuite/print/duplicate_ids/expected/print.html
index b184261f22..97bb8beaf2 100644
--- a/tests/testsuite/print/duplicate_ids/expected/print.html
+++ b/tests/testsuite/print/duplicate_ids/expected/print.html
@@ -1,11 +1,12 @@
 <h1 id="chapter-1"><a class="header" href="#chapter-1">Chapter 1</a></h1>
 <h2 id="some-title"><a class="header" href="#some-title">Some title</a></h2>
-<p>See <a href="chapter_2.html#some-title">other</a></p>
-<p>See <a href="chapter_1.html#some-title">this</a></p>
-<p>See <a href="chapter_1.html#some-title">this anchor only</a></p>
-<div style="break-before: page; page-break-before: always;"></div><h1 id="chapter-2"><a class="header" href="#chapter-2">Chapter 2</a></h1>
+<p>See <a href="#some-title-1">other</a></p>
+<p>See <a href="#some-title">this</a></p>
+<p>See <a href="#some-title">this anchor only</a></p>
+<div style="break-before: page; page-break-before: always;"></div>
+<h1 id="chapter-2"><a class="header" href="#chapter-2">Chapter 2</a></h1>
 <h2 id="some-title-1"><a class="header" href="#some-title-1">Some title</a></h2>
-<p>See <a href="chapter_1.html#some-title">other</a></p>
-<p>See <a href="chapter_2.html#some-title">this</a></p>
-<p>See <a href="chapter_2.html#some-title">this anchor only</a></p>
-<p><a href="chapter_1.html#some-title">Works with HTML extension too</a></p>
\ No newline at end of file
+<p>See <a href="#some-title">other</a></p>
+<p>See <a href="#some-title-1">this</a></p>
+<p>See <a href="#some-title-1">this anchor only</a></p>
+<p><a href="#some-title">Works with HTML extension too</a></p>
\ No newline at end of file
diff --git a/tests/testsuite/print/relative_links/expected/print.html b/tests/testsuite/print/relative_links/expected/print.html
index 68f6d1ed30..b1e181b7be 100644
--- a/tests/testsuite/print/relative_links/expected/print.html
+++ b/tests/testsuite/print/relative_links/expected/print.html
@@ -1,15 +1,17 @@
 <h1 id="first-chapter"><a class="header" href="#first-chapter">First Chapter</a></h1>
-<div style="break-before: page; page-break-before: always;"></div><h1 id="first-nested"><a class="header" href="#first-nested">First Nested</a></h1>
-<div style="break-before: page; page-break-before: always;"></div><h1 id="testing-relative-links-for-the-print-page"><a class="header" href="#testing-relative-links-for-the-print-page">Testing relative links for the print page</a></h1>
-<p>When we link to <a href="second/../first/nested.html">the first section</a>, it should work on
+<div style="break-before: page; page-break-before: always;"></div>
+<h1 id="first-nested"><a class="header" href="#first-nested">First Nested</a></h1>
+<div style="break-before: page; page-break-before: always;"></div>
+<h1 id="testing-relative-links-for-the-print-page"><a class="header" href="#testing-relative-links-for-the-print-page">Testing relative links for the print page</a></h1>
+<p>When we link to <a href="#first-nested">the first section</a>, it should work on
 both the print page and the non-print page.</p>
-<p>The same link should work <a href="second/../first/nested.html">with an html extension</a>.</p>
-<p>A <a href="second/nested.html#some-section">fragment link</a> should work.</p>
-<p>Link <a href="second/../../std/foo/bar.html">outside</a>.</p>
-<p>Link <a href="second/../../std/foo/bar.html#panic">outside with anchor</a>.</p>
-<p><img src="second/../images/picture.png" alt="Some image" /></p>
-<p><a href="second/../first/nested.html">HTML Link</a></p>
-<img src="second/../images/picture.png" alt="raw html">
+<p>The same link should work <a href="#first-nested">with an html extension</a>.</p>
+<p>A <a href="#some-section">fragment link</a> should work.</p>
+<p>Link <a href="../std/foo/bar.html">outside</a>.</p>
+<p>Link <a href="../std/foo/bar.html#panic">outside with anchor</a>.</p>
+<p><img src="images/picture.png" alt="Some image"></p>
+<p><a href="#first-nested">HTML Link</a></p>
+<img src="images/picture.png" alt="raw html">
 <h2 id="some-section"><a class="header" href="#some-section">Some section</a></h2>
 <p><a href="https://example.com/foo.html#bar">Links with scheme shouldn’t be touched.</a></p>
-<p><a href="second/../images/not-html?arg1&arg2#with-anchor">Non-html link</a></p>
\ No newline at end of file
+<p><a href="images/not-html?arg1&amp;arg2#with-anchor">Non-html link</a></p>
\ No newline at end of file
diff --git a/tests/testsuite/rendering.rs b/tests/testsuite/rendering.rs
index cdbfbeb148..d9ceb854f4 100644
--- a/tests/testsuite/rendering.rs
+++ b/tests/testsuite/rendering.rs
@@ -82,28 +82,26 @@ fn language_rust_playground() {
         "x()",
         "",
         str![[r#"
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>x()
-<span class="boring">}</span></code></pre></pre>
+<span class="boring">}</span></code></pre>
 "#]],
     );
     // `fn main` should not be wrapped, not boring.
     expect(
         "fn main() {}",
         "",
-        str![[
-            r#"<pre><pre class="playground"><code class="language-rust">fn main() {}</code></pre></pre>"#
-        ]],
+        str![[r#"<pre class="playground"><code class="language-rust">fn main() {}</code></pre>"#]],
     );
     // Lines starting with `#` are boring.
     expect(
         "let s = \"foo\n # bar\n\";",
         "editable",
         str![[r#"
-<pre><pre class="playground"><code class="language-rust editable">let s = "foo
+<pre class="playground"><code class="language-rust editable">let s = "foo
 <span class="boring"> bar
-</span>";</code></pre></pre>
+</span>";</code></pre>
 "#]],
     );
     // `##` is not boring and is used as an escape.
@@ -111,9 +109,9 @@ fn language_rust_playground() {
         "let s = \"foo\n ## bar\n\";",
         "editable",
         str![[r#"
-<pre><pre class="playground"><code class="language-rust editable">let s = "foo
+<pre class="playground"><code class="language-rust editable">let s = "foo
  # bar
-";</code></pre></pre>
+";</code></pre>
 "#]],
     );
     // `#` on a line by itself is boring.
@@ -121,10 +119,10 @@ fn language_rust_playground() {
         "let s = \"foo\n # bar\n#\n\";",
         "editable",
         str![[r#"
-<pre><pre class="playground"><code class="language-rust editable">let s = "foo
+<pre class="playground"><code class="language-rust editable">let s = "foo
 <span class="boring"> bar
 </span><span class="boring">
-</span>";</code></pre></pre>
+</span>";</code></pre>
 "#]],
     );
     // `#` must be followed by a space to be boring.
@@ -132,10 +130,10 @@ fn language_rust_playground() {
         "#x;",
         "",
         str![[r#"
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>#x;
-<span class="boring">}</span></code></pre></pre>
+<span class="boring">}</span></code></pre>
 "#]],
     );
 
@@ -155,9 +153,9 @@ fn language_rust_playground() {
         "#![no_std]\nlet s = \"foo\";\n #[some_attr]",
         "editable",
         str![[r#"
-<pre><pre class="playground"><code class="language-rust editable">#![no_std]
+<pre class="playground"><code class="language-rust editable">#![no_std]
 let s = "foo";
- #[some_attr]</code></pre></pre>
+ #[some_attr]</code></pre>
 "#]],
     );
 }
@@ -183,12 +181,12 @@ fn code_block_in_list() {
 <ul>
 <li>
 <p>inside list</p>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>fn foo() {
   let x = 1;
 }
-<span class="boring">}</span></code></pre></pre>
+<span class="boring">}</span></code></pre>
 </li>
 </ul>
 "#]],
@@ -210,14 +208,14 @@ fn busted_end_tag() {
             cmd.expect_stderr(str![[r#"
  INFO Book building has started
  INFO Running the html backend
+ WARN html parse error in `chapter_1.md`: Self-closing end tag
+Html text was:
+<div>x<span>foo</span/>y</div>
  INFO HTML book written to `[ROOT]/book`
 
 "#]]);
         })
-        .check_main_file(
-            "book/chapter_1.html",
-            str!["<div>x<span>foo</span/>y</div>"],
-        );
+        .check_main_file("book/chapter_1.html", str!["<div>x<span>foo</span>y</div>"]);
 }
 
 // Various html blocks.
diff --git a/tests/testsuite/rendering/default_rust_edition/expected/default-rust-edition.html b/tests/testsuite/rendering/default_rust_edition/expected/default-rust-edition.html
index a05ee9c10c..e47dfd6b6a 100644
--- a/tests/testsuite/rendering/default_rust_edition/expected/default-rust-edition.html
+++ b/tests/testsuite/rendering/default_rust_edition/expected/default-rust-edition.html
@@ -1,13 +1,13 @@
 <h1 id="chapter-1"><a class="header" href="#chapter-1">Chapter 1</a></h1>
-<pre><pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>let x = 2021;
-<span class="boring">}</span></code></pre></pre>
-<pre><pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
+<span class="boring">}</span></code></pre>
+<pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>let x = 2021;
-<span class="boring">}</span></code></pre></pre>
-<pre><pre class="playground"><code class="language-rust edition2024 edition2021"><span class="boring">#![allow(unused)]
+<span class="boring">}</span></code></pre>
+<pre class="playground"><code class="language-rust edition2024"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>let x = 2024;
-<span class="boring">}</span></code></pre></pre>
\ No newline at end of file
+<span class="boring">}</span></code></pre>
\ No newline at end of file
diff --git a/tests/testsuite/rendering/editable_rust_block/expected/editable-rust.html b/tests/testsuite/rendering/editable_rust_block/expected/editable-rust.html
index 217477adc6..055fe99e7f 100644
--- a/tests/testsuite/rendering/editable_rust_block/expected/editable-rust.html
+++ b/tests/testsuite/rendering/editable_rust_block/expected/editable-rust.html
@@ -1,8 +1,8 @@
 <h1 id="chapter-1"><a class="header" href="#chapter-1">Chapter 1</a></h1>
-<pre><pre class="playground"><code class="language-rust editable">fn f() {
+<pre class="playground"><code class="language-rust editable">fn f() {
     println!("hello");
-}</code></pre></pre>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+}</code></pre>
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span><span class="boring">fn main() {
 </span>// Not editable.
-<span class="boring">}</span></code></pre></pre>
\ No newline at end of file
+<span class="boring">}</span></code></pre>
\ No newline at end of file
diff --git a/tests/testsuite/rendering/fontawesome/expected/fa.html b/tests/testsuite/rendering/fontawesome/expected/fa.html
index 61b7db7375..a5cf5bf5ad 100644
--- a/tests/testsuite/rendering/fontawesome/expected/fa.html
+++ b/tests/testsuite/rendering/fontawesome/expected/fa.html
@@ -1,5 +1,5 @@
 <h1 id="chapter-1"><a class="header" href="#chapter-1">Chapter 1</a></h1>
-<p><span id="example1" class="fa-svg extra-class"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M47.6 300.4L228.3 469.1c7.5 7 17.4 10.9 27.7 10.9s20.2-3.9 27.7-10.9L464.4 300.4c30.4-28.3 47.6-68 47.6-109.5v-5.8c0-69.9-50.5-129.5-119.4-141C347 36.5 300.6 51.4 268 84L256 96 244 84c-32.6-32.6-79-47.5-124.6-39.9C50.5 55.6 0 115.2 0 185.1v5.8c0 41.5 17.2 81.2 47.6 109.5z"/></svg></span></p>
+<p><span class="fa-svg extra-class" id="example1"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M47.6 300.4L228.3 469.1c7.5 7 17.4 10.9 27.7 10.9s20.2-3.9 27.7-10.9L464.4 300.4c30.4-28.3 47.6-68 47.6-109.5v-5.8c0-69.9-50.5-129.5-119.4-141C347 36.5 300.6 51.4 268 84L256 96 244 84c-32.6-32.6-79-47.5-124.6-39.9C50.5 55.6 0 115.2 0 185.1v5.8c0 41.5 17.2 81.2 47.6 109.5z"/></svg></span></p>
 <p><span class="fa-svg"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M272 304h-96C78.8 304 0 382.8 0 480c0 17.67 14.33 32 32 32h384c17.67 0 32-14.33 32-32C448 382.8 369.2 304 272 304zM48.99 464C56.89 400.9 110.8 352 176 352h96c65.16 0 119.1 48.95 127 112H48.99zM224 256c70.69 0 128-57.31 128-128c0-70.69-57.31-128-128-128S96 57.31 96 128C96 198.7 153.3 256 224 256zM224 48c44.11 0 80 35.89 80 80c0 44.11-35.89 80-80 80S144 172.1 144 128C144 83.89 179.9 48 224 48z"/></svg></span></p>
 <p><span class="fa-svg"><svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Free 6.2.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2022 Fonticons, Inc. --><path d="M448 48V384C385 407 366 416 329 416C266 416 242 384 179 384C159 384 143 388 128 392V328C143 324 159 320 179 320C242 320 266 352 329 352C349 352 364 349 384 343V135C364 141 349 144 329 144C266 144 242 112 179 112C128 112 104 133 64 141V448C64 466 50 480 32 480S0 466 0 448V64C0 46 14 32 32 32S64 46 64 64V77C104 69 128 48 179 48C242 48 266 80 329 80C366 80 385 71 448 48Z"/></svg></span></p>
 <p><i class="fas fa-heart">Some text here.</i></p>
\ No newline at end of file
diff --git a/tests/testsuite/rendering/hidelines/expected/hide-lines.html b/tests/testsuite/rendering/hidelines/expected/hide-lines.html
index 4a37bb0ffb..f8175cc14f 100644
--- a/tests/testsuite/rendering/hidelines/expected/hide-lines.html
+++ b/tests/testsuite/rendering/hidelines/expected/hide-lines.html
@@ -11,7 +11,7 @@ <h1 id="hide-lines"><a class="header" href="#hide-lines">Hide Lines</a></h1>
 </span><span class="boring">    hidden()
 </span>    nothidden()
 </code></pre>
-<pre><pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
+<pre class="playground"><code class="language-rust"><span class="boring">#![allow(unused)]
 </span>#![allow(something)]
 <span class="boring">fn main() {
 </span><span class="boring">
@@ -20,4 +20,4 @@ <h1 id="hide-lines"><a class="header" href="#hide-lines">Hide Lines</a></h1>
 </span># not_hidden();
 #[not_hidden]
 not_hidden();
-<span class="boring">}</span></code></pre></pre>
\ No newline at end of file
+<span class="boring">}</span></code></pre>
\ No newline at end of file
diff --git a/tests/testsuite/search.rs b/tests/testsuite/search.rs
index 0596f9c7f1..2aed2e3a42 100644
--- a/tests/testsuite/search.rs
+++ b/tests/testsuite/search.rs
@@ -63,7 +63,7 @@ fn reasonable_search_index() {
     // html.
     assert_eq!(
         docs[&sneaky]["body"],
-        "I put &lt;HTML&gt; in here! Sneaky inline event alert(“inline”);. But regular inline is indexed."
+        "I put <HTML> in here! Sneaky inline event . But regular inline is indexed."
     );
     assert_eq!(
         docs[&no_headers]["breadcrumbs"],
diff --git a/tests/testsuite/search/reasonable_search_index/expected_index.js b/tests/testsuite/search/reasonable_search_index/expected_index.js
index 76e62193e6..60e98ac6be 100644
--- a/tests/testsuite/search/reasonable_search_index/expected_index.js
+++ b/tests/testsuite/search/reasonable_search_index/expected_index.js
@@ -1 +1 @@
-window.search = Object.assign(window.search, JSON.parse('{"doc_urls":["intro.html#introduction","intro.html#sneaky","first/index.html#first-chapter","first/index.html#some-section","first/includes.html#includes","first/includes.html#summary","first/unicode.html#unicode-stress-tests","first/no-headers.html","first/duplicate-headers.html#duplicate-headers","first/duplicate-headers.html#header-text","first/duplicate-headers.html#header-text-1","first/duplicate-headers.html#header-text-2","first/heading-attributes.html#attrs","first/heading-attributes.html#heading-with-classes","first/heading-attributes.html#both"],"index":{"documentStore":{"docInfo":{"0":{"body":3,"breadcrumbs":2,"title":1},"1":{"body":10,"breadcrumbs":2,"title":1},"10":{"body":0,"breadcrumbs":6,"title":2},"11":{"body":0,"breadcrumbs":6,"title":2},"12":{"body":0,"breadcrumbs":6,"title":2},"13":{"body":0,"breadcrumbs":6,"title":2},"14":{"body":0,"breadcrumbs":7,"title":3},"2":{"body":2,"breadcrumbs":4,"title":2},"3":{"body":0,"breadcrumbs":3,"title":1},"4":{"body":0,"breadcrumbs":4,"title":1},"5":{"body":10,"breadcrumbs":4,"title":1},"6":{"body":29,"breadcrumbs":6,"title":3},"7":{"body":6,"breadcrumbs":3,"title":2},"8":{"body":5,"breadcrumbs":6,"title":2},"9":{"body":0,"breadcrumbs":6,"title":2}},"docs":{"0":{"body":"Here’s some interesting text…","breadcrumbs":"Introduction » Introduction","id":"0","title":"Introduction"},"1":{"body":"I put &lt;HTML&gt; in here! Sneaky inline event alert(“inline”);. But regular inline is indexed.","breadcrumbs":"Introduction » Sneaky","id":"1","title":"Sneaky"},"10":{"body":"","breadcrumbs":"First Chapter » Duplicate Headers » Header Text","id":"10","title":"Header Text"},"11":{"body":"","breadcrumbs":"First Chapter » Duplicate Headers » header-text","id":"11","title":"header-text"},"12":{"body":"","breadcrumbs":"First Chapter » Heading Attributes » Heading Attributes","id":"12","title":"Heading Attributes"},"13":{"body":"","breadcrumbs":"First Chapter » Heading Attributes » Heading with classes","id":"13","title":"Heading with classes"},"14":{"body":"","breadcrumbs":"First Chapter » Heading Attributes » Heading with id and classes","id":"14","title":"Heading with id and classes"},"2":{"body":"more text.","breadcrumbs":"First Chapter » First Chapter","id":"2","title":"First Chapter"},"3":{"body":"","breadcrumbs":"First Chapter » Some Section","id":"3","title":"Some Section"},"4":{"body":"","breadcrumbs":"First Chapter » Includes » Includes","id":"4","title":"Includes"},"5":{"body":"Introduction First Chapter Includes Unicode No Headers Duplicate Headers Heading Attributes","breadcrumbs":"First Chapter » Includes » Summary","id":"5","title":"Summary"},"6":{"body":"Please be careful editing, this contains carefully crafted characters. Two byte character: spatiëring Combining character: spatiëring Three byte character: 书こんにちは Four byte character: 𐌀‮𐌁‮𐌂‮𐌃‮𐌄‮𐌅‮𐌆‮𐌇‮𐌈‬ Right-to-left: مرحبا Emoticons: 🔊 😍 💜 1️⃣ right-to-left mark: hello באמת!‏ Zalgo: ǫ̛̖̱̗̝͈̋͒͋̏ͥͫ̒̆ͩ̏͌̾͊͐ͪ̾̚","breadcrumbs":"First Chapter » Unicode » Unicode stress tests","id":"6","title":"Unicode stress tests"},"7":{"body":"Capybara capybara capybara. Capybara capybara capybara. ThisLongWordIsIncludedSoWeCanCheckThatSufficientlyLongWordsAreOmittedFromTheSearchIndex.","breadcrumbs":"First Chapter » No Headers","id":"7","title":"First Chapter"},"8":{"body":"This page validates behaviour of duplicate headers.","breadcrumbs":"First Chapter » Duplicate Headers » Duplicate headers","id":"8","title":"Duplicate headers"},"9":{"body":"","breadcrumbs":"First Chapter » Duplicate Headers » Header Text","id":"9","title":"Header Text"}},"length":15,"save":true},"fields":["title","body","breadcrumbs"],"index":{"body":{"root":{"1":{"df":1,"docs":{"6":{"tf":1.0}}},"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":0,"docs":{},"t":{"(":{"df":0,"docs":{},"“":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"1":{"tf":1.0}}}}}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"b":{"df":0,"docs":{},"u":{"df":0,"docs":{},"t":{"df":2,"docs":{"12":{"tf":1.0},"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"b":{"df":0,"docs":{},"e":{"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"v":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"8":{"tf":1.0}}}}}}}},"df":0,"docs":{}}},"y":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.7320508075688772}}}}}},"c":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"y":{"b":{"a":{"df":0,"docs":{},"r":{"a":{"df":1,"docs":{"7":{"tf":2.449489742783178}}},"df":0,"docs":{}}},"df":0,"docs":{}},"df":0,"docs":{}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}},"f":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":1,"docs":{"6":{"tf":1.0}}}}}}}}}},"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":3,"docs":{"2":{"tf":1.0},"5":{"tf":1.0},"7":{"tf":1.0}}}}}},"r":{"a":{"c":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":2.23606797749979}}}},"df":0,"docs":{}},"df":0,"docs":{}}},"df":0,"docs":{}},"l":{"a":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":2,"docs":{"13":{"tf":1.0},"14":{"tf":1.0}}}}},"df":0,"docs":{}},"o":{"df":0,"docs":{},"m":{"b":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"t":{"a":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}},"r":{"a":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}},"d":{"df":0,"docs":{},"u":{"df":0,"docs":{},"p":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"c":{"df":2,"docs":{"5":{"tf":1.0},"8":{"tf":1.4142135623730951}}},"df":0,"docs":{}}}}}},"df":0,"docs":{},"e":{"d":{"df":0,"docs":{},"i":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"m":{"df":0,"docs":{},"o":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"v":{"df":0,"docs":{},"e":{"df":0,"docs":{},"n":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}}}},"f":{"df":0,"docs":{},"i":{"df":0,"docs":{},"r":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":3,"docs":{"2":{"tf":1.0},"5":{"tf":1.0},"7":{"tf":1.0}}}}}},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"h":{"df":0,"docs":{},"e":{"a":{"d":{"df":4,"docs":{"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0},"5":{"tf":1.0}},"e":{"df":0,"docs":{},"r":{"df":5,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"5":{"tf":1.4142135623730951},"8":{"tf":1.4142135623730951},"9":{"tf":1.0}}}}},"df":0,"docs":{}},"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"1":{"tf":1.0}},"’":{"df":1,"docs":{"0":{"tf":1.0}}}}}}},"i":{"d":{"df":1,"docs":{"14":{"tf":1.0}}},"df":0,"docs":{},"n":{"c":{"df":0,"docs":{},"l":{"df":0,"docs":{},"u":{"d":{"df":2,"docs":{"4":{"tf":1.0},"5":{"tf":1.0}}},"df":0,"docs":{}}}},"d":{"df":0,"docs":{},"e":{"df":0,"docs":{},"x":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"1":{"tf":1.4142135623730951}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"0":{"tf":1.0}}}}}}},"r":{"df":0,"docs":{},"o":{"d":{"df":0,"docs":{},"u":{"c":{"df":0,"docs":{},"t":{"df":2,"docs":{"0":{"tf":1.0},"5":{"tf":1.0}}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}},"l":{"df":0,"docs":{},"e":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}},"t":{";":{"df":0,"docs":{},"h":{"df":0,"docs":{},"t":{"df":0,"docs":{},"m":{"df":0,"docs":{},"l":{"&":{"df":0,"docs":{},"g":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"df":0,"docs":{}}},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"k":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"o":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"2":{"tf":1.0}}}}}},"p":{"a":{"df":0,"docs":{},"g":{"df":0,"docs":{},"e":{"df":1,"docs":{"8":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}},"df":0,"docs":{}}},"u":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"g":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"a":{"df":0,"docs":{},"r":{"df":1,"docs":{"1":{"tf":1.0}}}},"df":0,"docs":{}}}}},"i":{"df":0,"docs":{},"g":{"df":0,"docs":{},"h":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}}},"s":{"df":0,"docs":{},"e":{"c":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"3":{"tf":1.0}}}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"k":{"df":0,"docs":{},"i":{"df":1,"docs":{"1":{"tf":1.4142135623730951}}}}},"df":0,"docs":{}}},"p":{"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"e":{"df":0,"docs":{},"̈":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}},"ë":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"df":0,"docs":{}},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"u":{"df":0,"docs":{},"m":{"df":0,"docs":{},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"df":1,"docs":{"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}},"x":{"df":0,"docs":{},"t":{"df":5,"docs":{"0":{"tf":1.0},"10":{"tf":1.0},"11":{"tf":1.0},"2":{"tf":1.0},"9":{"tf":1.0}}}}},"h":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"w":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"u":{"df":0,"docs":{},"n":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"d":{"df":2,"docs":{"5":{"tf":1.0},"6":{"tf":1.0}}},"df":0,"docs":{}}},"df":0,"docs":{}}}},"v":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"d":{"df":1,"docs":{"8":{"tf":1.0}}},"df":0,"docs":{}}}},"df":0,"docs":{}},"z":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"g":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"df":0,"docs":{}}}},"breadcrumbs":{"root":{"1":{"df":1,"docs":{"6":{"tf":1.0}}},"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":0,"docs":{},"t":{"(":{"df":0,"docs":{},"“":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"1":{"tf":1.0}}}}}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"b":{"df":0,"docs":{},"u":{"df":0,"docs":{},"t":{"df":4,"docs":{"12":{"tf":1.7320508075688772},"13":{"tf":1.0},"14":{"tf":1.0},"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"b":{"df":0,"docs":{},"e":{"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"v":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"8":{"tf":1.0}}}}}}}},"df":0,"docs":{}}},"y":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.7320508075688772}}}}}},"c":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"y":{"b":{"a":{"df":0,"docs":{},"r":{"a":{"df":1,"docs":{"7":{"tf":2.449489742783178}}},"df":0,"docs":{}}},"df":0,"docs":{}},"df":0,"docs":{}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}},"f":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":1,"docs":{"6":{"tf":1.0}}}}}}}}}},"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":13,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0},"2":{"tf":1.7320508075688772},"3":{"tf":1.0},"4":{"tf":1.0},"5":{"tf":1.4142135623730951},"6":{"tf":1.0},"7":{"tf":1.4142135623730951},"8":{"tf":1.0},"9":{"tf":1.0}}}}}},"r":{"a":{"c":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":2.23606797749979}}}},"df":0,"docs":{}},"df":0,"docs":{}}},"df":0,"docs":{}},"l":{"a":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":2,"docs":{"13":{"tf":1.4142135623730951},"14":{"tf":1.4142135623730951}}}}},"df":0,"docs":{}},"o":{"df":0,"docs":{},"m":{"b":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"t":{"a":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}},"r":{"a":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}},"d":{"df":0,"docs":{},"u":{"df":0,"docs":{},"p":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"c":{"df":5,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"5":{"tf":1.0},"8":{"tf":2.0},"9":{"tf":1.0}}},"df":0,"docs":{}}}}}},"df":0,"docs":{},"e":{"d":{"df":0,"docs":{},"i":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"m":{"df":0,"docs":{},"o":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"v":{"df":0,"docs":{},"e":{"df":0,"docs":{},"n":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}}}},"f":{"df":0,"docs":{},"i":{"df":0,"docs":{},"r":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":13,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0},"2":{"tf":1.7320508075688772},"3":{"tf":1.0},"4":{"tf":1.0},"5":{"tf":1.4142135623730951},"6":{"tf":1.0},"7":{"tf":1.4142135623730951},"8":{"tf":1.0},"9":{"tf":1.0}}}}}},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"h":{"df":0,"docs":{},"e":{"a":{"d":{"df":4,"docs":{"12":{"tf":1.7320508075688772},"13":{"tf":1.7320508075688772},"14":{"tf":1.7320508075688772},"5":{"tf":1.0}},"e":{"df":0,"docs":{},"r":{"df":6,"docs":{"10":{"tf":1.7320508075688772},"11":{"tf":1.7320508075688772},"5":{"tf":1.4142135623730951},"7":{"tf":1.0},"8":{"tf":2.0},"9":{"tf":1.7320508075688772}}}}},"df":0,"docs":{}},"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"1":{"tf":1.0}},"’":{"df":1,"docs":{"0":{"tf":1.0}}}}}}},"i":{"d":{"df":1,"docs":{"14":{"tf":1.4142135623730951}}},"df":0,"docs":{},"n":{"c":{"df":0,"docs":{},"l":{"df":0,"docs":{},"u":{"d":{"df":2,"docs":{"4":{"tf":1.7320508075688772},"5":{"tf":1.4142135623730951}}},"df":0,"docs":{}}}},"d":{"df":0,"docs":{},"e":{"df":0,"docs":{},"x":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"1":{"tf":1.4142135623730951}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"0":{"tf":1.0}}}}}}},"r":{"df":0,"docs":{},"o":{"d":{"df":0,"docs":{},"u":{"c":{"df":0,"docs":{},"t":{"df":3,"docs":{"0":{"tf":1.7320508075688772},"1":{"tf":1.0},"5":{"tf":1.0}}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}},"l":{"df":0,"docs":{},"e":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}},"t":{";":{"df":0,"docs":{},"h":{"df":0,"docs":{},"t":{"df":0,"docs":{},"m":{"df":0,"docs":{},"l":{"&":{"df":0,"docs":{},"g":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"df":0,"docs":{}}},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"k":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"o":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"2":{"tf":1.0}}}}}},"p":{"a":{"df":0,"docs":{},"g":{"df":0,"docs":{},"e":{"df":1,"docs":{"8":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}},"df":0,"docs":{}}},"u":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"g":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"a":{"df":0,"docs":{},"r":{"df":1,"docs":{"1":{"tf":1.0}}}},"df":0,"docs":{}}}}},"i":{"df":0,"docs":{},"g":{"df":0,"docs":{},"h":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}}},"s":{"df":0,"docs":{},"e":{"c":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"3":{"tf":1.4142135623730951}}}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"k":{"df":0,"docs":{},"i":{"df":1,"docs":{"1":{"tf":1.7320508075688772}}}}},"df":0,"docs":{}}},"p":{"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"e":{"df":0,"docs":{},"̈":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}},"ë":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"df":0,"docs":{}},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}}},"u":{"df":0,"docs":{},"m":{"df":0,"docs":{},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"df":1,"docs":{"5":{"tf":1.4142135623730951}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}},"x":{"df":0,"docs":{},"t":{"df":5,"docs":{"0":{"tf":1.0},"10":{"tf":1.4142135623730951},"11":{"tf":1.4142135623730951},"2":{"tf":1.0},"9":{"tf":1.4142135623730951}}}}},"h":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"w":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"u":{"df":0,"docs":{},"n":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"d":{"df":2,"docs":{"5":{"tf":1.0},"6":{"tf":1.7320508075688772}}},"df":0,"docs":{}}},"df":0,"docs":{}}}},"v":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"d":{"df":1,"docs":{"8":{"tf":1.0}}},"df":0,"docs":{}}}},"df":0,"docs":{}},"z":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"g":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"df":0,"docs":{}}}},"title":{"root":{"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"b":{"df":0,"docs":{},"u":{"df":0,"docs":{},"t":{"df":1,"docs":{"12":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"c":{"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":2,"docs":{"2":{"tf":1.0},"7":{"tf":1.0}}}}}}},"df":0,"docs":{}},"l":{"a":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":2,"docs":{"13":{"tf":1.0},"14":{"tf":1.0}}}}},"df":0,"docs":{}}},"d":{"df":0,"docs":{},"u":{"df":0,"docs":{},"p":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"c":{"df":1,"docs":{"8":{"tf":1.0}}},"df":0,"docs":{}}}}}},"df":0,"docs":{},"f":{"df":0,"docs":{},"i":{"df":0,"docs":{},"r":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":2,"docs":{"2":{"tf":1.0},"7":{"tf":1.0}}}}}}},"h":{"df":0,"docs":{},"e":{"a":{"d":{"df":3,"docs":{"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0}},"e":{"df":0,"docs":{},"r":{"df":4,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"8":{"tf":1.0},"9":{"tf":1.0}}}}},"df":0,"docs":{}},"df":0,"docs":{}}},"i":{"d":{"df":1,"docs":{"14":{"tf":1.0}}},"df":0,"docs":{},"n":{"c":{"df":0,"docs":{},"l":{"df":0,"docs":{},"u":{"d":{"df":1,"docs":{"4":{"tf":1.0}}},"df":0,"docs":{}}}},"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"o":{"d":{"df":0,"docs":{},"u":{"c":{"df":0,"docs":{},"t":{"df":1,"docs":{"0":{"tf":1.0}}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}},"s":{"df":0,"docs":{},"e":{"c":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"3":{"tf":1.0}}}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"k":{"df":0,"docs":{},"i":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{}}},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"u":{"df":0,"docs":{},"m":{"df":0,"docs":{},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"df":1,"docs":{"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}},"x":{"df":0,"docs":{},"t":{"df":3,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"9":{"tf":1.0}}}}}},"u":{"df":0,"docs":{},"n":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"d":{"df":1,"docs":{"6":{"tf":1.0}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}}},"lang":"English","pipeline":["trimmer","stopWordFilter","stemmer"],"ref":"id","version":"0.9.5"},"results_options":{"limit_results":30,"teaser_word_count":30},"search_options":{"bool":"OR","expand":true,"fields":{"body":{"boost":1},"breadcrumbs":{"boost":1},"title":{"boost":2}}}}'));
\ No newline at end of file
+window.search = Object.assign(window.search, JSON.parse('{"doc_urls":["intro.html#introduction","intro.html#sneaky","first/index.html#first-chapter","first/index.html#some-section","first/includes.html#includes","first/includes.html#summary","first/unicode.html#unicode-stress-tests","first/no-headers.html","first/duplicate-headers.html#duplicate-headers","first/duplicate-headers.html#header-text","first/duplicate-headers.html#header-text-1","first/duplicate-headers.html#header-text-2","first/heading-attributes.html#attrs","first/heading-attributes.html#heading-with-classes","first/heading-attributes.html#both"],"index":{"documentStore":{"docInfo":{"0":{"body":3,"breadcrumbs":2,"title":1},"1":{"body":9,"breadcrumbs":2,"title":1},"10":{"body":0,"breadcrumbs":6,"title":2},"11":{"body":0,"breadcrumbs":6,"title":2},"12":{"body":0,"breadcrumbs":6,"title":2},"13":{"body":0,"breadcrumbs":6,"title":2},"14":{"body":0,"breadcrumbs":7,"title":3},"2":{"body":2,"breadcrumbs":4,"title":2},"3":{"body":0,"breadcrumbs":3,"title":1},"4":{"body":0,"breadcrumbs":4,"title":1},"5":{"body":10,"breadcrumbs":4,"title":1},"6":{"body":29,"breadcrumbs":6,"title":3},"7":{"body":6,"breadcrumbs":3,"title":2},"8":{"body":5,"breadcrumbs":6,"title":2},"9":{"body":0,"breadcrumbs":6,"title":2}},"docs":{"0":{"body":"Here’s some interesting text…","breadcrumbs":"Introduction » Introduction","id":"0","title":"Introduction"},"1":{"body":"I put <HTML> in here! Sneaky inline event . But regular inline is indexed.","breadcrumbs":"Introduction » Sneaky","id":"1","title":"Sneaky"},"10":{"body":"","breadcrumbs":"First Chapter » Duplicate Headers » Header Text","id":"10","title":"Header Text"},"11":{"body":"","breadcrumbs":"First Chapter » Duplicate Headers » header-text","id":"11","title":"header-text"},"12":{"body":"","breadcrumbs":"First Chapter » Heading Attributes » Heading Attributes","id":"12","title":"Heading Attributes"},"13":{"body":"","breadcrumbs":"First Chapter » Heading Attributes » Heading with classes","id":"13","title":"Heading with classes"},"14":{"body":"","breadcrumbs":"First Chapter » Heading Attributes » Heading with id and classes","id":"14","title":"Heading with id and classes"},"2":{"body":"more text.","breadcrumbs":"First Chapter » First Chapter","id":"2","title":"First Chapter"},"3":{"body":"","breadcrumbs":"First Chapter » Some Section","id":"3","title":"Some Section"},"4":{"body":"","breadcrumbs":"First Chapter » Includes » Includes","id":"4","title":"Includes"},"5":{"body":"Introduction First Chapter Includes Unicode No Headers Duplicate Headers Heading Attributes","breadcrumbs":"First Chapter » Includes » Summary","id":"5","title":"Summary"},"6":{"body":"Please be careful editing, this contains carefully crafted characters. Two byte character: spatiëring Combining character: spatiëring Three byte character: 书こんにちは Four byte character: 𐌀‮𐌁‮𐌂‮𐌃‮𐌄‮𐌅‮𐌆‮𐌇‮𐌈‬ Right-to-left: مرحبا Emoticons: 🔊 😍 💜 1️⃣ right-to-left mark: hello באמת!‏ Zalgo: ǫ̛̖̱̗̝͈̋͒͋̏ͥͫ̒̆ͩ̏͌̾͊͐ͪ̾̚","breadcrumbs":"First Chapter » Unicode » Unicode stress tests","id":"6","title":"Unicode stress tests"},"7":{"body":"Capybara capybara capybara. Capybara capybara capybara. ThisLongWordIsIncludedSoWeCanCheckThatSufficientlyLongWordsAreOmittedFromTheSearchIndex.","breadcrumbs":"First Chapter » No Headers","id":"7","title":"First Chapter"},"8":{"body":"This page validates behaviour of duplicate headers.","breadcrumbs":"First Chapter » Duplicate Headers » Duplicate headers","id":"8","title":"Duplicate headers"},"9":{"body":"","breadcrumbs":"First Chapter » Duplicate Headers » Header Text","id":"9","title":"Header Text"}},"length":15,"save":true},"fields":["title","body","breadcrumbs"],"index":{"body":{"root":{"1":{"df":1,"docs":{"6":{"tf":1.0}}},"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"b":{"df":0,"docs":{},"u":{"df":0,"docs":{},"t":{"df":2,"docs":{"12":{"tf":1.0},"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"b":{"df":0,"docs":{},"e":{"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"v":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"8":{"tf":1.0}}}}}}}},"df":0,"docs":{}}},"y":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.7320508075688772}}}}}},"c":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"y":{"b":{"a":{"df":0,"docs":{},"r":{"a":{"df":1,"docs":{"7":{"tf":2.449489742783178}}},"df":0,"docs":{}}},"df":0,"docs":{}},"df":0,"docs":{}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}},"f":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":1,"docs":{"6":{"tf":1.0}}}}}}}}}},"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":3,"docs":{"2":{"tf":1.0},"5":{"tf":1.0},"7":{"tf":1.0}}}}}},"r":{"a":{"c":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":2.23606797749979}}}},"df":0,"docs":{}},"df":0,"docs":{}}},"df":0,"docs":{}},"l":{"a":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":2,"docs":{"13":{"tf":1.0},"14":{"tf":1.0}}}}},"df":0,"docs":{}},"o":{"df":0,"docs":{},"m":{"b":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"t":{"a":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}},"r":{"a":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}},"d":{"df":0,"docs":{},"u":{"df":0,"docs":{},"p":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"c":{"df":2,"docs":{"5":{"tf":1.0},"8":{"tf":1.4142135623730951}}},"df":0,"docs":{}}}}}},"df":0,"docs":{},"e":{"d":{"df":0,"docs":{},"i":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"m":{"df":0,"docs":{},"o":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"v":{"df":0,"docs":{},"e":{"df":0,"docs":{},"n":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}}}},"f":{"df":0,"docs":{},"i":{"df":0,"docs":{},"r":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":3,"docs":{"2":{"tf":1.0},"5":{"tf":1.0},"7":{"tf":1.0}}}}}},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"h":{"df":0,"docs":{},"e":{"a":{"d":{"df":4,"docs":{"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0},"5":{"tf":1.0}},"e":{"df":0,"docs":{},"r":{"df":5,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"5":{"tf":1.4142135623730951},"8":{"tf":1.4142135623730951},"9":{"tf":1.0}}}}},"df":0,"docs":{}},"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"1":{"tf":1.0}},"’":{"df":1,"docs":{"0":{"tf":1.0}}}}}},"t":{"df":0,"docs":{},"m":{"df":0,"docs":{},"l":{"df":1,"docs":{"1":{"tf":1.0}}}}}},"i":{"d":{"df":1,"docs":{"14":{"tf":1.0}}},"df":0,"docs":{},"n":{"c":{"df":0,"docs":{},"l":{"df":0,"docs":{},"u":{"d":{"df":2,"docs":{"4":{"tf":1.0},"5":{"tf":1.0}}},"df":0,"docs":{}}}},"d":{"df":0,"docs":{},"e":{"df":0,"docs":{},"x":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"1":{"tf":1.4142135623730951}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"0":{"tf":1.0}}}}}}},"r":{"df":0,"docs":{},"o":{"d":{"df":0,"docs":{},"u":{"c":{"df":0,"docs":{},"t":{"df":2,"docs":{"0":{"tf":1.0},"5":{"tf":1.0}}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}},"l":{"df":0,"docs":{},"e":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"k":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"o":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"2":{"tf":1.0}}}}}},"p":{"a":{"df":0,"docs":{},"g":{"df":0,"docs":{},"e":{"df":1,"docs":{"8":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}},"df":0,"docs":{}}},"u":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"g":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"a":{"df":0,"docs":{},"r":{"df":1,"docs":{"1":{"tf":1.0}}}},"df":0,"docs":{}}}}},"i":{"df":0,"docs":{},"g":{"df":0,"docs":{},"h":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}}},"s":{"df":0,"docs":{},"e":{"c":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"3":{"tf":1.0}}}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"k":{"df":0,"docs":{},"i":{"df":1,"docs":{"1":{"tf":1.4142135623730951}}}}},"df":0,"docs":{}}},"p":{"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"e":{"df":0,"docs":{},"̈":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}},"ë":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"df":0,"docs":{}},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"u":{"df":0,"docs":{},"m":{"df":0,"docs":{},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"df":1,"docs":{"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}},"x":{"df":0,"docs":{},"t":{"df":5,"docs":{"0":{"tf":1.0},"10":{"tf":1.0},"11":{"tf":1.0},"2":{"tf":1.0},"9":{"tf":1.0}}}}},"h":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"w":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"u":{"df":0,"docs":{},"n":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"d":{"df":2,"docs":{"5":{"tf":1.0},"6":{"tf":1.0}}},"df":0,"docs":{}}},"df":0,"docs":{}}}},"v":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"d":{"df":1,"docs":{"8":{"tf":1.0}}},"df":0,"docs":{}}}},"df":0,"docs":{}},"z":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"g":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"df":0,"docs":{}}}},"breadcrumbs":{"root":{"1":{"df":1,"docs":{"6":{"tf":1.0}}},"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"b":{"df":0,"docs":{},"u":{"df":0,"docs":{},"t":{"df":4,"docs":{"12":{"tf":1.7320508075688772},"13":{"tf":1.0},"14":{"tf":1.0},"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"b":{"df":0,"docs":{},"e":{"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"v":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"8":{"tf":1.0}}}}}}}},"df":0,"docs":{}}},"y":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.7320508075688772}}}}}},"c":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"y":{"b":{"a":{"df":0,"docs":{},"r":{"a":{"df":1,"docs":{"7":{"tf":2.449489742783178}}},"df":0,"docs":{}}},"df":0,"docs":{}},"df":0,"docs":{}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}},"f":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":1,"docs":{"6":{"tf":1.0}}}}}}}}}},"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":13,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0},"2":{"tf":1.7320508075688772},"3":{"tf":1.0},"4":{"tf":1.0},"5":{"tf":1.4142135623730951},"6":{"tf":1.0},"7":{"tf":1.4142135623730951},"8":{"tf":1.0},"9":{"tf":1.0}}}}}},"r":{"a":{"c":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":2.23606797749979}}}},"df":0,"docs":{}},"df":0,"docs":{}}},"df":0,"docs":{}},"l":{"a":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":2,"docs":{"13":{"tf":1.4142135623730951},"14":{"tf":1.4142135623730951}}}}},"df":0,"docs":{}},"o":{"df":0,"docs":{},"m":{"b":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"t":{"a":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}},"r":{"a":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}},"d":{"df":0,"docs":{},"u":{"df":0,"docs":{},"p":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"c":{"df":5,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"5":{"tf":1.0},"8":{"tf":2.0},"9":{"tf":1.0}}},"df":0,"docs":{}}}}}},"df":0,"docs":{},"e":{"d":{"df":0,"docs":{},"i":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"m":{"df":0,"docs":{},"o":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"v":{"df":0,"docs":{},"e":{"df":0,"docs":{},"n":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}}}},"f":{"df":0,"docs":{},"i":{"df":0,"docs":{},"r":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":13,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0},"2":{"tf":1.7320508075688772},"3":{"tf":1.0},"4":{"tf":1.0},"5":{"tf":1.4142135623730951},"6":{"tf":1.0},"7":{"tf":1.4142135623730951},"8":{"tf":1.0},"9":{"tf":1.0}}}}}},"o":{"df":0,"docs":{},"u":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"h":{"df":0,"docs":{},"e":{"a":{"d":{"df":4,"docs":{"12":{"tf":1.7320508075688772},"13":{"tf":1.7320508075688772},"14":{"tf":1.7320508075688772},"5":{"tf":1.0}},"e":{"df":0,"docs":{},"r":{"df":6,"docs":{"10":{"tf":1.7320508075688772},"11":{"tf":1.7320508075688772},"5":{"tf":1.4142135623730951},"7":{"tf":1.0},"8":{"tf":2.0},"9":{"tf":1.7320508075688772}}}}},"df":0,"docs":{}},"df":0,"docs":{},"l":{"df":0,"docs":{},"l":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"1":{"tf":1.0}},"’":{"df":1,"docs":{"0":{"tf":1.0}}}}}},"t":{"df":0,"docs":{},"m":{"df":0,"docs":{},"l":{"df":1,"docs":{"1":{"tf":1.0}}}}}},"i":{"d":{"df":1,"docs":{"14":{"tf":1.4142135623730951}}},"df":0,"docs":{},"n":{"c":{"df":0,"docs":{},"l":{"df":0,"docs":{},"u":{"d":{"df":2,"docs":{"4":{"tf":1.7320508075688772},"5":{"tf":1.4142135623730951}}},"df":0,"docs":{}}}},"d":{"df":0,"docs":{},"e":{"df":0,"docs":{},"x":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"df":0,"docs":{},"n":{"df":1,"docs":{"1":{"tf":1.4142135623730951}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"0":{"tf":1.0}}}}}}},"r":{"df":0,"docs":{},"o":{"d":{"df":0,"docs":{},"u":{"c":{"df":0,"docs":{},"t":{"df":3,"docs":{"0":{"tf":1.7320508075688772},"1":{"tf":1.0},"5":{"tf":1.0}}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}},"l":{"df":0,"docs":{},"e":{"df":0,"docs":{},"f":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"k":{"df":1,"docs":{"6":{"tf":1.0}}}}},"df":0,"docs":{},"o":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":1,"docs":{"2":{"tf":1.0}}}}}},"p":{"a":{"df":0,"docs":{},"g":{"df":0,"docs":{},"e":{"df":1,"docs":{"8":{"tf":1.0}}}}},"df":0,"docs":{},"l":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}},"df":0,"docs":{}}},"u":{"df":0,"docs":{},"t":{"df":1,"docs":{"1":{"tf":1.0}}}}},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"g":{"df":0,"docs":{},"u":{"df":0,"docs":{},"l":{"a":{"df":0,"docs":{},"r":{"df":1,"docs":{"1":{"tf":1.0}}}},"df":0,"docs":{}}}}},"i":{"df":0,"docs":{},"g":{"df":0,"docs":{},"h":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}}},"s":{"df":0,"docs":{},"e":{"c":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"3":{"tf":1.4142135623730951}}}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"k":{"df":0,"docs":{},"i":{"df":1,"docs":{"1":{"tf":1.7320508075688772}}}}},"df":0,"docs":{}}},"p":{"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"e":{"df":0,"docs":{},"̈":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}},"ë":{"df":0,"docs":{},"r":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"df":0,"docs":{}},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}}}}},"u":{"df":0,"docs":{},"m":{"df":0,"docs":{},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"df":1,"docs":{"5":{"tf":1.4142135623730951}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.4142135623730951}}}},"x":{"df":0,"docs":{},"t":{"df":5,"docs":{"0":{"tf":1.0},"10":{"tf":1.4142135623730951},"11":{"tf":1.4142135623730951},"2":{"tf":1.0},"9":{"tf":1.4142135623730951}}}}},"h":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"e":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"w":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}},"u":{"df":0,"docs":{},"n":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"d":{"df":2,"docs":{"5":{"tf":1.0},"6":{"tf":1.7320508075688772}}},"df":0,"docs":{}}},"df":0,"docs":{}}}},"v":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"d":{"df":1,"docs":{"8":{"tf":1.0}}},"df":0,"docs":{}}}},"df":0,"docs":{}},"z":{"a":{"df":0,"docs":{},"l":{"df":0,"docs":{},"g":{"df":0,"docs":{},"o":{"df":1,"docs":{"6":{"tf":1.0}}}}}},"df":0,"docs":{}}}},"title":{"root":{"a":{"df":0,"docs":{},"t":{"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"b":{"df":0,"docs":{},"u":{"df":0,"docs":{},"t":{"df":1,"docs":{"12":{"tf":1.0}}}}},"df":0,"docs":{}}}}}},"c":{"df":0,"docs":{},"h":{"a":{"df":0,"docs":{},"p":{"df":0,"docs":{},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"r":{"df":2,"docs":{"2":{"tf":1.0},"7":{"tf":1.0}}}}}}},"df":0,"docs":{}},"l":{"a":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":2,"docs":{"13":{"tf":1.0},"14":{"tf":1.0}}}}},"df":0,"docs":{}}},"d":{"df":0,"docs":{},"u":{"df":0,"docs":{},"p":{"df":0,"docs":{},"l":{"df":0,"docs":{},"i":{"c":{"df":1,"docs":{"8":{"tf":1.0}}},"df":0,"docs":{}}}}}},"df":0,"docs":{},"f":{"df":0,"docs":{},"i":{"df":0,"docs":{},"r":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":2,"docs":{"2":{"tf":1.0},"7":{"tf":1.0}}}}}}},"h":{"df":0,"docs":{},"e":{"a":{"d":{"df":3,"docs":{"12":{"tf":1.0},"13":{"tf":1.0},"14":{"tf":1.0}},"e":{"df":0,"docs":{},"r":{"df":4,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"8":{"tf":1.0},"9":{"tf":1.0}}}}},"df":0,"docs":{}},"df":0,"docs":{}}},"i":{"d":{"df":1,"docs":{"14":{"tf":1.0}}},"df":0,"docs":{},"n":{"c":{"df":0,"docs":{},"l":{"df":0,"docs":{},"u":{"d":{"df":1,"docs":{"4":{"tf":1.0}}},"df":0,"docs":{}}}},"df":0,"docs":{},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"o":{"d":{"df":0,"docs":{},"u":{"c":{"df":0,"docs":{},"t":{"df":1,"docs":{"0":{"tf":1.0}}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}},"s":{"df":0,"docs":{},"e":{"c":{"df":0,"docs":{},"t":{"df":0,"docs":{},"i":{"df":0,"docs":{},"o":{"df":0,"docs":{},"n":{"df":1,"docs":{"3":{"tf":1.0}}}}}}},"df":0,"docs":{}},"n":{"df":0,"docs":{},"e":{"a":{"df":0,"docs":{},"k":{"df":0,"docs":{},"i":{"df":1,"docs":{"1":{"tf":1.0}}}}},"df":0,"docs":{}}},"t":{"df":0,"docs":{},"r":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"s":{"df":1,"docs":{"6":{"tf":1.0}}}}}}},"u":{"df":0,"docs":{},"m":{"df":0,"docs":{},"m":{"a":{"df":0,"docs":{},"r":{"df":0,"docs":{},"i":{"df":1,"docs":{"5":{"tf":1.0}}}}},"df":0,"docs":{}}}}},"t":{"df":0,"docs":{},"e":{"df":0,"docs":{},"s":{"df":0,"docs":{},"t":{"df":1,"docs":{"6":{"tf":1.0}}}},"x":{"df":0,"docs":{},"t":{"df":3,"docs":{"10":{"tf":1.0},"11":{"tf":1.0},"9":{"tf":1.0}}}}}},"u":{"df":0,"docs":{},"n":{"df":0,"docs":{},"i":{"c":{"df":0,"docs":{},"o":{"d":{"df":1,"docs":{"6":{"tf":1.0}}},"df":0,"docs":{}}},"df":0,"docs":{}}}}}}},"lang":"English","pipeline":["trimmer","stopWordFilter","stemmer"],"ref":"id","version":"0.9.5"},"results_options":{"limit_results":30,"teaser_word_count":30},"search_options":{"bool":"OR","expand":true,"fields":{"body":{"boost":1},"breadcrumbs":{"boost":1},"title":{"boost":2}}}}'));
\ No newline at end of file