diff --git a/.forgejo/workflows/test.yml b/.forgejo/workflows/test.yml
new file mode 100644
index 0000000..bed4795
--- /dev/null
+++ b/.forgejo/workflows/test.yml
@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
+on: [push, pull_request]
+
+env:
+  PDF_HASH: 56372d23ece7e9e2c1b381a639443982a3e16e38109df1c141d655b779b61fdb
+  OUTPUT_XML_HASH: c0b4592cbd0a3e59b9b2931a6a75a3d87ebf23bf453e8587a1522dd157f15ee9
+
+jobs:
+  test:
+    runs-on: debian-12
+    container:
+      image: git.libre-chip.org/libre-chip/fayalite-deps:latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - run: |
+          scripts/check-copyright.sh
+      - uses: https://git.libre-chip.org/mirrors/rust-cache@v2
+        with:
+          save-if: ${{ github.ref == 'refs/heads/master' }}
+      - run: |
+          apt-get update -qq
+          apt-get install -qq python3-venv wget
+          # copy of https://files.openpower.foundation/s/9izgC5Rogi5Ywmm/download/OPF_PowerISA_v3.1C.pdf
+          wget -O OPF_PowerISA_v3.1C.pdf https://libre-chip.org/OPF_PowerISA_v3.1C.pdf
+          echo "$PDF_HASH  OPF_PowerISA_v3.1C.pdf" | sha256sum -c
+      - run: |
+          cargo test
+      - run: |
+          cargo build --release
+      - run: |
+          cargo run --release -- OPF_PowerISA_v3.1C.pdf &> >(tee out.log | grep '^page ') || { tail -n1000 out.log; false; }
+          echo "expected output (not all instructions are decoded yet, change when the output is improved):"
+          echo "$OUTPUT_XML_HASH  powerisa-instructions.xml" | sha256sum -c
+          mv powerisa-instructions.xml powerisa-instructions-rust.xml
+      - run: |
+          python3 -m venv --upgrade-deps .venv
+          . .venv/bin/activate
+          pip install -e .
+          parse_powerisa_pdf OPF_PowerISA_v3.1C.pdf &> >(tee out.log | grep '^page ') || { tail -n1000 out.log; false; }
+          echo "expected output (not all instructions are decoded yet, change when the output is improved):"
+          echo "$OUTPUT_XML_HASH  powerisa-instructions.xml" | sha256sum -c
+          mv powerisa-instructions.xml powerisa-instructions-python.xml
+
diff --git a/.gitignore b/.gitignore
index e11e257..454d147 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,10 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
 /.venv
 /.vscode
 *.egg-info
 __pycache__
 *.log
 /powerisa-instructions.xml
+/*.pdf
 /target
diff --git a/Cargo.lock b/Cargo.lock
index 10be7b1..4321809 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,10 +3,56 @@
 version = 4
 
 [[package]]
-name = "adler2"
-version = "2.0.1"
+name = "aho-corasick"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.71.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "cc"
+version = "1.2.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
 
 [[package]]
 name = "cfg-if"
@@ -15,39 +61,16 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
-name = "crc32fast"
-version = "1.5.0"
+name = "clang-sys"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
- "cfg-if",
+ "glob",
+ "libc",
+ "libloading",
 ]
 
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
-dependencies = [
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
-
 [[package]]
 name = "either"
 version = "1.15.0"
@@ -55,55 +78,228 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
-name = "flate2"
-version = "1.1.5"
+name = "equivalent"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "indexmap"
+version = "2.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ad4bb2b565bca0645f4d68c5c9af97fba094e9791da685bf83cb5f3ce74acf2"
 dependencies = [
- "crc32fast",
- "miniz_oxide",
+ "equivalent",
+ "hashbrown",
 ]
 
 [[package]]
-name = "miniz_oxide"
+name = "itertools"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "libloading"
 version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
 dependencies = [
- "adler2",
- "simd-adler32",
+ "cfg-if",
+ "windows-link",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "mupdf-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13e9a0d4e844ab50315d43312f3d62f72c77205b07c8ee21cbd4b52bdc2a9910"
+dependencies = [
+ "bindgen",
+ "cc",
+ "pkg-config",
+ "regex",
+ "zerocopy",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
 ]
 
 [[package]]
 name = "parse_powerisa_pdf"
 version = "0.1.0"
 dependencies = [
- "flate2",
- "rayon",
+ "indexmap",
+ "libm",
+ "mupdf-sys",
+ "quick-xml",
 ]
 
 [[package]]
-name = "rayon"
-version = "1.11.0"
+name = "pkg-config"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
 dependencies = [
- "either",
- "rayon-core",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "rayon-core"
-version = "1.13.0"
+name = "quick-xml"
+version = "0.38.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
 dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
+ "memchr",
 ]
 
 [[package]]
-name = "simd-adler32"
-version = "0.3.8"
+name = "quote"
+version = "1.0.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "syn"
+version = "2.0.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21f182278bf2d2bcb3c88b1b08a37df029d71ce3d3ae26168e3c653b213b99d4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 20ecf46..21175d6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,17 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
 [package]
 name = "parse_powerisa_pdf"
 version = "0.1.0"
-edition = "2024"
 license = "LGPL-3.0-or-later"
+edition = "2024"
+repository = ""
+keywords = []
+categories = []
+rust-version = "1.89.0"
 
 [dependencies]
-flate2 = "1.1.5"
-rayon = "1.11.0"
-
+indexmap = "2.12.1"
+libm = "0.2.15"
+mupdf-sys = { version = "0.5.0", default-features = false }
+quick-xml = "0.38.4"
diff --git a/README.md b/README.md
index f8fae5d..f589559 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,38 @@
+<!--
+SPDX-License-Identifier: LGPL-3.0-or-later
+See Notices.txt for copyright information
+-->
 parser for the OPF PowerISA 3.1C pdf to attempt to extract all instructions' pseudo-code including subscripts/superscripts and other formatting
 
+# Using the new Rust code:
+
+Usage:
+* Download the OPF PowerISA 3.1C pdf (yes you need that exact version) from <https://openpower.foundation/specifications/isa/>
+
+* Install Rust -- you need version 1.89.0 or later.
+
+  Getting it from https://rustup.rs/ is recommended.
+
+* Install required build dependencies:
+
+  On Debian 12:
+
+  ```bash
+  sudo apt update
+  sudo apt install build-essential clang unzip
+  ```
+
+* Compile and run:
+
+  ```bash
+  cargo run -- path/to/downloaded/OPF_PowerISA_v3.1C.pdf > out.log
+  ```
+
+* This will spit out lots of errors and then successfully create
+  the output file -- `powerisa-instructions.xml` in the current directory.
+
+# Using the old Python code:
+
 Usage:
 * Download the OPF PowerISA 3.1C pdf (yes you need that exact version) from <https://openpower.foundation/specifications/isa/>
 * Obtain CPython 3.11 (the default `python3` in [Debian Bookworm](https://www.debian.org/releases/bookworm/))
diff --git a/parse_powerisa_pdf/parse_powerisa_pdf.py b/parse_powerisa_pdf/parse_powerisa_pdf.py
index c7187d1..3c2afe5 100755
--- a/parse_powerisa_pdf/parse_powerisa_pdf.py
+++ b/parse_powerisa_pdf/parse_powerisa_pdf.py
@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
 from __future__ import annotations
 from collections import defaultdict
 from collections.abc import Generator, Iterable, Iterator, Callable
@@ -763,7 +765,7 @@ class Page:
     unprocessed_non_text: SetById[LTLine | LTRect]
 
     @staticmethod
-    def from_lt_page(page_num: int, page: LTPage) -> Page:
+    def from_lt_page(page_num: int, page: LTPage, first_seen_fonts: defaultdict[str, set[float]]) -> Page:
         qt: defaultdict[TextSection, QuadTree[Char | LTLine | LTRect]] = defaultdict(QuadTree)
         unprocessed_chars = defaultdict(lambda: defaultdict(SetById[Char]))
         unprocessed_non_text: SetById[LTLine | LTRect] = SetById()
@@ -802,20 +804,25 @@ class Page:
                                 raise AssertionError(
                                     f"char not in text section: {element}\npage_num={page_num}")
                         continue
+                    font_size = round(element.size, 3)
                     char = Char(
                         text=element.get_text(),
-                        font=Font(font_name=element.fontname, size=round(element.size, 3)),
+                        font=Font(font_name=element.fontname, size=font_size),
                         adv=element.adv,
                         min_x=element.x0,
                         min_y=element.y0,
                         max_x=element.x1,
                         max_y=element.y1,
                     )
+                    if font_size not in first_seen_fonts[element.fontname]:
+                        first_seen_fonts[element.fontname].add(font_size)
+                        print(f"first seen font: {element.fontname!r} {font_size}: page {page_num} {char!r}")
                     qt[text_section].insert(char.min_x, char.min_y, char)
                     unprocessed_chars[text_section][char.font].add(char)
-        for i in unprocessed_chars.values():
-            for j in i.values():
-                j.sort(key=Char.top_down_left_to_right_sort_key)
+        for text_section, i in unprocessed_chars.items():
+            for chars in i.values():
+                chars.sort(key=Char.top_down_left_to_right_sort_key)
+                print(f"first char: {text_section!r}: {next(iter(chars), None)!r}")
         unknown_fonts=[]
         unknown_font_errors=[]
         for i in unprocessed_chars.values():
@@ -1179,13 +1186,14 @@ class Parser:
     def __pages_gen(file: Path, page_numbers: Iterable[int] | None) -> Generator[Page, None, None]:
         if page_numbers is not None:
             page_numbers = sorted(i - 1 for i in page_numbers)
+        first_seen_fonts = defaultdict(set)
         for i, page in enumerate(extract_pages(file, page_numbers=page_numbers)):
             if page_numbers is not None:
                 page_num = page_numbers[i] + 1
             else:
                 page_num = i + 1
             print(f"page {page_num}")
-            yield Page.from_lt_page(page_num=page_num, page=page)
+            yield Page.from_lt_page(page_num=page_num, page=page, first_seen_fonts=first_seen_fonts)
 
     def parse_pdf(self, file: Path, page_numbers: Iterable[int] | None = None):
         self.pages = Pages(pages_gen=Parser.__pages_gen(
@@ -1501,7 +1509,7 @@ class Parser:
                 f"instruction bit fields box has wrong number of horizontal lines:\n{h_lines}")
         if len(v_lines) < 2:
             raise InsnParseError(
-                f"instruction bit fields box has too few vertical lines:\n{h_lines}")
+                f"instruction bit fields box has too few vertical lines:\n{v_lines}")
         bottom_line, top_line = h_lines
         box_min_x = v_lines[0].x0
         box_max_x = v_lines[-1].x0
diff --git a/parse_powerisa_pdf/quad_tree.py b/parse_powerisa_pdf/quad_tree.py
index 34343e8..bee9d76 100644
--- a/parse_powerisa_pdf/quad_tree.py
+++ b/parse_powerisa_pdf/quad_tree.py
@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
 from __future__ import annotations
 from typing import Callable, Generic, Iterable, Iterator, TypeVar
 from math import frexp, isfinite, isnan, ldexp
diff --git a/parse_powerisa_pdf/set_by_id.py b/parse_powerisa_pdf/set_by_id.py
index 444741b..969f8d7 100644
--- a/parse_powerisa_pdf/set_by_id.py
+++ b/parse_powerisa_pdf/set_by_id.py
@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
 from collections import abc
 from typing import Callable, Generic, Iterable, Iterator, Protocol, TypeAlias, TypeVar, overload
 
diff --git a/pyproject.toml b/pyproject.toml
index c2ec3e0..0f3e887 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
 [build-system]
 requires = ["setuptools >= 61.0"]
 build-backend = "setuptools.build_meta"
@@ -11,4 +13,7 @@ dependencies = [
 requires-python = ">= 3.11"
 
 [project.scripts]
-parse_powerisa_pdf = "parse_powerisa_pdf.parse_powerisa_pdf:main"
\ No newline at end of file
+parse_powerisa_pdf = "parse_powerisa_pdf.parse_powerisa_pdf:main"
+
+[tool.setuptools]
+packages = ["parse_powerisa_pdf"]
diff --git a/scripts/check-copyright.sh b/scripts/check-copyright.sh
new file mode 100755
index 0000000..a9dc2bc
--- /dev/null
+++ b/scripts/check-copyright.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# See Notices.txt for copyright information
+set -e
+
+function fail()
+{
+    local error="$1"
+    echo "error: $error" >&2
+    exit 1
+}
+
+function fail_file()
+{
+    local file="$1" line="$2" error="$3"
+    fail "$file:$((line + 1)): $error"
+}
+
+function check_file()
+{
+    local file="$1" regexes=("${@:2}")
+    local lines
+    mapfile -t lines < "$file"
+    if (("${#lines[@]}" == 0)); then
+        return # empty file, no copyright needed
+    fi
+    local line
+    for line in "${!regexes[@]}"; do
+        eval '[[ "${lines[i]}" =~ '"${regexes[i]}"' ]]' ||
+            fail_file "$file" "$line" "doesn't match regex: ${regexes[i]}"
+    done
+}
+
+POUND_HEADER=('^"# SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"# See Notices.txt for copyright information"$')
+SLASH_HEADER=('^"// SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"// See Notices.txt for copyright information"$')
+MD_HEADER=('^"<!--"$' '^"SPDX-License-Identifier: LGPL-3.0-or-later"$' '^"See Notices.txt for copyright information"$')
+
+function main()
+{
+    local IFS=$'\n'
+    [[ -z "$(git status --porcelain)" ]] || fail "git repo is dirty"
+    local file
+    for file in $(git ls-tree --name-only --full-tree -r HEAD); do
+        case "/$file" in
+        /Cargo.lock)
+            # generated file
+            ;;
+        */LICENSE.md|*/Notices.txt)
+            # copyright file
+            ;;
+        /.forgejo/workflows/*.yml|*/.gitignore|*.toml|*.py)
+            check_file "$file" "${POUND_HEADER[@]}"
+            ;;
+        *.md)
+            check_file "$file" "${MD_HEADER[@]}"
+            ;;
+        *.sh)
+            check_file "$file" '^'\''#!'\' "${POUND_HEADER[@]}"
+            ;;
+        *.rs)
+            check_file "$file" "${SLASH_HEADER[@]}"
+            ;;
+        *)
+            fail_file "$file" 0 "unimplemented file kind -- you need to add it to $0"
+            ;;
+        esac
+    done
+}
+
+main
diff --git a/src/lib.rs b/src/lib.rs
index d0e7860..0ea6a19 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,3828 @@
-#[doc(hidden)]
-pub use std as __std;
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
 
-pub mod pdf;
-pub mod util;
+use crate::{
+    mupdf_ffi::{
+        MuPdfError, WriteMode, add_points, point_max_components, point_min_components,
+        transform_vector,
+    },
+    quad_tree::QuadTree,
+};
+use indexmap::IndexSet;
+use mupdf_sys::{fz_matrix, fz_point, fz_text_item};
+use non_nan_float::NonNaNF32;
+use std::{
+    backtrace::Backtrace,
+    cell::RefCell,
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
+    convert::Infallible,
+    fmt,
+    num::NonZero,
+    ops::ControlFlow,
+    rc::Rc,
+    sync::OnceLock,
+};
+
+mod mupdf_ffi;
+mod quad_tree;
+mod xml_tree;
+
+mod non_nan_float {
+    #[derive(Default, PartialEq, PartialOrd, Clone, Copy)]
+    pub(crate) struct NonNaNF32(f32);
+
+    impl std::fmt::Debug for NonNaNF32 {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl std::fmt::Display for NonNaNF32 {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl NonNaNF32 {
+        pub(crate) const fn new(v: f32) -> Option<Self> {
+            if v.is_nan() { None } else { Some(Self(v)) }
+        }
+        pub(crate) const fn get(self) -> f32 {
+            self.0
+        }
+        pub(crate) const fn min(self, other: Self) -> Self {
+            Self(self.0.min(other.0))
+        }
+        pub(crate) const fn max(self, other: Self) -> Self {
+            Self(self.0.max(other.0))
+        }
+    }
+
+    impl std::hash::Hash for NonNaNF32 {
+        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+            if self.0 == 0.0 { 0.0 } else { self.0 }
+                .to_bits()
+                .hash(state);
+        }
+    }
+
+    impl Eq for NonNaNF32 {}
+
+    impl Ord for NonNaNF32 {
+        fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+            self.partial_cmp(other).expect("known to be non-NaN")
+        }
+    }
+
+    impl std::ops::Neg for NonNaNF32 {
+        type Output = Self;
+
+        fn neg(self) -> Self::Output {
+            Self(-self.0)
+        }
+    }
+}
+
+const fn str_eq(a: &str, b: &str) -> bool {
+    let a = a.as_bytes();
+    let b = b.as_bytes();
+    if a.len() != b.len() {
+        return false;
+    }
+    let mut i = 0;
+    while i < a.len() {
+        if a[i] != b[i] {
+            return false;
+        }
+        i += 1;
+    }
+    true
+}
+
+macro_rules! make_enum_font {
+    (
+        enum $Font:ident {
+            #[other]
+            $Other:ident $other_body:tt,
+            $(#[group]
+            $KnownFontGroup:ident {
+                $(#[name_with_tag = $known_font_name_with_tag:literal, size = $known_font_size:literal]
+                $KnownFont:ident,)*
+            },)*
+        }
+    ) => {
+        #[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Clone)]
+        enum $Font {
+            $Other $other_body,
+            $($($KnownFont,)*)*
+        }
+
+        #[derive(Hash, PartialEq, Eq, PartialOrd, Ord, Debug, Copy, Clone)]
+        enum KnownFontGroup {
+            $($KnownFontGroup,)*
+        }
+
+        impl KnownFontGroup {
+            const fn fonts(self) -> &'static [Font] {
+                match self {
+                    $(Self::$KnownFontGroup => &[$(Font::$KnownFont,)*],)*
+                }
+            }
+            const INSN_CODE_FONT_GROUPS: &[Self] = &[Self::InsnCode, Self::InsnCodeSubscript];
+        }
+
+        impl $Font {
+            const fn extract_font_name_from_font_name_with_tag(font_name_with_tag: &str) -> &str {
+                if let [b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'A'..=b'Z',b'+',_,..] = font_name_with_tag.as_bytes() {
+                    font_name_with_tag.split_at(7).1
+                } else {
+                    panic!("invalid font name with id")
+                }
+            }
+            const fn known_from_name_with_tag(font_name_with_tag: &str, size: NonNaNF32) -> Option<Self> {
+                match size.get() {
+                    $($($known_font_size if str_eq(font_name_with_tag, $known_font_name_with_tag) => Some(Self::$KnownFont),)*)*
+                    _ => None,
+                }
+            }
+            const fn new_known(font_name: &str, size: NonNaNF32) -> Option<Self> {
+                match size.get() {
+                    $($($known_font_size if str_eq(font_name, const {
+                        Self::extract_font_name_from_font_name_with_tag($known_font_name_with_tag)
+                    }) => Some(Self::$KnownFont),)*)*
+                    _ => None,
+                }
+            }
+            #[allow(dead_code)]
+            fn new(font_name: &str, size: NonNaNF32) -> Self {
+                if let Some(v) = Self::new_known(font_name, size) {
+                    v
+                } else {
+                    Self::Other {
+                        font_name: Box::from(font_name),
+                        size,
+                    }
+                }
+            }
+            const fn size(&self) -> f32 {
+                match *self {
+                    Self::$Other { size, .. } => size.get(),
+                    $($(Self::$KnownFont => $known_font_size,)*)*
+                }
+            }
+            const fn font_name(&self) -> &str {
+                match self {
+                    Self::$Other { font_name, .. } => font_name,
+                    $($(Self::$KnownFont => const { Self::extract_font_name_from_font_name_with_tag($known_font_name_with_tag) },)*)*
+                }
+            }
+            const fn known_font_group(&self) -> Option<KnownFontGroup> {
+                match self {
+                    Self::$Other { .. } => None,
+                    $($(Self::$KnownFont => Some(KnownFontGroup::$KnownFontGroup),)*)*
+                }
+            }
+            const fn line_height(&self) -> f32 {
+                match self {
+                    Self::$Other { .. } => self.line_height_helper(),
+                    $($(Self::$KnownFont => const { Self::$KnownFont.line_height_helper() },)*)*
+                }
+            }
+        }
+
+        const _: () = {
+            $($(
+                let (known_font_name, known_font) = const {
+                    let known_font_name = Font::extract_font_name_from_font_name_with_tag($known_font_name_with_tag);
+                    (known_font_name, &Font::new_known(known_font_name, NonNaNF32::new($known_font_size).unwrap()).unwrap())
+                };
+                assert!(str_eq(known_font_name, known_font.font_name()));
+                assert!(matches!(known_font, Font::$KnownFont));
+            )*)*
+        };
+    };
+}
+
+make_enum_font! {
+    enum Font {
+        #[other]
+        Other {
+            font_name: Box<str>,
+            size: NonNaNF32,
+        },
+        #[group]
+        InsnHeader {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 9.963]
+            InsnHeader,
+        },
+        #[group]
+        RtlFnHeader {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 9.963]
+            RtlFnHeader,
+        },
+        #[group]
+        PageHeader {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 9.963]
+            PageHeader,
+        },
+        #[group]
+        PageFooter {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.981]
+            PageFooter,
+        },
+        #[group]
+        InsnDesc {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 8.966]
+            InsnDesc0,
+            #[name_with_tag = "FZTIYT+CMMI9", size = 8.966]
+            InsnDesc1,
+            #[name_with_tag = "ONUAYC+CMSSI9", size = 8.966]
+            InsnDesc2,
+            #[name_with_tag = "TNGBFZ+CMSY9", size = 8.966]
+            InsnDesc3,
+            #[name_with_tag = "WHMZPU+CMEX9", size = 8.966]
+            InsnDesc4,
+            #[name_with_tag = "ZJTMSG+CMSS9", size = 8.966]
+            InsnDesc5,
+        },
+        #[group]
+        InsnDescMisc {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 2.377]
+            InsnDescMisc0,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 2.561]
+            InsnDescMisc1,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.492]
+            InsnDescMisc2,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.641]
+            InsnDescMisc3,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.772]
+            InsnDescMisc4,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.864]
+            InsnDescMisc5,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 4.925]
+            InsnDescMisc6,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.097]
+            InsnDescMisc7,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.123]
+            InsnDescMisc8,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.131]
+            InsnDescMisc9,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.516]
+            InsnDescMisc10,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.604]
+            InsnDescMisc11,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.634]
+            InsnDescMisc12,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.906]
+            InsnDescMisc13,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.033]
+            InsnDescMisc14,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.068]
+            InsnDescMisc15,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.213]
+            InsnDescMisc16,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.238]
+            InsnDescMisc17,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.252]
+            InsnDescMisc18,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.962]
+            InsnDescMisc19,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 7.977]
+            InsnDescMisc20,
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 8.506]
+            InsnDescMisc21,
+        },
+        #[group]
+        InsnDescCode {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 6.974]
+            InsnDescCode,
+        },
+        #[group]
+        InsnDescCodeMisc {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 3.587]
+            InsnDescCodeMisc0,
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 4.483]
+            InsnDescCodeMisc1,
+        },
+        #[group]
+        InsnDescItalic {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 8.966]
+            InsnDescItalic,
+        },
+        #[group]
+        InsnDescBold {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.966]
+            InsnDescBold,
+        },
+        #[group]
+        InsnDescBoldItalic {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 8.966]
+            InsnDescBoldItalic,
+        },
+        #[group]
+        InsnDescSmall {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 7.97]
+            InsnDescSmall,
+        },
+        #[group]
+        InsnDescSmallItalic {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 7.97]
+            InsnDescSmallItalic,
+        },
+        #[group]
+        InsnDescSmallBold {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 7.97]
+            InsnDescSmallBold,
+        },
+        #[group]
+        InsnDescSmallBoldItalic {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 7.97]
+            InsnDescSmallBoldItalic,
+        },
+        #[group]
+        InsnDescBoldMisc {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.21]
+            InsnDescBoldMisc0,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.399]
+            InsnDescBoldMisc1,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.763]
+            InsnDescBoldMisc2,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.946]
+            InsnDescBoldMisc3,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.949]
+            InsnDescBoldMisc4,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 2.999]
+            InsnDescBoldMisc5,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.065]
+            InsnDescBoldMisc6,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.086]
+            InsnDescBoldMisc7,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.183]
+            InsnDescBoldMisc8,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.686]
+            InsnDescBoldMisc9,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.744]
+            InsnDescBoldMisc10,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.825]
+            InsnDescBoldMisc11,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.842]
+            InsnDescBoldMisc12,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.857]
+            InsnDescBoldMisc13,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 3.979]
+            InsnDescBoldMisc14,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.032]
+            InsnDescBoldMisc15,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.112]
+            InsnDescBoldMisc16,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.161]
+            InsnDescBoldMisc17,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.206]
+            InsnDescBoldMisc18,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.353]
+            InsnDescBoldMisc19,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.378]
+            InsnDescBoldMisc20,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.434]
+            InsnDescBoldMisc21,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.595]
+            InsnDescBoldMisc22,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.619]
+            InsnDescBoldMisc23,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.647]
+            InsnDescBoldMisc24,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.68]
+            InsnDescBoldMisc25,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.693]
+            InsnDescBoldMisc26,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.736]
+            InsnDescBoldMisc27,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.781]
+            InsnDescBoldMisc28,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.802]
+            InsnDescBoldMisc29,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 4.995]
+            InsnDescBoldMisc30,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.201]
+            InsnDescBoldMisc31,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.258]
+            InsnDescBoldMisc32,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.363]
+            InsnDescBoldMisc33,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.442]
+            InsnDescBoldMisc34,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.473]
+            InsnDescBoldMisc35,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.485]
+            InsnDescBoldMisc36,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.512]
+            InsnDescBoldMisc37,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.543]
+            InsnDescBoldMisc38,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.613]
+            InsnDescBoldMisc39,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.744]
+            InsnDescBoldMisc40,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.774]
+            InsnDescBoldMisc41,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.809]
+            InsnDescBoldMisc42,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.849]
+            InsnDescBoldMisc43,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.911]
+            InsnDescBoldMisc44,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.92]
+            InsnDescBoldMisc45,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.962]
+            InsnDescBoldMisc46,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.981]
+            InsnDescBoldMisc47,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.146]
+            InsnDescBoldMisc48,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.213]
+            InsnDescBoldMisc49,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.221]
+            InsnDescBoldMisc50,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.243]
+            InsnDescBoldMisc51,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.55]
+            InsnDescBoldMisc52,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.62]
+            InsnDescBoldMisc53,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.699]
+            InsnDescBoldMisc54,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.725]
+            InsnDescBoldMisc55,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.751]
+            InsnDescBoldMisc56,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.856]
+            InsnDescBoldMisc57,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.029]
+            InsnDescBoldMisc58,
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 8.406]
+            InsnDescBoldMisc59,
+        },
+        #[group]
+        InsnDescSubscript {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 5.978]
+            InsnDescSubscript,
+        },
+        #[group]
+        InsnDescBoldSubscript {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 5.978]
+            InsnDescBoldSubscript,
+        },
+        #[group]
+        InsnDescItalicSubscript {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 5.978]
+            InsnDescItalicSubscript,
+        },
+        #[group]
+        InsnDescBoldItalicSubscript {
+            #[name_with_tag = "YDJYQV+DejaVuSansCondensed-BoldOblique", size = 5.978]
+            InsnDescBoldItalicSubscript,
+        },
+        #[group]
+        InsnExtMnemonic {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 8.966]
+            InsnExtMnemonic,
+        },
+        #[group]
+        InsnCode {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 7.97]
+            InsnCode0,
+            #[name_with_tag = "RRFUNA+CMSY8", size = 7.97]
+            InsnCode1,
+            #[name_with_tag = "HPXOZC+CMSS8", size = 7.97]
+            InsnCode2,
+        },
+        #[group]
+        InsnCodeSubscript {
+            #[name_with_tag = "APUYSQ+zcoN-Regular", size = 5.978]
+            InsnCodeSubscript0,
+            #[name_with_tag = "DBQTKF+CMSY6", size = 5.978]
+            InsnCodeSubscript1,
+        },
+        #[group]
+        TitlePageBig {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 24.787]
+            TitlePageBig,
+        },
+        #[group]
+        TitlePageVersion {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 9.963]
+            TitlePageVersion,
+        },
+        #[group]
+        TitlePageTm {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 6.974]
+            TitlePageTm,
+        },
+        #[group]
+        TitlePageRev {
+            #[name_with_tag = "MJBFWM+DejaVuSansCondensed", size = 6.974]
+            TitlePageRev,
+        },
+        #[group]
+        TitlePageBook {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 20.663]
+            TitlePageBook,
+        },
+        #[group]
+        LegalPageItalic {
+            #[name_with_tag = "CGMSHV+DejaVuSansCondensed-Oblique", size = 9.963]
+            LegalPageItalic,
+        },
+        #[group]
+        ChangeSummaryPageBold {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 11.955]
+            ChangeSummaryPageBold,
+        },
+        #[group]
+        ChapterTitle {
+            #[name_with_tag = "NHUPPK+DejaVuSansCondensed-Bold", size = 17.215]
+            ChapterTitle,
+        },
+        #[group]
+        MathMisc {
+            #[name_with_tag = "AAJMKT+CMMI6", size = 5.978]
+            MathMisc0,
+            #[name_with_tag = "CUTMFD+CMSSI8", size = 5.978]
+            MathMisc1,
+            #[name_with_tag = "CUTMFD+CMSSI8", size = 7.97]
+            MathMisc2,
+            #[name_with_tag = "FZTIYT+CMMI9", size = 5.734]
+            MathMisc3,
+            #[name_with_tag = "FZTIYT+CMMI9", size = 7.168]
+            MathMisc4,
+            #[name_with_tag = "HONFQS+CMMI8", size = 7.97]
+            MathMisc5,
+            #[name_with_tag = "HPXOZC+CMSS8", size = 5.978]
+            MathMisc6,
+            #[name_with_tag = "LLVRDD+CMSY10", size = 11.955]
+            MathMisc7,
+            #[name_with_tag = "ZJTMSG+CMSS9", size = 7.168]
+            MathMisc8,
+        },
+    }
+}
+
+impl Font {
+    const fn space_width(&self) -> f32 {
+        self.size() * const { 3.985 / Font::InsnCode0.size() }
+    }
+    const fn line_height_helper(&self) -> f32 {
+        let font_name = self.font_name();
+        let mut i = 0;
+        while i < KnownFontGroup::INSN_CODE_FONT_GROUPS.len() {
+            let fonts = KnownFontGroup::INSN_CODE_FONT_GROUPS[i].fonts();
+            let mut j = 0;
+            while j < fonts.len() {
+                if str_eq(font_name, fonts[j].font_name()) {
+                    return 9.464 * self.size() / Font::InsnCode0.size();
+                }
+                j += 1;
+            }
+            i += 1;
+        }
+        let group = self.known_font_group();
+        if matches!(group, Some(KnownFontGroup::InsnDesc))
+            || str_eq(font_name, Font::InsnDesc0.font_name())
+            || str_eq(font_name, Font::InsnDescBold.font_name())
+            || str_eq(font_name, Font::InsnDescItalic.font_name())
+            || str_eq(font_name, Font::InsnDescBoldItalic.font_name())
+            || matches!(group, Some(KnownFontGroup::MathMisc))
+        {
+            return 10.959 * self.size() / Font::InsnDesc0.size();
+        }
+        panic!("no line height")
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct Char {
+    font: Font,
+    text: String,
+    min_x: NonNaNF32,
+    min_y: NonNaNF32,
+    max_x: NonNaNF32,
+    max_y: NonNaNF32,
+}
+
+impl Char {
+    #[allow(dead_code)]
+    fn width(&self) -> f32 {
+        self.max_x.get() - self.min_x.get()
+    }
+    #[allow(dead_code)]
+    fn height(&self) -> f32 {
+        self.max_y.get() - self.min_y.get()
+    }
+    fn top_down_left_to_right_sort_key(&self) -> impl Ord + use<> {
+        (-self.min_y, self.min_x)
+    }
+}
+
+const COLUMN_SPLIT_X: f32 = 300.0;
+const PAGE_BODY_MAX_X: f32 = 600.0;
+const PAGE_BODY_MIN_X: f32 = 50.0;
+const PAGE_BODY_MAX_Y: f32 = 780.0;
+const PAGE_BODY_MIN_Y: f32 = 45.0;
+const ONE_TITLE_LINE_SPLIT_Y: f32 = 734.0;
+const TWO_TITLE_LINES_SPLIT_Y: f32 = 715.0;
+const INSN_BIT_FIELDS_PREFIX_TEXT_TOP_PAD_HEIGHT: f32 = 29.938;
+const INSN_BIT_FIELDS_AFFIX_TEXT_TO_BOX_TOP_HEIGHT: f32 = 9.278;
+const INSN_BIT_FIELDS_PREFIX_BOX_BOTTOM_TO_SUFFIX_TEXT_HEIGHT: f32 = 20.971;
+const INSN_BIT_FIELDS_TOP_PAD_HEIGHT: f32 = 20.175;
+const INSN_BIT_FIELDS_TOP_PAD_HEIGHT2: f32 = 14.694;
+const INSN_BIT_FIELDS_BOX_HEIGHT: f32 = 22.317;
+#[allow(dead_code)]
+const INSN_SP_REGS_ALTERED_REGISTER_COLUMN_X: f32 = 34.405;
+const INSN_SP_REGS_ALTERED_FIELDS_COLUMN_X: f32 = 86.692;
+const INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X: f32 = 188.74;
+
+#[derive(Clone)]
+struct ParsedTextLine {
+    element: xml_tree::Element,
+    regular_min_y: f32,
+    regular_max_y: f32,
+    fonts: TextLineFonts,
+    chars: Vec<Char>,
+    preceding_blank_lines: u32,
+}
+
+impl ParsedTextLine {
+    #[allow(dead_code)]
+    fn regular_height(&self) -> f32 {
+        self.regular_max_y - self.regular_min_y
+    }
+    fn get_header_text(&self) -> Option<String> {
+        assert_eq!(self.fonts, TextLineFonts::InsnDescFonts);
+        if !self.element.text.trim().is_empty() {
+            return None;
+        }
+        if !self.element.tail.trim().is_empty() {
+            return None;
+        }
+        let [b] = &*self.element.children else {
+            return None;
+        };
+        if b.tag.normal() != Some("b") {
+            return None;
+        }
+        if b.children.len() != 0 {
+            return None;
+        }
+        let text = self.element.inner_text();
+        // should also check titlecase, but rust doesn't include that in std
+        if text.ends_with(":") && text.chars().next().is_some_and(|ch| ch.is_uppercase()) {
+            Some(text)
+        } else {
+            None
+        }
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element, trailing_nl: bool) {
+        for _ in 0..self.preceding_blank_lines {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+        if let Some(last_child) = parent.children.last_mut() {
+            last_child.tail += &self.element.text;
+        } else {
+            parent.text += &self.element.text;
+        }
+        parent.children.extend_from_slice(&self.element.children);
+        if trailing_nl {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+    }
+    fn write_xml_lines(
+        lines: impl IntoIterator<Item: std::borrow::Borrow<ParsedTextLine>>,
+        parent: &mut xml_tree::Element,
+        trailing_nl: bool,
+        preceding_nl: bool,
+    ) {
+        if preceding_nl {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+        let mut first = true;
+        for line in lines {
+            let line = std::borrow::Borrow::borrow(&line);
+            if first {
+                first = false;
+            } else {
+                parent.sub_element("br".into(), []).tail = "\n".into();
+            }
+            line.write_xml(parent, false);
+        }
+        if trailing_nl {
+            parent.sub_element("br".into(), []).tail = "\n".into();
+        }
+    }
+}
+
+impl fmt::Debug for ParsedTextLine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            element,
+            regular_min_y,
+            regular_max_y,
+            fonts,
+            chars,
+            preceding_blank_lines,
+        } = self;
+        f.debug_struct("ParsedTextLine")
+            .field("element", &format_args!("{element}"))
+            .field("regular_min_y", regular_min_y)
+            .field("regular_max_y", regular_max_y)
+            .field("fonts", fonts)
+            .field("chars", chars)
+            .field("preceding_blank_lines", preceding_blank_lines)
+            .finish()
+    }
+}
+
+impl fmt::Display for ParsedTextLine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for _ in 0..self.preceding_blank_lines {
+            f.write_str("\n")?;
+        }
+        self.element.fmt(f)
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+enum BaselinePos {
+    Above,
+    Below,
+}
+
+macro_rules! make_enum_with_values {
+    (
+        $(#[$enum_meta:meta])*
+        enum $Enum:ident {
+            $($Variant:ident,)*
+        }
+    ) => {
+        $(#[$enum_meta])*
+        enum $Enum {
+            $($Variant,)*
+        }
+
+        impl $Enum {
+            const VALUES: &[Self] = &[$(Self::$Variant,)*];
+        }
+    };
+}
+
+make_enum_with_values! {
+    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+    enum TextLineFonts {
+        InsnMnemonicFonts,
+        InsnHeaderFonts,
+        InsnBitFieldBitNumberFonts,
+        InsnBitFieldNameFonts,
+        InsnBitFieldsAffixTitleFonts,
+        InsnCodeFonts,
+        InsnDescFonts,
+    }
+}
+
+impl TextLineFonts {
+    fn regular(self) -> &'static [Font] {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => KnownFontGroup::InsnDesc.fonts(),
+            TextLineFonts::InsnHeaderFonts => &[Font::InsnHeader],
+            TextLineFonts::InsnBitFieldBitNumberFonts => &[Font::InsnDescSmall, Font::TitlePageRev],
+            TextLineFonts::InsnBitFieldNameFonts => KnownFontGroup::InsnDesc.fonts(),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => &[Font::InsnDescSmall],
+            TextLineFonts::InsnCodeFonts => KnownFontGroup::InsnCode.fonts(),
+            TextLineFonts::InsnDescFonts => {
+                static FONTS: OnceLock<Box<[Font]>> = OnceLock::new();
+                FONTS.get_or_init(|| {
+                    Box::from_iter(
+                        KnownFontGroup::InsnDesc
+                            .fonts()
+                            .iter()
+                            .cloned()
+                            .chain([Font::InsnDescSmall]),
+                    )
+                })
+            }
+        }
+    }
+    fn italic(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => {
+                Some(&[Font::InsnDescItalic, Font::InsnDescSmallItalic])
+            }
+        }
+    }
+    fn bold(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => Some(&[Font::InsnDescSmallBold]),
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescBold, Font::InsnDescSmallBold]),
+        }
+    }
+    fn bold_italic(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => {
+                Some(&[Font::InsnDescBoldItalic, Font::InsnDescSmallBoldItalic])
+            }
+        }
+    }
+    fn subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => Some(&[Font::InsnDescSubscript]),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => Some(KnownFontGroup::InsnCodeSubscript.fonts()),
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescSubscript]),
+        }
+    }
+    fn bold_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescBoldSubscript]),
+        }
+    }
+    fn italic_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescItalicSubscript]),
+        }
+    }
+    fn bold_italic_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescBoldItalicSubscript]),
+        }
+    }
+    fn code(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(&[Font::InsnDescCode, Font::InsnExtMnemonic]),
+        }
+    }
+    fn code_subscript(self) -> Option<&'static [Font]> {
+        match self {
+            TextLineFonts::InsnMnemonicFonts => None,
+            TextLineFonts::InsnHeaderFonts => None,
+            TextLineFonts::InsnBitFieldBitNumberFonts => None,
+            TextLineFonts::InsnBitFieldNameFonts => None,
+            TextLineFonts::InsnBitFieldsAffixTitleFonts => None,
+            TextLineFonts::InsnCodeFonts => None,
+            TextLineFonts::InsnDescFonts => Some(KnownFontGroup::InsnCodeSubscript.fonts()),
+        }
+    }
+    fn get_fonts(
+        self,
+        part_kind: TextLineFontKind,
+    ) -> Option<(&'static [Font], Option<BaselinePos>)> {
+        let fonts = match part_kind {
+            TextLineFontKind::Regular => self.regular(),
+            TextLineFontKind::Italic => self.italic()?,
+            TextLineFontKind::Bold => self.bold()?,
+            TextLineFontKind::BoldItalic => self.bold_italic()?,
+            TextLineFontKind::Subscript => self.subscript()?,
+            TextLineFontKind::Superscript => self.subscript()?,
+            TextLineFontKind::BoldSubscript => self.bold_subscript()?,
+            TextLineFontKind::BoldSuperscript => self.bold_subscript()?,
+            TextLineFontKind::ItalicSubscript => self.italic_subscript()?,
+            TextLineFontKind::ItalicSuperscript => self.italic_subscript()?,
+            TextLineFontKind::BoldItalicSubscript => self.bold_italic_subscript()?,
+            TextLineFontKind::BoldItalicSuperscript => self.bold_italic_subscript()?,
+            TextLineFontKind::Code => self.code()?,
+            TextLineFontKind::CodeSubscript => self.code_subscript()?,
+            TextLineFontKind::CodeSuperscript => self.code_subscript()?,
+        };
+        Some((fonts, part_kind.sub_super().baseline_pos()))
+    }
+    fn font_to_kind_map(self) -> &'static HashMap<(Font, Option<BaselinePos>), TextLineFontKind> {
+        static MAPS: OnceLock<
+            HashMap<TextLineFonts, HashMap<(Font, Option<BaselinePos>), TextLineFontKind>>,
+        > = OnceLock::new();
+        &MAPS.get_or_init(|| {
+            Self::VALUES
+                .iter()
+                .map(|&this: &TextLineFonts| {
+                    let mut map = HashMap::new();
+                    for &kind in TextLineFontKind::VALUES {
+                        let Some((fonts, baseline_pos)) = this.get_fonts(kind) else {
+                            continue;
+                        };
+                        for font in fonts {
+                            let old_kind = map.insert((font.clone(), baseline_pos), kind);
+                            assert!(
+                                old_kind.is_none(),
+                                "duplicate font: kind={kind:?} old_kind={old_kind:?} font={font:?}"
+                            );
+                        }
+                    }
+                    (this, map)
+                })
+                .collect()
+        })[&self]
+    }
+    fn fonts(self) -> &'static HashSet<Font> {
+        static SETS: OnceLock<HashMap<TextLineFonts, HashSet<Font>>> = OnceLock::new();
+        &SETS.get_or_init(|| {
+            Self::VALUES
+                .iter()
+                .map(|&this: &TextLineFonts| {
+                    let mut set = HashSet::new();
+                    for &kind in TextLineFontKind::VALUES {
+                        let Some((fonts, _baseline_pos)) = this.get_fonts(kind) else {
+                            continue;
+                        };
+                        set.extend(fonts.iter().cloned());
+                    }
+                    (this, set)
+                })
+                .collect()
+        })[&self]
+    }
+    fn get_kind(self, font: Font, baseline_pos: BaselinePos) -> Option<TextLineFontKind> {
+        let font_to_kind_map = self.font_to_kind_map();
+        font_to_kind_map
+            .get(&(font.clone(), Some(baseline_pos)))
+            .or_else(|| font_to_kind_map.get(&(font, None)))
+            .copied()
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantCode {
+    Code,
+    NotCode,
+}
+
+impl FontVariantCode {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::Code => &["code"],
+            Self::NotCode => &[],
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantBold {
+    Bold,
+    NotBold,
+}
+
+impl FontVariantBold {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::Bold => &["b"],
+            Self::NotBold => &[],
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantItalic {
+    Italic,
+    NotItalic,
+}
+
+impl FontVariantItalic {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::Italic => &["i"],
+            Self::NotItalic => &[],
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum FontVariantSubSuper {
+    NotSubSuper,
+    Subscript,
+    Superscript,
+}
+
+impl FontVariantSubSuper {
+    const fn value(self) -> &'static [&'static str] {
+        match self {
+            Self::NotSubSuper => &[],
+            Self::Subscript => &["sub"],
+            Self::Superscript => &["sup"],
+        }
+    }
+}
+
+impl FontVariantSubSuper {
+    fn baseline_pos(self) -> Option<BaselinePos> {
+        match self {
+            FontVariantSubSuper::NotSubSuper => None,
+            FontVariantSubSuper::Subscript => Some(BaselinePos::Below),
+            FontVariantSubSuper::Superscript => Some(BaselinePos::Above),
+        }
+    }
+}
+
+make_enum_with_values! {
+    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+    enum TextLineFontKind {
+        Regular,
+        Subscript,
+        Superscript,
+        Italic,
+        ItalicSubscript,
+        ItalicSuperscript,
+        Bold,
+        BoldSubscript,
+        BoldSuperscript,
+        BoldItalic,
+        BoldItalicSubscript,
+        BoldItalicSuperscript,
+        Code,
+        CodeSubscript,
+        CodeSuperscript,
+    }
+}
+
+impl TextLineFontKind {
+    fn code(self) -> FontVariantCode {
+        match self {
+            Self::Regular
+            | Self::Subscript
+            | Self::Superscript
+            | Self::Italic
+            | Self::ItalicSubscript
+            | Self::ItalicSuperscript
+            | Self::Bold
+            | Self::BoldSubscript
+            | Self::BoldSuperscript
+            | Self::BoldItalic
+            | Self::BoldItalicSubscript
+            | Self::BoldItalicSuperscript => FontVariantCode::NotCode,
+            Self::Code | Self::CodeSubscript | Self::CodeSuperscript => FontVariantCode::Code,
+        }
+    }
+    fn bold(self) -> FontVariantBold {
+        match self {
+            Self::Regular
+            | Self::Subscript
+            | Self::Superscript
+            | Self::Italic
+            | Self::ItalicSubscript
+            | Self::ItalicSuperscript => FontVariantBold::NotBold,
+            Self::Bold
+            | Self::BoldSubscript
+            | Self::BoldSuperscript
+            | Self::BoldItalic
+            | Self::BoldItalicSubscript
+            | Self::BoldItalicSuperscript => FontVariantBold::Bold,
+            Self::Code | Self::CodeSubscript | Self::CodeSuperscript => FontVariantBold::NotBold,
+        }
+    }
+    fn italic(self) -> FontVariantItalic {
+        match self {
+            Self::Regular | Self::Subscript | Self::Superscript => FontVariantItalic::NotItalic,
+            Self::Italic | Self::ItalicSubscript | Self::ItalicSuperscript => {
+                FontVariantItalic::Italic
+            }
+            Self::Bold | Self::BoldSubscript | Self::BoldSuperscript => {
+                FontVariantItalic::NotItalic
+            }
+            Self::BoldItalic | Self::BoldItalicSubscript | Self::BoldItalicSuperscript => {
+                FontVariantItalic::Italic
+            }
+            Self::Code | Self::CodeSubscript | Self::CodeSuperscript => {
+                FontVariantItalic::NotItalic
+            }
+        }
+    }
+    fn sub_super(self) -> FontVariantSubSuper {
+        match self {
+            Self::Regular => FontVariantSubSuper::NotSubSuper,
+            Self::Subscript => FontVariantSubSuper::Subscript,
+            Self::Superscript => FontVariantSubSuper::Superscript,
+            Self::Italic => FontVariantSubSuper::NotSubSuper,
+            Self::ItalicSubscript => FontVariantSubSuper::Subscript,
+            Self::ItalicSuperscript => FontVariantSubSuper::Superscript,
+            Self::Bold => FontVariantSubSuper::NotSubSuper,
+            Self::BoldSubscript => FontVariantSubSuper::Subscript,
+            Self::BoldSuperscript => FontVariantSubSuper::Superscript,
+            Self::BoldItalic => FontVariantSubSuper::NotSubSuper,
+            Self::BoldItalicSubscript => FontVariantSubSuper::Subscript,
+            Self::BoldItalicSuperscript => FontVariantSubSuper::Superscript,
+            Self::Code => FontVariantSubSuper::NotSubSuper,
+            Self::CodeSubscript => FontVariantSubSuper::Subscript,
+            Self::CodeSuperscript => FontVariantSubSuper::Superscript,
+        }
+    }
+    fn text_line_tags(self) -> impl Clone + Iterator<Item = &'static str> {
+        self.code()
+            .value()
+            .iter()
+            .copied()
+            .chain(self.bold().value().iter().copied())
+            .chain(self.italic().value().iter().copied())
+            .chain(self.sub_super().value().iter().copied())
+    }
+}
+
+#[derive(Debug)]
+struct ElementBodyBuilder<'a> {
+    containing_element: &'a mut xml_tree::Element,
+    stack: Vec<xml_tree::Element>,
+}
+
+impl<'a> ElementBodyBuilder<'a> {
+    fn new(containing_element: &'a mut xml_tree::Element) -> Self {
+        Self {
+            containing_element,
+            stack: Vec::with_capacity(5),
+        }
+    }
+    fn shrink_stack(&mut self, new_len: usize) {
+        while new_len < self.stack.len() {
+            let Some(element) = self.stack.pop() else {
+                unreachable!();
+            };
+            self.insert_point().children.push(element);
+        }
+    }
+    fn set_tag_stack<'b>(&mut self, tag_stack: impl IntoIterator<Item = &'b str>) {
+        let mut new_len = 0;
+        for (i, tag) in tag_stack.into_iter().enumerate() {
+            new_len = i + 1;
+            if i >= self.stack.len() {
+                self.stack.push(xml_tree::Element::new(tag.into(), []));
+            } else if self.stack[i].tag.normal() != Some(tag) {
+                self.shrink_stack(new_len);
+            }
+        }
+        self.shrink_stack(new_len);
+    }
+    fn write_text(&mut self, text: impl std::borrow::Borrow<str>) {
+        let text = std::borrow::Borrow::borrow(&text);
+        let insert_point = self.insert_point();
+        if let Some(child) = insert_point.children.last_mut() {
+            child.tail += text;
+        } else {
+            insert_point.text += text;
+        }
+    }
+    fn insert_point(&mut self) -> &mut xml_tree::Element {
+        self.stack.last_mut().unwrap_or(self.containing_element)
+    }
+    fn scope<R>(&mut self, f: impl FnOnce(&mut Self) -> R) -> R {
+        let retval = f(self);
+        self.flush();
+        retval
+    }
+    fn flush(&mut self) {
+        self.set_tag_stack([]);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitField {
+    box_min_x: f32,
+    box_max_x: f32,
+    name: ParsedTextLine,
+    bit_number: ParsedTextLine,
+}
+
+impl fmt::Display for InsnBitField {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            box_min_x,
+            box_max_x,
+            name,
+            bit_number,
+        } = self;
+        write!(
+            f,
+            "<InsnBitField: x={box_min_x}..{box_max_x} name={name} bit_number={bit_number}>"
+        )
+    }
+}
+
+impl InsnBitField {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let field = parent.sub_element("field".into(), []);
+        field.text = "\n".into();
+        field.tail = "\n".into();
+        let name = field.sub_element("name".into(), []);
+        name.tail = "\n".into();
+        self.name.write_xml(name, false);
+        let bit_number = field.sub_element("bit-number".into(), []);
+        bit_number.tail = "\n".into();
+        self.bit_number.write_xml(bit_number, false);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitFieldsPrefix {
+    box_min_x: f32,
+    box_min_y: f32,
+    box_max_x: f32,
+    box_max_y: f32,
+    prefix_text: ParsedTextLine,
+    fields: Vec<InsnBitField>,
+    suffix_text: ParsedTextLine,
+}
+
+impl fmt::Display for InsnBitFieldsPrefix {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            prefix_text,
+            fields,
+            suffix_text,
+        } = self;
+        writeln!(
+            f,
+            "<InsnBitFieldsPrefix: ({box_min_x},{box_min_y})..({box_max_x},{box_max_y})"
+        )?;
+        writeln!(f, "    prefix_text={prefix_text}")?;
+        writeln!(f, "    [")?;
+        for field in fields {
+            writeln!(f, "        {field},")?;
+        }
+        writeln!(f, "    ]")?;
+        write!(f, "    suffix_text={suffix_text}>")
+    }
+}
+
+impl InsnBitFieldsPrefix {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let prefix_elm = parent.sub_element("prefix".into(), []);
+        prefix_elm.text = "\n".into();
+        prefix_elm.tail = "\n".into();
+        let prefix_text = prefix_elm.sub_element("prefix-text".into(), []);
+        prefix_text.tail = "\n".into();
+        self.prefix_text.write_xml(prefix_text, false);
+        InsnBitFields::write_xml_fields(&self.fields, prefix_elm);
+        let suffix_text = prefix_elm.sub_element("suffix-text".into(), []);
+        suffix_text.tail = "\n".into();
+        self.suffix_text.write_xml(suffix_text, false);
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnBitFields {
+    prefix: Option<InsnBitFieldsPrefix>,
+    box_min_x: f32,
+    box_min_y: f32,
+    box_max_x: f32,
+    box_max_y: f32,
+    fields: Vec<InsnBitField>,
+}
+
+impl fmt::Display for InsnBitFields {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            prefix,
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            fields,
+        } = self;
+        if let Some(prefix) = prefix {
+            prefix.fmt(f)?;
+        }
+        writeln!(
+            f,
+            "<InsnBitFields: ({box_min_x},{box_min_y})..({box_max_x},{box_max_y}) ["
+        )?;
+        for field in fields {
+            writeln!(f, "    {field},")?;
+        }
+        write!(f, "]>")
+    }
+}
+
+impl InsnBitFields {
+    fn write_xml_fields(
+        fields: impl IntoIterator<Item: std::borrow::Borrow<InsnBitField>>,
+        parent: &mut xml_tree::Element,
+    ) {
+        let fields_elm = parent.sub_element("fields".into(), []);
+        fields_elm.text = "\n".into();
+        fields_elm.tail = "\n".into();
+        for field in fields {
+            std::borrow::Borrow::borrow(&field).write_xml(fields_elm);
+        }
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let bit_fields = parent.sub_element("bit-fields".into(), []);
+        bit_fields.text = "\n".into();
+        bit_fields.tail = "\n".into();
+        if let Some(prefix) = &self.prefix {
+            prefix.write_xml(bit_fields);
+        }
+        Self::write_xml_fields(&self.fields, bit_fields)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnSpRegsAlteredEntry {
+    reg: ParsedTextLine,
+    fields: Vec<ParsedTextLine>,
+    conds: Vec<ParsedTextLine>,
+}
+
+impl InsnSpRegsAlteredEntry {
+    fn display_fmt_with_indent(&self, f: &mut fmt::Formatter<'_>, indent: &str) -> fmt::Result {
+        let Self { reg, fields, conds } = self;
+        writeln!(f, "Entry(")?;
+        writeln!(f, "{indent}    reg={reg},")?;
+        write!(f, "{indent}    fields=")?;
+        if fields.is_empty() {
+            write!(f, "()")?;
+        } else {
+            writeln!(f, "(")?;
+            for field in fields {
+                writeln!(f, "{indent}        {field},")?;
+            }
+            write!(f, "{indent}    )")?;
+        }
+        writeln!(f, ",")?;
+        writeln!(f, "{indent}    conds=")?;
+        if conds.is_empty() {
+            write!(f, "()")?;
+        } else {
+            writeln!(f, "(")?;
+            for cond in conds {
+                writeln!(f, "{indent}        {cond},")?;
+            }
+            write!(f, "{indent}    )")?;
+        }
+        writeln!(f, ",")?;
+        write!(f, "{indent})")
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let entry = parent.sub_element("entry".into(), []);
+        entry.text = "\n".into();
+        entry.tail = "\n".into();
+        let reg = entry.sub_element("register".into(), []);
+        reg.tail = "\n".into();
+        self.reg.write_xml(reg, false);
+        let fields = entry.sub_element("fields".into(), []);
+        fields.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.fields, fields, false, false);
+        let conds = entry.sub_element("conditions".into(), []);
+        conds.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.conds, conds, false, false);
+    }
+}
+
+impl fmt::Display for InsnSpRegsAlteredEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display_fmt_with_indent(f, "")
+    }
+}
+
+#[derive(Clone, Debug)]
+struct InsnSpRegsAltered {
+    sp_regs_altered_text: ParsedTextLine,
+    special_text: Option<ParsedTextLine>,
+    table_header_reg: Option<ParsedTextLine>,
+    table_header_fields: Option<ParsedTextLine>,
+    entries: Vec<InsnSpRegsAlteredEntry>,
+    final_regular_min_y: f32,
+}
+
+impl fmt::Display for InsnSpRegsAltered {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            sp_regs_altered_text,
+            special_text,
+            table_header_reg,
+            table_header_fields,
+            entries,
+            final_regular_min_y,
+        } = self;
+        writeln!(f, "InsnSpRegsAltered(")?;
+        writeln!(f, "    sp_regs_altered_text={sp_regs_altered_text},")?;
+        if let Some(special_text) = special_text {
+            writeln!(f, "    special_text={special_text},")?;
+        }
+        if let Some(table_header_reg) = table_header_reg {
+            writeln!(f, "    table_header_reg={table_header_reg},")?;
+        }
+        if let Some(table_header_fields) = table_header_fields {
+            writeln!(f, "    table_header_fields={table_header_fields},")?;
+        }
+        if self.entries.is_empty() {
+            writeln!(f, "    entries=(),")?;
+        } else {
+            writeln!(f, "    entries=(")?;
+            for entry in entries {
+                write!(f, "        ")?;
+                entry.display_fmt_with_indent(f, "        ")?;
+                writeln!(f, ",")?;
+            }
+            writeln!(f, "    ),")?;
+        }
+        writeln!(f, "    final_regular_min_y={final_regular_min_y},")?;
+        write!(f, ")")
+    }
+}
+
+impl InsnSpRegsAltered {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let sp_regs_altered = parent.sub_element("special-registers-altered".into(), []);
+        sp_regs_altered.text = "\n".into();
+        sp_regs_altered.tail = "\n".into();
+        let title = sp_regs_altered.sub_element("title".into(), []);
+        title.tail = "\n".into();
+        self.sp_regs_altered_text.write_xml(title, false);
+        if let Some(special_text) = &self.special_text {
+            let special_text_el = sp_regs_altered.sub_element("special-text".into(), []);
+            special_text_el.tail = "\n".into();
+            special_text.write_xml(special_text_el, false);
+        }
+        if let Some(table_header_reg) = &self.table_header_reg {
+            let table_header_reg_el =
+                sp_regs_altered.sub_element("table-header-register".into(), []);
+            table_header_reg_el.tail = "\n".into();
+            table_header_reg.write_xml(table_header_reg_el, false);
+        }
+        if let Some(table_header_fields) = &self.table_header_fields {
+            let table_header_fields_el =
+                sp_regs_altered.sub_element("table-header-fields".into(), []);
+            table_header_fields_el.tail = "\n".into();
+            table_header_fields.write_xml(table_header_fields_el, false);
+        }
+        for entry in &self.entries {
+            entry.write_xml(sp_regs_altered);
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+enum InsnParseSection {
+    Code,
+    Header,
+    Desc,
+}
+
+#[derive(Clone, Debug)]
+enum PageItem {
+    Char(Char),
+    LineOrRect(LineOrRect),
+}
+
+#[derive(Copy, Clone, Debug)]
+enum LineOrRect {
+    Line(Line),
+    Rect(Rect),
+}
+
+impl LineOrRect {
+    fn width(self) -> f32 {
+        match self {
+            Self::Line(v) => v.width(),
+            Self::Rect(v) => v.width(),
+        }
+    }
+    #[allow(dead_code)]
+    fn height(self) -> f32 {
+        match self {
+            Self::Line(v) => v.height(),
+            Self::Rect(v) => v.height(),
+        }
+    }
+    fn min_x(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.min_x(),
+            Self::Rect(v) => v.min_x,
+        }
+    }
+    fn max_x(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.max_x(),
+            Self::Rect(v) => v.max_x,
+        }
+    }
+    fn min_y(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.min_y(),
+            Self::Rect(v) => v.min_y,
+        }
+    }
+    fn max_y(self) -> NonNaNF32 {
+        match self {
+            Self::Line(v) => v.max_y(),
+            Self::Rect(v) => v.max_y,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+struct Line {
+    p0_x: NonNaNF32,
+    p0_y: NonNaNF32,
+    p1_x: NonNaNF32,
+    p1_y: NonNaNF32,
+}
+
+impl Line {
+    fn width(self) -> f32 {
+        f32::abs(self.p0_x.get() - self.p1_x.get())
+    }
+    fn height(self) -> f32 {
+        f32::abs(self.p0_y.get() - self.p1_y.get())
+    }
+    fn min_x(self) -> NonNaNF32 {
+        self.p0_x.min(self.p1_x)
+    }
+    fn max_x(self) -> NonNaNF32 {
+        self.p0_x.max(self.p1_x)
+    }
+    fn min_y(self) -> NonNaNF32 {
+        self.p0_y.min(self.p1_y)
+    }
+    fn max_y(self) -> NonNaNF32 {
+        self.p0_y.max(self.p1_y)
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+struct Rect {
+    min_x: NonNaNF32,
+    max_x: NonNaNF32,
+    min_y: NonNaNF32,
+    max_y: NonNaNF32,
+}
+
+impl Rect {
+    fn width(self) -> f32 {
+        self.max_x.get() - self.min_x.get()
+    }
+    fn height(self) -> f32 {
+        self.max_y.get() - self.min_y.get()
+    }
+}
+
+#[derive(Debug)]
+struct Page {
+    page_num: u32,
+    qt: BTreeMap<TextSection, QuadTree<PageItem>>,
+    unprocessed_chars:
+        Rc<RefCell<BTreeMap<TextSection, Rc<RefCell<BTreeMap<Font, IndexSet<Char>>>>>>>,
+    #[allow(dead_code)]
+    unprocessed_non_text: Rc<RefCell<IndexSet<LineOrRect>>>,
+}
+
+struct Pages<'ctx> {
+    pages_gen: Option<Box<dyn Iterator<Item = Result<Page, Error>> + 'ctx>>,
+    pages: BTreeMap<u32, Rc<Page>>,
+    max_page_num: u32,
+}
+
+impl<'ctx> fmt::Debug for Pages<'ctx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            pages_gen,
+            pages,
+            max_page_num,
+        } = self;
+        f.debug_struct("Pages")
+            .field(
+                "pages_gen",
+                &pages_gen.is_some().then_some(format_args!("...")),
+            )
+            .field("pages", pages)
+            .field("max_page_num", max_page_num)
+            .finish()
+    }
+}
+
+impl<'ctx> Pages<'ctx> {
+    fn new(pages_gen: Option<Box<dyn Iterator<Item = Result<Page, Error>> + 'ctx>>) -> Self {
+        Self {
+            pages_gen,
+            pages: BTreeMap::new(),
+            max_page_num: 0,
+        }
+    }
+    fn close(&mut self) {
+        self.pages_gen = None;
+    }
+    fn is_past_end(&mut self, page_num: u32) -> Result<bool, Error> {
+        while self.pages_gen.is_some() && page_num > self.max_page_num {
+            self.fill_page()?;
+        }
+        Ok(page_num > self.max_page_num)
+    }
+    fn fill_page(&mut self) -> Result<bool, Error> {
+        let Some(pages_gen) = &mut self.pages_gen else {
+            return Ok(false);
+        };
+        let page = pages_gen.next();
+        let Some(page) = page else {
+            self.close();
+            return Ok(false);
+        };
+        let page = page?;
+        let page_num = page.page_num;
+        assert!(
+            page_num > self.max_page_num,
+            "page numbers must be a strictly-increasing positive integer sequence:\n\
+            got {page_num} which isn't more than {}",
+            self.max_page_num
+        );
+        self.pages.insert(page_num, Rc::new(page));
+        self.max_page_num = page_num;
+        Ok(true)
+    }
+    fn get(&mut self, page_num: u32) -> Result<Option<Rc<Page>>, Error> {
+        loop {
+            if let Some(page) = self.pages.get(&page_num) {
+                return Ok(Some(page.clone()));
+            }
+            if self.pages_gen.is_none() {
+                return Ok(None);
+            }
+            if page_num < self.max_page_num {
+                return Ok(None);
+            }
+            self.fill_page()?;
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct TextSection {
+    page_num: u32,
+    min_x: NonNaNF32,
+    min_y: NonNaNF32,
+    max_x: NonNaNF32,
+    max_y: NonNaNF32,
+}
+
+struct TextSectionPagesData {
+    columns_then_full_page: BTreeMap<u32, f32>,
+    full_page_then_columns: BTreeMap<u32, f32>,
+    one_title_line_then_columns_then_full_page: BTreeMap<u32, f32>,
+    two_title_lines_then_columns_then_full_page: BTreeMap<u32, f32>,
+    columns_then_columns: BTreeMap<u32, f32>,
+    one_title_line_then_columns_then_columns: BTreeMap<u32, f32>,
+    one_title_line_then_columns: BTreeSet<u32>,
+    two_title_lines_then_columns: BTreeSet<u32>,
+    full_page: BTreeSet<u32>,
+}
+
+impl TextSectionPagesData {
+    fn get() -> &'static Self {
+        static DATA: OnceLock<TextSectionPagesData> = OnceLock::new();
+        DATA.get_or_init(|| Self {
+            columns_then_full_page: FromIterator::from_iter([
+                (129, 438.992),
+                (241, 512.419),
+                (242, 408.077),
+                (243, 488.509),
+                (244, 437.518),
+                (245, 444.522),
+                (247, 352.082),
+                (248, 356.723),
+                (249, 365.944),
+                (251, 334.553),
+                (264, 184.67),
+                (296, 267.29),
+                (297, 200.043),
+                (298, 440.64),
+                (299, 197.356),
+                (300, 160.076),
+                (301, 364.924),
+                (303, 330.055),
+                (305, 344.867),
+                (306, 335.403),
+                (307, 336.897),
+                (308, 365.233),
+                (309, 364.735),
+            ]),
+            full_page_then_columns: FromIterator::from_iter([
+                (246, 689.039),
+                (250, 615.315),
+                (266, 678.088),
+            ]),
+            one_title_line_then_columns_then_full_page: FromIterator::from_iter([(128, 301.55)]),
+            two_title_lines_then_columns_then_full_page: FromIterator::from_iter([(304, 242.732)]),
+            columns_then_columns: FromIterator::from_iter([(79, 621.66), (126, 519.89)]),
+            one_title_line_then_columns_then_columns: FromIterator::from_iter([
+                (130, 550.43),
+                (162, 599.247),
+                (194, 622.161),
+                (196, 682.933),
+                (204, 613.195),
+                (215, 633.12),
+            ]),
+            one_title_line_then_columns: FromIterator::from_iter([
+                103, 104, 105, 121, 139, 143, 146, 151, 153, 158, 207, 213, 218,
+            ]),
+            two_title_lines_then_columns: FromIterator::from_iter([198, 206]),
+            full_page: FromIterator::from_iter(
+                [
+                    118, 157, 252, 254, 255, 257, 259, 260, 265, 268, 270, 271, 272,
+                ]
+                .into_iter()
+                .chain(274..286),
+            ),
+        })
+    }
+}
+
+impl TextSection {
+    fn first() -> TextSection {
+        Self::page_sections(1)[0]
+    }
+
+    fn next(self) -> TextSection {
+        let page_sections = Self::page_sections(self.page_num);
+        let Some(index) = page_sections.iter().position(|v| *v == self) else {
+            panic!("not a known TextSection: {self:?}");
+        };
+        if let Some(&retval) = page_sections.get(index + 1) {
+            return retval;
+        }
+        for page_num in self.page_num + 1..self.page_num + 100000 {
+            let page_sections = Self::page_sections(page_num);
+            if let Some(&retval) = page_sections.get(0) {
+                return retval;
+            }
+        }
+        panic!("can't find next TextSection after {self:?}")
+    }
+
+    fn new(page_num: u32, min_x: f32, min_y: f32, max_x: f32, max_y: f32) -> Self {
+        Self {
+            page_num,
+            min_x: NonNaNF32::new(min_x).expect("invalid min_x"),
+            min_y: NonNaNF32::new(min_y).expect("invalid min_y"),
+            max_x: NonNaNF32::new(max_x).expect("invalid max_x"),
+            max_y: NonNaNF32::new(max_y).expect("invalid max_y"),
+        }
+    }
+
+    fn left_column(page_num: u32, min_y: f32, max_y: f32) -> TextSection {
+        Self::new(page_num, PAGE_BODY_MIN_X, min_y, COLUMN_SPLIT_X, max_y)
+    }
+
+    fn right_column(page_num: u32, min_y: f32, max_y: f32) -> TextSection {
+        Self::new(page_num, COLUMN_SPLIT_X, min_y, PAGE_BODY_MAX_X, max_y)
+    }
+
+    fn columns(page_num: u32, min_y: f32, max_y: f32) -> [TextSection; 2] {
+        [
+            Self::left_column(page_num, min_y, max_y),
+            Self::right_column(page_num, min_y, max_y),
+        ]
+    }
+
+    fn full_page(page_num: u32, min_y: f32, max_y: f32) -> TextSection {
+        Self::new(page_num, PAGE_BODY_MIN_X, min_y, PAGE_BODY_MAX_X, max_y)
+    }
+
+    fn page_sections_helper(page_num: u32) -> Box<[TextSection]> {
+        let TextSectionPagesData {
+            columns_then_full_page,
+            full_page_then_columns,
+            one_title_line_then_columns_then_full_page,
+            two_title_lines_then_columns_then_full_page,
+            columns_then_columns,
+            one_title_line_then_columns_then_columns,
+            one_title_line_then_columns,
+            two_title_lines_then_columns,
+            full_page,
+        } = TextSectionPagesData::get();
+        if let Some(split_y) = columns_then_columns.get(&page_num) {
+            return Box::from_iter(
+                Self::columns(page_num, *split_y, PAGE_BODY_MAX_Y)
+                    .into_iter()
+                    .chain(Self::columns(page_num, PAGE_BODY_MIN_Y, *split_y)),
+            );
+        }
+        if one_title_line_then_columns.contains(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(
+                    page_num,
+                    PAGE_BODY_MIN_Y,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                )),
+            );
+        }
+        if full_page.contains(&page_num) {
+            return Box::new([Self::full_page(page_num, PAGE_BODY_MIN_Y, PAGE_BODY_MAX_Y)]);
+        }
+        if let Some(split_y) = one_title_line_then_columns_then_columns.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(page_num, *split_y, ONE_TITLE_LINE_SPLIT_Y))
+                .chain(Self::columns(page_num, PAGE_BODY_MIN_Y, *split_y)),
+            );
+        }
+        if two_title_lines_then_columns.contains(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    TWO_TITLE_LINES_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(
+                    page_num,
+                    PAGE_BODY_MIN_Y,
+                    TWO_TITLE_LINES_SPLIT_Y,
+                )),
+            );
+        }
+        if let Some(split_y) = columns_then_full_page.get(&page_num) {
+            return Box::from_iter(
+                Self::columns(page_num, *split_y, PAGE_BODY_MAX_Y)
+                    .into_iter()
+                    .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, *split_y)]),
+            );
+        }
+        if let Some(split_y) = full_page_then_columns.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(page_num, *split_y, PAGE_BODY_MAX_Y)]
+                    .into_iter()
+                    .chain(Self::columns(page_num, PAGE_BODY_MIN_Y, *split_y)),
+            );
+        }
+        if let Some(split_y) = one_title_line_then_columns_then_full_page.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    ONE_TITLE_LINE_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(page_num, *split_y, ONE_TITLE_LINE_SPLIT_Y))
+                .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, *split_y)]),
+            );
+        }
+        if let Some(split_y) = two_title_lines_then_columns_then_full_page.get(&page_num) {
+            return Box::from_iter(
+                [Self::full_page(
+                    page_num,
+                    TWO_TITLE_LINES_SPLIT_Y,
+                    PAGE_BODY_MAX_Y,
+                )]
+                .into_iter()
+                .chain(Self::columns(page_num, *split_y, TWO_TITLE_LINES_SPLIT_Y))
+                .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, *split_y)]),
+            );
+        }
+        if page_num == 263 {
+            return Box::from_iter(
+                [Self::full_page(page_num, 699.997, PAGE_BODY_MAX_Y)]
+                    .into_iter()
+                    .chain(Self::columns(page_num, 366.396, 699.997))
+                    .chain(Self::columns(page_num, 207.0, 366.396))
+                    .chain([Self::full_page(page_num, PAGE_BODY_MIN_Y, 207.0)]),
+            );
+        }
+        // TODO: checked up to page 309 (page named 273)
+        Box::new(Self::columns(page_num, PAGE_BODY_MIN_Y, PAGE_BODY_MAX_Y))
+    }
+    fn page_sections(page_num: u32) -> &'static [TextSection] {
+        static CACHE: [OnceLock<Box<[TextSection]>>; 2000] = [const { OnceLock::new() }; _];
+        CACHE
+            .get(page_num as usize)
+            .expect("page_num out of range")
+            .get_or_init(|| Self::page_sections_helper(page_num))
+    }
+    fn for_position(page_num: u32, x: f32, y: f32) -> Option<Self> {
+        for &i in Self::page_sections(page_num) {
+            if i.min_x.get() <= x && x <= i.max_x.get() && i.min_y.get() <= y && y <= i.max_y.get()
+            {
+                return Some(i);
+            }
+        }
+        None
+    }
+}
+
+#[derive(Debug, Clone)]
+struct InsnHeader {
+    header_lines: Vec<ParsedTextLine>,
+    mnemonic_lines: Vec<ParsedTextLine>,
+    bit_fields: InsnBitFields,
+}
+
+impl InsnHeader {
+    fn min_y(&self) -> f32 {
+        self.bit_fields.box_min_y
+    }
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let header = parent.sub_element("header".into(), []);
+        header.text = "\n".into();
+        header.tail = "\n".into();
+        let title = header.sub_element("title".into(), []);
+        title.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.header_lines, title, false, false);
+        let mnemonics = header.sub_element("mnemonics".into(), []);
+        mnemonics.tail = "\n".into();
+        ParsedTextLine::write_xml_lines(&self.mnemonic_lines, mnemonics, false, false);
+        self.bit_fields.write_xml(header);
+    }
+}
+
+#[derive(Debug, Clone)]
+struct Insn {
+    headers: Vec<InsnHeader>,
+    code_lines: Vec<ParsedTextLine>,
+    desc_lines: Vec<ParsedTextLine>,
+    sp_regs_altered: Option<InsnSpRegsAltered>,
+}
+
+impl Insn {
+    fn write_xml(&self, parent: &mut xml_tree::Element) {
+        let insn = parent.sub_element("instruction".into(), []);
+        insn.text = "\n".into();
+        insn.tail = "\n".into();
+        for header in &self.headers {
+            header.write_xml(insn);
+        }
+        if !self.code_lines.is_empty() {
+            let code = insn.sub_element("code".into(), []);
+            code.tail = "\n".into();
+            ParsedTextLine::write_xml_lines(&self.code_lines, code, false, false);
+        }
+        if !self.desc_lines.is_empty() {
+            let desc = insn.sub_element("description".into(), []);
+            desc.tail = "\n".into();
+            ParsedTextLine::write_xml_lines(&self.desc_lines, desc, false, false);
+        }
+        if let Some(sp_regs_altered) = &self.sp_regs_altered {
+            sp_regs_altered.write_xml(insn);
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Parser<'ctx> {
+    pages: Pages<'ctx>,
+    text_section: TextSection,
+    insns: Vec<Insn>,
+}
+
+#[derive(Debug)]
+pub struct Error(String, Backtrace);
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.0)?;
+        f.write_str("\n")?;
+        fmt::Display::fmt(&self.1, f)
+    }
+}
+
+impl std::error::Error for Error {}
+
+trait IntoError: fmt::Display {}
+
+impl<T: IntoError> From<T> for Error {
+    fn from(value: T) -> Self {
+        Error(value.to_string(), Backtrace::capture())
+    }
+}
+
+impl IntoError for &'_ str {}
+impl IntoError for String {}
+impl IntoError for MuPdfError {}
+impl IntoError for std::ffi::NulError {}
+impl IntoError for std::num::ParseIntError {}
+impl IntoError for std::io::Error {}
+impl<T: fmt::Display> IntoError for ErrorWithNote<T> {}
+
+enum ExtractInsnsError {
+    InsnParseError(String, Backtrace),
+    PageParseError(String, Backtrace),
+    Other(Error),
+}
+
+impl fmt::Display for ExtractInsnsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let backtrace = match self {
+            ExtractInsnsError::InsnParseError(msg, backtrace) => {
+                writeln!(f, "instruction parse error: {msg}")?;
+                backtrace
+            }
+            ExtractInsnsError::PageParseError(msg, backtrace) => {
+                writeln!(f, "page parse error: {msg}")?;
+                backtrace
+            }
+            ExtractInsnsError::Other(e) => return fmt::Display::fmt(&e, f),
+        };
+        backtrace.fmt(f)
+    }
+}
+
+#[derive(Clone, Debug)]
+struct ErrorWithNote<E> {
+    error: E,
+    note: String,
+}
+
+impl<E: fmt::Display> fmt::Display for ErrorWithNote<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self { error, note } = self;
+        fmt::Display::fmt(error, f)?;
+        write!(f, "\nnote: {note}")
+    }
+}
+
+impl<E: fmt::Display + fmt::Debug> std::error::Error for ErrorWithNote<E> {}
+
+impl<'ctx> Parser<'ctx> {
+    fn new() -> Self {
+        Self {
+            pages: Pages::new(None),
+            text_section: TextSection::first(),
+            insns: Vec::new(),
+        }
+    }
+    fn page(&mut self) -> Result<Rc<Page>, Error> {
+        Ok(self
+            .pages
+            .get(self.text_section.page_num)?
+            .ok_or("page_num is out of range")?)
+    }
+    fn unprocessed_chars(&mut self) -> Result<Rc<RefCell<BTreeMap<Font, IndexSet<Char>>>>, Error> {
+        Ok(self
+            .page()?
+            .unprocessed_chars
+            .borrow_mut()
+            .entry(self.text_section)
+            .or_default()
+            .clone())
+    }
+    fn pages_gen(
+        ctx: impl Into<mupdf_ffi::ContextRef<'ctx>>,
+        file: &str,
+        page_numbers: Option<Vec<NonZero<u32>>>,
+        dump_mupdf_page_xml: bool,
+    ) -> Result<Box<dyn Iterator<Item = Result<Page, Error>> + 'ctx>, Error> {
+        let ctx = ctx.into();
+        let page_indexes = page_numbers.map(|page_numbers| {
+            let mut retval = Vec::from_iter(page_numbers.into_iter().map(|v| v.get() as usize - 1));
+            retval.sort();
+            retval
+        });
+        let document = mupdf_ffi::Document::open(ctx, &std::ffi::CString::new(file)?)?;
+        let page_count = document.page_count()?;
+        let page_indexes = page_indexes.unwrap_or_else(|| (0..page_count).collect());
+        let mut first_seen_fonts = BTreeMap::new();
+        Ok(Box::new(page_indexes.into_iter().map(move |page_index| {
+            let page_num = page_index as u32 + 1;
+            println!("page {page_num}");
+            let page = document
+                .load_page(page_index)
+                .map_err(|e| format!("error reading pdf page {page_num}: {e}"))?;
+            Ok(
+                Page::from_mupdf_page(page_num, &page, &mut first_seen_fonts, dump_mupdf_page_xml)
+                    .map_err(|e| format!("error reading pdf page {page_num}: {e}"))?,
+            )
+        })))
+    }
+    fn parse_pdf<I: Iterator<Item = NonZero<u32>>>(
+        &mut self,
+        ctx: impl Into<mupdf_ffi::ContextRef<'ctx>>,
+        file: &str,
+        page_numbers: Option<I>,
+        dump_mupdf_page_xml: bool,
+    ) -> Result<(), Error> {
+        self.pages = Pages::new(Some(Self::pages_gen(
+            ctx,
+            file,
+            page_numbers.map(|v| v.into_iter().collect()),
+            dump_mupdf_page_xml,
+        )?));
+        self.text_section = TextSection::first();
+        loop {
+            self.text_section = self.text_section.next();
+            if self.pages.is_past_end(self.text_section.page_num)? {
+                return Ok(());
+            }
+            if self.pages.get(self.text_section.page_num)?.is_some() {
+                println!("section {:?}", self.text_section);
+                self.note_text_section(Self::parse_text_section)?;
+            }
+        }
+    }
+    fn note_text_section<E>(
+        &mut self,
+        f: impl FnOnce(&mut Self) -> Result<(), E>,
+    ) -> Result<(), ErrorWithNote<E>> {
+        let start_text_section = self.text_section;
+        match f(self) {
+            Ok(()) => Ok(()),
+            Err(error) => {
+                let note = if self.text_section == start_text_section {
+                    format!("text_section={:?}", self.text_section)
+                } else {
+                    format!(
+                        "start_text_section={start_text_section:?}\ntext_section={:?}",
+                        self.text_section
+                    )
+                };
+                Err(ErrorWithNote { error, note })
+            }
+        }
+    }
+    fn parse_text_section(&mut self) -> Result<(), ErrorWithNote<Error>> {
+        match self.note_text_section(Self::extract_insns) {
+            Ok(()) => Ok(()),
+            Err(
+                e @ ErrorWithNote {
+                    error:
+                        ExtractInsnsError::InsnParseError(..) | ExtractInsnsError::PageParseError(..),
+                    ..
+                },
+            ) => {
+                println!("{e}");
+                Ok(())
+            }
+            Err(ErrorWithNote {
+                error: ExtractInsnsError::Other(error),
+                note,
+            }) => Err(ErrorWithNote { error, note }),
+        }
+    }
+    fn find_top_left_char_in_range(
+        &mut self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        allow_processed: bool,
+    ) -> Result<Option<Char>, Error> {
+        let mut retval = None;
+        let page = self.page()?;
+        let unprocessed_chars = self.unprocessed_chars()?;
+        let ControlFlow::<Infallible>::Continue(()) =
+            page.qt[&self.text_section].range(min_x, max_x, min_y, max_y, |_x, _y, ch| {
+                let PageItem::Char(ch) = ch else {
+                    return ControlFlow::Continue(());
+                };
+                if !allow_processed && !RefCell::borrow(&*unprocessed_chars)[&ch.font].contains(ch)
+                {
+                    return ControlFlow::Continue(());
+                }
+                match &mut retval {
+                    None => retval = Some(ch.clone()),
+                    Some(retval)
+                        if ch.min_x.get() - ch.min_y.get()
+                            < retval.min_x.get() - retval.min_y.get() =>
+                    {
+                        *retval = ch.clone();
+                    }
+                    Some(_) => {}
+                }
+                ControlFlow::Continue(())
+            });
+        Ok(retval)
+    }
+    fn extract_text_line(
+        &mut self,
+        start_char: Option<Char>,
+        mut start_min_y: f32,
+        min_x: f32,
+        max_x: f32,
+        fonts: TextLineFonts,
+        preceding_blank_lines: u32,
+        mut skip_initial_spaces: bool,
+        allowed_start_min_y_error: Option<f32>,
+    ) -> Result<Option<ParsedTextLine>, ExtractInsnsError> {
+        let mut chars: Vec<Char> = Vec::new();
+        let mut chars_set: IndexSet<Char> = IndexSet::new();
+        if let Some(start_char) = start_char.clone() {
+            chars.push(start_char.clone());
+            chars_set.insert(start_char);
+        }
+        if let Some(start_char) = start_char
+            && start_char.text == "*"
+            && self.text_section.page_num == 168
+            && fonts
+                .subscript()
+                .is_some_and(|v| v.contains(&start_char.font))
+        {
+            start_min_y = start_char.max_y.get() - fonts.regular()[0].size();
+        }
+        let page = self.page().map_err(ExtractInsnsError::Other)?;
+        let unprocessed_chars = self.unprocessed_chars().map_err(ExtractInsnsError::Other)?;
+        let ControlFlow::<Infallible>::Continue(()) = page.qt[&self.text_section].range(
+            min_x - fonts.regular()[0].size() * 0.5,
+            max_x,
+            start_min_y - fonts.regular()[0].size() * 0.4,
+            start_min_y + fonts.regular()[0].size() * 0.6,
+            |_x, _y, ch| {
+                let PageItem::Char(ch) = ch else {
+                    return ControlFlow::Continue(());
+                };
+                if !RefCell::borrow(&*unprocessed_chars)[&ch.font].contains(ch)
+                    || chars_set.contains(ch)
+                {
+                    return ControlFlow::Continue(());
+                }
+                chars_set.insert(ch.clone());
+                chars.push(ch.clone());
+                ControlFlow::Continue(())
+            },
+        );
+        if chars.is_empty() {
+            return Ok(None);
+        }
+        chars.sort_by(|a, b| (a.min_x, &a.text).cmp(&(b.min_x, &b.text)));
+        let mut regular_min_y = chars[0].min_y.get();
+        let mut regular_max_y = chars[0].max_y.get();
+        for ch in &chars {
+            let Some(kind) = fonts.get_kind(ch.font.clone(), BaselinePos::Below) else {
+                continue;
+            };
+            if kind.sub_super() == FontVariantSubSuper::NotSubSuper {
+                regular_min_y = ch.min_y.get();
+                regular_max_y = ch.max_y.get();
+                break;
+            }
+        }
+        let mut retval = ParsedTextLine {
+            element: xml_tree::Element::new("text-line".into(), []),
+            regular_min_y,
+            regular_max_y,
+            fonts,
+            chars,
+            preceding_blank_lines,
+        };
+        let mut text_and_tag_stacks: Vec<(String, Vec<&str>)> = Vec::new();
+        let mut last_max_x = min_x;
+        let mut last_kind = None;
+        let mut last_char: Option<Char> = None;
+        for ch in &retval.chars {
+            let baseline_pos = if (ch.max_y.get() + ch.min_y.get()) * 0.5
+                > (retval.regular_max_y + retval.regular_min_y) * 0.5
+            {
+                BaselinePos::Above
+            } else {
+                BaselinePos::Below
+            };
+            let Some(kind) = fonts.get_kind(ch.font.clone(), baseline_pos) else {
+                println!(
+                    "font kind is None:\n\
+                    regular_min_y={}\n\
+                    fonts={fonts:?}\n\
+                    ch={ch:?}\n\
+                    baseline_pos={baseline_pos:?}\n\
+                    chars[0]={:?}",
+                    retval.regular_min_y, retval.chars[0],
+                );
+                return Ok(None);
+            };
+            let space_kind = match last_kind {
+                None => kind,
+                Some(last_kind) if last_kind != kind => TextLineFontKind::Regular,
+                _ => kind,
+            };
+            let (space_fonts, _) = fonts
+                .get_fonts(space_kind)
+                .unwrap_or((fonts.regular(), None));
+            let space_width = ch.min_x.get() - last_max_x;
+            let space_count_f = space_width / space_fonts[0].space_width();
+            let mut space_count = space_count_f.round() as usize;
+            if space_count == 0 && space_count_f > 0.35 {
+                space_count = 1
+            }
+            if space_count_f > 0.25 && f32::abs(space_count as f32 - space_count_f) > 0.15 {
+                println!("spaces: space_count_f={space_count_f} space_width={space_width}");
+            }
+            if space_count > 0 && !skip_initial_spaces {
+                text_and_tag_stacks.push((
+                    " ".repeat(space_count),
+                    space_kind.text_line_tags().collect(),
+                ));
+            }
+            skip_initial_spaces = false;
+            if ch.text == "\u{0338}"
+                && let Some(last_char) = last_char
+                && last_char.text == "="
+                && f32::abs(ch.min_x.get() - last_char.min_x.get()) < 0.01
+                && f32::abs(ch.min_y.get() - last_char.min_y.get()) < 0.01
+            {
+                *text_and_tag_stacks
+                    .last_mut()
+                    .expect("known to be non-empty") = ("\u{2260}".into(), Vec::new());
+                last_max_x = last_char.max_x.get();
+            } else {
+                let char_text = match &*ch.text {
+                    "\u{fb00}" => "ff",
+                    "\u{fb01}" => "fi",
+                    "\u{fb02}" => "fl",
+                    "\u{fb03}" => "ffi",
+                    "\u{fb04}" => "ffl",
+                    v => v,
+                };
+                if char_text.chars().skip(1).next().is_some() {
+                    dbg!(&ch);
+                }
+                text_and_tag_stacks.push((char_text.into(), kind.text_line_tags().collect()));
+                last_max_x = ch.max_x.get();
+            }
+            last_kind = Some(kind);
+            last_char = Some(ch.clone());
+        }
+        ElementBodyBuilder::scope(
+            &mut ElementBodyBuilder::new(&mut retval.element),
+            |body_builder| {
+                for (text, tag_stack) in text_and_tag_stacks {
+                    body_builder.set_tag_stack(tag_stack);
+                    body_builder.write_text(text)
+                }
+            },
+        );
+        for ch in &retval.chars {
+            RefCell::borrow_mut(&*unprocessed_chars)
+                .get_mut(&ch.font)
+                .expect("known to exist")
+                .shift_remove(ch);
+        }
+        let allowed_start_min_y_error = allowed_start_min_y_error.unwrap_or(0.01);
+        if f32::abs(start_min_y - retval.regular_min_y) > allowed_start_min_y_error {
+            return Err(ExtractInsnsError::PageParseError(
+                format!(
+                    "start_min_y={start_min_y} regular_min_y={}\n\
+                start_min_y error: {}\n\
+                allowed_start_min_y_error={allowed_start_min_y_error}",
+                    retval.regular_min_y,
+                    start_min_y - retval.regular_min_y,
+                ),
+                Backtrace::capture(),
+            ));
+        }
+        Ok(Some(retval))
+    }
+    fn extract_following_text_lines(
+        &mut self,
+        first_text_line: ParsedTextLine,
+        min_x: f32,
+        max_x: f32,
+        allowed_start_min_y_error: Option<f32>,
+    ) -> Result<Vec<ParsedTextLine>, ExtractInsnsError> {
+        let mut retval = Vec::new();
+        let fonts = first_text_line.fonts;
+        let mut line = Some(first_text_line);
+        while let Some(cur_line) = line {
+            let start_min_y = cur_line.regular_min_y - fonts.regular()[0].line_height();
+            retval.push(cur_line);
+            line = self.extract_text_line(
+                None,
+                start_min_y,
+                min_x,
+                max_x,
+                fonts,
+                0,
+                false,
+                allowed_start_min_y_error,
+            )?;
+        }
+        return Ok(retval);
+    }
+    fn extract_insn_bit_fields(
+        &mut self,
+        mnemonic_lines: &[ParsedTextLine],
+    ) -> Result<Option<InsnBitFields>, ExtractInsnsError> {
+        let mut found_non_affix_line = false;
+        let [.., last_mnemonic_line] = mnemonic_lines else {
+            unreachable!();
+        };
+        let expected_non_affix_line_y = last_mnemonic_line.regular_min_y
+            - if mnemonic_lines.len() > 1 {
+                INSN_BIT_FIELDS_TOP_PAD_HEIGHT2
+            } else {
+                INSN_BIT_FIELDS_TOP_PAD_HEIGHT
+            };
+        let page = self.page().map_err(ExtractInsnsError::Other)?;
+        let _ = page.qt[&self.text_section].range(
+            self.text_section.min_x.get() - 5.0,
+            self.text_section.max_x.get() + 5.0,
+            expected_non_affix_line_y - 5.0,
+            expected_non_affix_line_y + 5.0,
+            |_x, _y, line| {
+                let PageItem::LineOrRect(LineOrRect::Line(line)) = line else {
+                    return ControlFlow::Continue(());
+                };
+                if line.width() > line.height() {
+                    found_non_affix_line = true;
+                    return ControlFlow::Break(());
+                }
+                ControlFlow::Continue(())
+            },
+        );
+        if found_non_affix_line {
+            return self.extract_insn_bit_fields_box(expected_non_affix_line_y);
+        };
+        let prefix_text = self.extract_text_line(
+            None,
+            last_mnemonic_line.regular_min_y - INSN_BIT_FIELDS_PREFIX_TEXT_TOP_PAD_HEIGHT,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts,
+            0,
+            true,
+            Some(2.0),
+        )?;
+        let Some(prefix_text) = prefix_text else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn prefix bit fields title".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let prefix_text_str = prefix_text.element.inner_text();
+        if prefix_text_str != "Prefix:" {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!("insn prefix bit fields title is not as expected: {prefix_text_str:?}"),
+                Backtrace::capture(),
+            ));
+        }
+        let prefix_bit_fields = self.extract_insn_bit_fields_box(
+            prefix_text.regular_min_y - INSN_BIT_FIELDS_AFFIX_TEXT_TO_BOX_TOP_HEIGHT,
+        )?;
+        let Some(prefix_bit_fields) = prefix_bit_fields else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn prefix bit fields".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let suffix_text = self.extract_text_line(
+            None,
+            prefix_bit_fields.box_min_y - INSN_BIT_FIELDS_PREFIX_BOX_BOTTOM_TO_SUFFIX_TEXT_HEIGHT,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnBitFieldsAffixTitleFonts,
+            0,
+            true,
+            Some(2.0),
+        )?;
+        let Some(suffix_text) = suffix_text else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn suffix bit fields title".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let suffix_text_str = suffix_text.element.inner_text();
+        if suffix_text_str != "Suffix:" {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!("insn suffix bit fields title is not as expected: {suffix_text_str:?}"),
+                Backtrace::capture(),
+            ));
+        }
+        let suffix_bit_fields = self.extract_insn_bit_fields_box(
+            suffix_text.regular_min_y - INSN_BIT_FIELDS_AFFIX_TEXT_TO_BOX_TOP_HEIGHT,
+        )?;
+        let Some(suffix_bit_fields) = suffix_bit_fields else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn suffix bit fields".into(),
+                Backtrace::capture(),
+            ));
+        };
+        return Ok(Some(InsnBitFields {
+            prefix: Some(InsnBitFieldsPrefix {
+                box_min_x: prefix_bit_fields.box_min_x,
+                box_min_y: prefix_bit_fields.box_min_y,
+                box_max_x: prefix_bit_fields.box_max_x,
+                box_max_y: prefix_bit_fields.box_max_y,
+                prefix_text: prefix_text,
+                fields: prefix_bit_fields.fields,
+                suffix_text: suffix_text,
+            }),
+            box_min_x: suffix_bit_fields.box_min_x,
+            box_min_y: suffix_bit_fields.box_min_y,
+            box_max_x: suffix_bit_fields.box_max_x,
+            box_max_y: suffix_bit_fields.box_max_y,
+            fields: suffix_bit_fields.fields,
+        }));
+    }
+    fn extract_insn_bit_fields_box(
+        &mut self,
+        expected_box_max_y: f32,
+    ) -> Result<Option<InsnBitFields>, ExtractInsnsError> {
+        let mut h_lines = Vec::new();
+        let mut v_lines = Vec::new();
+        let page = self.page().map_err(ExtractInsnsError::Other)?;
+        let ControlFlow::<Infallible>::Continue(()) = page.qt[&self.text_section].range(
+            self.text_section.min_x.get() - 5.0,
+            self.text_section.max_x.get() + 5.0,
+            expected_box_max_y - INSN_BIT_FIELDS_BOX_HEIGHT - 5.0,
+            expected_box_max_y + 5.0,
+            |_x, _y, line| {
+                let PageItem::LineOrRect(LineOrRect::Line(line)) = *line else {
+                    return ControlFlow::Continue(());
+                };
+                if line.width() > line.height() {
+                    h_lines.push(line);
+                } else {
+                    v_lines.push(line);
+                }
+                ControlFlow::Continue(())
+            },
+        );
+        h_lines.sort_by_key(|line| line.min_y());
+        v_lines.sort_by_key(|line| line.min_x());
+        for i in (0..v_lines.len().saturating_sub(1)).rev() {
+            if f32::abs(v_lines[i].min_x().get() - v_lines[i + 1].min_x().get()) < 0.5 {
+                v_lines.remove(i + 1); // remove duplicates
+            }
+        }
+        if h_lines.is_empty() && v_lines.is_empty() {
+            return Ok(None);
+        }
+        let [bottom_line, top_line] = &*h_lines else {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!(
+                    "instruction bit fields box has wrong number of horizontal lines:\n{h_lines:?}"
+                ),
+                Backtrace::capture(),
+            ));
+        };
+        let [leftmost_line, .., rightmost_line] = &*v_lines else {
+            return Err(ExtractInsnsError::InsnParseError(
+                format!("instruction bit fields box has too few vertical lines:\n{v_lines:?}"),
+                Backtrace::capture(),
+            ));
+        };
+        let box_min_x = leftmost_line.min_x().get();
+        let box_max_x = rightmost_line.min_x().get();
+        let box_min_y = bottom_line.min_y().get();
+        let box_max_y = top_line.max_y().get();
+        let box_mid_y = (box_min_y + box_max_y) * 0.5;
+        println!("bottom_line={bottom_line:?}");
+        println!("top_line={top_line:?}");
+        println!("{v_lines:?}");
+        let mut fields = Vec::new();
+        for i in 0..v_lines.len() - 1 {
+            let left_line = v_lines[i];
+            let right_line = v_lines[i + 1];
+            let field_box_min_x = left_line.max_x().get();
+            let field_box_max_x = right_line.min_x().get();
+            let bit_field_name_start_min_y = box_mid_y + 3.288;
+            let bit_field_name = self.extract_text_line(
+                None,
+                bit_field_name_start_min_y,
+                field_box_min_x,
+                field_box_max_x,
+                TextLineFonts::InsnBitFieldNameFonts,
+                0,
+                true,
+                Some(0.4),
+            )?;
+            let Some(bit_field_name) = bit_field_name else {
+                return Err(ExtractInsnsError::InsnParseError(
+                    format!(
+                        "instruction bit field name not found:\n\
+                start_min_y={bit_field_name_start_min_y} \
+                    field_box_min_x={field_box_min_x} \
+                    field_box_max_x={field_box_max_x}"
+                    ),
+                    Backtrace::capture(),
+                ));
+            };
+            let bit_field_number_start_min_y = box_min_y + 3.487;
+            let bit_number = self.extract_text_line(
+                None,
+                bit_field_number_start_min_y,
+                field_box_min_x,
+                field_box_max_x,
+                TextLineFonts::InsnBitFieldBitNumberFonts,
+                0,
+                true,
+                None,
+            )?;
+            let Some(bit_number) = bit_number else {
+                return Err(ExtractInsnsError::InsnParseError(
+                    format!(
+                        "instruction bit field bit number not found:\n\
+                    start_min_y={bit_field_number_start_min_y} \
+                    field_box_min_x={field_box_min_x} \
+                    field_box_max_x={field_box_max_x}"
+                    ),
+                    Backtrace::capture(),
+                ));
+            };
+            fields.push(InsnBitField {
+                box_min_x: field_box_min_x,
+                box_max_x: field_box_max_x,
+                name: bit_field_name,
+                bit_number: bit_number,
+            });
+        }
+        return Ok(Some(InsnBitFields {
+            prefix: None,
+            box_min_x,
+            box_min_y,
+            box_max_x,
+            box_max_y,
+            fields,
+        }));
+    }
+    fn extract_insn_header_mnemonics_and_bit_fields(
+        &mut self,
+        start_min_y: f32,
+        header_start_char: Option<Char>,
+    ) -> Result<Option<InsnHeader>, ExtractInsnsError> {
+        assert!(
+            header_start_char
+                .as_ref()
+                .is_none_or(|v| v.font == Font::InsnHeader)
+        );
+        let Some(header_line) = self.extract_text_line(
+            header_start_char,
+            start_min_y,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnHeaderFonts,
+            0,
+            true,
+            Some(6.0),
+        )?
+        else {
+            return Ok(None);
+        };
+        println!("found header line:\n{header_line}");
+        let header_lines = self.extract_following_text_lines(
+            header_line,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            Some(1.5),
+        )?;
+        println!("insn header lines:");
+        for header_line in &header_lines {
+            println!("{header_line}");
+        }
+        let [.., last_header_line] = &*header_lines else {
+            unreachable!();
+        };
+        let Some(mnemonic_start_char) = self
+            .find_top_left_char_in_range(
+                self.text_section.min_x.get() - 5.0,
+                self.text_section.max_x.get() + 5.0,
+                last_header_line.regular_min_y - 50.0,
+                last_header_line.regular_min_y - 5.0,
+                false,
+            )
+            .map_err(ExtractInsnsError::Other)?
+        else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn mnemonic text line".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let mnemonic_start_char_min_y = mnemonic_start_char.min_y.get();
+        let Some(mnemonic_line) = self.extract_text_line(
+            Some(mnemonic_start_char),
+            mnemonic_start_char_min_y,
+            self.text_section.min_x.get(),
+            self.text_section.max_x.get(),
+            TextLineFonts::InsnMnemonicFonts,
+            0,
+            true,
+            None,
+        )?
+        else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn mnemonic text line".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let mnemonic_line_first_char_min_x = mnemonic_line.chars[0].min_x.get();
+        let mnemonic_lines = self.extract_following_text_lines(
+            mnemonic_line,
+            mnemonic_line_first_char_min_x,
+            self.text_section.max_x.get(),
+            None,
+        )?;
+        println!("insn mnemonic lines:");
+        for mnemonic_line in &mnemonic_lines {
+            println!("{mnemonic_line}");
+        }
+        let Some(insn_bit_fields) = self.extract_insn_bit_fields(&mnemonic_lines)? else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find insn bit fields".into(),
+                Backtrace::capture(),
+            ));
+        };
+        println!("{insn_bit_fields}");
+        return Ok(Some(InsnHeader {
+            header_lines,
+            mnemonic_lines,
+            bit_fields: insn_bit_fields,
+        }));
+    }
+    fn extract_insn_sp_regs_altered(
+        &mut self,
+        mut sp_regs_altered_text: ParsedTextLine,
+    ) -> Result<InsnSpRegsAltered, ExtractInsnsError> {
+        sp_regs_altered_text.preceding_blank_lines = 0;
+        let fonts = TextLineFonts::InsnDescFonts;
+        let column_min_x = sp_regs_altered_text.chars[0].min_x.get();
+        let Some(table_header_reg_char) = self
+            .find_top_left_char_in_range(
+                column_min_x - 1.0,
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_COLUMN_X - 1.0,
+                sp_regs_altered_text.regular_min_y - 30.0,
+                sp_regs_altered_text.regular_min_y - 5.0,
+                false,
+            )
+            .map_err(ExtractInsnsError::Other)?
+        else {
+            return Err(ExtractInsnsError::InsnParseError(
+                "can't find special registers altered table's register-column's header".into(),
+                Backtrace::capture(),
+            ));
+        };
+        const KNOWN_SPECIAL_TEXTS: &[&str] = &[
+            "None",
+            "Dependent on the system service",
+            "See above.",
+            "See Table 5.1",
+        ];
+        match &*table_header_reg_char.text {
+            "R" => {}
+            text if KNOWN_SPECIAL_TEXTS.iter().any(|i| text == &i[..1]) => {
+                let start_min_y = table_header_reg_char.min_y.get();
+                let special_text = self.extract_text_line(
+                    Some(table_header_reg_char),
+                    start_min_y,
+                    column_min_x,
+                    self.text_section.max_x.get(),
+                    fonts,
+                    0,
+                    true,
+                    None,
+                )?;
+                let special_text = match special_text {
+                    Some(special_text)
+                        if KNOWN_SPECIAL_TEXTS.contains(&&*special_text.element.text) =>
+                    {
+                        special_text
+                    }
+                    _ => return Err(ExtractInsnsError::Other(
+                        format!(
+                            "can't find special-registers-altered special-text:\n{special_text:?}"
+                        )
+                        .into(),
+                    )),
+                };
+                let final_regular_min_y = special_text.regular_min_y;
+                return Ok(InsnSpRegsAltered {
+                    sp_regs_altered_text,
+                    special_text: Some(special_text),
+                    table_header_reg: None,
+                    table_header_fields: None,
+                    entries: vec![],
+                    final_regular_min_y,
+                });
+            }
+            text => {
+                return Err(ExtractInsnsError::InsnParseError(
+                    format!(
+                        "unknown special-registers-altered special-text start character: {text:?}"
+                    ),
+                    Backtrace::capture(),
+                ));
+            }
+        }
+        let Some(table_header_fields_char) = self
+            .find_top_left_char_in_range(
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_COLUMN_X - 10.0,
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X,
+                table_header_reg_char.min_y.get() - 5.0,
+                table_header_reg_char.min_y.get() + 5.0,
+                false,
+            )
+            .map_err(ExtractInsnsError::Other)?
+        else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's fields-column's header".into(),
+            ));
+        };
+        if table_header_fields_char.text != "F" {
+            return Err(ExtractInsnsError::Other(
+                format!(
+                    "can't find special registers altered table's fields-column's header:\n\
+            table_header_fields_char={table_header_fields_char:?}"
+                )
+                .into(),
+            ));
+        }
+        let columns_x_bounds = [
+            (
+                table_header_reg_char.min_x.get(),
+                table_header_fields_char.min_x.get() - 1.0,
+            ),
+            (
+                table_header_fields_char.min_x.get(),
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X,
+            ),
+            (
+                column_min_x + INSN_SP_REGS_ALTERED_FIELDS_CONDS_SPLIT_X,
+                self.text_section.max_x.get(),
+            ),
+        ];
+        let start_min_y = table_header_reg_char.min_y.get();
+        let Some(table_header_reg) = self.extract_text_line(
+            Some(table_header_reg_char),
+            start_min_y,
+            columns_x_bounds[0].0,
+            columns_x_bounds[0].1,
+            fonts,
+            0,
+            false,
+            None,
+        )?
+        else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's register-column's header".into(),
+            ));
+        };
+        let table_header_reg_text = table_header_reg.element.inner_text();
+        if table_header_reg_text != "Register" {
+            return Err(ExtractInsnsError::Other(
+                format!(
+                    "can't find special registers altered table's register-column's header:\n\
+            table_header_reg_text={table_header_reg_text:?}"
+                )
+                .into(),
+            ));
+        }
+        let start_min_y = table_header_fields_char.min_y.get();
+        let Some(table_header_fields) = self.extract_text_line(
+            Some(table_header_fields_char),
+            start_min_y,
+            columns_x_bounds[1].0,
+            columns_x_bounds[1].1,
+            fonts,
+            0,
+            false,
+            None,
+        )?
+        else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's fields-column's header".into(),
+            ));
+        };
+        let table_header_fields_text = table_header_fields.element.inner_text();
+        if table_header_fields_text != "Field(s)" {
+            return Err(ExtractInsnsError::Other(
+                format!(
+                    "can't find special registers altered table's fields-column's header:\n\
+                    table_header_fields_text={table_header_fields_text:?}"
+                )
+                .into(),
+            ));
+        }
+        let mut regular_min_y = table_header_reg.regular_min_y;
+        let mut entries = Vec::new();
+        let mut cur_reg = None;
+        let mut cur_fields = Vec::new();
+        let mut cur_conds = Vec::new();
+        loop {
+            let mut row = [None, None, None];
+            let mut next_regular_min_y = None;
+            for (i, (min_x, max_x)) in columns_x_bounds.into_iter().enumerate() {
+                row[i] = self.extract_text_line(
+                    None,
+                    regular_min_y - fonts.regular()[0].line_height(),
+                    min_x,
+                    max_x,
+                    fonts,
+                    0,
+                    true,
+                    Some(2.0),
+                )?;
+                if let Some(cell) = &row[i]
+                    && next_regular_min_y.is_none()
+                {
+                    next_regular_min_y = Some(cell.regular_min_y);
+                }
+            }
+            match next_regular_min_y {
+                Some(v) => regular_min_y = v,
+                None => break,
+            }
+            let [cur_reg_cell, cur_fields_cell, cur_conds_cell] = row;
+            if cur_reg_cell.is_none() {
+                if cur_reg.is_none() {
+                    return Err(ExtractInsnsError::Other(
+                        "can't find special registers altered table's first register".into(),
+                    ));
+                }
+                cur_fields.extend(cur_fields_cell);
+                cur_conds.extend(cur_conds_cell);
+                continue;
+            }
+            if let Some(cur_reg) = cur_reg {
+                entries.push(InsnSpRegsAlteredEntry {
+                    reg: cur_reg,
+                    fields: cur_fields,
+                    conds: cur_conds,
+                });
+                cur_fields = Vec::new();
+                cur_conds = Vec::new();
+            }
+            cur_reg = cur_reg_cell;
+            cur_fields.extend(cur_fields_cell);
+            cur_conds.extend(cur_conds_cell);
+        }
+        let Some(cur_reg) = cur_reg else {
+            return Err(ExtractInsnsError::Other(
+                "can't find special registers altered table's first register".into(),
+            ));
+        };
+        entries.push(InsnSpRegsAlteredEntry {
+            reg: cur_reg,
+            fields: cur_fields,
+            conds: cur_conds,
+        });
+        return Ok(InsnSpRegsAltered {
+            sp_regs_altered_text: sp_regs_altered_text,
+            special_text: None,
+            table_header_reg: Some(table_header_reg),
+            table_header_fields: Some(table_header_fields),
+            entries,
+            final_regular_min_y: regular_min_y,
+        });
+    }
+    fn extract_insn(&mut self, header_start_char: Char) -> Result<Insn, ExtractInsnsError> {
+        assert_eq!(header_start_char.font, Font::InsnHeader);
+        println!("{header_start_char:?}");
+        let Some(header) = self.extract_insn_header_mnemonics_and_bit_fields(
+            header_start_char.min_y.get(),
+            Some(header_start_char),
+        )?
+        else {
+            return Err(ExtractInsnsError::PageParseError(
+                "can't find header text line".into(),
+                Backtrace::capture(),
+            ));
+        };
+        let mut next_start_min_y = header.min_y() - 5.0;
+        let mut headers = vec![header];
+        let mut code_lines: Vec<ParsedTextLine> = Vec::new();
+        let mut desc_lines: Vec<ParsedTextLine> = Vec::new();
+        let mut sp_regs_altered = None;
+        loop {
+            let search_min_y = next_start_min_y - 70.0;
+            let Some(next_char) = self
+                .find_top_left_char_in_range(
+                    self.text_section.min_x.get() - 5.0,
+                    self.text_section.max_x.get() + 5.0,
+                    search_min_y.max(self.text_section.min_y.get()),
+                    next_start_min_y,
+                    false,
+                )
+                .map_err(ExtractInsnsError::Other)?
+            else {
+                if search_min_y <= self.text_section.min_y.get()
+                    && self
+                        .pages
+                        .get(self.text_section.next().page_num)
+                        .map_err(ExtractInsnsError::Other)?
+                        .is_some()
+                {
+                    // go to next section
+                    self.text_section = self.text_section.next();
+                    next_start_min_y = self.text_section.max_y.get();
+                    continue;
+                } else {
+                    return Err(ExtractInsnsError::InsnParseError(
+                        "can't find insn code or description text".into(),
+                        Backtrace::capture(),
+                    ));
+                }
+            };
+            let next_section = match &next_char.font {
+                font if TextLineFonts::InsnCodeFonts.fonts().contains(font) => {
+                    InsnParseSection::Code
+                }
+                font if TextLineFonts::InsnDescFonts.fonts().contains(font) => {
+                    InsnParseSection::Desc
+                }
+                Font::InsnHeader => InsnParseSection::Header,
+                font => {
+                    return Err(ExtractInsnsError::InsnParseError(
+                        format!("can't find insn code or description text\nfont={font:?}"),
+                        Backtrace::capture(),
+                    ));
+                }
+            };
+            match next_section {
+                InsnParseSection::Code => {
+                    if !desc_lines.is_empty() {
+                        break;
+                    }
+                    let start_min_y = next_char.min_y.get();
+                    let min_x = next_char.min_x.get();
+                    let Some(code_line) = self.extract_text_line(
+                        Some(next_char),
+                        start_min_y,
+                        min_x,
+                        self.text_section.max_x.get(),
+                        TextLineFonts::InsnCodeFonts,
+                        if code_lines.is_empty() { 0 } else { 1 },
+                        false,
+                        None,
+                    )?
+                    else {
+                        return Err(ExtractInsnsError::InsnParseError(
+                            "can't find insn code text line".into(),
+                            Backtrace::capture(),
+                        ));
+                    };
+                    let min_x = code_line.chars[0].min_x.get();
+                    let more_code_lines = self.extract_following_text_lines(
+                        code_line,
+                        min_x,
+                        self.text_section.max_x.get(),
+                        Some(0.05),
+                    )?;
+                    println!("more insn code lines:");
+                    for i in &more_code_lines {
+                        println!("{i}");
+                    }
+                    code_lines.extend(more_code_lines);
+                    let Some(last) = code_lines.last() else {
+                        unreachable!()
+                    };
+                    next_start_min_y = last.regular_min_y - 5.0;
+                }
+                InsnParseSection::Header => {
+                    if !(code_lines.is_empty() && desc_lines.is_empty()) {
+                        break;
+                    }
+                    let Some(header) = self.extract_insn_header_mnemonics_and_bit_fields(
+                        next_char.min_y.get(),
+                        Some(next_char),
+                    )?
+                    else {
+                        return Err(ExtractInsnsError::InsnParseError(
+                            "can't find header text line".into(),
+                            Backtrace::capture(),
+                        ));
+                    };
+                    next_start_min_y = header.min_y() - 5.0;
+                    headers.push(header);
+                }
+                InsnParseSection::Desc => {
+                    let start_min_y = next_char.min_y.get();
+                    let min_x = next_char.min_x.get();
+                    let Some(desc_line) = self.extract_text_line(
+                        Some(next_char),
+                        start_min_y,
+                        min_x,
+                        self.text_section.max_x.get(),
+                        TextLineFonts::InsnDescFonts,
+                        if desc_lines.is_empty() { 0 } else { 1 },
+                        false,
+                        Some(3.0),
+                    )?
+                    else {
+                        return Err(ExtractInsnsError::InsnParseError(
+                            "can't find insn desc text line".into(),
+                            Backtrace::capture(),
+                        ));
+                    };
+                    match desc_line.get_header_text() {
+                        None => {
+                            let min_x = desc_line.chars[0].min_x.get();
+                            let more_desc_lines = self.extract_following_text_lines(
+                                desc_line,
+                                min_x,
+                                self.text_section.max_x.get(),
+                                Some(3.5),
+                            )?;
+                            println!("more insn desc lines:");
+                            for i in &more_desc_lines {
+                                println!("{i}");
+                            }
+                            desc_lines.extend(more_desc_lines);
+                            next_start_min_y = desc_lines
+                                .last()
+                                .expect("known to be non-empty")
+                                .regular_min_y
+                                - 5.0;
+                        }
+                        Some(header_text) if header_text == "Special Registers Altered:" => {
+                            let new_sp_regs_altered =
+                                self.extract_insn_sp_regs_altered(desc_line)?;
+                            #[allow(unused_assignments)]
+                            {
+                                next_start_min_y = new_sp_regs_altered.final_regular_min_y;
+                            }
+                            sp_regs_altered = Some(new_sp_regs_altered);
+                            break;
+                        }
+                        Some(header_text) => {
+                            return Err(ExtractInsnsError::Other(
+                                format!("unhandled header text: {header_text:?}\n{desc_line}")
+                                    .into(),
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+        println!("insn code lines:");
+        for i in &code_lines {
+            println!("{i}");
+        }
+        println!("insn desc lines:");
+        for i in &desc_lines {
+            println!("{i}");
+        }
+        println!("sp_regs_altered:");
+        println!("{sp_regs_altered:?}");
+        // TODO: finish
+        return Ok(Insn {
+            headers,
+            code_lines,
+            desc_lines,
+            sp_regs_altered,
+        });
+    }
+    fn extract_insns(&mut self) -> Result<(), ExtractInsnsError> {
+        loop {
+            let Some(header_start_char) =
+                RefCell::borrow(&*self.unprocessed_chars().map_err(ExtractInsnsError::Other)?)
+                    .get(&Font::InsnHeader)
+                    .and_then(|v| v.first().cloned())
+            else {
+                return Ok(());
+            };
+            let insn = self.extract_insn(header_start_char)?;
+            self.insns.push(insn);
+        }
+    }
+}
+
+#[derive(Debug)]
+struct MyDevice<'a> {
+    page_num: u32,
+    qt: RefCell<BTreeMap<TextSection, QuadTree<PageItem>>>,
+    unprocessed_chars:
+        Rc<RefCell<BTreeMap<TextSection, Rc<RefCell<BTreeMap<Font, IndexSet<Char>>>>>>>,
+    unprocessed_non_text: Rc<RefCell<IndexSet<LineOrRect>>>,
+    first_seen_fonts: RefCell<&'a mut BTreeMap<String, BTreeSet<NonNaNF32>>>,
+    error: RefCell<Result<(), Error>>,
+}
+
+impl<'a> MyDevice<'a> {
+    fn new(page_num: u32, first_seen_fonts: &'a mut BTreeMap<String, BTreeSet<NonNaNF32>>) -> Self {
+        Self {
+            page_num,
+            qt: Default::default(),
+            unprocessed_chars: Default::default(),
+            unprocessed_non_text: Default::default(),
+            first_seen_fonts: RefCell::new(first_seen_fonts),
+            error: RefCell::new(Ok(())),
+        }
+    }
+    fn path(&self, path: &mupdf_ffi::Path<'_>, ctm: fz_matrix) {
+        if self.error.borrow().is_err() {
+            return;
+        }
+        enum Walker {
+            Empty,
+            Moved { x: f32, y: f32 },
+            Line(Line),
+            Rect { x1: f32, y1: f32, x2: f32, y2: f32 },
+            NotRecognized,
+        }
+        fn new_line(p0_x: f32, p0_y: f32, p1_x: f32, p1_y: f32) -> Option<Line> {
+            Some(Line {
+                p0_x: NonNaNF32::new(p0_x)?,
+                p0_y: NonNaNF32::new(p0_y)?,
+                p1_x: NonNaNF32::new(p1_x)?,
+                p1_y: NonNaNF32::new(p1_y)?,
+            })
+        }
+        impl<'ctx> mupdf_ffi::PathWalker<'ctx> for Walker {
+            fn move_to(&mut self, _ctx: mupdf_ffi::ContextRef<'ctx>, x: f32, y: f32) {
+                *self = match *self {
+                    Walker::Empty | Walker::Moved { .. } => Walker::Moved { x, y },
+                    Walker::Line(_) | Walker::Rect { .. } | Walker::NotRecognized => {
+                        Walker::NotRecognized
+                    }
+                };
+            }
+            fn line_to(&mut self, _ctx: mupdf_ffi::ContextRef<'ctx>, x: f32, y: f32) {
+                *self = match *self {
+                    Walker::Empty => Walker::NotRecognized,
+                    Walker::Moved { x: p0_x, y: p0_y } => new_line(p0_x, p0_y, x, y)
+                        .map(Walker::Line)
+                        .unwrap_or(Walker::NotRecognized),
+                    Walker::Line(_) | Walker::Rect { .. } | Walker::NotRecognized => {
+                        Walker::NotRecognized
+                    }
+                };
+            }
+            fn curve_to(
+                &mut self,
+                _ctx: mupdf_ffi::ContextRef<'ctx>,
+                _cx1: f32,
+                _cy1: f32,
+                _cx2: f32,
+                _cy2: f32,
+                _ex: f32,
+                _ey: f32,
+            ) {
+                *self = Walker::NotRecognized;
+            }
+            fn close_path(&mut self, _ctx: mupdf_ffi::ContextRef<'ctx>) {}
+            fn rect_to(
+                &mut self,
+                _ctx: mupdf_ffi::ContextRef<'ctx>,
+                x1: f32,
+                y1: f32,
+                x2: f32,
+                y2: f32,
+            ) {
+                *self = match *self {
+                    Walker::Empty => Walker::Rect { x1, y1, x2, y2 },
+                    Walker::Moved { .. }
+                    | Walker::Line(..)
+                    | Walker::Rect { .. }
+                    | Walker::NotRecognized => Walker::NotRecognized,
+                };
+            }
+        }
+        let mut walker = Walker::Empty;
+        path.walk(&mut walker);
+        let component = match walker {
+            Walker::Empty | Walker::Moved { .. } | Walker::NotRecognized => return,
+            Walker::Line(Line {
+                p0_x,
+                p0_y,
+                p1_x,
+                p1_y,
+            }) => {
+                let mupdf_sys::fz_point { x: p0_x, y: p0_y } =
+                    mupdf_ffi::transform_point_xy(p0_x.get(), p0_y.get(), ctm);
+                let mupdf_sys::fz_point { x: p1_x, y: p1_y } =
+                    mupdf_ffi::transform_point_xy(p1_x.get(), p1_y.get(), ctm);
+                let Some(line) = new_line(p0_x, p0_y, p1_x, p1_y) else {
+                    return;
+                };
+                LineOrRect::Line(line)
+            }
+            Walker::Rect { x1, y1, x2, y2 } => {
+                let p1 = mupdf_ffi::transform_point_xy(x1, y1, ctm);
+                let p2 = mupdf_ffi::transform_point_xy(x2, y1, ctm);
+                let p3 = mupdf_ffi::transform_point_xy(x2, y2, ctm);
+                let p4 = mupdf_ffi::transform_point_xy(x1, y2, ctm);
+                let min_x = NonNaNF32::new(p1.x.min(p2.x).min(p3.x).min(p4.x));
+                let max_x = NonNaNF32::new(p1.x.max(p2.x).max(p3.x).max(p4.x));
+                let min_y = NonNaNF32::new(p1.y.min(p2.y).min(p3.y).min(p4.y));
+                let max_y = NonNaNF32::new(p1.y.max(p2.y).max(p3.y).max(p4.y));
+                let (Some(min_x), Some(max_x), Some(min_y), Some(max_y)) =
+                    (min_x, max_x, min_y, max_y)
+                else {
+                    return;
+                };
+                LineOrRect::Rect(Rect {
+                    min_x,
+                    max_x,
+                    min_y,
+                    max_y,
+                })
+            }
+        };
+        if component.width() > 100.0
+            && component.min_x().get() < COLUMN_SPLIT_X - 10.0
+            && component.max_x().get() > COLUMN_SPLIT_X + 10.0
+        {
+            println!("wide component: {component:?}");
+        } else {
+            println!("component: {component:?}");
+        }
+        let text_section = TextSection::for_position(
+            self.page_num,
+            (component.min_x().get() + component.max_x().get()) * 0.5,
+            (component.min_y().get() + component.max_y().get()) * 0.5,
+        );
+        if let Some(text_section) = text_section {
+            self.qt
+                .borrow_mut()
+                .entry(text_section)
+                .or_default()
+                .insert(
+                    component.min_x().get(),
+                    component.min_y().get(),
+                    PageItem::LineOrRect(component),
+                );
+        }
+    }
+    fn text(&self, text: &mupdf_ffi::Text<'_>, ctm: fz_matrix) {
+        if self.error.borrow().is_err() {
+            return;
+        }
+        let mut first_seen_fonts = self.first_seen_fonts.borrow_mut();
+        for span in text.spans() {
+            let tm = span.trm();
+            const ROUND_FACTOR: f32 = 1000.0;
+            let font_size = (mupdf_ffi::matrix_expansion(tm) * ROUND_FACTOR).round() / ROUND_FACTOR;
+            let Some(font_size) = NonNaNF32::new(font_size) else {
+                continue;
+            };
+            let font_name_with_tag = span.font().name();
+            let font_name_with_tag = match font_name_with_tag {
+                "CGMSHV+DejaVuSansCondensed-Obli" => "CGMSHV+DejaVuSansCondensed-Oblique",
+                "YDJYQV+DejaVuSansCondensed-Bold" => "YDJYQV+DejaVuSansCondensed-BoldOblique",
+                "NHUPPK+DejaVuSansCondensed-Bold" => "NHUPPK+DejaVuSansCondensed-Bold",
+                _ if font_name_with_tag.len() == 31 => {
+                    let _ = self.error.replace(Err(format!(
+                        "probably truncated font name: {font_name_with_tag:?}"
+                    )
+                    .into()));
+                    return;
+                }
+                _ => font_name_with_tag,
+            };
+            let mut flush_char = |char: Char| -> Result<(), ()> {
+                let Some(text_section) = TextSection::for_position(
+                    self.page_num,
+                    (char.min_x.get() + char.max_x.get()) * 0.5,
+                    (char.min_y.get() + char.max_y.get()) * 0.5,
+                ) else {
+                    if PAGE_BODY_MIN_Y <= char.min_y.get() && char.min_y.get() <= PAGE_BODY_MAX_Y {
+                        if self.page_num != 1072 {
+                            // page 1072 has characters in the margins
+                            let _ = self.error.replace(Err(format!(
+                                "char not in text section: {:?}\npage_num={}",
+                                char.text, self.page_num,
+                            )
+                            .into()));
+                            return Err(());
+                        }
+                    }
+                    return Ok(());
+                };
+                let set = match first_seen_fonts.get_mut(font_name_with_tag) {
+                    Some(v) => v,
+                    None => first_seen_fonts
+                        .entry(String::from(font_name_with_tag))
+                        .or_default(),
+                };
+                if set.insert(font_size) {
+                    println!(
+                        "first seen font: {font_name_with_tag:?} {font_size}: page {} {char:?}",
+                        self.page_num,
+                    );
+                }
+                self.qt
+                    .borrow_mut()
+                    .entry(text_section)
+                    .or_default()
+                    .insert(
+                        char.min_x.get(),
+                        char.min_y.get(),
+                        PageItem::Char(char.clone()),
+                    );
+                self.unprocessed_chars
+                    .borrow_mut()
+                    .entry(text_section)
+                    .or_default()
+                    .borrow_mut()
+                    .entry(char.font.clone())
+                    .or_default()
+                    .insert(char);
+                Ok(())
+            };
+            let mut last_char = None;
+            for &fz_text_item {
+                x,
+                y,
+                adv,
+                gid,
+                ucs,
+                cid: _,
+            } in span.items()
+            {
+                let adv = if gid >= 0 { adv } else { 0.0 };
+                let tm = fz_matrix { e: x, f: y, ..tm };
+                let trm = mupdf_ffi::concat(tm, ctm);
+                let dir = match span.write_mode() {
+                    WriteMode::Horizontal => fz_point { x: 1.0, y: 0.0 },
+                    WriteMode::Vertical => fz_point { x: 0.0, y: -1.0 },
+                };
+                let dir = mupdf_ffi::transform_vector(dir, trm);
+                let glyph_start;
+                let glyph_stop;
+                let mut glyph_ascender;
+                let glyph_descender;
+                match span.write_mode() {
+                    WriteMode::Horizontal => {
+                        glyph_start = fz_point { x: trm.e, y: trm.f };
+                        glyph_stop = fz_point {
+                            x: trm.e + adv * dir.x,
+                            y: trm.f + adv * dir.y,
+                        };
+                        glyph_ascender = fz_point {
+                            x: 0.0,
+                            y: span.font().ascender(),
+                        };
+                        glyph_descender = fz_point {
+                            x: 0.0,
+                            y: span.font().descender(),
+                        };
+                        if glyph_ascender.y == glyph_descender.y {
+                            glyph_ascender.y += 1.0;
+                        }
+                    }
+                    WriteMode::Vertical => {
+                        glyph_start = fz_point {
+                            x: trm.e - adv * dir.x,
+                            y: trm.f - adv * dir.y,
+                        };
+                        glyph_stop = fz_point { x: trm.e, y: trm.f };
+                        glyph_ascender = fz_point { x: 1.0, y: 0.0 };
+                        glyph_descender = fz_point { x: 0.0, y: 0.0 };
+                    }
+                };
+                let glyph_ascender = transform_vector(glyph_ascender, trm);
+                let glyph_descender = transform_vector(glyph_descender, trm);
+                let points = [
+                    add_points(glyph_start, glyph_descender),
+                    add_points(glyph_start, glyph_ascender),
+                    add_points(glyph_stop, glyph_descender),
+                    add_points(glyph_stop, glyph_ascender),
+                ];
+                let min = point_min_components(
+                    point_min_components(point_min_components(points[0], points[1]), points[2]),
+                    points[3],
+                );
+                let max = point_max_components(
+                    point_max_components(point_max_components(points[0], points[1]), points[2]),
+                    points[3],
+                );
+                let Some(ch) = u32::try_from(ucs).ok().and_then(|v| char::try_from(v).ok()) else {
+                    continue;
+                };
+                let text = String::from(ch);
+                if text.trim().is_empty() {
+                    continue;
+                }
+                let font = Font::known_from_name_with_tag(font_name_with_tag, font_size)
+                    .unwrap_or_else(|| Font::Other {
+                        font_name: font_name_with_tag.into(),
+                        size: font_size,
+                    });
+                let (Some(min_x), Some(min_y), Some(max_x), Some(max_y)) = (
+                    NonNaNF32::new(min.x),
+                    NonNaNF32::new(min.y),
+                    NonNaNF32::new(max.x),
+                    NonNaNF32::new(max.y),
+                ) else {
+                    let _ = self
+                        .error
+                        .replace(Err("char position shouldn't be NaN".into()));
+                    return;
+                };
+                if gid < 0
+                    && last_char
+                        .as_ref()
+                        .is_some_and(|last_char: &Char| last_char.font == font)
+                {
+                    if let Some(Char {
+                        font,
+                        text: last_text,
+                        min_x: last_min_x,
+                        min_y: last_min_y,
+                        max_x: last_max_x,
+                        max_y: last_max_y,
+                    }) = last_char.take()
+                    {
+                        last_char = Some(Char {
+                            font,
+                            text: last_text + &text,
+                            min_x: last_min_x.min(min_x),
+                            min_y: last_min_y.min(min_y),
+                            max_x: last_max_x.max(max_x),
+                            max_y: last_max_y.max(max_y),
+                        });
+                        continue;
+                    }
+                }
+                if let Some(last_char) = last_char.take() {
+                    match flush_char(last_char) {
+                        Ok(()) => {}
+                        Err(()) => return,
+                    }
+                }
+                last_char = Some(Char {
+                    font,
+                    text,
+                    min_x,
+                    min_y,
+                    max_x,
+                    max_y,
+                });
+            }
+            if let Some(last_char) = last_char {
+                match flush_char(last_char) {
+                    Ok(()) => {}
+                    Err(()) => return,
+                }
+            }
+        }
+    }
+}
+
+impl<'ctx> mupdf_ffi::DeviceCallbacks<'ctx> for MyDevice<'_> {
+    fn fill_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        _even_odd: bool,
+        ctm: fz_matrix,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn stroke_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn clip_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        _even_odd: bool,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn clip_stroke_path(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        path: &mupdf_ffi::Path<'ctx>,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.path(path, ctm);
+    }
+
+    fn fill_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn stroke_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn clip_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn clip_stroke_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+        _scissor: mupdf_sys::fz_rect,
+    ) {
+        self.text(text, ctm);
+    }
+
+    fn ignore_text(
+        &self,
+        _ctx: mupdf_ffi::ContextRef<'ctx>,
+        text: &mupdf_ffi::Text<'ctx>,
+        ctm: fz_matrix,
+    ) {
+        self.text(text, ctm);
+    }
+}
+
+impl Page {
+    fn from_mupdf_page(
+        page_num: u32,
+        page: &mupdf_ffi::Page<'_>,
+        first_seen_fonts: &mut BTreeMap<String, BTreeSet<NonNaNF32>>,
+        dump_mupdf_page_xml: bool,
+    ) -> Result<Self, Error> {
+        if dump_mupdf_page_xml {
+            println!("{}", page.to_xml()?);
+        }
+        let Some(pdf_page) = page.pdf_page() else {
+            return Err("page is not from a pdf".into());
+        };
+        let device = mupdf_ffi::Device::new(
+            page.ctx(),
+            Box::new(MyDevice::new(page_num, first_seen_fonts)),
+        )?;
+        page.run(&device, pdf_page.transform()?)?;
+        let MyDevice {
+            page_num: _,
+            qt,
+            unprocessed_chars,
+            unprocessed_non_text,
+            first_seen_fonts: _,
+            error,
+        } = device.get();
+        error.replace(Ok(()))?;
+        for (text_section, i) in unprocessed_chars.borrow_mut().iter_mut() {
+            for chars in i.borrow_mut().values_mut() {
+                chars.sort_by_key(Char::top_down_left_to_right_sort_key);
+                println!("first char: {text_section:?}: {:?}", chars.first());
+            }
+        }
+        let mut unknown_fonts = Vec::new();
+        let mut unknown_font_errors = Vec::new();
+        for i in RefCell::borrow(&unprocessed_chars).values() {
+            for (font, chars) in RefCell::borrow(i).iter() {
+                if font.known_font_group().is_none() {
+                    let mut text = String::new();
+                    for char in chars {
+                        text += &char.text;
+                    }
+                    unknown_fonts.push(format!("{font:?},"));
+                    unknown_font_errors.push(format!(
+                        "unknown font {font:?}\nlast char: {:?}\ntext: {text:?}",
+                        chars.last()
+                    ));
+                }
+            }
+        }
+        unknown_fonts.sort();
+        if !unknown_fonts.is_empty() {
+            return Err(format!(
+                "\nunknown fonts:\n{}\n\n{}",
+                unknown_fonts.join("\n"),
+                unknown_font_errors.join("\n")
+            )
+            .into());
+        }
+        Ok(Self {
+            page_num,
+            qt: qt.take(),
+            unprocessed_chars: unprocessed_chars.clone(),
+            unprocessed_non_text: unprocessed_non_text.clone(),
+        })
+    }
+}
+
+fn main_inner() -> Result<(), Error> {
+    let mut args: Vec<String> = std::env::args().collect();
+    let dump_mupdf_page_xml = if args.get(1).is_some_and(|v| v == "--dump-mupdf-page-xml") {
+        args.remove(1);
+        true
+    } else {
+        false
+    };
+    let page_numbers: Option<Box<dyn Iterator<Item = NonZero<u32>>>> = if 2 < args.len() {
+        Some(if let Some((start, end)) = args[2].split_once(":") {
+            let start: NonZero<u32> = start.trim().parse()?;
+            let end: NonZero<u32> = end.trim().parse()?;
+            Box::new(
+                (start.get()..end.get()).map(|v| NonZero::new(v).expect("known to be non-zero")),
+            )
+        } else {
+            Box::new(
+                Result::<BTreeSet<NonZero<u32>>, _>::from_iter(
+                    args[2].split(",").map(|v| v.trim().parse()),
+                )?
+                .into_iter(),
+            )
+        })
+    } else {
+        None
+    };
+
+    std::fs::write(
+        "powerisa-instructions.xml",
+        parse_powerisa_pdf_and_generate_xml(&args[1], page_numbers, dump_mupdf_page_xml)?,
+    )?;
+    Ok(())
+}
+
+pub fn parse_powerisa_pdf_and_generate_xml(
+    file_name: &str,
+    page_numbers: Option<Box<dyn Iterator<Item = NonZero<u32>>>>,
+    dump_mupdf_page_xml: bool,
+) -> Result<String, Error> {
+    mupdf_ffi::Context::with(|ctx| {
+        let mut parser = Parser::new();
+        let is_subset = page_numbers.is_some();
+        parser.parse_pdf(ctx, file_name, page_numbers, dump_mupdf_page_xml)?;
+        let mut insns = xml_tree::Element::new(
+            "instructions".into(),
+            [(
+                "is-subset".into(),
+                if is_subset {
+                    "True".into()
+                } else {
+                    "False".into()
+                },
+            )],
+        );
+        insns.text = "\n".into();
+        insns.tail = "\n".into();
+        let mut comment =
+            xml_tree::Element::comment(format!(" Automatically generated from {file_name} "));
+        comment.tail = "\n".into();
+        insns.children.push(comment);
+        for insn in parser.insns {
+            insn.write_xml(&mut insns);
+        }
+        let mut output = Vec::new();
+        insns.write(&mut output, true)?;
+        Ok(String::from_utf8(output).expect("known to generate valid utf-8"))
+    })
+}
+
+pub fn main() -> std::process::ExitCode {
+    match main_inner() {
+        Ok(()) => std::process::ExitCode::SUCCESS,
+        Err(e) => {
+            eprintln!("Error: {e}");
+            std::process::ExitCode::FAILURE
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 533a408..23e46da 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,38 +1,6 @@
-use parse_powerisa_pdf::pdf::Pdf;
-use std::{
-    error::Error,
-    io::{IsTerminal, Read},
-    process::ExitCode,
-};
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
 
-fn main() -> Result<ExitCode, Box<dyn Error>> {
-    let args: Vec<_> = std::env::args_os().collect();
-    if args
-        .iter()
-        .skip(1)
-        .any(|v| v.as_encoded_bytes().starts_with(b"-") && v != "-")
-        || args.len() > 2
-        || (args.len() == 1 && std::io::stdin().is_terminal())
-    {
-        eprintln!(
-            "Usage: {} [<path/to/file.pdf>]\n\
-            Reads the PDF file passed on the command line,\n\
-            Reads stdin if no arguments are passed or if the file name is just a dash `-`.\n\
-            If stdin is a terminal, you have to pass `-` explicitly to read from it.",
-            args[0].display()
-        );
-        return Ok(ExitCode::FAILURE);
-    }
-    let file_path = args.get(1).filter(|v| *v != "-");
-    let input = if let Some(file_path) = file_path {
-        std::fs::read(file_path)?
-    } else {
-        let mut buf = Vec::new();
-        std::io::stdin().lock().read_to_end(&mut buf)?;
-        buf
-    };
-    let pdf = Pdf::parse(input)?;
-    println!("{:#?}", pdf.trailer.trailer_dictionary());
-    todo!();
-    Ok(ExitCode::SUCCESS)
+fn main() -> std::process::ExitCode {
+    parse_powerisa_pdf::main()
 }
diff --git a/src/mupdf_ffi.rs b/src/mupdf_ffi.rs
new file mode 100644
index 0000000..809ee44
--- /dev/null
+++ b/src/mupdf_ffi.rs
@@ -0,0 +1,871 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use mupdf_sys::{
+    fz_buffer, fz_buffer_storage, fz_clone_context, fz_color_params, fz_colorspace, fz_concat,
+    fz_context, fz_device, fz_document, fz_drop_buffer, fz_drop_context, fz_drop_device,
+    fz_drop_document, fz_drop_page, fz_drop_path, fz_drop_text, fz_error_type_FZ_ERROR_GENERIC,
+    fz_font, fz_font_ascender, fz_font_descender, fz_font_is_bold, fz_font_is_italic, fz_font_name,
+    fz_matrix, fz_matrix_expansion, fz_page, fz_path, fz_path_walker, fz_point, fz_rect,
+    fz_stroke_state, fz_text, fz_text_item, fz_text_span, fz_transform_point,
+    fz_transform_point_xy, fz_transform_vector, fz_walk_path, mupdf_document_page_count,
+    mupdf_drop_error, mupdf_error_t, mupdf_load_page, mupdf_new_base_context,
+    mupdf_new_derived_device, mupdf_open_document, mupdf_page_to_xml, mupdf_pdf_page_transform,
+    mupdf_run_page, pdf_page, pdf_page_from_fz_page,
+};
+use std::{
+    cell::{Cell, UnsafeCell},
+    ffi::{CStr, c_int, c_void},
+    fmt,
+    marker::PhantomData,
+    mem::ManuallyDrop,
+    ptr::{self, NonNull},
+    sync::{Mutex, OnceLock},
+};
+
+#[derive(Debug)]
+pub(crate) struct MuPdfError {
+    type_: c_int,
+    message: String,
+}
+
+impl MuPdfError {
+    fn new_generic(message: impl ToString) -> Self {
+        Self {
+            type_: fz_error_type_FZ_ERROR_GENERIC as _,
+            message: message.to_string(),
+        }
+    }
+}
+
+impl fmt::Display for MuPdfError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "MuPDF error: type: {}, message: {}",
+            self.type_, self.message
+        )
+    }
+}
+
+impl std::error::Error for MuPdfError {}
+
+struct OwnedMuPdfError(NonNull<mupdf_error_t>);
+
+impl Drop for OwnedMuPdfError {
+    fn drop(&mut self) {
+        unsafe {
+            mupdf_drop_error(self.0.as_ptr());
+        }
+    }
+}
+
+unsafe fn mupdf_try<R>(f: impl FnOnce(&mut *mut mupdf_error_t) -> R) -> Result<R, MuPdfError> {
+    let mut err = ptr::null_mut();
+    let retval = f(&mut err);
+    let Some(err) = NonNull::new(err).map(OwnedMuPdfError) else {
+        return Ok(retval);
+    };
+    unsafe {
+        Err(MuPdfError {
+            type_: (*err.0.as_ptr()).type_,
+            message: CStr::from_ptr((*err.0.as_ptr()).message)
+                .to_string_lossy()
+                .into_owned(),
+        })
+    }
+}
+
+pub(crate) struct Context(NonNull<fz_context>);
+
+impl Context {
+    fn new() -> Self {
+        struct BaseContext(NonNull<fz_context>);
+        unsafe impl Send for BaseContext {}
+        static CTX: OnceLock<Mutex<BaseContext>> = OnceLock::new();
+        let base = CTX
+            .get_or_init(|| {
+                let ctx = unsafe { mupdf_new_base_context() };
+                let Some(ctx) = NonNull::new(ctx).map(BaseContext) else {
+                    panic!("failed to allocate a MuPDF context");
+                };
+                Mutex::new(ctx)
+            })
+            .lock()
+            .expect("not poisoned");
+        let ctx = unsafe { fz_clone_context(base.0.as_ptr()) };
+        let Some(ctx) = NonNull::new(ctx).map(Self) else {
+            drop(base);
+            panic!("failed to clone a MuPDF context");
+        };
+        ctx
+    }
+    pub(crate) fn with<R>(f: impl FnOnce(&Self) -> R) -> R {
+        thread_local! {
+            static CTX: Context = Context::new();
+        }
+        CTX.with(f)
+    }
+    pub(crate) fn as_ref(&self) -> ContextRef<'_> {
+        unsafe { ContextRef::from_ptr(self.0.as_ptr()) }
+    }
+}
+
+impl Drop for Context {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_context(self.0.as_ptr());
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct ContextRef<'ctx>(&'ctx UnsafeCell<fz_context>);
+
+impl<'ctx> ContextRef<'ctx> {
+    unsafe fn from_ptr(ptr: *mut fz_context) -> Self {
+        Self(unsafe { &*ptr.cast() })
+    }
+}
+
+impl<'ctx> From<&'ctx Context> for ContextRef<'ctx> {
+    fn from(value: &'ctx Context) -> Self {
+        value.as_ref()
+    }
+}
+
+pub(crate) struct Document<'ctx> {
+    ptr: *mut fz_document,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Document<'ctx> {
+    pub(crate) fn open(
+        ctx: impl Into<ContextRef<'ctx>>,
+        file_name: &CStr,
+    ) -> Result<Document<'ctx>, MuPdfError> {
+        let ctx = ctx.into();
+        unsafe {
+            mupdf_try(|errptr| mupdf_open_document(ctx.0.get(), file_name.as_ptr(), errptr))
+                .map(|ptr| Document { ptr, ctx })
+        }
+    }
+    pub(crate) fn page_count(&self) -> Result<usize, MuPdfError> {
+        unsafe {
+            mupdf_try(|errptr| mupdf_document_page_count(self.ctx.0.get(), self.ptr, errptr))?
+                .try_into()
+                .map_err(MuPdfError::new_generic)
+        }
+    }
+    pub(crate) fn load_page(&self, page: usize) -> Result<Page<'ctx>, MuPdfError> {
+        let page = page.try_into().map_err(MuPdfError::new_generic)?;
+        unsafe {
+            mupdf_try(|errptr| mupdf_load_page(self.ctx.0.get(), self.ptr, page, errptr))
+                .map(|ptr| Page { ptr, ctx: self.ctx })
+        }
+    }
+}
+
+impl<'ctx> Drop for Document<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_document(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+struct Buffer<'ctx> {
+    ptr: *mut fz_buffer,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Buffer<'ctx> {
+    fn storage(&mut self) -> &mut [u8] {
+        unsafe {
+            let mut ptr = ptr::null_mut();
+            let len = fz_buffer_storage(self.ctx.0.get(), self.ptr, &raw mut ptr);
+            if len == 0 {
+                &mut []
+            } else {
+                std::slice::from_raw_parts_mut(ptr, len)
+            }
+        }
+    }
+}
+
+impl<'ctx> Drop for Buffer<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_buffer(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+pub(crate) struct Page<'ctx> {
+    ptr: *mut fz_page,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Page<'ctx> {
+    pub(crate) fn ctx(&self) -> ContextRef<'ctx> {
+        self.ctx
+    }
+    pub(crate) fn run<T>(
+        &self,
+        device: &Device<'ctx, T>,
+        ctm: fz_matrix,
+    ) -> Result<(), MuPdfError> {
+        unsafe {
+            mupdf_try(|errptr| {
+                mupdf_run_page(
+                    self.ctx.0.get(),
+                    self.ptr,
+                    device.dev,
+                    ctm,
+                    ptr::null_mut(),
+                    errptr,
+                )
+            })
+        }
+    }
+    pub(crate) fn to_xml(&self) -> Result<String, MuPdfError> {
+        unsafe {
+            let mut buffer =
+                mupdf_try(|errptr| mupdf_page_to_xml(self.ctx.0.get(), self.ptr, errptr))
+                    .map(|ptr| Buffer { ptr, ctx: self.ctx })?;
+            Ok(str::from_utf8(buffer.storage())
+                .map_err(MuPdfError::new_generic)?
+                .into())
+        }
+    }
+    pub(crate) fn pdf_page<'a>(&'a self) -> Option<PdfPageRef<'a, 'ctx>> {
+        unsafe {
+            let ptr = pdf_page_from_fz_page(self.ctx.0.get(), self.ptr);
+            NonNull::new(ptr).map(|ptr| PdfPageRef {
+                ptr: &*ptr.as_ptr().cast(),
+                ctx: self.ctx,
+            })
+        }
+    }
+}
+
+impl<'ctx> Drop for Page<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_page(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct PdfPageRef<'a, 'ctx> {
+    ptr: &'a UnsafeCell<pdf_page>,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'a, 'ctx> PdfPageRef<'a, 'ctx> {
+    pub(crate) fn transform(self) -> Result<fz_matrix, MuPdfError> {
+        unsafe {
+            mupdf_try(|errptr| mupdf_pdf_page_transform(self.ctx.0.get(), self.ptr.get(), errptr))
+        }
+    }
+}
+
+pub(crate) struct Device<'ctx, T: 'ctx> {
+    dev: *mut fz_device,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<Box<Cell<T>>>,
+}
+
+pub(crate) trait DeviceCallbacks<'ctx> {
+    fn fill_path(&self, ctx: ContextRef<'ctx>, path: &Path<'ctx>, even_odd: bool, ctm: fz_matrix);
+    fn stroke_path(&self, ctx: ContextRef<'ctx>, path: &Path<'ctx>, ctm: fz_matrix);
+    fn clip_path(
+        &self,
+        ctx: ContextRef<'ctx>,
+        path: &Path<'ctx>,
+        even_odd: bool,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    );
+    fn clip_stroke_path(
+        &self,
+        ctx: ContextRef<'ctx>,
+        path: &Path<'ctx>,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    );
+    fn fill_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix);
+    fn stroke_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix);
+    fn clip_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix, scissor: fz_rect);
+    fn clip_stroke_text(
+        &self,
+        ctx: ContextRef<'ctx>,
+        text: &Text<'ctx>,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    );
+    fn ignore_text(&self, ctx: ContextRef<'ctx>, text: &Text<'ctx>, ctm: fz_matrix);
+}
+
+impl<'ctx, T: DeviceCallbacks<'ctx>> Device<'ctx, T> {
+    pub(crate) fn new(ctx: impl Into<ContextRef<'ctx>>, value: Box<T>) -> Result<Self, MuPdfError> {
+        let ctx = ctx.into();
+        unsafe {
+            let dev_ptr = mupdf_try(|errptr| {
+                mupdf_new_derived_device::<DeviceStruct<T>>(
+                    ctx.0.get(),
+                    c"parse_powerisa_pdf::mupdf_ffi::Device",
+                    errptr,
+                )
+            })?;
+            let retval = Device {
+                dev: dev_ptr.cast(),
+                ctx,
+                _phantom: PhantomData,
+            };
+            (&raw mut (*dev_ptr).value).write(value);
+            let fz_device {
+                drop_device,
+                fill_path,
+                stroke_path,
+                clip_path,
+                clip_stroke_path,
+                fill_text,
+                stroke_text,
+                clip_text,
+                clip_stroke_text,
+                ignore_text,
+                ..
+            } = &mut (*dev_ptr).base;
+            *drop_device = Some(Self::drop_device_fn);
+            *fill_path = Some(Self::fill_path_fn);
+            *stroke_path = Some(Self::stroke_path_fn);
+            *clip_path = Some(Self::clip_path_fn);
+            *clip_stroke_path = Some(Self::clip_stroke_path_fn);
+            *fill_text = Some(Self::fill_text_fn);
+            *stroke_text = Some(Self::stroke_text_fn);
+            *clip_text = Some(Self::clip_text_fn);
+            *clip_stroke_text = Some(Self::clip_stroke_text_fn);
+            *ignore_text = Some(Self::ignore_text_fn);
+            Ok(retval)
+        }
+    }
+    pub(crate) fn get(&self) -> &T {
+        unsafe { &(*self.dev.cast::<DeviceStruct<T>>()).value }
+    }
+    unsafe extern "C" fn drop_device_fn(_ctx: *mut fz_context, dev: *mut fz_device) {
+        unsafe {
+            (&raw mut (*dev.cast::<DeviceStruct<T>>()).value).drop_in_place();
+        }
+    }
+    unsafe extern "C" fn fill_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        even_odd: c_int,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.fill_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            even_odd != 0,
+            ctm,
+        );
+    }
+    unsafe extern "C" fn stroke_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.stroke_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+    unsafe extern "C" fn clip_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        even_odd: ::std::os::raw::c_int,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            even_odd != 0,
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn clip_stroke_path_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        path: *const fz_path,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_stroke_path(
+            ctx,
+            &ManuallyDrop::new(Path {
+                ptr: path.cast_mut(),
+                ctx,
+            }),
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn fill_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.fill_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+    unsafe extern "C" fn stroke_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        _color_space: *mut fz_colorspace,
+        _color: *const f32,
+        _alpha: f32,
+        _color_params: fz_color_params,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.stroke_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+    unsafe extern "C" fn clip_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn clip_stroke_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        _stroke_state: *const fz_stroke_state,
+        ctm: fz_matrix,
+        scissor: fz_rect,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.clip_stroke_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+            scissor,
+        );
+    }
+    unsafe extern "C" fn ignore_text_fn(
+        ctx: *mut fz_context,
+        dev: *mut fz_device,
+        text: *const fz_text,
+        ctm: fz_matrix,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut (*dev.cast::<DeviceStruct<T>>()).value };
+        this.ignore_text(
+            ctx,
+            &ManuallyDrop::new(Text {
+                ptr: text.cast_mut(),
+                ctx,
+            }),
+            ctm,
+        );
+    }
+}
+
+impl<'ctx, T> Drop for Device<'ctx, T> {
+    fn drop(&mut self) {
+        unsafe {
+            // FIXME: fz_close_device may throw exceptions
+            // fz_close_device(self.ctx.0.get(), self.dev);
+            fz_drop_device(self.ctx.0.get(), self.dev);
+        }
+    }
+}
+
+#[repr(C)]
+struct DeviceStruct<T> {
+    base: fz_device,
+    value: Box<T>,
+}
+
+pub(crate) trait PathWalker<'ctx> {
+    fn move_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32);
+    fn line_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32);
+    fn curve_to(
+        &mut self,
+        ctx: ContextRef<'ctx>,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    );
+    fn close_path(&mut self, ctx: ContextRef<'ctx>);
+    fn rect_to(&mut self, ctx: ContextRef<'ctx>, x1: f32, y1: f32, x2: f32, y2: f32) {
+        self.move_to(ctx, x1, y1);
+        self.move_to(ctx, x2, y1);
+        self.move_to(ctx, x2, y2);
+        self.move_to(ctx, x1, y2);
+        self.close_path(ctx);
+    }
+}
+
+impl<'ctx, T: ?Sized + PathWalker<'ctx>> PathWalker<'ctx> for &'_ mut T {
+    fn move_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32) {
+        T::move_to(self, ctx, x, y);
+    }
+
+    fn line_to(&mut self, ctx: ContextRef<'ctx>, x: f32, y: f32) {
+        T::line_to(self, ctx, x, y);
+    }
+
+    fn curve_to(
+        &mut self,
+        ctx: ContextRef<'ctx>,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    ) {
+        T::curve_to(self, ctx, x1, y1, x2, y2, x3, y3);
+    }
+
+    fn close_path(&mut self, ctx: ContextRef<'ctx>) {
+        T::close_path(self, ctx);
+    }
+
+    fn rect_to(&mut self, ctx: ContextRef<'ctx>, x1: f32, y1: f32, x2: f32, y2: f32) {
+        T::rect_to(self, ctx, x1, y1, x2, y2);
+    }
+}
+
+pub(crate) struct Path<'ctx> {
+    ptr: *mut fz_path,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Path<'ctx> {
+    pub(crate) fn walk<W: PathWalker<'ctx>>(&self, mut walker: W) {
+        unsafe {
+            fz_walk_path(
+                self.ctx.0.get(),
+                self.ptr,
+                const {
+                    &fz_path_walker {
+                        moveto: Some(Self::move_to_fn::<W>),
+                        lineto: Some(Self::line_to_fn::<W>),
+                        curveto: Some(Self::curve_to_fn::<W>),
+                        closepath: Some(Self::close_path_fn::<W>),
+                        quadto: None,
+                        curvetov: None,
+                        curvetoy: None,
+                        rectto: Some(Self::rect_to_fn::<W>),
+                    }
+                },
+                (&raw mut walker).cast(),
+            );
+        }
+    }
+    unsafe extern "C" fn move_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x: f32,
+        y: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.move_to(ctx, x, y);
+    }
+    unsafe extern "C" fn line_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x: f32,
+        y: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.line_to(ctx, x, y);
+    }
+    unsafe extern "C" fn curve_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+        x3: f32,
+        y3: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.curve_to(ctx, x1, y1, x2, y2, x3, y3);
+    }
+    unsafe extern "C" fn close_path_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.close_path(ctx);
+    }
+    unsafe extern "C" fn rect_to_fn<W: PathWalker<'ctx>>(
+        ctx: *mut fz_context,
+        arg: *mut c_void,
+        x1: f32,
+        y1: f32,
+        x2: f32,
+        y2: f32,
+    ) {
+        let ctx = unsafe { ContextRef::from_ptr(ctx) };
+        let this = unsafe { &mut *arg.cast::<W>() };
+        this.rect_to(ctx, x1, y1, x2, y2);
+    }
+}
+
+impl<'ctx> Drop for Path<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_path(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+pub(crate) struct Text<'ctx> {
+    ptr: *mut fz_text,
+    ctx: ContextRef<'ctx>,
+}
+
+impl<'ctx> Drop for Text<'ctx> {
+    fn drop(&mut self) {
+        unsafe {
+            fz_drop_text(self.ctx.0.get(), self.ptr);
+        }
+    }
+}
+
+impl<'ctx> Text<'ctx> {
+    pub(crate) fn spans<'a>(&'a self) -> TextSpanIter<'a, 'ctx> {
+        TextSpanIter {
+            ptr: unsafe { NonNull::new((*self.ptr).head).map(|ptr| &*ptr.as_ptr().cast()) },
+            ctx: self.ctx,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct TextSpanIter<'a, 'ctx> {
+    ptr: Option<&'a UnsafeCell<fz_text_span>>,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<&'a Text<'ctx>>,
+}
+
+impl<'a, 'ctx> Iterator for TextSpanIter<'a, 'ctx> {
+    type Item = TextSpanRef<'a, 'ctx>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let ptr = self.ptr?;
+        self.ptr = unsafe { NonNull::new((*ptr.get()).next).map(|ptr| &*ptr.as_ptr().cast()) };
+        Some(TextSpanRef {
+            ptr,
+            ctx: self.ctx,
+            _phantom: PhantomData,
+        })
+    }
+}
+
+#[derive(Copy, Clone)]
+pub(crate) struct TextSpanRef<'a, 'ctx> {
+    ptr: &'a UnsafeCell<fz_text_span>,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<&'a Text<'ctx>>,
+}
+
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+pub(crate) enum WriteMode {
+    Horizontal,
+    Vertical,
+}
+
+impl<'a, 'ctx> TextSpanRef<'a, 'ctx> {
+    #[allow(dead_code)]
+    pub(crate) fn get(self) -> &'a UnsafeCell<fz_text_span> {
+        self.ptr
+    }
+    pub(crate) fn font(self) -> FontRef<'a, 'ctx> {
+        FontRef {
+            ptr: unsafe { &*(*self.ptr.get()).font.cast::<UnsafeCell<fz_font>>() },
+            ctx: self.ctx,
+            _phantom: PhantomData,
+        }
+    }
+    pub(crate) fn trm(self) -> fz_matrix {
+        unsafe { (*self.ptr.get()).trm }
+    }
+    pub(crate) fn write_mode(self) -> WriteMode {
+        if unsafe { (*self.ptr.get()).wmode() != 0 } {
+            WriteMode::Vertical
+        } else {
+            WriteMode::Horizontal
+        }
+    }
+    pub(crate) fn items(self) -> &'a [fz_text_item] {
+        let len = unsafe { (*self.ptr.get()).len } as usize;
+        if len == 0 {
+            return &[];
+        }
+        unsafe { std::slice::from_raw_parts((*self.ptr.get()).items, len) }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) struct FontRef<'a, 'ctx> {
+    ptr: &'a UnsafeCell<fz_font>,
+    ctx: ContextRef<'ctx>,
+    _phantom: PhantomData<&'a Text<'ctx>>,
+}
+
+impl<'a, 'ctx> FontRef<'a, 'ctx> {
+    #[allow(dead_code)]
+    pub(crate) fn get(self) -> &'a UnsafeCell<fz_font> {
+        self.ptr
+    }
+    pub(crate) fn name(self) -> &'a str {
+        unsafe { CStr::from_ptr(fz_font_name(self.ctx.0.get(), self.ptr.get())) }
+            .to_str()
+            .expect("font name isn't valid UTF-8")
+    }
+    #[allow(dead_code)]
+    pub(crate) fn is_bold(self) -> bool {
+        unsafe { fz_font_is_bold(self.ctx.0.get(), self.ptr.get()) != 0 }
+    }
+    #[allow(dead_code)]
+    pub(crate) fn is_italic(self) -> bool {
+        unsafe { fz_font_is_italic(self.ctx.0.get(), self.ptr.get()) != 0 }
+    }
+    pub(crate) fn ascender(self) -> f32 {
+        unsafe { fz_font_ascender(self.ctx.0.get(), self.ptr.get()) }
+    }
+    pub(crate) fn descender(self) -> f32 {
+        unsafe { fz_font_descender(self.ctx.0.get(), self.ptr.get()) }
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) fn transform_point(point: fz_point, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_point(point, m) }
+}
+
+pub(crate) fn transform_point_xy(x: f32, y: f32, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_point_xy(x, y, m) }
+}
+
+pub(crate) fn transform_vector(vector: fz_point, m: fz_matrix) -> fz_point {
+    unsafe { fz_transform_vector(vector, m) }
+}
+
+pub(crate) fn matrix_expansion(m: fz_matrix) -> f32 {
+    unsafe { fz_matrix_expansion(m) }
+}
+
+pub(crate) fn concat(left: fz_matrix, right: fz_matrix) -> fz_matrix {
+    unsafe { fz_concat(left, right) }
+}
+
+pub(crate) fn add_points(a: fz_point, b: fz_point) -> fz_point {
+    fz_point {
+        x: a.x + b.x,
+        y: a.y + b.y,
+    }
+}
+
+pub(crate) fn point_min_components(a: fz_point, b: fz_point) -> fz_point {
+    fz_point {
+        x: a.x.min(b.x),
+        y: a.y.min(b.y),
+    }
+}
+
+pub(crate) fn point_max_components(a: fz_point, b: fz_point) -> fz_point {
+    fz_point {
+        x: a.x.max(b.x),
+        y: a.y.max(b.y),
+    }
+}
diff --git a/src/pdf.rs b/src/pdf.rs
deleted file mode 100644
index be57b31..0000000
--- a/src/pdf.rs
+++ /dev/null
@@ -1,1279 +0,0 @@
-use crate::{
-    pdf::{
-        content_stream::PdfOperatorUnparsed,
-        document_structure::PdfDocumentCatalog,
-        object::{
-            PdfArray, PdfBoolean, PdfDictionary, PdfInteger, PdfName, PdfNull, PdfObject,
-            PdfObjectIdentifier, PdfObjectIndirect, PdfObjectStreamDictionary, PdfReal, PdfStream,
-            PdfStreamDictionary, PdfString,
-        },
-        parse::{
-            GetPdfInputPosition, PdfInputPosition, PdfInputPositionKnown, PdfParse, PdfParseError,
-        },
-    },
-    pdf_parse,
-    util::{ArcOrRef, DagDebugState},
-};
-use std::{
-    any::{Any, TypeId},
-    collections::{BTreeMap, HashMap},
-    convert::Infallible,
-    fmt,
-    num::NonZero,
-    str::FromStr,
-    sync::{Arc, Mutex, OnceLock},
-};
-
-pub mod content_stream;
-pub mod document_structure;
-pub mod font;
-pub mod object;
-pub mod parse;
-pub mod render;
-pub mod stream_filters;
-
-struct ParseCache {
-    parse_results: HashMap<TypeId, std::sync::Weak<dyn Any + Send + Sync>>,
-    steps_till_next_gc: usize,
-}
-
-impl Default for ParseCache {
-    fn default() -> Self {
-        Self {
-            parse_results: HashMap::new(),
-            steps_till_next_gc: 1,
-        }
-    }
-}
-
-impl ParseCache {
-    fn gc(&mut self) {
-        if self.steps_till_next_gc == 0 {
-            self.parse_results.retain(|_k, v| v.strong_count() > 0);
-            let mut adjusted_len = self.parse_results.len();
-            if adjusted_len < 10 {
-                adjusted_len = 10;
-            }
-            self.steps_till_next_gc = adjusted_len.saturating_mul(20);
-        } else {
-            self.steps_till_next_gc -= 1;
-        }
-    }
-    fn get<T: 'static + Send + Sync>(&mut self) -> Option<Arc<T>> {
-        self.gc();
-        let Ok(retval) = self
-            .parse_results
-            .get(&TypeId::of::<T>())?
-            .upgrade()?
-            .downcast()
-        else {
-            unreachable!();
-        };
-        Some(retval)
-    }
-    fn get_or_insert<T: 'static + Send + Sync>(
-        &mut self,
-        value: Arc<T>,
-    ) -> (Arc<T>, impl Sized + use<T>) {
-        use std::collections::hash_map::Entry;
-        self.gc();
-        match self.parse_results.entry(TypeId::of::<T>()) {
-            Entry::Occupied(mut entry) => {
-                if let Some(retval) = entry.get().upgrade() {
-                    let Ok(retval) = retval.downcast::<T>() else {
-                        unreachable!();
-                    };
-                    (retval, Some(value))
-                } else {
-                    entry.insert(Arc::<T>::downgrade(&value));
-                    (value, None)
-                }
-            }
-            Entry::Vacant(entry) => {
-                entry.insert(Arc::<T>::downgrade(&value));
-                (value, None)
-            }
-        }
-    }
-}
-
-struct PdfObjectAndParseCache {
-    object: PdfObject,
-    parse_cache: Mutex<ParseCache>,
-}
-
-impl PdfObjectAndParseCache {
-    fn new(object: PdfObject) -> Self {
-        Self {
-            object,
-            parse_cache: Mutex::default(),
-        }
-    }
-    fn parse_cache_get<T: 'static + Send + Sync>(&self) -> Option<Arc<T>> {
-        self.parse_cache.lock().expect("not poisoned").get()
-    }
-    fn parse_cache_get_or_insert<T: 'static + Send + Sync>(&self, value: Arc<T>) -> Arc<T> {
-        let mut parse_cache = self.parse_cache.lock().expect("not poisoned");
-        let (retval, to_drop_after_unlock) = parse_cache.get_or_insert(value);
-        drop(parse_cache);
-        drop(to_drop_after_unlock);
-        retval
-    }
-}
-
-struct PdfObjectsInner {
-    objects: BTreeMap<PdfObjectIdentifier, PdfObjectAndParseCache>,
-    #[allow(dead_code)]
-    object_streams: Vec<PdfStream<PdfObjectStreamDictionary>>,
-}
-
-pub struct PdfObjects {
-    inner: OnceLock<PdfObjectsInner>,
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct PdfHeader {
-    pub major: NonZero<u16>,
-    pub minor: u16,
-}
-
-impl PdfHeader {
-    pub const PREFIX: &str = "%PDF-";
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfTrailerDictionary {
-        #[pdf(name = "Size")]
-        pub size: usize,
-        #[pdf(name = "Prev")]
-        pub prev: Option<usize>,
-        #[pdf(name = "Root")]
-        pub root: PdfDocumentCatalog,
-        #[pdf(name = "Encrypt")]
-        pub encrypt: Option<PdfDictionary>,
-        #[pdf(name = "Info")]
-        pub info: Option<PdfDictionary>,
-        #[pdf(name = "ID")]
-        pub id: Option<[PdfString; 2]>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl fmt::Debug for PdfTrailerDictionary {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                size,
-                prev,
-                root,
-                encrypt,
-                info,
-                id,
-                rest,
-            } = self;
-            f.debug_struct("PdfTrailerDictionary")
-                .field("size", size)
-                .field("prev", prev)
-                .field("root", root)
-                .field("encrypt", encrypt)
-                .field("info", info)
-                .field("id", id)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfXRefName {
-        #[pdf(name = "XRef")]
-        #[default]
-        XRef,
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfXRefStreamDictionaryRest {
-        #[pdf(name = "Type")]
-        pub ty: PdfXRefName,
-        #[pdf(name = "Index")]
-        pub index: Option<Arc<[usize]>>,
-        #[pdf(name = "W")]
-        pub w: Option<Arc<[usize]>>,
-        #[pdf(flatten)]
-        pub rest: PdfTrailerDictionary,
-    }
-}
-
-impl fmt::Debug for PdfXRefStreamDictionaryRest {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self { ty, index, w, rest } = self;
-            f.debug_struct("PdfXRefStreamDictionaryRest")
-                .field("ty", ty)
-                .field("index", index)
-                .field("w", w)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-#[derive(Clone)]
-pub enum PdfTrailer {
-    Trailer {
-        trailer_dictionary: PdfTrailerDictionary,
-        start_xref: usize,
-    },
-    Stream {
-        xref_stream: PdfStream<PdfXRefStreamDictionaryRest>,
-        start_xref: usize,
-    },
-}
-
-impl fmt::Debug for PdfTrailer {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| match self {
-            Self::Trailer {
-                trailer_dictionary,
-                start_xref,
-            } => f
-                .debug_struct("Trailer")
-                .field("trailer_dictionary", trailer_dictionary)
-                .field("start_xref", start_xref)
-                .finish(),
-            Self::Stream {
-                xref_stream,
-                start_xref,
-            } => f
-                .debug_struct("Stream")
-                .field("xref_stream", xref_stream)
-                .field("start_xref", start_xref)
-                .finish(),
-        })
-    }
-}
-
-impl PdfTrailer {
-    pub fn trailer_dictionary(&self) -> &PdfTrailerDictionary {
-        match self {
-            PdfTrailer::Trailer {
-                trailer_dictionary, ..
-            } => trailer_dictionary,
-            PdfTrailer::Stream { xref_stream, .. } => &xref_stream.dictionary().rest.rest,
-        }
-    }
-}
-
-pub struct Pdf {
-    pub header: PdfHeader,
-    pub objects: Arc<PdfObjects>,
-    pub trailer: PdfTrailer,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-enum PdfCharCategory {
-    Regular,
-    Whitespace,
-    LParen,
-    RParen,
-    LAngle,
-    RAngle,
-    LBracket,
-    RBracket,
-    LBrace,
-    RBrace,
-    FSlash,
-    Percent,
-}
-
-impl PdfCharCategory {
-    fn new(b: u8) -> Self {
-        match b {
-            b'\0' | b'\t' | b'\n' | b'\x0C' | b'\r' | b' ' => Self::Whitespace,
-            b'(' => Self::LParen,
-            b')' => Self::RParen,
-            b'<' => Self::LAngle,
-            b'>' => Self::RAngle,
-            b'[' => Self::LBracket,
-            b']' => Self::RBracket,
-            b'{' => Self::LBrace,
-            b'}' => Self::RBrace,
-            b'/' => Self::FSlash,
-            b'%' => Self::Percent,
-            _ => Self::Regular,
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq)]
-enum PdfToken<'a> {
-    Regular(&'a [u8]),
-    LParen,
-    RParen,
-    LAngle,
-    RAngle,
-    LBracket,
-    RBracket,
-    LBrace,
-    RBrace,
-    FSlash,
-    Comment(&'a [u8]),
-}
-
-impl<'a> fmt::Debug for PdfToken<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Regular(contents) => {
-                if let Ok(contents) = str::from_utf8(contents) {
-                    write!(f, "Regular({contents:?})")
-                } else {
-                    write!(f, "Regular({contents:?})")
-                }
-            }
-            Self::LParen => write!(f, "LParen"),
-            Self::RParen => write!(f, "RParen"),
-            Self::LAngle => write!(f, "LAngle"),
-            Self::RAngle => write!(f, "RAngle"),
-            Self::LBracket => write!(f, "LBracket"),
-            Self::RBracket => write!(f, "RBracket"),
-            Self::LBrace => write!(f, "LBrace"),
-            Self::RBrace => write!(f, "RBrace"),
-            Self::FSlash => write!(f, "FSlash"),
-            Self::Comment(contents) => {
-                if let Ok(contents) = str::from_utf8(contents) {
-                    write!(f, "Comment({contents:?})")
-                } else {
-                    write!(f, "Comment({contents:?})")
-                }
-            }
-        }
-    }
-}
-
-#[derive(Clone)]
-struct PdfTokenizerPeek<'a> {
-    token: PdfToken<'a>,
-    pos_after_token: usize,
-}
-
-#[derive(Clone)]
-struct PdfTokenizer<'a> {
-    bytes: &'a [u8],
-    pos: PdfInputPositionKnown,
-    peek_cache: Option<PdfTokenizerPeek<'a>>,
-}
-
-impl<'a> PdfTokenizer<'a> {
-    fn new(bytes: &'a [u8], pos: PdfInputPositionKnown) -> Self {
-        Self {
-            bytes,
-            pos,
-            peek_cache: None,
-        }
-    }
-    fn pos(&self) -> PdfInputPosition {
-        PdfInputPosition::new(Some(self.pos))
-    }
-    fn peek_byte(&mut self) -> Option<u8> {
-        self.bytes.get(self.pos.pos).copied()
-    }
-    fn next_byte(&mut self) -> Option<u8> {
-        let b = self.bytes.get(self.pos.pos)?;
-        self.pos.pos += 1;
-        self.peek_cache = None;
-        Some(*b)
-    }
-    fn skip_whitespace(&mut self) {
-        while let Some(PdfCharCategory::Whitespace) = self.peek_byte().map(PdfCharCategory::new) {
-            self.next_byte();
-        }
-    }
-    fn peek(&mut self) -> Option<PdfToken<'a>> {
-        if let Some(PdfTokenizerPeek { token, .. }) = self.peek_cache {
-            return Some(token);
-        }
-        let mut tokenizer = self.clone();
-        let token = tokenizer.next()?;
-        self.peek_cache = Some(PdfTokenizerPeek {
-            token,
-            pos_after_token: tokenizer.pos.pos,
-        });
-        Some(token)
-    }
-    fn read_bytes(&mut self, len: usize) -> Option<&'a [u8]> {
-        let retval = self
-            .bytes
-            .get(self.pos.pos..self.pos.pos.saturating_add(len))?;
-        self.peek_cache = None;
-        self.pos.pos += len;
-        Some(retval)
-    }
-}
-
-impl<'a> Iterator for PdfTokenizer<'a> {
-    type Item = PdfToken<'a>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(PdfTokenizerPeek {
-            token,
-            pos_after_token,
-        }) = self.peek_cache.take()
-        {
-            self.pos.pos = pos_after_token;
-            return Some(token);
-        }
-        loop {
-            let start_pos = self.pos.pos;
-            break match PdfCharCategory::new(self.next_byte()?) {
-                PdfCharCategory::Whitespace => continue,
-                PdfCharCategory::LParen => Some(PdfToken::LParen),
-                PdfCharCategory::RParen => Some(PdfToken::RParen),
-                PdfCharCategory::LAngle => Some(PdfToken::LAngle),
-                PdfCharCategory::RAngle => Some(PdfToken::RAngle),
-                PdfCharCategory::LBracket => Some(PdfToken::LBracket),
-                PdfCharCategory::RBracket => Some(PdfToken::RBracket),
-                PdfCharCategory::LBrace => Some(PdfToken::LBrace),
-                PdfCharCategory::RBrace => Some(PdfToken::RBrace),
-                PdfCharCategory::FSlash => Some(PdfToken::FSlash),
-                PdfCharCategory::Percent => {
-                    loop {
-                        match self.next_byte() {
-                            None | Some(b'\n') => break,
-                            Some(b'\r') => {
-                                if let Some(b'\n') = self.peek_byte() {
-                                    self.pos.pos += 1;
-                                }
-                                break;
-                            }
-                            Some(_) => continue,
-                        }
-                    }
-                    Some(PdfToken::Comment(&self.bytes[start_pos..self.pos.pos]))
-                }
-                PdfCharCategory::Regular => {
-                    while let Some(PdfCharCategory::Regular) =
-                        self.peek_byte().map(PdfCharCategory::new)
-                    {
-                        self.pos.pos += 1;
-                    }
-                    Some(PdfToken::Regular(&self.bytes[start_pos..self.pos.pos]))
-                }
-            };
-        }
-    }
-}
-
-struct PdfParser<'a> {
-    objects: Arc<PdfObjects>,
-    tokenizer: PdfTokenizer<'a>,
-}
-
-enum PdfObjectOrStreamDictionaryOrOperator {
-    StreamDictionary {
-        dictionary: PdfDictionary,
-        stream_kw_pos: PdfInputPosition,
-    },
-    Object(PdfObject),
-    Operator(PdfOperatorUnparsed),
-}
-
-impl PdfObjectOrStreamDictionaryOrOperator {
-    fn error_on_stream_or_operator(self) -> Result<PdfObject, PdfParseError> {
-        match self {
-            PdfObjectOrStreamDictionaryOrOperator::StreamDictionary {
-                dictionary: _,
-                stream_kw_pos,
-            } => Err(PdfParseError::StreamNotAllowedHere { pos: stream_kw_pos }),
-            PdfObjectOrStreamDictionaryOrOperator::Object(object) => Ok(object),
-            PdfObjectOrStreamDictionaryOrOperator::Operator(operator) => {
-                Err(PdfParseError::OperatorNotAllowedHere { operator })
-            }
-        }
-    }
-}
-
-impl<'a> PdfParser<'a> {
-    fn skip_comments_and_whitespace(&mut self) {
-        self.tokenizer.skip_whitespace();
-        while let Some(PdfToken::Comment(_)) = self.tokenizer.peek() {
-            self.tokenizer.next();
-            self.tokenizer.skip_whitespace();
-        }
-    }
-    fn parse_digits<T: FromStr>(
-        &mut self,
-        on_parse_failed: impl FnOnce(PdfInputPosition) -> Result<Option<Infallible>, PdfParseError>,
-    ) -> Result<Option<(PdfInputPosition, T)>, PdfParseError> {
-        self.skip_comments_and_whitespace();
-        let old_tokenizer = self.tokenizer.clone();
-        let pos = self.tokenizer.pos();
-        let Some(PdfToken::Regular(number)) = self.tokenizer.next() else {
-            self.tokenizer = old_tokenizer;
-            return Ok(None);
-        };
-        if !number.iter().all(|b| b.is_ascii_digit()) {
-            self.tokenizer = old_tokenizer;
-            return Ok(None);
-        }
-        let Some(number) = str::from_utf8(number).ok().and_then(|v| v.parse().ok()) else {
-            self.tokenizer = old_tokenizer;
-            return Ok(match on_parse_failed(pos)? {
-                None => None,
-            });
-        };
-        Ok(Some((pos, number)))
-    }
-    fn parse_object_identifier(
-        &mut self,
-        return_none_for_out_of_range: bool,
-    ) -> Result<Option<PdfObjectIdentifier>, PdfParseError> {
-        let old_tokenizer = self.tokenizer.clone();
-        let Some((pos, object_number)) = self.parse_digits(|pos| {
-            if return_none_for_out_of_range {
-                Ok(None)
-            } else {
-                Err(PdfParseError::InvalidObjectNumber { pos })
-            }
-        })?
-        else {
-            self.tokenizer = old_tokenizer;
-            return Ok(None);
-        };
-        let Some((_pos, generation_number)) = self.parse_digits(|pos| {
-            if return_none_for_out_of_range {
-                Ok(None)
-            } else {
-                Err(PdfParseError::InvalidGenerationNumber { pos })
-            }
-        })?
-        else {
-            self.tokenizer = old_tokenizer;
-            return Ok(None);
-        };
-        Ok(Some(PdfObjectIdentifier {
-            pos: pos.into(),
-            object_number,
-            generation_number,
-        }))
-    }
-    fn parse_indirect_object(&mut self) -> Result<Option<PdfObjectIndirect>, PdfParseError> {
-        let old_tokenizer = self.tokenizer.clone();
-        let Some(id) = self.parse_object_identifier(true)? else {
-            self.tokenizer = old_tokenizer;
-            return Ok(None);
-        };
-        if let Some(PdfToken::Regular(b"R")) = self.tokenizer.next() {
-            Ok(Some(PdfObjectIndirect::new(&self.objects, id)))
-        } else {
-            self.tokenizer = old_tokenizer;
-            Ok(None)
-        }
-    }
-    fn parse_string_after_l_paren(&mut self) -> Result<PdfString, PdfParseError> {
-        let mut contents = Vec::new();
-        let mut paren_level = NonZero::new(1usize).expect("non-zero");
-        let string_pos = self.tokenizer.pos();
-        while let Some(b) = self.tokenizer.next_byte() {
-            contents.push(match b {
-                b'(' => {
-                    paren_level = paren_level.checked_add(1).expect("overflow");
-                    b
-                }
-                b')' => {
-                    let Some(new_paren_level) = NonZero::new(paren_level.get() - 1) else {
-                        return Ok(PdfString::new(
-                            string_pos,
-                            ArcOrRef::Arc(Arc::from(contents)),
-                        ));
-                    };
-                    paren_level = new_paren_level;
-                    b
-                }
-                b'\r' if self.tokenizer.peek_byte() == Some(b'\n') => {
-                    self.tokenizer.next_byte();
-                    b'\n'
-                }
-                b'\r' | b'\n' => b'\n',
-                b'\\' => {
-                    let pos = self.tokenizer.pos();
-                    let Some(b) = self.tokenizer.next_byte() else {
-                        return Err(PdfParseError::InvalidStringEscape { pos });
-                    };
-                    match b {
-                        b'\r' if self.tokenizer.peek_byte() == Some(b'\n') => {
-                            self.tokenizer.next_byte();
-                            continue;
-                        }
-                        b'\r' | b'\n' => continue,
-                        b'n' => b'\n',
-                        b'r' => b'\r',
-                        b't' => b'\t',
-                        b'b' => b'\x08',
-                        b'f' => b'\x0C',
-                        b'(' | b')' | b'\\' => b,
-                        b'0'..=b'7' => {
-                            const MAX_OCTAL_DIGITS: usize = 3;
-                            let mut value = b - b'0';
-                            let mut len = 1;
-                            while len < MAX_OCTAL_DIGITS {
-                                let Some(b @ b'0'..=b'7') = self.tokenizer.peek_byte() else {
-                                    break;
-                                };
-                                value <<= 3;
-                                value |= b - b'0';
-                                len += 1;
-                                self.tokenizer.next_byte();
-                            }
-                            value
-                        }
-                        _ => {
-                            return Err(PdfParseError::InvalidStringEscape { pos });
-                        }
-                    }
-                }
-                _ => b,
-            });
-        }
-        Err(PdfParseError::TruncatedFile {
-            pos: self.tokenizer.pos(),
-        })
-    }
-    fn parse_string_after_l_angle(&mut self) -> Result<PdfString, PdfParseError> {
-        let mut contents = Vec::new();
-        let mut high_digit_value = None;
-        let mut push_digit_value = |value: u8| {
-            high_digit_value = match high_digit_value {
-                Some(high_digit_value) => {
-                    contents.push((high_digit_value << 4) | value);
-                    None
-                }
-                None => Some(value),
-            };
-        };
-        let string_pos = self.tokenizer.pos();
-        loop {
-            let pos = self.tokenizer.pos();
-            match self.tokenizer.next_byte() {
-                None => {
-                    return Err(PdfParseError::TruncatedFile { pos });
-                }
-                Some(b) if PdfCharCategory::new(b) == PdfCharCategory::Whitespace => {}
-                Some(b'>') => {
-                    // if we have an odd trailing digit, add the final digit, otherwise doesn't modify contents
-                    push_digit_value(0);
-                    return Ok(PdfString::new(
-                        string_pos,
-                        Arc::<[u8]>::from(contents).into(),
-                    ));
-                }
-                Some(b) => {
-                    let Some(value) = (b as char).to_digit(0x10) else {
-                        return Err(PdfParseError::InvalidHexStringDigit { pos });
-                    };
-                    push_digit_value(value as u8);
-                }
-            }
-        }
-    }
-    fn parse_name_after_f_slash(&mut self) -> Result<PdfName, PdfParseError> {
-        let mut name = vec![];
-        let name_pos = self.tokenizer.pos();
-        loop {
-            let Some(PdfCharCategory::Regular) =
-                self.tokenizer.peek_byte().map(PdfCharCategory::new)
-            else {
-                return Ok(PdfName::new(name_pos, ArcOrRef::Arc(Arc::from(name))));
-            };
-            let pos = self.tokenizer.pos();
-            match self
-                .tokenizer
-                .next_byte()
-                .expect("just checked that it's not None")
-            {
-                b'#' => {
-                    let mut value = 0u8;
-                    for _ in 0..2 {
-                        let Some(digit) = self
-                            .tokenizer
-                            .next_byte()
-                            .and_then(|b| (b as char).to_digit(0x10))
-                        else {
-                            return Err(PdfParseError::InvalidNameEscape { pos });
-                        };
-                        value <<= 4;
-                        value |= digit as u8;
-                    }
-                    name.push(value);
-                }
-                b => name.push(b),
-            }
-        }
-    }
-    fn parse_array_after_l_bracket(&mut self) -> Result<PdfArray, PdfParseError> {
-        let array_pos = self.tokenizer.pos();
-        let mut contents: Vec<PdfObject> = Vec::new();
-        loop {
-            self.skip_comments_and_whitespace();
-            if let Some(PdfToken::RBracket) = self.tokenizer.peek() {
-                self.tokenizer.next();
-                return Ok(PdfArray::from_elements(array_pos, Arc::from(contents)));
-            }
-            contents.push(
-                self.parse_object_or_operator()?
-                    .error_on_stream_or_operator()?,
-            );
-        }
-    }
-    /// assumes `self.tokenizer.peek_byte() == Some(b'<')`
-    fn parse_dictionary_after_one_l_angle(&mut self) -> Result<PdfDictionary, PdfParseError> {
-        let l_angle = self.tokenizer.next_byte();
-        assert_eq!(l_angle, Some(b'<'));
-        let dictionary_pos = self.tokenizer.pos();
-        let mut contents: BTreeMap<PdfName, PdfObject> = BTreeMap::new();
-        loop {
-            self.skip_comments_and_whitespace();
-            if let Some(PdfToken::RAngle) = self.tokenizer.peek() {
-                self.tokenizer.next();
-                let pos = self.tokenizer.pos();
-                let b'>' = self
-                    .tokenizer
-                    .next_byte()
-                    .ok_or(PdfParseError::TruncatedFile { pos })?
-                else {
-                    return Err(PdfParseError::InvalidDictionaryClosingDoubleRAngle { pos });
-                };
-                return Ok(PdfDictionary::from_fields(
-                    dictionary_pos,
-                    Arc::new(contents),
-                ));
-            }
-            let name = PdfName::parse(
-                self.parse_object_or_operator()?
-                    .error_on_stream_or_operator()?,
-            )?;
-            let name_pos = name.pos();
-            match contents.entry(name) {
-                std::collections::btree_map::Entry::Vacant(entry) => {
-                    entry.insert(
-                        self.parse_object_or_operator()?
-                            .error_on_stream_or_operator()?,
-                    );
-                }
-                std::collections::btree_map::Entry::Occupied(entry) => {
-                    return Err(PdfParseError::DuplicateDictionaryKey {
-                        pos: name_pos,
-                        name: entry.key().clone(),
-                    });
-                }
-            }
-        }
-    }
-    fn parse_object_or_operator(
-        &mut self,
-    ) -> Result<PdfObjectOrStreamDictionaryOrOperator, PdfParseError> {
-        self.skip_comments_and_whitespace();
-        if let Some(indirect) = self.parse_indirect_object()? {
-            return Ok(PdfObjectOrStreamDictionaryOrOperator::Object(
-                indirect.into(),
-            ));
-        }
-        let pos = self.tokenizer.pos();
-        Ok(PdfObjectOrStreamDictionaryOrOperator::Object(
-            match self
-                .tokenizer
-                .next()
-                .ok_or(PdfParseError::TruncatedFile { pos })?
-            {
-                PdfToken::Regular(b"true") => PdfObject::Boolean(PdfBoolean::new(pos, true)),
-                PdfToken::Regular(b"false") => PdfObject::Boolean(PdfBoolean::new(pos, false)),
-                PdfToken::Regular(b"null") => PdfObject::Null(PdfNull::new(pos)),
-                PdfToken::Regular(
-                    number @ ([b'+' | b'-', b'0'..=b'9' | b'.', ..] | [b'0'..=b'9' | b'.', ..]),
-                ) => {
-                    // parse number
-                    let Ok(number) = str::from_utf8(number) else {
-                        return Err(PdfParseError::InvalidNumber { pos });
-                    };
-                    let mut parts = number
-                        .strip_prefix(&['+', '-'])
-                        .unwrap_or(number)
-                        .split('.');
-                    let integer_part = parts
-                        .next()
-                        .expect("split always returns at least one part");
-                    let fraction_part = parts.next();
-                    if parts.next().is_some() {
-                        return Err(PdfParseError::InvalidNumber { pos });
-                    }
-                    if integer_part.is_empty() && fraction_part.is_none_or(|v| v.is_empty()) {
-                        return Err(PdfParseError::InvalidNumber { pos });
-                    }
-                    if !integer_part.bytes().all(|v| v.is_ascii_digit()) {
-                        return Err(PdfParseError::InvalidNumber { pos });
-                    }
-                    if let Some(fraction_part) = fraction_part {
-                        if !fraction_part.bytes().all(|v| v.is_ascii_digit()) {
-                            return Err(PdfParseError::InvalidNumber { pos });
-                        }
-                        PdfObject::Real(PdfReal::new(
-                            pos,
-                            number
-                                .parse()
-                                .map_err(|_| PdfParseError::InvalidNumber { pos })?,
-                        ))
-                    } else {
-                        PdfObject::Integer(PdfInteger::new(
-                            pos,
-                            number
-                                .parse()
-                                .map_err(|_| PdfParseError::InvalidNumber { pos })?,
-                        ))
-                    }
-                }
-                PdfToken::Regular(name) => {
-                    return Ok(PdfObjectOrStreamDictionaryOrOperator::Operator(
-                        PdfOperatorUnparsed::new(pos, ArcOrRef::Arc(name.into())),
-                    ));
-                }
-                PdfToken::LParen => PdfObject::String(self.parse_string_after_l_paren()?),
-                PdfToken::RParen => todo!(),
-                PdfToken::LAngle => {
-                    if self.tokenizer.peek_byte() == Some(b'<') {
-                        let dictionary = self.parse_dictionary_after_one_l_angle()?;
-                        self.skip_comments_and_whitespace();
-                        if let Some(PdfToken::Regular(b"stream")) = self.tokenizer.peek() {
-                            return Ok(PdfObjectOrStreamDictionaryOrOperator::StreamDictionary {
-                                dictionary,
-                                stream_kw_pos: self.tokenizer.pos(),
-                            });
-                        } else {
-                            dictionary.into()
-                        }
-                    } else {
-                        self.parse_string_after_l_angle()?.into()
-                    }
-                }
-                PdfToken::RAngle => todo!(),
-                PdfToken::LBracket => self.parse_array_after_l_bracket()?.into(),
-                PdfToken::RBracket => todo!(),
-                PdfToken::LBrace => todo!(),
-                PdfToken::RBrace => todo!(),
-                PdfToken::FSlash => self.parse_name_after_f_slash()?.into(),
-                PdfToken::Comment(_) => unreachable!(),
-            },
-        ))
-    }
-}
-
-struct PdfFileParser<'a> {
-    parser: PdfParser<'a>,
-    objects_map: BTreeMap<PdfObjectIdentifier, PdfObjectAndParseCache>,
-}
-
-impl<'a> PdfFileParser<'a> {
-    fn parse_header(&mut self) -> Result<PdfHeader, PdfParseError> {
-        let Some(b'%') = self.parser.tokenizer.bytes.first() else {
-            return Err(PdfParseError::NotAPdfFile);
-        };
-        let Some(PdfToken::Comment(header)) = self.parser.tokenizer.next() else {
-            unreachable!()
-        };
-        let Ok(header) = str::from_utf8(header) else {
-            return Err(PdfParseError::NotAPdfFile);
-        };
-        let header = header.trim_end_matches(['\n', '\r']);
-        let Some(version) = header.strip_prefix(PdfHeader::PREFIX) else {
-            return Err(PdfParseError::NotAPdfFile);
-        };
-        let Some((major_str, minor_str)) = version.split_once('.') else {
-            return Err(PdfParseError::NotAPdfFile);
-        };
-        let (Ok(major), Ok(minor)) = (major_str.parse(), minor_str.parse()) else {
-            return Err(PdfParseError::NotAPdfFile);
-        };
-        Ok(PdfHeader { major, minor })
-    }
-    /// assumes `self.tokenizer.peek() == Some(PdfToken::Regular(b"stream"))`
-    fn parse_stream_after_dictionary(
-        &mut self,
-        dictionary: PdfDictionary,
-    ) -> Result<PdfStream, PdfParseError> {
-        self.parser.tokenizer.skip_whitespace();
-        let stream_pos = self.parser.tokenizer.pos();
-        let stream = self.parser.tokenizer.next();
-        assert_eq!(stream, Some(PdfToken::Regular(b"stream")));
-        let dictionary = PdfStreamDictionary::parse(dictionary.into())?;
-        let eol_pos = self.parser.tokenizer.pos();
-        match self.parser.tokenizer.next_byte() {
-            None => return Err(PdfParseError::TruncatedFile { pos: eol_pos }),
-            Some(b'\r') => {
-                let Some(b'\n') = self.parser.tokenizer.next_byte() else {
-                    return Err(PdfParseError::InvalidOrMissingEolAfterStreamKeyword {
-                        pos: eol_pos,
-                    });
-                };
-            }
-            Some(b'\n') => {}
-            _ => return Err(PdfParseError::InvalidOrMissingEolAfterStreamKeyword { pos: eol_pos }),
-        }
-        let Some(data) = self.parser.tokenizer.read_bytes(dictionary.len) else {
-            return Err(PdfParseError::TruncatedFile {
-                pos: PdfInputPosition::new(Some(PdfInputPositionKnown {
-                    pos: self.parser.tokenizer.bytes.len(),
-                    ..self.parser.tokenizer.pos
-                })),
-            });
-        };
-        let stream = PdfStream::new(
-            stream_pos,
-            &self.parser.objects,
-            dictionary,
-            Arc::from(data),
-        );
-        self.parser.skip_comments_and_whitespace();
-        let pos = self.parser.tokenizer.pos();
-        if let Some(PdfToken::Regular(b"endstream")) = self.parser.tokenizer.next() {
-            Ok(stream)
-        } else {
-            Err(PdfParseError::MissingEndStreamKeyword { pos })
-        }
-    }
-    fn parse_object(&mut self) -> Result<PdfObject, PdfParseError> {
-        match self.parser.parse_object_or_operator()? {
-            PdfObjectOrStreamDictionaryOrOperator::StreamDictionary {
-                dictionary,
-                stream_kw_pos: _,
-            } => Ok(PdfObject::Stream(
-                self.parse_stream_after_dictionary(dictionary)?,
-            )),
-            PdfObjectOrStreamDictionaryOrOperator::Object(object) => Ok(object),
-            PdfObjectOrStreamDictionaryOrOperator::Operator(operator) => {
-                Err(PdfParseError::OperatorNotAllowedHere { operator })
-            }
-        }
-    }
-    fn parse_indirect_object_definition(&mut self) -> Result<Option<()>, PdfParseError> {
-        self.parser.skip_comments_and_whitespace();
-        let Some(id) = self.parser.parse_object_identifier(false)? else {
-            return Ok(None);
-        };
-        self.parser.skip_comments_and_whitespace();
-        let obj_pos = self.parser.tokenizer.pos();
-        let Some(PdfToken::Regular(b"obj")) = self.parser.tokenizer.next() else {
-            return Err(PdfParseError::MissingObj { pos: obj_pos });
-        };
-        let object = self.parse_object()?;
-        self.parser.skip_comments_and_whitespace();
-        let end_obj_pos = self.parser.tokenizer.pos();
-        let Some(PdfToken::Regular(b"endobj")) = self.parser.tokenizer.next() else {
-            return Err(PdfParseError::MissingEndObj { pos: end_obj_pos });
-        };
-        if self
-            .objects_map
-            .insert(id, PdfObjectAndParseCache::new(object))
-            .is_some()
-        {
-            Err(PdfParseError::DuplicateIndirectObjectDefinition { pos: id.pos.0, id })
-        } else {
-            Ok(Some(()))
-        }
-    }
-    fn parse_object_stream(
-        &mut self,
-        object_stream: &PdfStream<PdfObjectStreamDictionary>,
-    ) -> Result<(), PdfParseError> {
-        let data = object_stream.decoded_data().as_ref()?;
-        let mut parser = PdfParser {
-            tokenizer: PdfTokenizer::new(
-                data,
-                PdfInputPositionKnown {
-                    pos: 0,
-                    containing_streams_pos: Some(
-                        object_stream
-                            .get_pdf_input_position()
-                            .get()
-                            .expect("known to be set")
-                            .pos,
-                    ),
-                },
-            ),
-            objects: self.parser.objects.clone(),
-        };
-        let mut object_ids_and_byte_positions =
-            Vec::<(PdfObjectIdentifier, usize)>::with_capacity(object_stream.dictionary().rest.n);
-        for _ in 0..object_stream.dictionary().rest.n {
-            parser.skip_comments_and_whitespace();
-            let Some((pos, object_number)) =
-                parser.parse_digits(|pos| Err(PdfParseError::InvalidObjectNumber { pos }))?
-            else {
-                return Err(PdfParseError::InvalidObjectNumber {
-                    pos: parser.tokenizer.pos(),
-                });
-            };
-            parser.skip_comments_and_whitespace();
-            let Some((_, byte_position)) =
-                parser.parse_digits(|pos| Err(PdfParseError::InvalidNumber { pos }))?
-            else {
-                return Err(PdfParseError::InvalidNumber {
-                    pos: parser.tokenizer.pos(),
-                });
-            };
-            object_ids_and_byte_positions.push((
-                PdfObjectIdentifier {
-                    pos: pos.into(),
-                    object_number,
-                    generation_number: 0,
-                },
-                byte_position,
-            ));
-        }
-        for (id, _byte_position) in object_ids_and_byte_positions {
-            let object = parser
-                .parse_object_or_operator()?
-                .error_on_stream_or_operator()?;
-            if self
-                .objects_map
-                .insert(id, PdfObjectAndParseCache::new(object))
-                .is_some()
-            {
-                return Err(PdfParseError::DuplicateIndirectObjectDefinition { pos: id.pos.0, id });
-            }
-        }
-        Ok(())
-    }
-    fn parse_body(&mut self) -> Result<(), PdfParseError> {
-        while let Some(()) = self.parse_indirect_object_definition()? {}
-        let mut object_streams: Vec<PdfStream<PdfObjectStreamDictionary>> = Vec::new();
-        for object in self.objects_map.values_mut() {
-            let stream = match &object.object {
-                PdfObject::Stream(stream) => stream,
-                PdfObject::Boolean(_)
-                | PdfObject::Integer(_)
-                | PdfObject::Real(_)
-                | PdfObject::String(_)
-                | PdfObject::Name(_)
-                | PdfObject::Array(_)
-                | PdfObject::Dictionary(_)
-                | PdfObject::Null(_)
-                | PdfObject::Indirect(_) => continue,
-            };
-            if PdfObjectStreamDictionary::parse_type_from_dictionary(&stream.dictionary().rest)
-                .is_ok()
-            {
-                object_streams.push(PdfStream::parse(object.object.clone())?);
-            }
-        }
-        for object_stream in &object_streams {
-            self.parse_object_stream(object_stream)?;
-        }
-        let Ok(()) = self.parser.objects.inner.set(PdfObjectsInner {
-            objects: std::mem::take(&mut self.objects_map),
-            object_streams,
-        }) else {
-            unreachable!();
-        };
-        Ok(())
-    }
-    fn parse_xref_table(&mut self) -> Result<(), PdfParseError> {
-        self.parser.skip_comments_and_whitespace();
-        let xref_pos = self.parser.tokenizer.pos();
-        let Some(PdfToken::Regular(b"xref")) = self.parser.tokenizer.peek() else {
-            return Ok(());
-        };
-        todo!("{xref_pos}")
-    }
-    fn parse_trailer(&mut self) -> Result<PdfTrailer, PdfParseError> {
-        self.parser.skip_comments_and_whitespace();
-        let trailer_pos = self.parser.tokenizer.pos();
-        let trailer_dictionary = match self.parser.tokenizer.peek() {
-            Some(PdfToken::Regular(b"trailer")) => {
-                self.parser.tokenizer.next();
-                Some(PdfTrailerDictionary::parse(self.parse_object()?)?)
-            }
-            Some(PdfToken::Regular(b"startxref")) => None,
-            _ => {
-                return Err(PdfParseError::MissingTrailer { pos: trailer_pos });
-            }
-        };
-        self.parser.skip_comments_and_whitespace();
-        let start_xref_kw_pos = self.parser.tokenizer.pos();
-        let Some(PdfToken::Regular(b"startxref")) = self.parser.tokenizer.next() else {
-            return Err(PdfParseError::MissingStartXRefKeyword {
-                pos: start_xref_kw_pos,
-            });
-        };
-        let start_xref_pos = self.parser.tokenizer.pos();
-        let Some((start_xref_pos, start_xref)) = self
-            .parser
-            .parse_digits(|pos| Err(PdfParseError::IntegerOutOfRange { pos }))?
-        else {
-            return Err(PdfParseError::MissingStartXRefValue {
-                pos: start_xref_pos,
-            });
-        };
-        self.parser.tokenizer.skip_whitespace();
-        let eof_comment_pos = self.parser.tokenizer.pos();
-        let Some(PdfToken::Comment(b"%%EOF" | b"%%EOF\r" | b"%%EOF\r\n" | b"%%EOF\n")) =
-            self.parser.tokenizer.next()
-        else {
-            return Err(PdfParseError::MissingEofComment {
-                pos: eof_comment_pos,
-            });
-        };
-        self.parser.tokenizer.skip_whitespace();
-        if let Some(byte) = self.parser.tokenizer.peek_byte() {
-            return Err(PdfParseError::UnexpectedByte {
-                pos: self.parser.tokenizer.pos(),
-                byte,
-            });
-        }
-        if let Some(trailer_dictionary) = trailer_dictionary {
-            return Ok(PdfTrailer::Trailer {
-                trailer_dictionary,
-                start_xref,
-            });
-        }
-        let id = PdfParser {
-            tokenizer: PdfTokenizer::new(
-                self.parser.tokenizer.bytes,
-                PdfInputPositionKnown {
-                    pos: start_xref,
-                    containing_streams_pos: None,
-                },
-            ),
-            objects: self.parser.objects.clone(),
-        }
-        .parse_object_identifier(false);
-        let Some(id) = id? else {
-            return Err(PdfParseError::InvalidStartXRefValue {
-                pos: start_xref_pos,
-                start_xref,
-            });
-        };
-        let xref_stream = PdfStream::parse(
-            PdfObjectIndirect::new(&self.parser.objects, id)
-                .get()
-                .into(),
-        )?;
-        Ok(PdfTrailer::Stream {
-            xref_stream,
-            start_xref,
-        })
-    }
-    fn parse_file(mut self) -> Result<Pdf, PdfParseError> {
-        let header = self.parse_header()?;
-        self.parse_body()?;
-        self.parse_xref_table()?;
-        let trailer = self.parse_trailer()?;
-        Ok(Pdf {
-            header,
-            objects: self.parser.objects,
-            trailer,
-        })
-    }
-}
-
-impl Pdf {
-    pub fn parse(bytes: impl AsRef<[u8]>) -> Result<Pdf, PdfParseError> {
-        PdfFileParser {
-            parser: PdfParser {
-                objects: Arc::new(PdfObjects {
-                    inner: OnceLock::new(),
-                }),
-                tokenizer: PdfTokenizer::new(
-                    bytes.as_ref(),
-                    PdfInputPositionKnown {
-                        pos: 0,
-                        containing_streams_pos: None,
-                    },
-                ),
-            },
-            objects_map: BTreeMap::new(),
-        }
-        .parse_file()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        pdf::{
-            object::{
-                PdfBoolean, PdfDictionary, PdfInteger, PdfName, PdfNull, PdfObject, PdfString,
-            },
-            parse::{PdfInputPosition, PdfParse, PdfParseError},
-        },
-        util::ArcOrRef,
-    };
-
-    #[test]
-    fn test_deserialize_dict() -> Result<(), PdfParseError> {
-        crate::pdf::parse::pdf_parse! {
-            #[pdf]
-            #[derive(Debug)]
-            #[allow(dead_code)]
-            struct TestStruct {
-                #[pdf(name = "a")]
-                a: i32,
-                #[pdf(name = "c")]
-                c: i32,
-                #[pdf(name = "b")]
-                b: i32,
-                #[pdf(flatten)]
-                rest: PdfDictionary,
-            }
-        }
-
-        let v: TestStruct = PdfParse::parse(PdfObject::from(PdfDictionary::from_iter([
-            (
-                PdfName::new_static(b"a"),
-                PdfInteger::new(PdfInputPosition::empty(), 1).into(),
-            ),
-            (
-                PdfName::new_static(b"c"),
-                PdfInteger::new(PdfInputPosition::empty(), 7).into(),
-            ),
-            (
-                PdfName::new_static(b"b"),
-                PdfInteger::new(PdfInputPosition::empty(), 5).into(),
-            ),
-            (
-                PdfName::new_static(b"d"),
-                PdfBoolean::new(PdfInputPosition::empty(), false).into(),
-            ),
-            (
-                PdfName::new_static(b"e"),
-                PdfNull::new(PdfInputPosition::empty()).into(),
-            ),
-            (
-                PdfName::new_static(b"f"),
-                PdfString::new(PdfInputPosition::empty(), ArcOrRef::Ref(b"test")).into(),
-            ),
-        ])))?;
-        let expected = TestStruct {
-            a: 1,
-            c: 7,
-            b: 5,
-            rest: PdfDictionary::from_iter([
-                (
-                    PdfName::new_static(b"d"),
-                    PdfBoolean::new(PdfInputPosition::empty(), false).into(),
-                ),
-                (
-                    PdfName::new_static(b"f"),
-                    PdfString::new(PdfInputPosition::empty(), ArcOrRef::Ref(b"test")).into(),
-                ),
-            ]),
-        };
-        assert_eq!(format!("{v:?}"), format!("{expected:?}"));
-        Ok(())
-    }
-}
diff --git a/src/pdf/content_stream.rs b/src/pdf/content_stream.rs
deleted file mode 100644
index 79764c2..0000000
--- a/src/pdf/content_stream.rs
+++ /dev/null
@@ -1,829 +0,0 @@
-use crate::{
-    pdf::{
-        PdfObjectOrStreamDictionaryOrOperator, PdfObjects, PdfParser, PdfTokenizer,
-        object::{
-            NameOr, PdfDictionary, PdfMatrix, PdfName, PdfObject, PdfObjectDirect, PdfRectangle,
-            PdfStream, PdfStreamContents, PdfString, PdfStringBytesDebug, PdfStringOrNumber,
-            PdfVec2D,
-        },
-        parse::{
-            GetPdfInputPosition, PdfInputPosition, PdfInputPositionKnown,
-            PdfInputPositionNoCompare, PdfParse, PdfParseError,
-        },
-        render::{
-            PdfColorDeviceGray, PdfColorDeviceRgb, PdfRenderOperator, PdfRenderState,
-            PdfRenderingIntent,
-        },
-    },
-    util::ArcOrRef,
-};
-use std::{fmt, sync::Arc};
-
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct PdfOperatorUnparsed {
-    pos: PdfInputPositionNoCompare,
-    bytes: ArcOrRef<'static, [u8]>,
-}
-
-impl GetPdfInputPosition for PdfOperatorUnparsed {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos()
-    }
-}
-
-impl fmt::Debug for PdfOperatorUnparsed {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Self::debug_with_name("PdfOperatorUnparsed", &self.bytes, self.pos.0, f)
-    }
-}
-
-trait PdfParseIter: Sized {
-    fn parse_iter(iter: impl IntoIterator<Item = PdfObject>) -> Result<Self, PdfParseError>;
-}
-
-impl<T: PdfParse> PdfParseIter for Arc<[T]> {
-    fn parse_iter(iter: impl IntoIterator<Item = PdfObject>) -> Result<Self, PdfParseError> {
-        FromIterator::from_iter(iter.into_iter().map(T::parse))
-    }
-}
-
-impl PdfOperatorUnparsed {
-    pub fn new(
-        pos: impl Into<PdfInputPositionNoCompare>,
-        bytes: impl Into<ArcOrRef<'static, [u8]>>,
-    ) -> Self {
-        Self {
-            pos: pos.into(),
-            bytes: bytes.into(),
-        }
-    }
-    pub const fn new_static(bytes: &'static [u8]) -> Self {
-        Self {
-            pos: PdfInputPositionNoCompare::empty(),
-            bytes: ArcOrRef::Ref(bytes),
-        }
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn bytes(&self) -> &ArcOrRef<'static, [u8]> {
-        &self.bytes
-    }
-    fn debug_with_name(
-        name: &str,
-        pdf_name: &[u8],
-        pos: PdfInputPosition,
-        f: &mut fmt::Formatter<'_>,
-    ) -> fmt::Result {
-        write!(f, "{name}(at {pos}, {})", PdfStringBytesDebug(pdf_name))
-    }
-    pub fn bytes_debug(&self) -> PdfStringBytesDebug<'_> {
-        PdfStringBytesDebug(&self.bytes)
-    }
-}
-
-macro_rules! make_pdf_operator_enum {
-    (
-        $(#[$($operator_meta:tt)*])*
-        $operator_enum_vis:vis enum $PdfOperator:ident;
-
-        $(#[$($operator_and_operands_meta:tt)*])*
-        $enum_vis:vis enum $PdfOperatorAndOperands:ident {
-            $(#[$($unknown_variant_meta:tt)*])*
-            $Unknown:ident {
-                $(#[$($unknown_operands_meta:tt)*])*
-                $unknown_operands:ident: $unknown_operands_ty:ty,
-                $(#[$($unknown_operator_meta:tt)*])*
-                $unknown_operator:ident: $unknown_operator_ty:ty,
-            },
-            $(
-                #[kw = $kw:literal]
-                $(#[$($variant_meta:tt)*])*
-                $Variant:ident($VariantStruct:ident {
-                    $pos:ident: PdfInputPositionNoCompare,
-                    $(
-                        #[$field_parse:ident($($parse_args:tt)*)]
-                        $(#[$($field_meta:tt)*])*
-                        $field:ident: $field_ty:ty,
-                    )*
-                }),
-            )*
-        }
-    ) => {
-        $(#[$($operator_meta)*])*
-        $operator_enum_vis enum $PdfOperator {
-            $(#[$($unknown_variant_meta)*])*
-            $Unknown($unknown_operator_ty),
-            $(
-                $(#[$($variant_meta)*])*
-                $Variant(PdfInputPositionNoCompare),
-            )*
-        }
-
-        impl $PdfOperator {
-            $operator_enum_vis fn parse(self, operands: impl IntoIterator<Item = PdfObject>) -> Result<$PdfOperatorAndOperands, PdfParseError> {
-                let operands = operands.into_iter();
-                Ok(match self {
-                    Self::$Unknown(operator) => $PdfOperatorAndOperands::$Unknown {
-                        operands: FromIterator::from_iter(operands.map(Into::into)),
-                        operator,
-                    },
-                    $(Self::$Variant(pos) => $VariantStruct::parse(pos, operands)?.into(),)*
-                })
-            }
-            $operator_enum_vis fn pos(&self) -> PdfInputPosition {
-                match *self {
-                    Self::$Unknown(ref operator) => operator.pos(),
-                    $(Self::$Variant(pos) => pos.0,)*
-                }
-            }
-        }
-
-        impl fmt::Debug for $PdfOperator {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                match self {
-                    Self::$Unknown(operator) => PdfOperatorUnparsed::debug_with_name("Unknown", &operator.bytes, operator.pos.0, f),
-                    $(Self::$Variant(pos) => PdfOperatorUnparsed::debug_with_name(stringify!($Variant), $kw, pos.0, f),)*
-                }
-            }
-        }
-
-        impl From<$PdfOperator> for PdfOperatorUnparsed {
-            fn from(v: $PdfOperator) -> PdfOperatorUnparsed {
-                match v {
-                    $PdfOperator::$Unknown(operator) => operator,
-                    $($PdfOperator::$Variant(pos) => PdfOperatorUnparsed { pos, bytes: ArcOrRef::Ref($kw) },)*
-                }
-            }
-        }
-
-        impl From<PdfOperatorUnparsed> for $PdfOperator {
-            fn from(v: PdfOperatorUnparsed) -> $PdfOperator {
-                match &**v.bytes() {
-                    $($kw => Self::$Variant(v.pos),)*
-                    _ => Self::$Unknown(v),
-                }
-            }
-        }
-
-        $(#[derive(Clone)]
-        $(#[$($variant_meta)*])*
-        $enum_vis struct $VariantStruct {
-            $enum_vis $pos: PdfInputPositionNoCompare,
-            $(
-                $(#[$($field_meta)*])*
-                $enum_vis $field: $field_ty,
-            )*
-        }
-
-        impl fmt::Debug for $VariantStruct {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                f.debug_struct(stringify!($VariantStruct)).field("pos", &self.pos)$(.field(stringify!($field), &self.$field))*.finish()
-            }
-        }
-
-        impl GetPdfInputPosition for $VariantStruct {
-            fn get_pdf_input_position(&self) -> PdfInputPosition {
-                self.pos()
-            }
-        }
-
-        impl From<$VariantStruct> for $PdfOperatorAndOperands {
-            fn from(v: $VariantStruct) -> Self {
-                Self::$Variant(v)
-            }
-        }
-
-        impl $VariantStruct {
-            $enum_vis fn operator_from_pos(pos: impl Into<PdfInputPositionNoCompare>) -> $PdfOperator {
-                $PdfOperator::$Variant(pos.into())
-            }
-            $enum_vis fn operator(&self) -> $PdfOperator {
-                $PdfOperator::$Variant(self.pos)
-            }
-            $enum_vis fn pos(&self) -> PdfInputPosition {
-                self.pos.0
-            }
-        }
-
-        make_pdf_operator_enum! {
-            @impl_variant_parse
-            $enum_vis enum;
-            struct $VariantStruct {
-                $pos: PdfInputPositionNoCompare,
-                $(
-                    #[$field_parse($($parse_args)*)]
-                    $(#[$($field_meta)*])*
-                    $field: $field_ty,
-                )*
-            }
-        })*
-
-        $(#[$($operator_and_operands_meta)*])*
-        $enum_vis enum $PdfOperatorAndOperands {
-            $(#[$($unknown_variant_meta)*])*
-            $Unknown {
-                $(#[$($unknown_operands_meta)*])*
-                $unknown_operands: $unknown_operands_ty,
-                $(#[$($unknown_operator_meta)*])*
-                $unknown_operator: $unknown_operator_ty,
-            },
-            $(
-                $(#[$($variant_meta)*])*
-                $Variant($VariantStruct),
-            )*
-        }
-
-        impl $PdfOperatorAndOperands {
-            $enum_vis fn operator(&self) -> $PdfOperator {
-                match self {
-                    Self::Unknown { operator, .. } => $PdfOperator::Unknown(operator.clone()),
-                    $(Self::$Variant(v) => v.operator(),)*
-                }
-            }
-            $enum_vis fn pos(&self) -> PdfInputPosition {
-                match self {
-                    Self::$Unknown { operator, .. } => operator.pos(),
-                    $(Self::$Variant(v) => v.pos(),)*
-                }
-            }
-        }
-
-        impl fmt::Debug for $PdfOperatorAndOperands {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                match self {
-                    Self::$Unknown {
-                        operands,
-                        operator,
-                    } => f.debug_struct("Unknown").field("operator", operator).field("operands", operands).finish(),
-                    $(Self::$Variant($VariantStruct {
-                        $pos,
-                        $($field,)*
-                    }) => f.debug_struct(stringify!($Variant)).field("pos", $pos)$(.field(stringify!($field), $field))*.finish(),)*
-                }
-            }
-        }
-
-        impl PdfRenderOperator for $PdfOperatorAndOperands {
-            fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-                match self {
-                    Self::$Unknown {
-                        operands,
-                        operator,
-                    } => state.handle_unknown_operator(operator, operands),
-                    $(Self::$Variant(v) => <$VariantStruct as PdfRenderOperator>::render(v, state),)*
-                }
-            }
-        }
-    };
-    (
-        @impl_variant_parse
-        $enum_vis:vis enum;
-        struct $VariantStruct:ident {
-            $pos:ident: PdfInputPositionNoCompare,
-            $(
-                #[$field_parse:ident($($parse_args:ident),* $(,)?)]
-                $(#[$($field_meta:tt)*])*
-                $field:ident: $field_ty:ty,
-            )*
-        }
-    ) => {
-        impl $VariantStruct {
-            $enum_vis fn parse(pos: impl Into<PdfInputPositionNoCompare>, operands: impl IntoIterator<Item = PdfObject>) -> Result<Self, PdfParseError> {
-                let pos = pos.into();
-                let mut operands = operands.into_iter();
-                $($(let Some($parse_args) = operands.next() else {
-                    return Err(PdfParseError::OperatorHasTooFewOperands { operator: Self::operator_from_pos(pos) });
-                };)*)*
-                if operands.next().is_some() {
-                    return Err(PdfParseError::OperatorHasTooManyOperands { operator: Self::operator_from_pos(pos) });
-                }
-                Ok(Self {
-                    pos,
-                    $($field: <$field_ty>::$field_parse($($parse_args),*)?,)*
-                })
-            }
-        }
-    };
-    (
-        @impl_variant_parse
-        $enum_vis:vis enum;
-        struct $VariantStruct:ident {
-            $pos:ident: PdfInputPositionNoCompare,
-            #[$field_parse:ident(...)]
-            $(#[$($field_meta:tt)*])*
-            $field:ident: $field_ty:ty,
-        }
-    ) => {
-        impl $VariantStruct {
-            $enum_vis fn parse(pos: impl Into<PdfInputPositionNoCompare>, operands: impl IntoIterator<Item = PdfObject>) -> Result<Self, PdfParseError> {
-                let pos = pos.into();
-                let operands = operands.into_iter();
-                Ok(Self {
-                    pos,
-                    $field: <$field_ty>::$field_parse(operands)?,
-                })
-            }
-        }
-    };
-}
-
-make_pdf_operator_enum! {
-    #[derive(Clone)]
-    pub enum PdfOperator;
-    #[derive(Clone)]
-    pub enum PdfOperatorAndOperands {
-        Unknown {
-            operands: Arc<[PdfObjectDirect]>,
-            operator: PdfOperatorUnparsed,
-        },
-        #[kw = b"b"]
-        CloseFillAndStrokePath(PdfOperatorCloseFillAndStrokePath {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"B"]
-        FillAndStrokePath(PdfOperatorFillAndStrokePath {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"b*"]
-        CloseFillAndStrokePathEvenOdd(PdfOperatorCloseFillAndStrokePathEvenOdd {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"B*"]
-        FillAndStrokePathEvenOdd(PdfOperatorFillAndStrokePathEvenOdd {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"BDC"]
-        BeginMarkedContentWithProperties(PdfOperatorBeginMarkedContentWithProperties {
-            pos: PdfInputPositionNoCompare,
-            #[parse(tag)]
-            tag: PdfName,
-            #[parse(properties)]
-            properties: NameOr<PdfDictionary>,
-        }),
-        #[kw = b"BI"]
-        BeginInlineImage(PdfOperatorBeginInlineImage {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"BMC"]
-        BeginMarkedContent(PdfOperatorBeginMarkedContent {
-            pos: PdfInputPositionNoCompare,
-            #[parse(tag)]
-            tag: PdfName,
-        }),
-        #[kw = b"BT"]
-        BeginText(PdfOperatorBeginText {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"BX"]
-        BeginCompatibilitySection(PdfOperatorBeginCompatibilitySection {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"c"]
-        CurveTo(PdfOperatorCurveTo {
-            pos: PdfInputPositionNoCompare,
-            #[parse(x1, y1)]
-            p1: PdfVec2D,
-            #[parse(x2, y2)]
-            p2: PdfVec2D,
-            #[parse(x3, y3)]
-            p3: PdfVec2D,
-        }),
-        #[kw = b"cm"]
-        ConcatMatrix(PdfOperatorConcatMatrix {
-            pos: PdfInputPositionNoCompare,
-            #[parse_flat(a, b, c, d, e, f)]
-            matrix: PdfMatrix,
-        }),
-        #[kw = b"CS"]
-        SetStrokeColorSpace(PdfOperatorSetStrokeColorSpace {
-            pos: PdfInputPositionNoCompare,
-            #[parse(name)]
-            name: PdfName,
-        }),
-        #[kw = b"cs"]
-        SetNonStrokeColorSpace(PdfOperatorSetNonStrokeColorSpace {
-            pos: PdfInputPositionNoCompare,
-            #[parse(name)]
-            name: PdfName,
-        }),
-        #[kw = b"d"]
-        SetLineDashPattern(PdfOperatorSetLineDashPattern {
-            pos: PdfInputPositionNoCompare,
-            #[parse(dash_array)]
-            dash_array: PdfObject, // TODO: actually parse
-            #[parse(dash_phase)]
-            dash_phase: PdfObject, // TODO: actually parse
-        }),
-        #[kw = b"d0"]
-        FontType3SetWidth(PdfOperatorFontType3SetWidth {
-            pos: PdfInputPositionNoCompare,
-            #[parse(x, y)]
-            width: PdfVec2D,
-        }),
-        #[kw = b"d1"]
-        FontType3SetWidthAndBBox(PdfOperatorFontType3SetWidthAndBBox {
-            pos: PdfInputPositionNoCompare,
-            #[parse(width_x, width_y)]
-            width: PdfVec2D,
-            #[parse_flat(lower_left_x, lower_left_y, upper_right_x, upper_right_y)]
-            bbox: PdfRectangle,
-        }),
-        #[kw = b"Do"]
-        PaintXObject(PdfOperatorPaintXObject {
-            pos: PdfInputPositionNoCompare,
-            #[parse(name)]
-            name: PdfName,
-        }),
-        #[kw = b"DP"]
-        DesignateMarkedContentPointWithProperties(PdfOperatorDesignateMarkedContentPointWithProperties {
-            pos: PdfInputPositionNoCompare,
-            #[parse(tag)]
-            tag: PdfName,
-            #[parse(properties)]
-            properties: NameOr<PdfDictionary>,
-        }),
-        #[kw = b"EI"]
-        EndInlineImage(PdfOperatorEndInlineImage {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"EMC"]
-        EndMarkedContent(PdfOperatorEndMarkedContent {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"ET"]
-        EndText(PdfOperatorEndText {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"EX"]
-        EndCompatibilitySection(PdfOperatorEndCompatibilitySection {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"f"]
-        FillPath(PdfOperatorFillPath {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"F"]
-        FillPathObsolete(PdfOperatorFillPathObsolete {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"f*"]
-        FillPathEvenOdd(PdfOperatorFillPathEvenOdd {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"G"]
-        SetStrokeGray(PdfOperatorSetStrokeGray {
-            pos: PdfInputPositionNoCompare,
-            #[parse(gray)]
-            gray: PdfColorDeviceGray,
-        }),
-        #[kw = b"g"]
-        SetNonStrokeGray(PdfOperatorSetNonStrokeGray {
-            pos: PdfInputPositionNoCompare,
-            #[parse(gray)]
-            gray: PdfColorDeviceGray,
-        }),
-        #[kw = b"gs"]
-        SetGraphicsState(PdfOperatorSetGraphicsState {
-            pos: PdfInputPositionNoCompare,
-            #[parse(dictionary_name)]
-            dictionary_name: PdfName,
-        }),
-        #[kw = b"h"]
-        CloseSubpath(PdfOperatorCloseSubpath {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"i"]
-        SetFlatnessTolerance(PdfOperatorSetFlatnessTolerance {
-            pos: PdfInputPositionNoCompare,
-            #[parse(flatness)]
-            flatness: f32,
-        }),
-        #[kw = b"ID"]
-        BeginInlineImageData(PdfOperatorBeginInlineImageData {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"j"]
-        SetLineJoinStyle(PdfOperatorSetLineJoinStyle {
-            pos: PdfInputPositionNoCompare,
-            #[parse(line_join_style)]
-            line_join_style: u8, // TODO parse
-        }),
-        #[kw = b"J"]
-        SetLineCapStyle(PdfOperatorSetLineCapStyle {
-            pos: PdfInputPositionNoCompare,
-            #[parse(line_cap_style)]
-            line_cap_style: u8, // TODO parse
-        }),
-        #[kw = b"K"]
-        SetStrokeCmyk(PdfOperatorSetStrokeCmyk {
-            pos: PdfInputPositionNoCompare,
-            #[parse(c)]
-            c: f32,
-            #[parse(m)]
-            m: f32,
-            #[parse(y)]
-            y: f32,
-            #[parse(k)]
-            k: f32,
-        }),
-        #[kw = b"k"]
-        SetNonStrokeCmyk(PdfOperatorSetNonStrokeCmyk {
-            pos: PdfInputPositionNoCompare,
-            #[parse(c)]
-            c: f32,
-            #[parse(m)]
-            m: f32,
-            #[parse(y)]
-            y: f32,
-            #[parse(k)]
-            k: f32,
-        }),
-        #[kw = b"l"]
-        LineTo(PdfOperatorLineTo {
-            pos: PdfInputPositionNoCompare,
-            #[parse(x, y)]
-            to: PdfVec2D,
-        }),
-        #[kw = b"m"]
-        MoveTo(PdfOperatorMoveTo {
-            pos: PdfInputPositionNoCompare,
-            #[parse(x, y)]
-            to: PdfVec2D,
-        }),
-        #[kw = b"M"]
-        SetMiterLimit(PdfOperatorSetMiterLimit {
-            pos: PdfInputPositionNoCompare,
-            #[parse(limit)]
-            limit: f32,
-        }),
-        #[kw = b"MP"]
-        DesignateMarkedContentPoint(PdfOperatorDesignateMarkedContentPoint {
-            pos: PdfInputPositionNoCompare,
-            #[parse(tag)]
-            tag: PdfName,
-        }),
-        #[kw = b"n"]
-        EndPath(PdfOperatorEndPath {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"q"]
-        SaveGraphicsState(PdfOperatorSaveGraphicsState {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"Q"]
-        RestoreGraphicsState(PdfOperatorRestoreGraphicsState {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"re"]
-        Rectangle(PdfOperatorRectangle {
-            pos: PdfInputPositionNoCompare,
-            #[parse(x, y)]
-            p: PdfVec2D,
-            #[parse(width, height)]
-            size: PdfVec2D,
-        }),
-        #[kw = b"RG"]
-        SetStrokeRgb(PdfOperatorSetStrokeRgb {
-            pos: PdfInputPositionNoCompare,
-            #[parse_flat(r, g, b)]
-            color: PdfColorDeviceRgb,
-        }),
-        #[kw = b"rg"]
-        SetNonStrokeRgb(PdfOperatorSetNonStrokeRgb {
-            pos: PdfInputPositionNoCompare,
-            #[parse_flat(r, g, b)]
-            color: PdfColorDeviceRgb,
-        }),
-        #[kw = b"ri"]
-        SetColorRenderingIntent(PdfOperatorSetColorRenderingIntent {
-            pos: PdfInputPositionNoCompare,
-            #[parse(intent)]
-            intent: PdfRenderingIntent,
-        }),
-        #[kw = b"s"]
-        CloseAndStrokePath(PdfOperatorCloseAndStrokePath {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"S"]
-        StrokePath(PdfOperatorStrokePath {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"SC"]
-        SetStrokeColor(PdfOperatorSetStrokeColor {
-            pos: PdfInputPositionNoCompare,
-            #[parse_iter(...)]
-            color: Arc<[f32]>,
-        }),
-        #[kw = b"sc"]
-        SetNonStrokeColor(PdfOperatorSetNonStrokeColor {
-            pos: PdfInputPositionNoCompare,
-            #[parse_iter(...)]
-            color: Arc<[f32]>,
-        }),
-        #[kw = b"SCN"]
-        SetStrokeColorWithName(PdfOperatorSetStrokeColorWithName {
-            pos: PdfInputPositionNoCompare,
-            #[parse_iter(...)]
-            color_and_name: Arc<[NameOr<f32>]>,
-        }),
-        #[kw = b"scn"]
-        SetNonStrokeColorWithName(PdfOperatorSetNonStrokeColorWithName {
-            pos: PdfInputPositionNoCompare,
-            #[parse_iter(...)]
-            color_and_name: Arc<[NameOr<f32>]>,
-        }),
-        #[kw = b"sh"]
-        Shade(PdfOperatorShade {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"T*"]
-        TextNextLine(PdfOperatorTextNextLine {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"Tc"]
-        SetCharacterSpacing(PdfOperatorSetCharacterSpacing {
-            pos: PdfInputPositionNoCompare,
-            #[parse(char_space)]
-            char_space: f32,
-        }),
-        #[kw = b"Td"]
-        TextNextLineWithOffset(PdfOperatorTextNextLineWithOffset {
-            pos: PdfInputPositionNoCompare,
-            #[parse(x, y)]
-            offset: PdfVec2D,
-        }),
-        #[kw = b"TD"]
-        TextNextLineWithOffsetAndLeading(PdfOperatorTextNextLineWithOffsetAndLeading {
-            pos: PdfInputPositionNoCompare,
-            #[parse(x, y)]
-            offset: PdfVec2D,
-        }),
-        #[kw = b"Tf"]
-        SetFontAndSize(PdfOperatorSetFontAndSize {
-            pos: PdfInputPositionNoCompare,
-            #[parse(font)]
-            font: PdfName,
-            #[parse(size)]
-            size: f32,
-        }),
-        #[kw = b"Tj"]
-        ShowText(PdfOperatorShowText {
-            pos: PdfInputPositionNoCompare,
-            #[parse(text)]
-            text: PdfString,
-        }),
-        #[kw = b"TJ"]
-        ShowTextWithGlyphPositioning(PdfOperatorShowTextWithGlyphPositioning {
-            pos: PdfInputPositionNoCompare,
-            #[parse(text_and_positioning)]
-            text_and_positioning: Arc<[PdfStringOrNumber]>,
-        }),
-        #[kw = b"TL"]
-        SetTextLeading(PdfOperatorSetTextLeading {
-            pos: PdfInputPositionNoCompare,
-            #[parse(leading)]
-            leading: f32,
-        }),
-        #[kw = b"Tm"]
-        SetTextMatrix(PdfOperatorSetTextMatrix {
-            pos: PdfInputPositionNoCompare,
-            #[parse_flat(a, b, c, d, e, f)]
-            matrix: PdfMatrix,
-        }),
-        #[kw = b"Tr"]
-        SetTextRenderingMode(PdfOperatorSetTextRenderingMode {
-            pos: PdfInputPositionNoCompare,
-            #[parse(rendering_mode)]
-            rendering_mode: u8, // TODO: parse
-        }),
-        #[kw = b"Ts"]
-        SetTextRise(PdfOperatorSetTextRise {
-            pos: PdfInputPositionNoCompare,
-            #[parse(rise)]
-            rise: f32,
-        }),
-        #[kw = b"Tw"]
-        SetWordSpacing(PdfOperatorSetWordSpacing {
-            pos: PdfInputPositionNoCompare,
-            #[parse(word_space)]
-            word_space: f32,
-        }),
-        #[kw = b"Tz"]
-        SetTextHorizontalScaling(PdfOperatorSetTextHorizontalScaling {
-            pos: PdfInputPositionNoCompare,
-            #[parse(scale_percent)]
-            scale_percent: f32,
-        }),
-        #[kw = b"v"]
-        CurveTo23(PdfOperatorCurveTo23 {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"w"]
-        SetLineWidth(PdfOperatorSetLineWidth {
-            pos: PdfInputPositionNoCompare,
-            #[parse(line_width)]
-            line_width: f32,
-        }),
-        #[kw = b"W"]
-        Clip(PdfOperatorClip {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"W*"]
-        ClipEvenOdd(PdfOperatorClipEvenOdd {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"y"]
-        CurveTo13(PdfOperatorCurveTo13 {
-            pos: PdfInputPositionNoCompare,
-        }),
-        #[kw = b"'"]
-        TextNextLineAndShow(PdfOperatorTextNextLineAndShow {
-            pos: PdfInputPositionNoCompare,
-            #[parse(text)]
-            text: PdfString,
-        }),
-        #[kw = b"\""]
-        SetSpacingThenTextNextLineAndShow(PdfOperatorSetSpacingThenTextNextLineAndShow {
-            pos: PdfInputPositionNoCompare,
-            #[parse(word_space)]
-            word_space: f32,
-            #[parse(char_space)]
-            char_space: f32,
-            #[parse(text)]
-            text: PdfString,
-        }),
-    }
-}
-
-impl GetPdfInputPosition for PdfOperator {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos()
-    }
-}
-
-impl GetPdfInputPosition for PdfOperatorAndOperands {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos()
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfContentStreamData {
-    pub operators: Arc<[PdfOperatorAndOperands]>,
-}
-
-impl fmt::Debug for PdfContentStreamData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("PdfContentStreamData")
-            .field("operators", &self.operators)
-            .finish()
-    }
-}
-
-impl PdfStreamContents for PdfContentStreamData {
-    fn parse(
-        data: &[u8],
-        stream_pos: PdfInputPosition,
-        objects: Arc<PdfObjects>,
-    ) -> Result<Self, PdfParseError> {
-        let mut parser = PdfParser {
-            objects,
-            tokenizer: PdfTokenizer::new(
-                data,
-                PdfInputPositionKnown {
-                    pos: 0,
-                    containing_streams_pos: stream_pos.get().map(|v| v.pos),
-                },
-            ),
-        };
-        let mut operands = Vec::new();
-        let mut operators = Vec::new();
-        loop {
-            parser.skip_comments_and_whitespace();
-            if parser.tokenizer.peek().is_none() {
-                break;
-            }
-            match parser.parse_object_or_operator()? {
-                PdfObjectOrStreamDictionaryOrOperator::StreamDictionary {
-                    stream_kw_pos, ..
-                } => return Err(PdfParseError::StreamNotAllowedHere { pos: stream_kw_pos }),
-                PdfObjectOrStreamDictionaryOrOperator::Object(object) => operands.push(object),
-                PdfObjectOrStreamDictionaryOrOperator::Operator(operator) => {
-                    operators.push(PdfOperator::from(operator).parse(operands.drain(..))?);
-                }
-            }
-        }
-        if operands.is_empty() {
-            Ok(Self {
-                operators: operators.into(),
-            })
-        } else {
-            Err(PdfParseError::MissingOperator {
-                pos: parser.tokenizer.pos(),
-            })
-        }
-    }
-}
-
-pub type PdfContentStream = PdfStream<PdfDictionary, PdfContentStreamData>;
diff --git a/src/pdf/document_structure.rs b/src/pdf/document_structure.rs
deleted file mode 100644
index 268d503..0000000
--- a/src/pdf/document_structure.rs
+++ /dev/null
@@ -1,743 +0,0 @@
-use crate::{
-    pdf::{
-        content_stream::PdfContentStream,
-        font::PdfFont,
-        object::{
-            IsPdfNull, MaybeArray, PdfDate, PdfDictionary, PdfInteger, PdfName, PdfObject,
-            PdfObjectDirect, PdfObjectIndirect, PdfRectangle, PdfStream, PdfString,
-        },
-        parse::{PdfParse, PdfParseError},
-        pdf_parse,
-        render::{PdfRenderOperator, PdfRenderState},
-    },
-    util::DagDebugState,
-};
-use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelIterator};
-use std::{borrow::Cow, fmt, sync::Arc};
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfDocumentCatalogType {
-        #[pdf(name = "Catalog")]
-        #[default]
-        Catalog,
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfDocumentCatalog {
-        #[pdf(name = "Type")]
-        pub ty: PdfDocumentCatalogType,
-        #[pdf(name = "Version")]
-        pub version: Option<PdfName>,
-        #[pdf(name = "Extensions")]
-        pub extensions: Option<PdfDictionary>,
-        #[pdf(name = "Pages")]
-        pub pages: PdfPageTree,
-        // TODO
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl fmt::Debug for PdfDocumentCatalog {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                version,
-                extensions,
-                pages,
-                rest,
-            } = self;
-            f.debug_struct("PdfDocumentCatalog")
-                .field("ty", ty)
-                .field("version", version)
-                .field("extensions", extensions)
-                .field("pages", pages)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone, Debug)]
-    pub struct PdfResourcesDictionary {
-        #[pdf(name = "Font")]
-        pub fonts: PdfDictionary<PdfFont>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfPageTree {
-    page_tree: PdfPageTreeNode,
-    pages: Arc<[PdfPage]>,
-}
-
-impl PdfPageTree {
-    fn collect_leaves(
-        node: &PdfPageTreeNode,
-        leaves: &mut Vec<PdfPageTreeLeaf>,
-    ) -> Result<(), PdfParseError> {
-        for kid in node.kids.iter() {
-            match kid {
-                PdfPageTreeNodeOrLeaf::Node(node) => Self::collect_leaves(node, leaves)?,
-                PdfPageTreeNodeOrLeaf::Leaf(leaf) => {
-                    leaves.push(leaf.clone());
-                }
-                PdfPageTreeNodeOrLeaf::Other(v) => {
-                    return Err(PdfParseError::InvalidType {
-                        pos: v.pos(),
-                        ty: "dictionary",
-                        expected_ty: "PdfPageTreeNodeOrLeaf",
-                    });
-                }
-            }
-        }
-        Ok(())
-    }
-    pub fn try_from_page_tree_root(mut page_tree: PdfPageTreeNode) -> Result<Self, PdfParseError> {
-        page_tree.propagate_inheritable_data_to_leaves();
-        let mut leaves = Vec::new();
-        Self::collect_leaves(&page_tree, &mut leaves)?;
-        Ok(Self {
-            page_tree,
-            pages: Result::from_par_iter(
-                leaves
-                    .into_par_iter()
-                    .map(PdfPage::parse_after_propagating_inheritable_data)
-                    .panic_fuse(),
-            )?,
-        })
-    }
-    pub fn page_tree(&self) -> &PdfPageTreeNode {
-        &self.page_tree
-    }
-    pub fn pages(&self) -> &Arc<[PdfPage]> {
-        &self.pages
-    }
-}
-
-impl fmt::Debug for PdfPageTree {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                page_tree: _,
-                pages,
-            } = self;
-            f.debug_struct("PdfPageTree")
-                .field("pages", pages)
-                .finish_non_exhaustive()
-        })
-    }
-}
-
-impl IsPdfNull for PdfPageTree {
-    fn is_pdf_null(&self) -> bool {
-        self.page_tree.is_pdf_null()
-    }
-}
-
-impl PdfParse for PdfPageTree {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("PdfPageTree")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Self::try_from_page_tree_root(PdfParse::parse(object)?)
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone, Default, Debug)]
-    pub struct PdfPageInheritableData {
-        #[pdf(name = "Resources")]
-        pub resources: Option<PdfResourcesDictionary>,
-        #[pdf(name = "MediaBox")]
-        pub media_box: Option<PdfRectangle>,
-        #[pdf(name = "CropBox")]
-        pub crop_box: Option<PdfRectangle>,
-        #[pdf(name = "Rotate")]
-        pub rotate: Option<PdfPageRotation>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl PdfPageInheritableData {
-    pub fn propagate_to(&self, target: &mut Self) {
-        let Self {
-            resources,
-            media_box,
-            crop_box,
-            rotate,
-            rest: _,
-        } = self;
-        fn propagate_to<T: Clone>(this: &Option<T>, target: &mut Option<T>) {
-            if let (Some(this), target @ None) = (this, target) {
-                *target = Some(this.clone());
-            }
-        }
-        propagate_to(resources, &mut target.resources);
-        propagate_to(media_box, &mut target.media_box);
-        propagate_to(crop_box, &mut target.crop_box);
-        propagate_to(rotate, &mut target.rotate);
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfPageTreeNodeType {
-        #[pdf(name = "Pages")]
-        #[default]
-        Pages,
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfPageTreeNode {
-        #[pdf(name = "Type")]
-        pub ty: PdfPageTreeNodeType,
-        #[pdf(name = "Parent")]
-        pub parent: Option<PdfObjectIndirect>,
-        #[pdf(name = "Kids")]
-        pub kids: Arc<[PdfPageTreeNodeOrLeaf]>,
-        #[pdf(name = "Count")]
-        pub count: usize,
-        // TODO
-        #[pdf(flatten)]
-        pub inheritable: PdfPageInheritableData,
-    }
-}
-
-impl fmt::Debug for PdfPageTreeNode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                parent,
-                kids,
-                count,
-                inheritable,
-            } = self;
-            f.debug_struct("PdfPageTreeNode")
-                .field("ty", ty)
-                .field("parent", parent)
-                .field("kids", kids)
-                .field("count", count)
-                .field("inheritable", inheritable)
-                .finish()
-        })
-    }
-}
-
-impl PdfPageTreeNode {
-    pub fn propagate_inheritable_data_to_leaves(&mut self) {
-        for kid in Arc::make_mut(&mut self.kids) {
-            if let Some(target) = kid.inheritable_data_mut() {
-                self.inheritable.propagate_to(target);
-            }
-            kid.propagate_inheritable_data_to_leaves();
-        }
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfPageType {
-        #[pdf(name = "Page")]
-        #[default]
-        Page,
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-    pub enum PdfPageAnnotationsTabOrder {
-        #[pdf(name = "R")]
-        RowOrder,
-        #[pdf(name = "C")]
-        ColumnOrder,
-        #[pdf(name = "S")]
-        StructureOrder,
-        #[pdf(other)]
-        Other(PdfName),
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfPageTreeLeaf {
-        #[pdf(name = "Type")]
-        pub ty: PdfPageType,
-        #[pdf(name = "Parent")]
-        pub parent: PdfObjectIndirect,
-        #[pdf(name = "LastModified")]
-        pub last_modified: Option<PdfDate>,
-        #[pdf(name = "BleedBox")]
-        pub bleed_box: Option<PdfRectangle>,
-        #[pdf(name = "TrimBox")]
-        pub trim_box: Option<PdfRectangle>,
-        #[pdf(name = "ArtBox")]
-        pub art_box: Option<PdfRectangle>,
-        #[pdf(name = "BoxColorInfo")]
-        pub box_color_info: Option<PdfDictionary>,
-        #[pdf(name = "Contents")]
-        pub contents: MaybeArray<PdfContentStream>,
-        #[pdf(name = "Group")]
-        pub group: Option<PdfDictionary>,
-        #[pdf(name = "Thumb")]
-        pub thumbnail: Option<PdfStream>,
-        #[pdf(name = "B")]
-        pub beads: Option<Arc<[PdfDictionary]>>,
-        #[pdf(name = "Dur")]
-        pub duration: Option<f32>,
-        #[pdf(name = "Trans")]
-        pub transition: Option<PdfDictionary>,
-        #[pdf(name = "Annots")]
-        pub annotations: Option<Arc<[PdfDictionary]>>,
-        #[pdf(name = "AA")]
-        pub additional_actions: Option<PdfDictionary>,
-        #[pdf(name = "Metadata")]
-        pub metadata: Option<PdfStream>,
-        #[pdf(name = "PieceInfo")]
-        pub piece_info: Option<PdfDictionary>,
-        #[pdf(name = "StructParents")]
-        pub structural_parents: Option<PdfInteger>,
-        #[pdf(name = "ID")]
-        pub parent_web_capture_content_set_id: Option<PdfString>,
-        #[pdf(name = "PZ")]
-        pub preferred_zoom_factor: Option<f32>,
-        #[pdf(name = "SeparationInfo")]
-        pub separation_info: Option<PdfDictionary>,
-        #[pdf(name = "Tabs")]
-        pub annotations_tab_order: Option<PdfPageAnnotationsTabOrder>,
-        #[pdf(name = "TemplateInstantiated")]
-        pub template_instantiated: Option<PdfName>,
-        #[pdf(name = "PresSteps")]
-        pub pres_steps: Option<PdfDictionary>,
-        #[pdf(name = "UserUnit")]
-        pub user_unit: Option<f32>,
-        #[pdf(name = "VP")]
-        pub viewports: Option<Arc<[PdfDictionary]>>,
-        #[pdf(flatten)]
-        pub inheritable: PdfPageInheritableData,
-    }
-}
-
-impl fmt::Debug for PdfPageTreeLeaf {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                parent,
-                last_modified,
-                bleed_box,
-                trim_box,
-                art_box,
-                box_color_info,
-                contents,
-                group,
-                thumbnail,
-                beads,
-                duration,
-                transition,
-                annotations,
-                additional_actions,
-                metadata,
-                piece_info,
-                structural_parents,
-                parent_web_capture_content_set_id,
-                preferred_zoom_factor,
-                separation_info,
-                annotations_tab_order,
-                template_instantiated,
-                pres_steps,
-                user_unit,
-                viewports,
-                inheritable,
-            } = self;
-            f.debug_struct("PdfPageTreeLeaf")
-                .field("ty", ty)
-                .field("parent", parent)
-                .field("last_modified", last_modified)
-                .field("bleed_box", bleed_box)
-                .field("trim_box", trim_box)
-                .field("art_box", art_box)
-                .field("box_color_info", box_color_info)
-                .field("contents", contents)
-                .field("group", group)
-                .field("thumbnail", thumbnail)
-                .field("beads", beads)
-                .field("duration", duration)
-                .field("transition", transition)
-                .field("annotations", annotations)
-                .field("additional_actions", additional_actions)
-                .field("metadata", metadata)
-                .field("piece_info", piece_info)
-                .field("structural_parents", structural_parents)
-                .field(
-                    "parent_web_capture_content_set_id",
-                    parent_web_capture_content_set_id,
-                )
-                .field("preferred_zoom_factor", preferred_zoom_factor)
-                .field("separation_info", separation_info)
-                .field("annotations_tab_order", annotations_tab_order)
-                .field("template_instantiated", template_instantiated)
-                .field("pres_steps", pres_steps)
-                .field("user_unit", user_unit)
-                .field("viewports", viewports)
-                .field("inheritable", inheritable)
-                .finish()
-        })
-    }
-}
-
-pdf_parse! {
-    #[pdf(tag = "Type")]
-    #[derive(Clone)]
-    pub enum PdfPageTreeNodeOrLeaf {
-        #[pdf(tag_value = "Pages")]
-        Node(PdfPageTreeNode),
-        #[pdf(tag_value = "Page")]
-        Leaf(PdfPageTreeLeaf),
-        #[pdf(other)]
-        Other(PdfDictionary),
-    }
-}
-
-impl PdfPageTreeNodeOrLeaf {
-    pub fn propagate_inheritable_data_to_leaves(&mut self) {
-        match self {
-            PdfPageTreeNodeOrLeaf::Node(v) => v.propagate_inheritable_data_to_leaves(),
-            PdfPageTreeNodeOrLeaf::Leaf(_) | PdfPageTreeNodeOrLeaf::Other(_) => {}
-        }
-    }
-    pub fn inheritable_data_mut(&mut self) -> Option<&mut PdfPageInheritableData> {
-        match self {
-            PdfPageTreeNodeOrLeaf::Node(v) => Some(&mut v.inheritable),
-            PdfPageTreeNodeOrLeaf::Leaf(v) => Some(&mut v.inheritable),
-            PdfPageTreeNodeOrLeaf::Other(_) => None,
-        }
-    }
-    pub fn inheritable_data(&self) -> Option<&PdfPageInheritableData> {
-        match self {
-            PdfPageTreeNodeOrLeaf::Node(v) => Some(&v.inheritable),
-            PdfPageTreeNodeOrLeaf::Leaf(v) => Some(&v.inheritable),
-            PdfPageTreeNodeOrLeaf::Other(_) => None,
-        }
-    }
-}
-
-impl fmt::Debug for PdfPageTreeNodeOrLeaf {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Node(v) => v.fmt(f),
-            Self::Leaf(v) => v.fmt(f),
-            Self::Other(v) => v.fmt(f),
-        }
-    }
-}
-
-/// the amount by which the page is rotated clockwise when displaying or printing, is always a multiple of 90 degrees.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
-pub enum PdfPageRotation {
-    #[default]
-    NoRotation = 0,
-    ClockwiseBy90Degrees = 90,
-    By180Degrees = 180,
-    ClockwiseBy270Degrees = 270,
-}
-
-impl PdfPageRotation {
-    pub fn from_clockwise_angle_in_degrees(angle: i32) -> Option<Self> {
-        match angle.rem_euclid(360) {
-            0 => Some(Self::NoRotation),
-            90 => Some(Self::ClockwiseBy90Degrees),
-            180 => Some(Self::By180Degrees),
-            270 => Some(Self::ClockwiseBy270Degrees),
-            _ => None,
-        }
-    }
-    pub fn from_clockwise_angle_in_degrees_i128(angle: i128) -> Option<Self> {
-        Self::from_clockwise_angle_in_degrees((angle % 360) as i32)
-    }
-}
-
-impl From<PdfPageRotation> for i32 {
-    fn from(value: PdfPageRotation) -> Self {
-        value as i32
-    }
-}
-
-impl IsPdfNull for PdfPageRotation {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfPageRotation {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("page rotation")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = PdfObjectDirect::from(object);
-        let pos = object.pos();
-        let angle = PdfInteger::parse(object.into())?;
-        Self::from_clockwise_angle_in_degrees_i128(angle.value())
-            .ok_or(PdfParseError::IntegerOutOfRange { pos })
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfPage {
-    pub ty: PdfPageType,
-    pub parent: PdfObjectIndirect,
-    pub last_modified: Option<PdfDate>,
-    pub resources: PdfResourcesDictionary,
-    pub media_box: PdfRectangle,
-    pub crop_box: PdfRectangle,
-    pub bleed_box: PdfRectangle,
-    pub trim_box: PdfRectangle,
-    pub art_box: PdfRectangle,
-    pub box_color_info: Option<PdfDictionary>,
-    pub contents: Arc<[PdfContentStream]>,
-    pub rotate: PdfPageRotation,
-    pub group: Option<PdfDictionary>,
-    pub thumbnail: Option<PdfStream>,
-    pub beads: Option<Arc<[PdfDictionary]>>,
-    pub duration: Option<f32>,
-    pub transition: Option<PdfDictionary>,
-    pub annotations: Option<Arc<[PdfDictionary]>>,
-    pub additional_actions: Option<PdfDictionary>,
-    pub metadata: Option<PdfStream>,
-    pub piece_info: Option<PdfDictionary>,
-    pub structural_parents: Option<PdfInteger>,
-    pub parent_web_capture_content_set_id: Option<PdfString>,
-    pub preferred_zoom_factor: Option<f32>,
-    pub separation_info: Option<PdfDictionary>,
-    pub annotations_tab_order: Option<PdfPageAnnotationsTabOrder>,
-    pub template_instantiated: Option<PdfName>,
-    pub pres_steps: Option<PdfDictionary>,
-    pub user_unit: f32,
-    pub viewports: Option<Arc<[PdfDictionary]>>,
-    pub rest: PdfDictionary,
-    rendered_objects: Option<PdfPageRenderedObjects>,
-}
-
-impl PdfPage {
-    pub fn rendered_objects(&self) -> &PdfPageRenderedObjects {
-        let Some(retval) = &self.rendered_objects else {
-            unreachable!();
-        };
-        retval
-    }
-    pub fn parse_after_propagating_inheritable_data(
-        leaf: PdfPageTreeLeaf,
-    ) -> Result<Self, PdfParseError> {
-        let PdfPageTreeLeaf {
-            ty,
-            parent,
-            last_modified,
-            bleed_box,
-            trim_box,
-            art_box,
-            box_color_info,
-            contents,
-            group,
-            thumbnail,
-            beads,
-            duration,
-            transition,
-            annotations,
-            additional_actions,
-            metadata,
-            piece_info,
-            structural_parents,
-            parent_web_capture_content_set_id,
-            preferred_zoom_factor,
-            separation_info,
-            annotations_tab_order,
-            template_instantiated,
-            pres_steps,
-            user_unit,
-            viewports,
-            inheritable:
-                PdfPageInheritableData {
-                    resources,
-                    media_box,
-                    crop_box,
-                    rotate,
-                    rest,
-                },
-        } = leaf;
-        let pos = rest.pos();
-        let resources = resources.ok_or(PdfParseError::InvalidType {
-            pos,
-            ty: "null",
-            expected_ty: "page resources dictionary",
-        })?;
-        let media_box = media_box.ok_or(PdfParseError::InvalidType {
-            pos,
-            ty: "null",
-            expected_ty: "page MediaBox rectangle",
-        })?;
-        let crop_box = crop_box.unwrap_or(media_box);
-        let rotate = rotate.unwrap_or(PdfPageRotation::NoRotation);
-        let mut retval = Self {
-            ty,
-            parent,
-            last_modified,
-            resources,
-            media_box,
-            crop_box,
-            bleed_box: bleed_box.unwrap_or(crop_box),
-            trim_box: trim_box.unwrap_or(crop_box),
-            art_box: art_box.unwrap_or(crop_box),
-            box_color_info,
-            contents: contents.0,
-            rotate,
-            group,
-            thumbnail,
-            beads,
-            duration,
-            transition,
-            annotations,
-            additional_actions,
-            metadata,
-            piece_info,
-            structural_parents,
-            parent_web_capture_content_set_id,
-            preferred_zoom_factor,
-            separation_info,
-            annotations_tab_order,
-            template_instantiated,
-            pres_steps,
-            user_unit: user_unit.unwrap_or(1.0),
-            viewports,
-            rest,
-            rendered_objects: None,
-        };
-        retval.rendered_objects = Some(PdfPageRenderedObjects::render_page(&retval)?);
-        Ok(retval)
-    }
-}
-
-impl fmt::Debug for PdfPage {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                parent,
-                last_modified,
-                resources,
-                media_box,
-                crop_box,
-                bleed_box,
-                trim_box,
-                art_box,
-                box_color_info,
-                contents,
-                rotate,
-                group,
-                thumbnail,
-                beads,
-                duration,
-                transition,
-                annotations,
-                additional_actions,
-                metadata,
-                piece_info,
-                structural_parents,
-                parent_web_capture_content_set_id,
-                preferred_zoom_factor,
-                separation_info,
-                annotations_tab_order,
-                template_instantiated,
-                pres_steps,
-                user_unit,
-                viewports,
-                rest,
-                rendered_objects,
-            } = self;
-            struct Unparsed;
-            impl fmt::Debug for Unparsed {
-                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                    f.write_str("<unparsed>")
-                }
-            }
-            f.debug_struct("PdfPage")
-                .field("ty", ty)
-                .field("parent", parent)
-                .field("last_modified", last_modified)
-                .field("resources", resources)
-                .field("media_box", media_box)
-                .field("crop_box", crop_box)
-                .field("bleed_box", bleed_box)
-                .field("trim_box", trim_box)
-                .field("art_box", art_box)
-                .field("box_color_info", box_color_info)
-                .field("contents", contents)
-                .field("rotate", rotate)
-                .field("group", group)
-                .field("thumbnail", thumbnail)
-                .field("beads", beads)
-                .field("duration", duration)
-                .field("transition", transition)
-                .field("annotations", annotations)
-                .field("additional_actions", additional_actions)
-                .field("metadata", metadata)
-                .field("piece_info", piece_info)
-                .field("structural_parents", structural_parents)
-                .field(
-                    "parent_web_capture_content_set_id",
-                    parent_web_capture_content_set_id,
-                )
-                .field("preferred_zoom_factor", preferred_zoom_factor)
-                .field("separation_info", separation_info)
-                .field("annotations_tab_order", annotations_tab_order)
-                .field("template_instantiated", template_instantiated)
-                .field("pres_steps", pres_steps)
-                .field("user_unit", user_unit)
-                .field("viewports", viewports)
-                .field("rest", rest)
-                .field(
-                    "rendered_objects",
-                    if let Some(rendered_objects) = rendered_objects {
-                        rendered_objects
-                    } else {
-                        &Unparsed
-                    },
-                )
-                .finish()
-        })
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct PdfPageRenderedObjects {}
-
-impl PdfPageRenderedObjects {
-    fn render_page(page: &PdfPage) -> Result<Self, PdfParseError> {
-        let mut state = PdfRenderState::new(page);
-        for content_stream in page.contents.iter() {
-            for op in content_stream.decoded_data().as_ref()?.operators.iter() {
-                op.render(&mut state)?;
-            }
-        }
-        Ok(Self {})
-    }
-}
diff --git a/src/pdf/font.rs b/src/pdf/font.rs
deleted file mode 100644
index 5f096b4..0000000
--- a/src/pdf/font.rs
+++ /dev/null
@@ -1,1057 +0,0 @@
-use crate::{
-    pdf::{
-        font::type_1_parse::PsFile,
-        object::{
-            IsPdfNull, PdfArray, PdfDictionary, PdfMatrix, PdfName, PdfNameOrInteger, PdfObject,
-            PdfObjectDirect, PdfRectangle, PdfStream, PdfString,
-        },
-        parse::{
-            GetPdfInputPosition, PdfInputPosition, PdfInputPositionNoCompare, PdfParse,
-            PdfParseError,
-        },
-        pdf_parse,
-    },
-    util::{ArcOrRef, DagDebugState},
-};
-use std::{borrow::Cow, collections::BTreeMap, fmt, sync::Arc};
-
-mod tables;
-mod to_unicode_parse;
-mod type_1_parse;
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone, Debug)]
-    pub struct PdfFontToUnicodeDictionary {
-        #[pdf(name = "UseCMap")]
-        pub base_map: Option<PdfObjectDirect>, // TODO: parse
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfFontToUnicode {
-    pub base_map: Option<PdfObjectDirect>, // TODO: parse
-    pub char_map_name: PdfName,
-    pub src_ranges: Arc<[std::ops::RangeInclusive<PdfString>]>,
-    pub to_unicode_map: Arc<BTreeMap<PdfString, Arc<str>>>,
-}
-
-impl fmt::Debug for PdfFontToUnicode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        struct DebugFn<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result>(F);
-        impl<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result> fmt::Debug for DebugFn<F> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                (self.0)(f)
-            }
-        }
-        let Self {
-            base_map,
-            char_map_name,
-            src_ranges,
-            to_unicode_map,
-        } = self;
-        f.debug_struct("PdfFontToUnicode")
-            .field("base_map", base_map)
-            .field("char_map_name", char_map_name)
-            .field(
-                "src_ranges",
-                &DebugFn(|f| {
-                    f.debug_set()
-                        .entries(
-                            src_ranges
-                                .iter()
-                                .map(|v| v.start().bytes_debug()..=v.end().bytes_debug()),
-                        )
-                        .finish()
-                }),
-            )
-            .field(
-                "to_unicode_map",
-                &DebugFn(|f| {
-                    f.debug_map()
-                        .entries(to_unicode_map.iter().map(|(k, v)| (k.bytes_debug(), v)))
-                        .finish()
-                }),
-            )
-            .finish()
-    }
-}
-
-impl IsPdfNull for PdfFontToUnicode {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfFontToUnicode {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("PdfFontToUnicode")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let stream = PdfStream::<PdfFontToUnicodeDictionary>::parse(object)?;
-        let base_map = stream.dictionary().rest.base_map.clone();
-        let decoded_data = stream.decoded_data().clone()?;
-        to_unicode_parse::ToUnicodeParser::new(PsFile::from_arc_bytes(
-            decoded_data,
-            stream.get_pdf_input_position(),
-        ))
-        .parse(base_map)
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfFontDescriptorType {
-        #[pdf(name = "FontDescriptor")]
-        #[default]
-        FontDescriptor,
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-    pub enum PdfFontStretch {
-        #[pdf(name = "UltraCondensed")]
-        UltraCondensed,
-        #[pdf(name = "ExtraCondensed")]
-        ExtraCondensed,
-        #[pdf(name = "Condensed")]
-        Condensed,
-        #[pdf(name = "SemiCondensed")]
-        SemiCondensed,
-        #[pdf(name = "Normal")]
-        Normal,
-        #[pdf(name = "SemiExpanded")]
-        SemiExpanded,
-        #[pdf(name = "Expanded")]
-        Expanded,
-        #[pdf(name = "ExtraExpanded")]
-        ExtraExpanded,
-        #[pdf(name = "UltraExpanded")]
-        UltraExpanded,
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfFontDescriptor {
-        #[pdf(name = "Type")]
-        pub ty: PdfFontDescriptorType,
-        #[pdf(name = "FontName")]
-        pub font_name: PdfName,
-        #[pdf(name = "FontFamily")]
-        pub font_family: Option<PdfString>,
-        #[pdf(name = "FontStretch")]
-        pub font_stretch: Option<PdfFontStretch>,
-        #[pdf(name = "FontWeight")]
-        pub font_weight: Option<u32>,
-        #[pdf(name = "Flags")]
-        pub flags: u32,
-        #[pdf(name = "FontBBox")]
-        pub font_bounding_box: Option<PdfRectangle>,
-        #[pdf(name = "ItalicAngle")]
-        pub italic_angle: f32,
-        #[pdf(name = "Ascent")]
-        pub ascent: Option<f32>,
-        #[pdf(name = "Descent")]
-        pub descent: Option<f32>,
-        #[pdf(name = "Leading")]
-        pub leading: Option<f32>,
-        #[pdf(name = "CapHeight")]
-        pub cap_height: Option<f32>,
-        #[pdf(name = "XHeight")]
-        pub x_height: Option<f32>,
-        #[pdf(name = "StemV")]
-        pub stem_v: Option<f32>,
-        #[pdf(name = "StemH")]
-        pub stem_h: Option<f32>,
-        #[pdf(name = "AvgWidth")]
-        pub avg_width: Option<f32>,
-        #[pdf(name = "MaxWidth")]
-        pub max_width: Option<f32>,
-        #[pdf(name = "MissingWidth")]
-        pub missing_width: Option<f32>,
-        #[pdf(name = "FontFile")]
-        pub font_file: Option<PdfStream<PdfDictionary, PdfFontType1Program>>,
-        #[pdf(name = "FontFile2")]
-        pub font_file2: Option<PdfStream>,
-        #[pdf(name = "FontFile3")]
-        pub font_file3: Option<PdfStream>,
-        #[pdf(name = "CharSet")]
-        pub char_set: Option<PdfString>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl fmt::Debug for PdfFontDescriptor {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                font_name,
-                font_family,
-                font_stretch,
-                font_weight,
-                flags,
-                font_bounding_box,
-                italic_angle,
-                ascent,
-                descent,
-                leading,
-                cap_height,
-                x_height,
-                stem_v,
-                stem_h,
-                avg_width,
-                max_width,
-                missing_width,
-                font_file,
-                font_file2,
-                font_file3,
-                char_set,
-                rest,
-            } = self;
-            f.debug_struct("PdfFontDescriptor")
-                .field("ty", ty)
-                .field("font_name", font_name)
-                .field("font_family", font_family)
-                .field("font_stretch", font_stretch)
-                .field("font_weight", font_weight)
-                .field("flags", flags)
-                .field("font_bounding_box", font_bounding_box)
-                .field("italic_angle", italic_angle)
-                .field("ascent", ascent)
-                .field("descent", descent)
-                .field("leading", leading)
-                .field("cap_height", cap_height)
-                .field("x_height", x_height)
-                .field("stem_v", stem_v)
-                .field("stem_h", stem_h)
-                .field("avg_width", avg_width)
-                .field("max_width", max_width)
-                .field("missing_width", missing_width)
-                .field("font_file", font_file)
-                .field("font_file2", font_file2)
-                .field("font_file3", font_file3)
-                .field("char_set", char_set)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-impl PdfFontDescriptor {
-    pub const DEFAULT_MISSING_WIDTH: f32 = 0.0;
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfFontType {
-        #[pdf(name = "Font")]
-        #[default]
-        Font,
-    }
-}
-
-#[derive(Clone)]
-pub enum PdfTodo {}
-
-impl fmt::Debug for PdfTodo {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {}
-    }
-}
-
-impl IsPdfNull for PdfTodo {
-    fn is_pdf_null(&self) -> bool {
-        match *self {}
-    }
-}
-
-impl PdfParse for PdfTodo {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("PdfTodo")
-    }
-    #[track_caller]
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        todo!("{object:?}")
-    }
-}
-
-pdf_parse! {
-    #[pdf(tag = "Subtype")]
-    #[derive(Clone)]
-    pub enum PdfFont {
-        #[pdf(tag_value = "Type0")]
-        Type0(Arc<PdfFontType0>),
-        #[pdf(tag_value = "Type1")]
-        Type1(PdfFontType1),
-        #[pdf(other)]
-        Other(Arc<PdfTodo>),
-    }
-}
-
-impl fmt::Debug for PdfFont {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|state| match self {
-            PdfFont::Type0(v) => state.debug_or_id(v, "PdfFontType0(...)").fmt(f),
-            PdfFont::Type1(v) => v.fmt(f),
-            PdfFont::Other(v) => match **v {},
-        })
-    }
-}
-
-impl PdfFont {
-    pub(crate) fn is_vertical_writing_mode(&self) -> bool {
-        // TODO:
-        false
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfFontType0Subtype {
-        #[pdf(name = "Type0")]
-        #[default]
-        Type0,
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfFontType0 {
-        #[pdf(name = "Type")]
-        pub ty: PdfFontType,
-        #[pdf(name = "Subtype")]
-        pub subtype: PdfFontType0Subtype,
-        #[pdf(name = "BaseFont")]
-        pub base_font: PdfName,
-        #[pdf(name = "Encoding")]
-        // TODO
-        pub encoding: PdfObjectDirect,
-        #[pdf(name = "DescendentFonts")]
-        // TODO
-        pub descendent_fonts: [PdfDictionary; 1],
-        #[pdf(name = "ToUnicode")]
-        pub to_unicode: Option<PdfFontToUnicode>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl fmt::Debug for PdfFontType0 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                subtype,
-                base_font,
-                encoding,
-                descendent_fonts,
-                to_unicode,
-                rest,
-            } = self;
-            f.debug_struct("PdfFontType0")
-                .field("ty", ty)
-                .field("subtype", subtype)
-                .field("base_font", base_font)
-                .field("encoding", encoding)
-                .field("descendent_fonts", descendent_fonts)
-                .field("to_unicode", to_unicode)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
-    pub enum PdfFontType1Subtype {
-        #[pdf(name = "Type1")]
-        #[default]
-        Type1,
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-    pub enum PdfStandardFontName {
-        #[pdf(name = "Times-Roman")]
-        TimesRoman,
-        #[pdf(name = "Helvetica")]
-        Helvetica,
-        #[pdf(name = "Courier")]
-        Courier,
-        #[pdf(name = "Symbol")]
-        Symbol,
-        #[pdf(name = "Times-Bold")]
-        TimesBold,
-        #[pdf(name = "Helvetica-Bold")]
-        HelveticaBold,
-        #[pdf(name = "Courier-Bold")]
-        CourierBold,
-        #[pdf(name = "ZapfDingbats")]
-        ZapfDingbats,
-        #[pdf(name = "Times-Italic")]
-        TimesItalic,
-        #[pdf(name = "Helvetica-Oblique")]
-        HelveticaOblique,
-        #[pdf(name = "Courier-Oblique")]
-        CourierOblique,
-        #[pdf(name = "Times-BoldItalic")]
-        TimesBoldItalic,
-        #[pdf(name = "Helvetica-BoldOblique")]
-        HelveticaBoldOblique,
-        #[pdf(name = "Courier-BoldOblique")]
-        CourierBoldOblique,
-    }
-}
-
-#[derive(Clone)]
-pub enum PdfFontType1 {
-    Standard(Arc<PdfFontType1Standard>),
-    Other(Arc<PdfFontType1Other>),
-}
-
-impl fmt::Debug for PdfFontType1 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|state| match self {
-            PdfFontType1::Standard(v) => state.debug_or_id(v, "PdfFontType1Standard(...)").fmt(f),
-            PdfFontType1::Other(v) => state.debug_or_id(v, "PdfFontType1Other(...)").fmt(f),
-        })
-    }
-}
-
-impl PdfFontType1 {
-    pub fn common(&self) -> PdfFontType1Common {
-        match self {
-            PdfFontType1::Standard(v) => v.common(),
-            PdfFontType1::Other(v) => v.common(),
-        }
-    }
-    pub fn name(&self) -> &Option<PdfName> {
-        match self {
-            Self::Standard(v) => &v.name,
-            Self::Other(v) => &v.name,
-        }
-    }
-    pub fn base_font(&self) -> PdfName {
-        match self {
-            Self::Standard(v) => v.base_font.into(),
-            Self::Other(v) => v.base_font.clone(),
-        }
-    }
-    pub fn first_char(&self) -> Option<u32> {
-        match self {
-            Self::Standard(v) => v.first_char,
-            Self::Other(v) => Some(v.first_char),
-        }
-    }
-    pub fn last_char(&self) -> Option<u32> {
-        match self {
-            Self::Standard(v) => v.last_char,
-            Self::Other(v) => Some(v.last_char),
-        }
-    }
-    pub fn widths(&self) -> Option<&Arc<[f32]>> {
-        match self {
-            Self::Standard(v) => v.widths.as_ref(),
-            Self::Other(v) => Some(&v.widths),
-        }
-    }
-    pub fn font_descriptor(&self) -> Option<&PdfFontDescriptor> {
-        match self {
-            Self::Standard(v) => v.font_descriptor.as_ref(),
-            Self::Other(v) => Some(&v.font_descriptor),
-        }
-    }
-    pub fn encoding(&self) -> &Option<PdfSimpleFontEncoding> {
-        match self {
-            Self::Standard(v) => &v.encoding,
-            Self::Other(v) => &v.encoding,
-        }
-    }
-    pub fn to_unicode(&self) -> &Option<PdfFontToUnicode> {
-        match self {
-            Self::Standard(v) => &v.to_unicode,
-            Self::Other(v) => &v.to_unicode,
-        }
-    }
-    pub fn rest(&self) -> &PdfDictionary {
-        match self {
-            Self::Standard(v) => &v.rest,
-            Self::Other(v) => &v.rest,
-        }
-    }
-}
-
-impl IsPdfNull for PdfFontType1 {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfFontType1 {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("PdfFontType1")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = object.into();
-        let font = if let PdfObjectDirect::Dictionary(object) = object {
-            if let Ok(_) = PdfStandardFontName::parse(object.get_or_null(b"BaseFont".as_slice())) {
-                Self::Standard(PdfParse::parse(object.into())?)
-            } else {
-                Self::Other(PdfParse::parse(object.into())?)
-            }
-        } else {
-            Self::Other(PdfParse::parse(object.into())?)
-        };
-        if let Some(font_file) = font.font_descriptor().and_then(|v| v.font_file.as_ref()) {
-            font_file.decoded_data().as_ref()?;
-        }
-        Ok(font)
-    }
-}
-
-impl GetPdfInputPosition for PdfFontType1 {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        match self {
-            PdfFontType1::Standard(v) => v.get_pdf_input_position(),
-            PdfFontType1::Other(v) => v.get_pdf_input_position(),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfFontType1Common {
-    pub ty: PdfFontType,
-    pub subtype: PdfFontType1Subtype,
-    pub name: Option<PdfName>,
-    pub base_font: PdfName,
-    pub first_char: Option<u32>,
-    pub last_char: Option<u32>,
-    pub widths: Option<Arc<[f32]>>,
-    pub font_descriptor: Option<PdfFontDescriptor>,
-    pub encoding: Option<PdfSimpleFontEncoding>,
-    pub to_unicode: Option<PdfFontToUnicode>,
-    pub rest: PdfDictionary,
-}
-
-impl PdfFontType1Common {
-    fn validate_first_last_char_and_widths(
-        pos: PdfInputPosition,
-        first_char: Option<u32>,
-        last_char: Option<u32>,
-        widths: Option<&[f32]>,
-    ) -> Result<(), PdfParseError> {
-        if first_char.is_some() || last_char.is_some() || widths.is_some() {
-            let (Some(first_char), Some(last_char), Some(widths)) = (first_char, last_char, widths)
-            else {
-                return Err(PdfParseError::InvalidFontFirstLastCharWidths { pos });
-            };
-            let Some(widths_len) = (u64::from(last_char) + 1).checked_sub(first_char.into()) else {
-                return Err(PdfParseError::InvalidFontFirstLastCharWidths { pos });
-            };
-            if u64::try_from(widths.len()).ok() != Some(widths_len) {
-                return Err(PdfParseError::InvalidFontFirstLastCharWidths { pos });
-            }
-        }
-        Ok(())
-    }
-}
-
-impl fmt::Debug for PdfFontType1Common {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                subtype,
-                name,
-                base_font,
-                first_char,
-                last_char,
-                widths,
-                font_descriptor,
-                encoding,
-                to_unicode,
-                rest,
-            } = self;
-            f.debug_struct("PdfFontType1Common")
-                .field("ty", ty)
-                .field("subtype", subtype)
-                .field("name", name)
-                .field("base_font", base_font)
-                .field("first_char", first_char)
-                .field("last_char", last_char)
-                .field("widths", widths)
-                .field("font_descriptor", font_descriptor)
-                .field("encoding", encoding)
-                .field("to_unicode", to_unicode)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-impl GetPdfInputPosition for PdfFontType1Common {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.rest.pos()
-    }
-}
-
-pdf_parse! {
-    #[pdf(validate = |pos| {
-        PdfFontType1Common::validate_first_last_char_and_widths(pos, first_char, last_char, widths.as_deref())?;
-    })]
-    #[derive(Clone)]
-    pub struct PdfFontType1Standard {
-        #[pdf(name = "Type")]
-        pub ty: PdfFontType,
-        #[pdf(name = "Subtype")]
-        pub subtype: PdfFontType1Subtype,
-        #[pdf(name = "Name")]
-        pub name: Option<PdfName>,
-        #[pdf(name = "BaseFont")]
-        pub base_font: PdfStandardFontName,
-        #[pdf(name = "FirstChar")]
-        pub first_char: Option<u32>,
-        #[pdf(name = "LastChar")]
-        pub last_char: Option<u32>,
-        #[pdf(name = "Widths")]
-        pub widths: Option<Arc<[f32]>>,
-        #[pdf(name = "FontDescriptor")]
-        pub font_descriptor: Option<PdfFontDescriptor>,
-        #[pdf(name = "Encoding")]
-        pub encoding: Option<PdfSimpleFontEncoding>,
-        #[pdf(name = "ToUnicode")]
-        pub to_unicode: Option<PdfFontToUnicode>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl fmt::Debug for PdfFontType1Standard {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                subtype,
-                name,
-                base_font,
-                first_char,
-                last_char,
-                widths,
-                font_descriptor,
-                encoding,
-                to_unicode,
-                rest,
-            } = self;
-            f.debug_struct("PdfFontType1Standard")
-                .field("ty", ty)
-                .field("subtype", subtype)
-                .field("name", name)
-                .field("base_font", base_font)
-                .field("first_char", first_char)
-                .field("last_char", last_char)
-                .field("widths", widths)
-                .field("font_descriptor", font_descriptor)
-                .field("encoding", encoding)
-                .field("to_unicode", to_unicode)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-impl PdfFontType1Standard {
-    pub fn common(&self) -> PdfFontType1Common {
-        let Self {
-            ty,
-            subtype,
-            ref name,
-            base_font,
-            first_char,
-            last_char,
-            ref widths,
-            ref font_descriptor,
-            ref encoding,
-            ref to_unicode,
-            ref rest,
-        } = *self;
-        PdfFontType1Common {
-            ty,
-            subtype,
-            name: name.clone(),
-            base_font: base_font.into(),
-            first_char,
-            last_char,
-            widths: widths.clone(),
-            font_descriptor: font_descriptor.clone(),
-            encoding: encoding.clone(),
-            to_unicode: to_unicode.clone(),
-            rest: rest.clone(),
-        }
-    }
-}
-
-impl GetPdfInputPosition for PdfFontType1Standard {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.rest.pos()
-    }
-}
-
-pdf_parse! {
-    #[pdf(validate = |pos| {
-        PdfFontType1Common::validate_first_last_char_and_widths(pos, Some(first_char), Some(last_char), Some(&widths))?;
-    })]
-    #[derive(Clone)]
-    pub struct PdfFontType1Other {
-        #[pdf(name = "Type")]
-        pub ty: PdfFontType,
-        #[pdf(name = "Subtype")]
-        pub subtype: PdfFontType1Subtype,
-        #[pdf(name = "Name")]
-        pub name: Option<PdfName>,
-        #[pdf(name = "BaseFont")]
-        pub base_font: PdfName,
-        #[pdf(name = "FirstChar")]
-        pub first_char: u32,
-        #[pdf(name = "LastChar")]
-        pub last_char: u32,
-        #[pdf(name = "Widths")]
-        pub widths: Arc<[f32]>,
-        #[pdf(name = "FontDescriptor")]
-        pub font_descriptor: PdfFontDescriptor,
-        #[pdf(name = "Encoding")]
-        pub encoding: Option<PdfSimpleFontEncoding>,
-        #[pdf(name = "ToUnicode")]
-        pub to_unicode: Option<PdfFontToUnicode>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl fmt::Debug for PdfFontType1Other {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                ty,
-                subtype,
-                name,
-                base_font,
-                first_char,
-                last_char,
-                widths,
-                font_descriptor,
-                encoding,
-                to_unicode,
-                rest,
-            } = self;
-            f.debug_struct("PdfFontType1Other")
-                .field("ty", ty)
-                .field("subtype", subtype)
-                .field("name", name)
-                .field("base_font", base_font)
-                .field("first_char", first_char)
-                .field("last_char", last_char)
-                .field("widths", widths)
-                .field("font_descriptor", font_descriptor)
-                .field("encoding", encoding)
-                .field("to_unicode", to_unicode)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-impl PdfFontType1Other {
-    pub fn common(&self) -> PdfFontType1Common {
-        let Self {
-            ty,
-            subtype,
-            ref name,
-            ref base_font,
-            first_char,
-            last_char,
-            ref widths,
-            ref font_descriptor,
-            ref encoding,
-            ref to_unicode,
-            ref rest,
-        } = *self;
-        PdfFontType1Common {
-            ty,
-            subtype,
-            name: name.clone(),
-            base_font: base_font.clone(),
-            first_char: Some(first_char),
-            last_char: Some(last_char),
-            widths: Some(widths.clone()),
-            font_descriptor: Some(font_descriptor.clone()),
-            encoding: encoding.clone(),
-            to_unicode: to_unicode.clone(),
-            rest: rest.clone(),
-        }
-    }
-}
-
-impl GetPdfInputPosition for PdfFontType1Other {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.rest.pos()
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-    pub enum PdfSimpleFontEncodingPredefined {
-        #[pdf(name = "MacRomanEncoding")]
-        MacRomanEncoding,
-        #[pdf(name = "MacExpertEncoding")]
-        MacExpertEncoding,
-        #[pdf(name = "WinAnsiEncoding")]
-        WinAnsiEncoding,
-    }
-}
-
-impl PdfSimpleFontEncodingPredefined {
-    pub const fn table(self) -> PdfSimpleFontEncodingTable {
-        match self {
-            Self::MacRomanEncoding => PdfSimpleFontEncodingTable::MAC_ROMAN,
-            Self::MacExpertEncoding => PdfSimpleFontEncodingTable::MAC_EXPERT,
-            Self::WinAnsiEncoding => PdfSimpleFontEncodingTable::WIN_ANSI,
-        }
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
-    pub enum PdfSimpleFontEncodingDictionaryType {
-        #[pdf(name = "Encoding")]
-        #[default]
-        Encoding,
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone, Debug)]
-    pub struct PdfSimpleFontEncodingDictionary {
-        #[pdf(name = "Type")]
-        pub ty: Option<PdfSimpleFontEncodingDictionaryType>,
-        #[pdf(name = "BaseEncoding")]
-        pub base_encoding: Option<PdfSimpleFontEncodingPredefined>,
-        #[pdf(name = "Differences")]
-        pub differences: Option<PdfSimpleFontEncodingDifferences>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl PdfSimpleFontEncodingDictionary {
-    pub fn table(
-        &self,
-        default_table: impl FnOnce() -> PdfSimpleFontEncodingTable,
-    ) -> PdfSimpleFontEncodingTable {
-        let Self {
-            ty: _,
-            base_encoding,
-            differences,
-            rest: _,
-        } = self;
-        let mut retval = base_encoding
-            .map(|v| v.table())
-            .unwrap_or_else(default_table);
-        if let Some(differences) = differences {
-            retval = differences.table(retval);
-        }
-        retval
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct PdfSimpleFontEncodingDifferences {
-    pos: PdfInputPositionNoCompare,
-    map: Arc<BTreeMap<u8, PdfName>>,
-}
-
-impl PdfSimpleFontEncodingDifferences {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>, map: Arc<BTreeMap<u8, PdfName>>) -> Self {
-        Self {
-            pos: pos.into(),
-            map,
-        }
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn map(&self) -> &Arc<BTreeMap<u8, PdfName>> {
-        &self.map
-    }
-    pub fn table(&self, base_table: PdfSimpleFontEncodingTable) -> PdfSimpleFontEncodingTable {
-        let mut retval = base_table;
-        let table: &mut [_; 0x100] = ArcOrRef::make_mut(&mut retval.table);
-        for (&byte, name) in self.map.iter() {
-            table[usize::from(byte)] = PdfSimpleFontEncodingTableEntry {
-                name: Some(name.clone()),
-                presumed_unicode: None,
-            };
-        }
-        retval
-    }
-}
-
-impl GetPdfInputPosition for PdfSimpleFontEncodingDifferences {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-impl IsPdfNull for PdfSimpleFontEncodingDifferences {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfSimpleFontEncodingDifferences {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("PdfSimpleFontEncodingDifferences")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let array = PdfArray::parse(object)?;
-        let pos = array.pos();
-        let mut map = BTreeMap::new();
-        let mut next_byte = None::<u8>;
-        for i in array.iter() {
-            let i = PdfNameOrInteger::parse(i.clone())?;
-            match i {
-                PdfNameOrInteger::Name(name) => {
-                    let pos = name.pos();
-                    let byte = next_byte.ok_or(PdfParseError::IntegerOutOfRange { pos })?;
-                    next_byte = byte.checked_add(1);
-                    map.insert(byte, name);
-                }
-                PdfNameOrInteger::Integer(v) => next_byte = Some(u8::parse(v.into())?),
-            }
-        }
-        Ok(Self {
-            pos: pos.into(),
-            map: Arc::new(map),
-        })
-    }
-}
-
-#[derive(Clone, Default, Debug)]
-pub struct PdfSimpleFontEncodingTableEntry {
-    pub name: Option<PdfName>,
-    pub presumed_unicode: Option<&'static str>,
-}
-
-impl PdfSimpleFontEncodingTableEntry {
-    pub const fn new_static(
-        name: Option<&'static [u8]>,
-        presumed_unicode: Option<&'static str>,
-    ) -> Self {
-        Self {
-            name: match name {
-                Some(name) => Some(PdfName::new_static(name)),
-                None => None,
-            },
-            presumed_unicode,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct PdfSimpleFontEncodingTable {
-    pub table: ArcOrRef<'static, [PdfSimpleFontEncodingTableEntry; 0x100]>,
-}
-
-impl PdfSimpleFontEncodingTable {
-    pub const fn empty() -> Self {
-        const EMPTY_ENTRY: PdfSimpleFontEncodingTableEntry =
-            PdfSimpleFontEncodingTableEntry::new_static(None, None);
-        const EMPTY_TABLE: &[PdfSimpleFontEncodingTableEntry; 0x100] = &[EMPTY_ENTRY; 0x100];
-        Self {
-            table: ArcOrRef::Ref(EMPTY_TABLE),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub enum PdfSimpleFontEncoding {
-    Predefined(PdfSimpleFontEncodingPredefined),
-    Dictionary(PdfSimpleFontEncodingDictionary),
-}
-
-impl PdfSimpleFontEncoding {
-    pub fn table(
-        &self,
-        default_table: impl FnOnce() -> PdfSimpleFontEncodingTable,
-    ) -> PdfSimpleFontEncodingTable {
-        match self {
-            PdfSimpleFontEncoding::Predefined(v) => v.table(),
-            PdfSimpleFontEncoding::Dictionary(v) => v.table(default_table),
-        }
-    }
-}
-
-impl IsPdfNull for PdfSimpleFontEncoding {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfSimpleFontEncoding {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("PdfSimpleFontEncoding")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = PdfObjectDirect::from(object);
-        match object {
-            PdfObjectDirect::Name(v) => Ok(Self::Predefined(PdfParse::parse(v.into())?)),
-            PdfObjectDirect::Dictionary(v) => Ok(Self::Dictionary(PdfParse::parse(v.into())?)),
-            _ => Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "PdfSimpleFontEncoding",
-            }),
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-#[non_exhaustive]
-pub struct PdfFontType1Program {
-    pub encoding: PdfSimpleFontEncodingTable,
-    pub font_bbox: PdfRectangle,
-    pub font_info: Option<PdfFontType1FontInfo>,
-    pub font_matrix: PdfMatrix,
-    pub font_name: Option<PdfName>,
-    pub vertical_writing_mode: bool,
-}
-
-#[derive(Clone, Debug)]
-pub struct PdfFontType1FontInfo {
-    pub family_name: Option<PdfString>,
-    pub full_name: Option<PdfString>,
-    pub notice: Option<PdfString>,
-    pub weight: Option<PdfString>,
-    pub version: Option<PdfString>,
-    pub italic_angle: Option<f32>,
-    pub is_fixed_pitch: Option<bool>,
-    pub underline_position: Option<f32>,
-    pub underline_thickness: Option<f32>,
-}
diff --git a/src/pdf/font/tables.rs b/src/pdf/font/tables.rs
deleted file mode 100644
index fcb8218..0000000
--- a/src/pdf/font/tables.rs
+++ /dev/null
@@ -1,1067 +0,0 @@
-use crate::{
-    pdf::font::{PdfSimpleFontEncodingTable, PdfSimpleFontEncodingTableEntry},
-    util::ArcOrRef,
-};
-
-macro_rules! opt_lit {
-    (None) => {
-        None
-    };
-    ($v:literal) => {
-        Some($v)
-    };
-}
-
-macro_rules! array_from_fn_0x100 {
-    (|$i:ident| $value:expr) => {
-        array_from_fn_0x100!(@step1 |$i| $value;
-            [
-                0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
-                0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF,
-            ];
-            [
-                0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70,
-                0x80, 0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0,
-            ]
-        )
-    };
-    (@step1 |$i:ident| $value:expr; [$($low_digits:literal,)*]; $high_digits:tt) => {
-        array_from_fn_0x100!(@step2 |$i| $value; [$($low_digits + $high_digits,)*])
-    };
-    (@step2 |$i:ident| $value:expr; [$($low_digits:literal + [$($high_digits:literal,)*],)*]) => {
-        [$($({
-            let $i = $low_digits + $high_digits;
-            $value
-        },)*)*]
-    };
-}
-
-macro_rules! builtin_simple_font_encoding_table {
-    (
-        $vis:vis const $const_name:ident;
-        $(#[default = ($default_name:literal, $default_presumed_unicode:literal)])?
-        [
-            $(($byte:literal, $name:tt, $presumed_unicode:tt),)*
-        ]
-    ) => {
-        impl PdfSimpleFontEncodingTable {
-            $vis const $const_name: Self = {
-                const TABLE: [PdfSimpleFontEncodingTableEntry; 0x100] = {
-                    #[allow(unused_mut, unused_assignments)]
-                    const DEFAULT: (Option<&[u8]>, Option<&str>) = {
-                        let mut value: (Option<&[u8]>, Option<&str>) = (None, None);
-                        $(value = (Some($default_name), Some($default_presumed_unicode));)?
-                        value
-                    };
-                    let mut encoding = [DEFAULT; 0x100];
-                    $(encoding[$byte] = (opt_lit!($name), opt_lit!($presumed_unicode));)*
-                    array_from_fn_0x100!(|i| PdfSimpleFontEncodingTableEntry::new_static(encoding[i].0, encoding[i].1))
-                };
-                Self { table: ArcOrRef::Ref(&TABLE)}
-            };
-        }
-    };
-}
-
-builtin_simple_font_encoding_table! {
-    pub const MAC_ROMAN;
-    [
-        (0o040, b"space", " "),
-        (0o041, b"exclam", "!"),
-        (0o042, b"quotedbl", "\""),
-        (0o043, b"numbersign", "#"),
-        (0o044, b"dollar", "$"),
-        (0o045, b"percent", "%"),
-        (0o046, b"ampersand", "&"),
-        (0o047, b"quotesingle", "\'"),
-        (0o050, b"parenleft", "("),
-        (0o051, b"parenright", ")"),
-        (0o052, b"asterisk", "*"),
-        (0o053, b"plus", "+"),
-        (0o054, b"comma", ","),
-        (0o055, b"hyphen", "-"),
-        (0o056, b"period", "."),
-        (0o057, b"slash", "/"),
-        (0o060, b"zero", "0"),
-        (0o061, b"one", "1"),
-        (0o062, b"two", "2"),
-        (0o063, b"three", "3"),
-        (0o064, b"four", "4"),
-        (0o065, b"five", "5"),
-        (0o066, b"six", "6"),
-        (0o067, b"seven", "7"),
-        (0o070, b"eight", "8"),
-        (0o071, b"nine", "9"),
-        (0o072, b"colon", ":"),
-        (0o073, b"semicolon", ";"),
-        (0o074, b"less", "<"),
-        (0o075, b"equal", "="),
-        (0o076, b"greater", ">"),
-        (0o077, b"question", "?"),
-        (0o100, b"at", "@"),
-        (0o101, b"A", "A"),
-        (0o102, b"B", "B"),
-        (0o103, b"C", "C"),
-        (0o104, b"D", "D"),
-        (0o105, b"E", "E"),
-        (0o106, b"F", "F"),
-        (0o107, b"G", "G"),
-        (0o110, b"H", "H"),
-        (0o111, b"I", "I"),
-        (0o112, b"J", "J"),
-        (0o113, b"K", "K"),
-        (0o114, b"L", "L"),
-        (0o115, b"M", "M"),
-        (0o116, b"N", "N"),
-        (0o117, b"O", "O"),
-        (0o120, b"P", "P"),
-        (0o121, b"Q", "Q"),
-        (0o122, b"R", "R"),
-        (0o123, b"S", "S"),
-        (0o124, b"T", "T"),
-        (0o125, b"U", "U"),
-        (0o126, b"V", "V"),
-        (0o127, b"W", "W"),
-        (0o130, b"X", "X"),
-        (0o131, b"Y", "Y"),
-        (0o132, b"Z", "Z"),
-        (0o133, b"bracketleft", "["),
-        (0o134, b"backslash", "\\"),
-        (0o135, b"bracketright", "]"),
-        (0o136, b"asciicircum", "^"),
-        (0o137, b"underscore", "_"),
-        (0o140, b"grave", "`"),
-        (0o141, b"a", "a"),
-        (0o142, b"b", "b"),
-        (0o143, b"c", "c"),
-        (0o144, b"d", "d"),
-        (0o145, b"e", "e"),
-        (0o146, b"f", "f"),
-        (0o147, b"g", "g"),
-        (0o150, b"h", "h"),
-        (0o151, b"i", "i"),
-        (0o152, b"j", "j"),
-        (0o153, b"k", "k"),
-        (0o154, b"l", "l"),
-        (0o155, b"m", "m"),
-        (0o156, b"n", "n"),
-        (0o157, b"o", "o"),
-        (0o160, b"p", "p"),
-        (0o161, b"q", "q"),
-        (0o162, b"r", "r"),
-        (0o163, b"s", "s"),
-        (0o164, b"t", "t"),
-        (0o165, b"u", "u"),
-        (0o166, b"v", "v"),
-        (0o167, b"w", "w"),
-        (0o170, b"x", "x"),
-        (0o171, b"y", "y"),
-        (0o172, b"z", "z"),
-        (0o173, b"braceleft", "{"),
-        (0o174, b"bar", "|"),
-        (0o175, b"braceright", "}"),
-        (0o176, b"asciitilde", "~"),
-        (0o200, b"Adieresis", "\u{c4}"),
-        (0o201, b"Aring", "\u{c5}"),
-        (0o202, b"Ccedilla", "\u{c7}"),
-        (0o203, b"Eacute", "\u{c9}"),
-        (0o204, b"Ntilde", "\u{d1}"),
-        (0o205, b"Odieresis", "\u{d6}"),
-        (0o206, b"Udieresis", "\u{dc}"),
-        (0o207, b"aacute", "\u{e1}"),
-        (0o210, b"agrave", "\u{e0}"),
-        (0o211, b"acircumflex", "\u{e2}"),
-        (0o212, b"adieresis", "\u{e4}"),
-        (0o213, b"atilde", "\u{e3}"),
-        (0o214, b"aring", "\u{e5}"),
-        (0o215, b"ccedilla", "\u{e7}"),
-        (0o216, b"eacute", "\u{e9}"),
-        (0o217, b"egrave", "\u{e8}"),
-        (0o220, b"ecircumflex", "\u{ea}"),
-        (0o221, b"edieresis", "\u{eb}"),
-        (0o222, b"iacute", "\u{ed}"),
-        (0o223, b"igrave", "\u{ec}"),
-        (0o224, b"icircumflex", "\u{ee}"),
-        (0o225, b"idieresis", "\u{ef}"),
-        (0o226, b"ntilde", "\u{f1}"),
-        (0o227, b"oacute", "\u{f3}"),
-        (0o230, b"ograve", "\u{f2}"),
-        (0o231, b"ocircumflex", "\u{f4}"),
-        (0o232, b"odieresis", "\u{f6}"),
-        (0o233, b"otilde", "\u{f5}"),
-        (0o234, b"uacute", "\u{fa}"),
-        (0o235, b"ugrave", "\u{f9}"),
-        (0o236, b"ucircumflex", "\u{fb}"),
-        (0o237, b"udieresis", "\u{fc}"),
-        (0o240, b"dagger", "\u{2020}"),
-        (0o241, b"degree", "\u{b0}"),
-        (0o242, b"cent", "\u{a2}"),
-        (0o243, b"sterling", "\u{a3}"),
-        (0o244, b"section", "\u{a7}"),
-        (0o245, b"bullet", "\u{2022}"),
-        (0o246, b"paragraph", "\u{b6}"),
-        (0o247, b"germandbls", "\u{df}"),
-        (0o250, b"registered", "\u{ae}"),
-        (0o251, b"copyright", "\u{a9}"),
-        (0o252, b"trademark", "\u{2122}"),
-        (0o253, b"acute", "\u{b4}"),
-        (0o254, b"dieresis", "\u{a8}"),
-        (0o256, b"AE", "\u{c6}"),
-        (0o257, b"Oslash", "\u{d8}"),
-        (0o261, b"plusminus", "\u{b1}"),
-        (0o264, b"yen", "\u{a5}"),
-        (0o265, b"mu", "\u{3bc}"),
-        (0o273, b"ordfeminine", "\u{aa}"),
-        (0o274, b"ordmasculine", "\u{ba}"),
-        (0o276, b"ae", "\u{e6}"),
-        (0o277, b"oslash", "\u{f8}"),
-        (0o300, b"questiondown", "\u{bf}"),
-        (0o301, b"exclamdown", "\u{a1}"),
-        (0o302, b"logicalnot", "\u{ac}"),
-        (0o304, b"florin", "\u{192}"),
-        (0o307, b"guillemotleft", "\u{ab}"),
-        (0o310, b"guillemotright", "\u{bb}"),
-        (0o311, b"ellipsis", "\u{2026}"),
-        (0o312, b"space", "\u{a0}"),
-        (0o313, b"Agrave", "\u{c0}"),
-        (0o314, b"Atilde", "\u{c3}"),
-        (0o315, b"Otilde", "\u{d5}"),
-        (0o316, b"OE", "\u{152}"),
-        (0o317, b"oe", "\u{153}"),
-        (0o320, b"endash", "\u{2013}"),
-        (0o321, b"emdash", "\u{2014}"),
-        (0o322, b"quotedblleft", "\u{201c}"),
-        (0o323, b"quotedblright", "\u{201d}"),
-        (0o324, b"quoteleft", "\u{2018}"),
-        (0o325, b"quoteright", "\u{2019}"),
-        (0o326, b"divide", "\u{f7}"),
-        (0o330, b"ydieresis", "\u{ff}"),
-        (0o331, b"Ydieresis", "\u{178}"),
-        (0o332, b"fraction", "\u{2044}"),
-        (0o333, b"currency", "\u{a4}"),
-        (0o334, b"guilsinglleft", "\u{2039}"),
-        (0o335, b"guilsinglright", "\u{203a}"),
-        (0o336, b"fi", "\u{fb01}"),
-        (0o337, b"fl", "\u{fb02}"),
-        (0o340, b"daggerdbl", "\u{2021}"),
-        (0o341, b"periodcentered", "\u{b7}"),
-        (0o342, b"quotesinglbase", "\u{201a}"),
-        (0o343, b"quotedblbase", "\u{201e}"),
-        (0o344, b"perthousand", "\u{2030}"),
-        (0o345, b"Acircumflex", "\u{c2}"),
-        (0o346, b"Ecircumflex", "\u{ca}"),
-        (0o347, b"Aacute", "\u{c1}"),
-        (0o350, b"Edieresis", "\u{cb}"),
-        (0o351, b"Egrave", "\u{c8}"),
-        (0o352, b"Iacute", "\u{cd}"),
-        (0o353, b"Icircumflex", "\u{ce}"),
-        (0o354, b"Idieresis", "\u{cf}"),
-        (0o355, b"Igrave", "\u{cc}"),
-        (0o356, b"Oacute", "\u{d3}"),
-        (0o357, b"Ocircumflex", "\u{d4}"),
-        (0o361, b"Ograve", "\u{d2}"),
-        (0o362, b"Uacute", "\u{da}"),
-        (0o363, b"Ucircumflex", "\u{db}"),
-        (0o364, b"Ugrave", "\u{d9}"),
-        (0o365, b"dotlessi", "\u{131}"),
-        (0o366, b"circumflex", "\u{2c6}"),
-        (0o367, b"tilde", "\u{2dc}"),
-        (0o370, b"macron", "\u{af}"),
-        (0o371, b"breve", "\u{2d8}"),
-        (0o372, b"dotaccent", "\u{2d9}"),
-        (0o373, b"ring", "\u{2da}"),
-        (0o374, b"cedilla", "\u{b8}"),
-        (0o375, b"hungarumlaut", "\u{2dd}"),
-        (0o376, b"ogonek", "\u{2db}"),
-        (0o377, b"caron", "\u{2c7}"),
-    ]
-}
-
-builtin_simple_font_encoding_table! {
-    pub const STANDARD;
-    [
-        (0o040, b"space", " "),
-        (0o041, b"exclam", "!"),
-        (0o042, b"quotedbl", "\""),
-        (0o043, b"numbersign", "#"),
-        (0o044, b"dollar", "$"),
-        (0o045, b"percent", "%"),
-        (0o046, b"ampersand", "&"),
-        (0o047, b"quoteright", "\u{2019}"),
-        (0o050, b"parenleft", "("),
-        (0o051, b"parenright", ")"),
-        (0o052, b"asterisk", "*"),
-        (0o053, b"plus", "+"),
-        (0o054, b"comma", ","),
-        (0o055, b"hyphen", "-"),
-        (0o056, b"period", "."),
-        (0o057, b"slash", "/"),
-        (0o060, b"zero", "0"),
-        (0o061, b"one", "1"),
-        (0o062, b"two", "2"),
-        (0o063, b"three", "3"),
-        (0o064, b"four", "4"),
-        (0o065, b"five", "5"),
-        (0o066, b"six", "6"),
-        (0o067, b"seven", "7"),
-        (0o070, b"eight", "8"),
-        (0o071, b"nine", "9"),
-        (0o072, b"colon", ":"),
-        (0o073, b"semicolon", ";"),
-        (0o074, b"less", "<"),
-        (0o075, b"equal", "="),
-        (0o076, b"greater", ">"),
-        (0o077, b"question", "?"),
-        (0o100, b"at", "@"),
-        (0o101, b"A", "A"),
-        (0o102, b"B", "B"),
-        (0o103, b"C", "C"),
-        (0o104, b"D", "D"),
-        (0o105, b"E", "E"),
-        (0o106, b"F", "F"),
-        (0o107, b"G", "G"),
-        (0o110, b"H", "H"),
-        (0o111, b"I", "I"),
-        (0o112, b"J", "J"),
-        (0o113, b"K", "K"),
-        (0o114, b"L", "L"),
-        (0o115, b"M", "M"),
-        (0o116, b"N", "N"),
-        (0o117, b"O", "O"),
-        (0o120, b"P", "P"),
-        (0o121, b"Q", "Q"),
-        (0o122, b"R", "R"),
-        (0o123, b"S", "S"),
-        (0o124, b"T", "T"),
-        (0o125, b"U", "U"),
-        (0o126, b"V", "V"),
-        (0o127, b"W", "W"),
-        (0o130, b"X", "X"),
-        (0o131, b"Y", "Y"),
-        (0o132, b"Z", "Z"),
-        (0o133, b"bracketleft", "["),
-        (0o134, b"backslash", "\\"),
-        (0o135, b"bracketright", "]"),
-        (0o136, b"asciicircum", "^"),
-        (0o137, b"underscore", "_"),
-        (0o140, b"quoteleft", "\u{2018}"),
-        (0o141, b"a", "a"),
-        (0o142, b"b", "b"),
-        (0o143, b"c", "c"),
-        (0o144, b"d", "d"),
-        (0o145, b"e", "e"),
-        (0o146, b"f", "f"),
-        (0o147, b"g", "g"),
-        (0o150, b"h", "h"),
-        (0o151, b"i", "i"),
-        (0o152, b"j", "j"),
-        (0o153, b"k", "k"),
-        (0o154, b"l", "l"),
-        (0o155, b"m", "m"),
-        (0o156, b"n", "n"),
-        (0o157, b"o", "o"),
-        (0o160, b"p", "p"),
-        (0o161, b"q", "q"),
-        (0o162, b"r", "r"),
-        (0o163, b"s", "s"),
-        (0o164, b"t", "t"),
-        (0o165, b"u", "u"),
-        (0o166, b"v", "v"),
-        (0o167, b"w", "w"),
-        (0o170, b"x", "x"),
-        (0o171, b"y", "y"),
-        (0o172, b"z", "z"),
-        (0o173, b"braceleft", "{"),
-        (0o174, b"bar", "|"),
-        (0o175, b"braceright", "}"),
-        (0o176, b"asciitilde", "~"),
-        (0o241, b"exclamdown", "\u{a1}"),
-        (0o242, b"cent", "\u{a2}"),
-        (0o243, b"sterling", "\u{a3}"),
-        (0o244, b"fraction", "\u{2044}"),
-        (0o245, b"yen", "\u{a5}"),
-        (0o246, b"florin", "\u{192}"),
-        (0o247, b"section", "\u{a7}"),
-        (0o250, b"currency", "\u{a4}"),
-        (0o251, b"quotesingle", "\'"),
-        (0o252, b"quotedblleft", "\u{201c}"),
-        (0o253, b"guillemotleft", "\u{ab}"),
-        (0o254, b"guilsinglleft", "\u{2039}"),
-        (0o255, b"guilsinglright", "\u{203a}"),
-        (0o256, b"fi", "\u{fb01}"),
-        (0o257, b"fl", "\u{fb02}"),
-        (0o261, b"endash", "\u{2013}"),
-        (0o262, b"dagger", "\u{2020}"),
-        (0o263, b"daggerdbl", "\u{2021}"),
-        (0o264, b"periodcentered", "\u{b7}"),
-        (0o266, b"paragraph", "\u{b6}"),
-        (0o267, b"bullet", "\u{2022}"),
-        (0o270, b"quotesinglbase", "\u{201a}"),
-        (0o271, b"quotedblbase", "\u{201e}"),
-        (0o272, b"quotedblright", "\u{201d}"),
-        (0o273, b"guillemotright", "\u{bb}"),
-        (0o274, b"ellipsis", "\u{2026}"),
-        (0o275, b"perthousand", "\u{2030}"),
-        (0o277, b"questiondown", "\u{bf}"),
-        (0o301, b"grave", "`"),
-        (0o302, b"acute", "\u{b4}"),
-        (0o303, b"circumflex", "\u{2c6}"),
-        (0o304, b"tilde", "\u{2dc}"),
-        (0o305, b"macron", "\u{af}"),
-        (0o306, b"breve", "\u{2d8}"),
-        (0o307, b"dotaccent", "\u{2d9}"),
-        (0o310, b"dieresis", "\u{a8}"),
-        (0o312, b"ring", "\u{2da}"),
-        (0o313, b"cedilla", "\u{b8}"),
-        (0o315, b"hungarumlaut", "\u{2dd}"),
-        (0o316, b"ogonek", "\u{2db}"),
-        (0o317, b"caron", "\u{2c7}"),
-        (0o320, b"emdash", "\u{2014}"),
-        (0o341, b"AE", "\u{c6}"),
-        (0o343, b"ordfeminine", "\u{aa}"),
-        (0o350, b"Lslash", "\u{141}"),
-        (0o351, b"Oslash", "\u{d8}"),
-        (0o352, b"OE", "\u{152}"),
-        (0o353, b"ordmasculine", "\u{ba}"),
-        (0o361, b"ae", "\u{e6}"),
-        (0o365, b"dotlessi", "\u{131}"),
-        (0o370, b"lslash", "\u{142}"),
-        (0o371, b"oslash", "\u{f8}"),
-        (0o372, b"oe", "\u{153}"),
-        (0o373, b"germandbls", "\u{df}"),
-    ]
-}
-
-builtin_simple_font_encoding_table! {
-    pub const WIN_ANSI;
-    #[default = (b"bullet", "\u{2022}")]
-    [
-        (0o040, b"space", " "),
-        (0o041, b"exclam", "!"),
-        (0o042, b"quotedbl", "\""),
-        (0o043, b"numbersign", "#"),
-        (0o044, b"dollar", "$"),
-        (0o045, b"percent", "%"),
-        (0o046, b"ampersand", "&"),
-        (0o047, b"quotesingle", "\'"),
-        (0o050, b"parenleft", "("),
-        (0o051, b"parenright", ")"),
-        (0o052, b"asterisk", "*"),
-        (0o053, b"plus", "+"),
-        (0o054, b"comma", ","),
-        (0o055, b"hyphen", "-"),
-        (0o056, b"period", "."),
-        (0o057, b"slash", "/"),
-        (0o060, b"zero", "0"),
-        (0o061, b"one", "1"),
-        (0o062, b"two", "2"),
-        (0o063, b"three", "3"),
-        (0o064, b"four", "4"),
-        (0o065, b"five", "5"),
-        (0o066, b"six", "6"),
-        (0o067, b"seven", "7"),
-        (0o070, b"eight", "8"),
-        (0o071, b"nine", "9"),
-        (0o072, b"colon", ":"),
-        (0o073, b"semicolon", ";"),
-        (0o074, b"less", "<"),
-        (0o075, b"equal", "="),
-        (0o076, b"greater", ">"),
-        (0o077, b"question", "?"),
-        (0o100, b"at", "@"),
-        (0o101, b"A", "A"),
-        (0o102, b"B", "B"),
-        (0o103, b"C", "C"),
-        (0o104, b"D", "D"),
-        (0o105, b"E", "E"),
-        (0o106, b"F", "F"),
-        (0o107, b"G", "G"),
-        (0o110, b"H", "H"),
-        (0o111, b"I", "I"),
-        (0o112, b"J", "J"),
-        (0o113, b"K", "K"),
-        (0o114, b"L", "L"),
-        (0o115, b"M", "M"),
-        (0o116, b"N", "N"),
-        (0o117, b"O", "O"),
-        (0o120, b"P", "P"),
-        (0o121, b"Q", "Q"),
-        (0o122, b"R", "R"),
-        (0o123, b"S", "S"),
-        (0o124, b"T", "T"),
-        (0o125, b"U", "U"),
-        (0o126, b"V", "V"),
-        (0o127, b"W", "W"),
-        (0o130, b"X", "X"),
-        (0o131, b"Y", "Y"),
-        (0o132, b"Z", "Z"),
-        (0o133, b"bracketleft", "["),
-        (0o134, b"backslash", "\\"),
-        (0o135, b"bracketright", "]"),
-        (0o136, b"asciicircum", "^"),
-        (0o137, b"underscore", "_"),
-        (0o140, b"grave", "`"),
-        (0o141, b"a", "a"),
-        (0o142, b"b", "b"),
-        (0o143, b"c", "c"),
-        (0o144, b"d", "d"),
-        (0o145, b"e", "e"),
-        (0o146, b"f", "f"),
-        (0o147, b"g", "g"),
-        (0o150, b"h", "h"),
-        (0o151, b"i", "i"),
-        (0o152, b"j", "j"),
-        (0o153, b"k", "k"),
-        (0o154, b"l", "l"),
-        (0o155, b"m", "m"),
-        (0o156, b"n", "n"),
-        (0o157, b"o", "o"),
-        (0o160, b"p", "p"),
-        (0o161, b"q", "q"),
-        (0o162, b"r", "r"),
-        (0o163, b"s", "s"),
-        (0o164, b"t", "t"),
-        (0o165, b"u", "u"),
-        (0o166, b"v", "v"),
-        (0o167, b"w", "w"),
-        (0o170, b"x", "x"),
-        (0o171, b"y", "y"),
-        (0o172, b"z", "z"),
-        (0o173, b"braceleft", "{"),
-        (0o174, b"bar", "|"),
-        (0o175, b"braceright", "}"),
-        (0o176, b"asciitilde", "~"),
-        (0o200, b"Euro", "\u{20ac}"),
-        (0o202, b"quotesinglbase", "\u{201a}"),
-        (0o203, b"florin", "\u{192}"),
-        (0o204, b"quotedblbase", "\u{201e}"),
-        (0o205, b"ellipsis", "\u{2026}"),
-        (0o206, b"dagger", "\u{2020}"),
-        (0o207, b"daggerdbl", "\u{2021}"),
-        (0o210, b"circumflex", "\u{2c6}"),
-        (0o211, b"perthousand", "\u{2030}"),
-        (0o212, b"Scaron", "\u{160}"),
-        (0o213, b"guilsinglleft", "\u{2039}"),
-        (0o214, b"OE", "\u{152}"),
-        (0o216, b"Zcaron", "\u{17d}"),
-        (0o221, b"quoteleft", "\u{2018}"),
-        (0o222, b"quoteright", "\u{2019}"),
-        (0o223, b"quotedblleft", "\u{201c}"),
-        (0o224, b"quotedblright", "\u{201d}"),
-        (0o225, b"bullet", "\u{2022}"),
-        (0o226, b"endash", "\u{2013}"),
-        (0o227, b"emdash", "\u{2014}"),
-        (0o230, b"tilde", "\u{2dc}"),
-        (0o231, b"trademark", "\u{2122}"),
-        (0o232, b"scaron", "\u{161}"),
-        (0o233, b"guilsinglright", "\u{203a}"),
-        (0o234, b"oe", "\u{153}"),
-        (0o236, b"zcaron", "\u{17e}"),
-        (0o237, b"Ydieresis", "\u{178}"),
-        (0o240, b"space", "\u{a0}"),
-        (0o241, b"exclamdown", "\u{a1}"),
-        (0o242, b"cent", "\u{a2}"),
-        (0o243, b"sterling", "\u{a3}"),
-        (0o244, b"currency", "\u{a4}"),
-        (0o245, b"yen", "\u{a5}"),
-        (0o246, b"brokenbar", "\u{a6}"),
-        (0o247, b"section", "\u{a7}"),
-        (0o250, b"dieresis", "\u{a8}"),
-        (0o251, b"copyright", "\u{a9}"),
-        (0o252, b"ordfeminine", "\u{aa}"),
-        (0o253, b"guillemotleft", "\u{ab}"),
-        (0o254, b"logicalnot", "\u{ac}"),
-        (0o255, b"hyphen", "\u{ad}"),
-        (0o256, b"registered", "\u{ae}"),
-        (0o257, b"macron", "\u{af}"),
-        (0o260, b"degree", "\u{b0}"),
-        (0o261, b"plusminus", "\u{b1}"),
-        (0o262, b"twosuperior", "\u{b2}"),
-        (0o263, b"threesuperior", "\u{b3}"),
-        (0o264, b"acute", "\u{b4}"),
-        (0o265, b"mu", "\u{3bc}"),
-        (0o266, b"paragraph", "\u{b6}"),
-        (0o267, b"periodcentered", "\u{b7}"),
-        (0o270, b"cedilla", "\u{b8}"),
-        (0o271, b"onesuperior", "\u{b9}"),
-        (0o272, b"ordmasculine", "\u{ba}"),
-        (0o273, b"guillemotright", "\u{bb}"),
-        (0o274, b"onequarter", "\u{bc}"),
-        (0o275, b"onehalf", "\u{bd}"),
-        (0o276, b"threequarters", "\u{be}"),
-        (0o277, b"questiondown", "\u{bf}"),
-        (0o300, b"Agrave", "\u{c0}"),
-        (0o301, b"Aacute", "\u{c1}"),
-        (0o302, b"Acircumflex", "\u{c2}"),
-        (0o303, b"Atilde", "\u{c3}"),
-        (0o304, b"Adieresis", "\u{c4}"),
-        (0o305, b"Aring", "\u{c5}"),
-        (0o306, b"AE", "\u{c6}"),
-        (0o307, b"Ccedilla", "\u{c7}"),
-        (0o310, b"Egrave", "\u{c8}"),
-        (0o311, b"Eacute", "\u{c9}"),
-        (0o312, b"Ecircumflex", "\u{ca}"),
-        (0o313, b"Edieresis", "\u{cb}"),
-        (0o314, b"Igrave", "\u{cc}"),
-        (0o315, b"Iacute", "\u{cd}"),
-        (0o316, b"Icircumflex", "\u{ce}"),
-        (0o317, b"Idieresis", "\u{cf}"),
-        (0o320, b"Eth", "\u{d0}"),
-        (0o321, b"Ntilde", "\u{d1}"),
-        (0o322, b"Ograve", "\u{d2}"),
-        (0o323, b"Oacute", "\u{d3}"),
-        (0o324, b"Ocircumflex", "\u{d4}"),
-        (0o325, b"Otilde", "\u{d5}"),
-        (0o326, b"Odieresis", "\u{d6}"),
-        (0o327, b"multiply", "\u{d7}"),
-        (0o330, b"Oslash", "\u{d8}"),
-        (0o331, b"Ugrave", "\u{d9}"),
-        (0o332, b"Uacute", "\u{da}"),
-        (0o333, b"Ucircumflex", "\u{db}"),
-        (0o334, b"Udieresis", "\u{dc}"),
-        (0o335, b"Yacute", "\u{dd}"),
-        (0o336, b"Thorn", "\u{de}"),
-        (0o337, b"germandbls", "\u{df}"),
-        (0o340, b"agrave", "\u{e0}"),
-        (0o341, b"aacute", "\u{e1}"),
-        (0o342, b"acircumflex", "\u{e2}"),
-        (0o343, b"atilde", "\u{e3}"),
-        (0o344, b"adieresis", "\u{e4}"),
-        (0o345, b"aring", "\u{e5}"),
-        (0o346, b"ae", "\u{e6}"),
-        (0o347, b"ccedilla", "\u{e7}"),
-        (0o350, b"egrave", "\u{e8}"),
-        (0o351, b"eacute", "\u{e9}"),
-        (0o352, b"ecircumflex", "\u{ea}"),
-        (0o353, b"edieresis", "\u{eb}"),
-        (0o354, b"igrave", "\u{ec}"),
-        (0o355, b"iacute", "\u{ed}"),
-        (0o356, b"icircumflex", "\u{ee}"),
-        (0o357, b"idieresis", "\u{ef}"),
-        (0o360, b"eth", "\u{f0}"),
-        (0o361, b"ntilde", "\u{f1}"),
-        (0o362, b"ograve", "\u{f2}"),
-        (0o363, b"oacute", "\u{f3}"),
-        (0o364, b"ocircumflex", "\u{f4}"),
-        (0o365, b"otilde", "\u{f5}"),
-        (0o366, b"odieresis", "\u{f6}"),
-        (0o367, b"divide", "\u{f7}"),
-        (0o370, b"oslash", "\u{f8}"),
-        (0o371, b"ugrave", "\u{f9}"),
-        (0o372, b"uacute", "\u{fa}"),
-        (0o373, b"ucircumflex", "\u{fb}"),
-        (0o374, b"udieresis", "\u{fc}"),
-        (0o375, b"yacute", "\u{fd}"),
-        (0o376, b"thorn", "\u{fe}"),
-        (0o377, b"ydieresis", "\u{ff}"),
-    ]
-}
-
-builtin_simple_font_encoding_table! {
-    pub const PDF_DOC;
-    [
-        (0o011, None, "\t"),
-        (0o012, None, "\n"),
-        (0o015, None, "\r"),
-        (0o030, b"breve", "\u{2d8}"),
-        (0o031, b"caron", "\u{2c7}"),
-        (0o032, b"circumflex", "\u{2c6}"),
-        (0o033, b"dotaccent", "\u{2d9}"),
-        (0o034, b"hungarumlaut", "\u{2dd}"),
-        (0o035, b"ogonek", "\u{2db}"),
-        (0o036, b"ring", "\u{2da}"),
-        (0o037, b"tilde", "\u{2dc}"),
-        (0o040, b"space", " "),
-        (0o041, b"exclam", "!"),
-        (0o042, b"quotedbl", "\""),
-        (0o043, b"numbersign", "#"),
-        (0o044, b"dollar", "$"),
-        (0o045, b"percent", "%"),
-        (0o046, b"ampersand", "&"),
-        (0o047, b"quotesingle", "\'"),
-        (0o050, b"parenleft", "("),
-        (0o051, b"parenright", ")"),
-        (0o052, b"asterisk", "*"),
-        (0o053, b"plus", "+"),
-        (0o054, b"comma", ","),
-        (0o055, b"hyphen", "-"),
-        (0o056, b"period", "."),
-        (0o057, b"slash", "/"),
-        (0o060, b"zero", "0"),
-        (0o061, b"one", "1"),
-        (0o062, b"two", "2"),
-        (0o063, b"three", "3"),
-        (0o064, b"four", "4"),
-        (0o065, b"five", "5"),
-        (0o066, b"six", "6"),
-        (0o067, b"seven", "7"),
-        (0o070, b"eight", "8"),
-        (0o071, b"nine", "9"),
-        (0o072, b"colon", ":"),
-        (0o073, b"semicolon", ";"),
-        (0o074, b"less", "<"),
-        (0o075, b"equal", "="),
-        (0o076, b"greater", ">"),
-        (0o077, b"question", "?"),
-        (0o100, b"at", "@"),
-        (0o101, b"A", "A"),
-        (0o102, b"B", "B"),
-        (0o103, b"C", "C"),
-        (0o104, b"D", "D"),
-        (0o105, b"E", "E"),
-        (0o106, b"F", "F"),
-        (0o107, b"G", "G"),
-        (0o110, b"H", "H"),
-        (0o111, b"I", "I"),
-        (0o112, b"J", "J"),
-        (0o113, b"K", "K"),
-        (0o114, b"L", "L"),
-        (0o115, b"M", "M"),
-        (0o116, b"N", "N"),
-        (0o117, b"O", "O"),
-        (0o120, b"P", "P"),
-        (0o121, b"Q", "Q"),
-        (0o122, b"R", "R"),
-        (0o123, b"S", "S"),
-        (0o124, b"T", "T"),
-        (0o125, b"U", "U"),
-        (0o126, b"V", "V"),
-        (0o127, b"W", "W"),
-        (0o130, b"X", "X"),
-        (0o131, b"Y", "Y"),
-        (0o132, b"Z", "Z"),
-        (0o133, b"bracketleft", "["),
-        (0o134, b"backslash", "\\"),
-        (0o135, b"bracketright", "]"),
-        (0o136, b"asciicircum", "^"),
-        (0o137, b"underscore", "_"),
-        (0o140, b"grave", "`"),
-        (0o141, b"a", "a"),
-        (0o142, b"b", "b"),
-        (0o143, b"c", "c"),
-        (0o144, b"d", "d"),
-        (0o145, b"e", "e"),
-        (0o146, b"f", "f"),
-        (0o147, b"g", "g"),
-        (0o150, b"h", "h"),
-        (0o151, b"i", "i"),
-        (0o152, b"j", "j"),
-        (0o153, b"k", "k"),
-        (0o154, b"l", "l"),
-        (0o155, b"m", "m"),
-        (0o156, b"n", "n"),
-        (0o157, b"o", "o"),
-        (0o160, b"p", "p"),
-        (0o161, b"q", "q"),
-        (0o162, b"r", "r"),
-        (0o163, b"s", "s"),
-        (0o164, b"t", "t"),
-        (0o165, b"u", "u"),
-        (0o166, b"v", "v"),
-        (0o167, b"w", "w"),
-        (0o170, b"x", "x"),
-        (0o171, b"y", "y"),
-        (0o172, b"z", "z"),
-        (0o173, b"braceleft", "{"),
-        (0o174, b"bar", "|"),
-        (0o175, b"braceright", "}"),
-        (0o176, b"asciitilde", "~"),
-        (0o200, b"bullet", "\u{2022}"),
-        (0o201, b"dagger", "\u{2020}"),
-        (0o202, b"daggerdbl", "\u{2021}"),
-        (0o203, b"ellipsis", "\u{2026}"),
-        (0o204, b"emdash", "\u{2014}"),
-        (0o205, b"endash", "\u{2013}"),
-        (0o206, b"florin", "\u{192}"),
-        (0o207, b"fraction", "\u{2044}"),
-        (0o210, b"guilsinglleft", "\u{2039}"),
-        (0o211, b"guilsinglright", "\u{203a}"),
-        (0o212, b"minus", "\u{2212}"),
-        (0o213, b"perthousand", "\u{2030}"),
-        (0o214, b"quotedblbase", "\u{201e}"),
-        (0o215, b"quotedblleft", "\u{201c}"),
-        (0o216, b"quotedblright", "\u{201d}"),
-        (0o217, b"quoteleft", "\u{2018}"),
-        (0o220, b"quoteright", "\u{2019}"),
-        (0o221, b"quotesinglbase", "\u{201a}"),
-        (0o222, b"trademark", "\u{2122}"),
-        (0o223, b"fi", "\u{fb01}"),
-        (0o224, b"fl", "\u{fb02}"),
-        (0o225, b"Lslash", "\u{141}"),
-        (0o226, b"OE", "\u{152}"),
-        (0o227, b"Scaron", "\u{160}"),
-        (0o230, b"Ydieresis", "\u{178}"),
-        (0o231, b"Zcaron", "\u{17d}"),
-        (0o232, b"dotlessi", "\u{131}"),
-        (0o233, b"lslash", "\u{142}"),
-        (0o234, b"oe", "\u{153}"),
-        (0o235, b"scaron", "\u{161}"),
-        (0o236, b"zcaron", "\u{17e}"),
-        (0o240, b"Euro", "\u{20ac}"),
-        (0o241, b"exclamdown", "\u{a1}"),
-        (0o242, b"cent", "\u{a2}"),
-        (0o243, b"sterling", "\u{a3}"),
-        (0o244, b"currency", "\u{a4}"),
-        (0o245, b"yen", "\u{a5}"),
-        (0o246, b"brokenbar", "\u{a6}"),
-        (0o247, b"section", "\u{a7}"),
-        (0o250, b"dieresis", "\u{a8}"),
-        (0o251, b"copyright", "\u{a9}"),
-        (0o252, b"ordfeminine", "\u{aa}"),
-        (0o253, b"guillemotleft", "\u{ab}"),
-        (0o254, b"logicalnot", "\u{ac}"),
-        (0o256, b"registered", "\u{ae}"),
-        (0o257, b"macron", "\u{af}"),
-        (0o260, b"degree", "\u{b0}"),
-        (0o261, b"plusminus", "\u{b1}"),
-        (0o262, b"twosuperior", "\u{b2}"),
-        (0o263, b"threesuperior", "\u{b3}"),
-        (0o264, b"acute", "\u{b4}"),
-        (0o265, b"mu", "\u{3bc}"),
-        (0o266, b"paragraph", "\u{b6}"),
-        (0o267, b"periodcentered", "\u{b7}"),
-        (0o270, b"cedilla", "\u{b8}"),
-        (0o271, b"onesuperior", "\u{b9}"),
-        (0o272, b"ordmasculine", "\u{ba}"),
-        (0o273, b"guillemotright", "\u{bb}"),
-        (0o274, b"onequarter", "\u{bc}"),
-        (0o275, b"onehalf", "\u{bd}"),
-        (0o276, b"threequarters", "\u{be}"),
-        (0o277, b"questiondown", "\u{bf}"),
-        (0o300, b"Agrave", "\u{c0}"),
-        (0o301, b"Aacute", "\u{c1}"),
-        (0o302, b"Acircumflex", "\u{c2}"),
-        (0o303, b"Atilde", "\u{c3}"),
-        (0o304, b"Adieresis", "\u{c4}"),
-        (0o305, b"Aring", "\u{c5}"),
-        (0o306, b"AE", "\u{c6}"),
-        (0o307, b"Ccedilla", "\u{c7}"),
-        (0o310, b"Egrave", "\u{c8}"),
-        (0o311, b"Eacute", "\u{c9}"),
-        (0o312, b"Ecircumflex", "\u{ca}"),
-        (0o313, b"Edieresis", "\u{cb}"),
-        (0o314, b"Igrave", "\u{cc}"),
-        (0o315, b"Iacute", "\u{cd}"),
-        (0o316, b"Icircumflex", "\u{ce}"),
-        (0o317, b"Idieresis", "\u{cf}"),
-        (0o320, b"Eth", "\u{d0}"),
-        (0o321, b"Ntilde", "\u{d1}"),
-        (0o322, b"Ograve", "\u{d2}"),
-        (0o323, b"Oacute", "\u{d3}"),
-        (0o324, b"Ocircumflex", "\u{d4}"),
-        (0o325, b"Otilde", "\u{d5}"),
-        (0o326, b"Odieresis", "\u{d6}"),
-        (0o327, b"multiply", "\u{d7}"),
-        (0o330, b"Oslash", "\u{d8}"),
-        (0o331, b"Ugrave", "\u{d9}"),
-        (0o332, b"Uacute", "\u{da}"),
-        (0o333, b"Ucircumflex", "\u{db}"),
-        (0o334, b"Udieresis", "\u{dc}"),
-        (0o335, b"Yacute", "\u{dd}"),
-        (0o336, b"Thorn", "\u{de}"),
-        (0o337, b"germandbls", "\u{df}"),
-        (0o340, b"agrave", "\u{e0}"),
-        (0o341, b"aacute", "\u{e1}"),
-        (0o342, b"acircumflex", "\u{e2}"),
-        (0o343, b"atilde", "\u{e3}"),
-        (0o344, b"adieresis", "\u{e4}"),
-        (0o345, b"aring", "\u{e5}"),
-        (0o346, b"ae", "\u{e6}"),
-        (0o347, b"ccedilla", "\u{e7}"),
-        (0o350, b"egrave", "\u{e8}"),
-        (0o351, b"eacute", "\u{e9}"),
-        (0o352, b"ecircumflex", "\u{ea}"),
-        (0o353, b"edieresis", "\u{eb}"),
-        (0o354, b"igrave", "\u{ec}"),
-        (0o355, b"iacute", "\u{ed}"),
-        (0o356, b"icircumflex", "\u{ee}"),
-        (0o357, b"idieresis", "\u{ef}"),
-        (0o360, b"eth", "\u{f0}"),
-        (0o361, b"ntilde", "\u{f1}"),
-        (0o362, b"ograve", "\u{f2}"),
-        (0o363, b"oacute", "\u{f3}"),
-        (0o364, b"ocircumflex", "\u{f4}"),
-        (0o365, b"otilde", "\u{f5}"),
-        (0o366, b"odieresis", "\u{f6}"),
-        (0o367, b"divide", "\u{f7}"),
-        (0o370, b"oslash", "\u{f8}"),
-        (0o371, b"ugrave", "\u{f9}"),
-        (0o372, b"uacute", "\u{fa}"),
-        (0o373, b"ucircumflex", "\u{fb}"),
-        (0o374, b"udieresis", "\u{fc}"),
-        (0o375, b"yacute", "\u{fd}"),
-        (0o376, b"thorn", "\u{fe}"),
-        (0o377, b"ydieresis", "\u{ff}"),
-    ]
-}
-
-builtin_simple_font_encoding_table! {
-    pub const MAC_EXPERT;
-    [
-        (0o040, b"space", " "),
-        (0o041, b"exclamsmall", "!"),
-        (0o042, b"Hungarumlautsmall", "\u{2dd}"),
-        (0o043, b"centoldstyle", "\u{a2}"),
-        (0o044, b"dollaroldstyle", "$"),
-        (0o045, b"dollarsuperior", "$"),
-        (0o046, b"ampersandsmall", "&"),
-        (0o047, b"Acutesmall", "\u{b4}"),
-        (0o050, b"parenleftsuperior", "\u{207d}"),
-        (0o051, b"parenrightsuperior", "\u{207e}"),
-        (0o052, b"twodotenleader", "\u{2025}"),
-        (0o053, b"onedotenleader", "\u{2024}"),
-        (0o054, b"comma", ","),
-        (0o055, b"hyphen", "-"),
-        (0o056, b"period", "."),
-        (0o057, b"fraction", "\u{2044}"),
-        (0o060, b"zerooldstyle", "0"),
-        (0o061, b"oneoldstyle", "1"),
-        (0o062, b"twooldstyle", "2"),
-        (0o063, b"threeoldstyle", "3"),
-        (0o064, b"fouroldstyle", "4"),
-        (0o065, b"fiveoldstyle", "5"),
-        (0o066, b"sixoldstyle", "6"),
-        (0o067, b"sevenoldstyle", "7"),
-        (0o070, b"eightoldstyle", "8"),
-        (0o071, b"nineoldstyle", "9"),
-        (0o072, b"colon", ":"),
-        (0o073, b"semicolon", ";"),
-        (0o075, b"threequartersemdash", "\u{2014}"),
-        (0o077, b"questionsmall", "?"),
-        (0o104, b"Ethsmall", "\u{f0}"),
-        (0o107, b"onequarter", "\u{bc}"),
-        (0o110, b"onehalf", "\u{bd}"),
-        (0o111, b"threequarters", "\u{be}"),
-        (0o112, b"oneeighth", "\u{215b}"),
-        (0o113, b"threeeighths", "\u{215c}"),
-        (0o114, b"fiveeighths", "\u{215d}"),
-        (0o115, b"seveneighths", "\u{215e}"),
-        (0o116, b"onethird", "\u{2153}"),
-        (0o117, b"twothirds", "\u{2154}"),
-        (0o126, b"ff", "\u{fb00}"),
-        (0o127, b"fi", "\u{fb01}"),
-        (0o130, b"fl", "\u{fb02}"),
-        (0o131, b"ffi", "\u{fb03}"),
-        (0o132, b"ffl", "\u{fb04}"),
-        (0o133, b"parenleftinferior", "\u{208d}"),
-        (0o135, b"parenrightinferior", "\u{208e}"),
-        (0o136, b"Circumflexsmall", "\u{2c6}"),
-        (0o137, b"hypheninferior", "-"),
-        (0o140, b"Gravesmall", "`"),
-        (0o141, b"Asmall", "a"),
-        (0o142, b"Bsmall", "b"),
-        (0o143, b"Csmall", "c"),
-        (0o144, b"Dsmall", "d"),
-        (0o145, b"Esmall", "e"),
-        (0o146, b"Fsmall", "f"),
-        (0o147, b"Gsmall", "g"),
-        (0o150, b"Hsmall", "h"),
-        (0o151, b"Ismall", "i"),
-        (0o152, b"Jsmall", "j"),
-        (0o153, b"Ksmall", "k"),
-        (0o154, b"Lsmall", "l"),
-        (0o155, b"Msmall", "m"),
-        (0o156, b"Nsmall", "n"),
-        (0o157, b"Osmall", "o"),
-        (0o160, b"Psmall", "p"),
-        (0o161, b"Qsmall", "q"),
-        (0o162, b"Rsmall", "r"),
-        (0o163, b"Ssmall", "s"),
-        (0o164, b"Tsmall", "t"),
-        (0o165, b"Usmall", "u"),
-        (0o166, b"Vsmall", "v"),
-        (0o167, b"Wsmall", "w"),
-        (0o170, b"Xsmall", "x"),
-        (0o171, b"Ysmall", "y"),
-        (0o172, b"Zsmall", "z"),
-        (0o173, b"colonmonetary", "\u{20a1}"),
-        (0o174, b"onefitted", "1"),
-        (0o175, b"rupiah", "Rp"),
-        (0o176, b"Tildesmall", "\u{2dc}"),
-        (0o201, b"asuperior", "a"),
-        (0o202, b"centsuperior", "\u{a2}"),
-        (0o207, b"Aacutesmall", "\u{e1}"),
-        (0o210, b"Agravesmall", "\u{e0}"),
-        (0o211, b"Acircumflexsmall", "\u{e2}"),
-        (0o212, b"Adieresissmall", "\u{e4}"),
-        (0o213, b"Atildesmall", "\u{e3}"),
-        (0o214, b"Aringsmall", "\u{e5}"),
-        (0o215, b"Ccedillasmall", "\u{e7}"),
-        (0o216, b"Eacutesmall", "\u{e9}"),
-        (0o217, b"Egravesmall", "\u{e8}"),
-        (0o220, b"Ecircumflexsmall", "\u{ea}"),
-        (0o221, b"Edieresissmall", "\u{eb}"),
-        (0o222, b"Iacutesmall", "\u{ed}"),
-        (0o223, b"Igravesmall", "\u{ec}"),
-        (0o224, b"Icircumflexsmall", "\u{ee}"),
-        (0o225, b"Idieresissmall", "\u{ef}"),
-        (0o226, b"Ntildesmall", "\u{f1}"),
-        (0o227, b"Oacutesmall", "\u{f3}"),
-        (0o230, b"Ogravesmall", "\u{f2}"),
-        (0o231, b"Ocircumflexsmall", "\u{f4}"),
-        (0o232, b"Odieresissmall", "\u{f6}"),
-        (0o233, b"Otildesmall", "\u{f5}"),
-        (0o234, b"Uacutesmall", "\u{fa}"),
-        (0o235, b"Ugravesmall", "\u{f9}"),
-        (0o236, b"Ucircumflexsmall", "\u{fb}"),
-        (0o237, b"Udieresissmall", "\u{fc}"),
-        (0o241, b"eightsuperior", "\u{2078}"),
-        (0o242, b"fourinferior", "\u{2084}"),
-        (0o243, b"threeinferior", "\u{2083}"),
-        (0o244, b"sixinferior", "\u{2086}"),
-        (0o245, b"eightinferior", "\u{2088}"),
-        (0o246, b"seveninferior", "\u{2087}"),
-        (0o247, b"Scaronsmall", "\u{161}"),
-        (0o251, b"centinferior", "\u{a2}"),
-        (0o252, b"twoinferior", "\u{2082}"),
-        (0o254, b"Dieresissmall", "\u{a8}"),
-        (0o256, b"Caronsmall", "\u{2c7}"),
-        (0o257, b"osuperior", "o"),
-        (0o260, b"fiveinferior", "\u{2085}"),
-        (0o262, b"commainferior", ","),
-        (0o263, b"periodinferior", "."),
-        (0o264, b"Yacutesmall", "\u{fd}"),
-        (0o266, b"dollarinferior", "$"),
-        (0o271, b"Thornsmall", "\u{fe}"),
-        (0o273, b"nineinferior", "\u{2089}"),
-        (0o274, b"zeroinferior", "\u{2080}"),
-        (0o275, b"Zcaronsmall", "\u{17e}"),
-        (0o276, b"AEsmall", "\u{e6}"),
-        (0o277, b"Oslashsmall", "\u{f8}"),
-        (0o300, b"questiondownsmall", "\u{bf}"),
-        (0o301, b"oneinferior", "\u{2081}"),
-        (0o302, b"Lslashsmall", "\u{142}"),
-        (0o311, b"Cedillasmall", "\u{b8}"),
-        (0o317, b"OEsmall", "\u{153}"),
-        (0o320, b"figuredash", "\u{2012}"),
-        (0o321, b"hyphensuperior", "-"),
-        (0o326, b"exclamdownsmall", "\u{a1}"),
-        (0o330, b"Ydieresissmall", "\u{ff}"),
-        (0o332, b"onesuperior", "\u{b9}"),
-        (0o333, b"twosuperior", "\u{b2}"),
-        (0o334, b"threesuperior", "\u{b3}"),
-        (0o335, b"foursuperior", "\u{2074}"),
-        (0o336, b"fivesuperior", "\u{2075}"),
-        (0o337, b"sixsuperior", "\u{2076}"),
-        (0o340, b"sevensuperior", "\u{2077}"),
-        (0o341, b"ninesuperior", "\u{2079}"),
-        (0o342, b"zerosuperior", "\u{2070}"),
-        (0o344, b"esuperior", "e"),
-        (0o345, b"rsuperior", "r"),
-        (0o346, b"tsuperior", "t"),
-        (0o351, b"isuperior", "i"),
-        (0o352, b"ssuperior", "s"),
-        (0o353, b"dsuperior", "d"),
-        (0o361, b"lsuperior", "l"),
-        (0o362, b"Ogoneksmall", "\u{2db}"),
-        (0o363, b"Brevesmall", "\u{2d8}"),
-        (0o364, b"Macronsmall", "\u{af}"),
-        (0o365, b"bsuperior", "b"),
-        (0o366, b"nsuperior", "\u{207f}"),
-        (0o367, b"msuperior", "m"),
-        (0o370, b"commasuperior", ","),
-        (0o371, b"periodsuperior", "."),
-        (0o372, b"Dotaccentsmall", "\u{2d9}"),
-        (0o373, b"Ringsmall", "\u{2da}"),
-    ]
-}
diff --git a/src/pdf/font/to_unicode_parse.rs b/src/pdf/font/to_unicode_parse.rs
deleted file mode 100644
index e5c57be..0000000
--- a/src/pdf/font/to_unicode_parse.rs
+++ /dev/null
@@ -1,325 +0,0 @@
-use std::{collections::BTreeMap, sync::Arc};
-
-use crate::{
-    pdf::{
-        font::{
-            PdfFontToUnicode,
-            type_1_parse::{PsFile, Token},
-        },
-        object::{PdfName, PdfObjectDirect, PdfString},
-        parse::{PdfInputPosition, PdfParseError},
-    },
-    util::ArcOrRef,
-};
-
-pub(crate) struct ToUnicodeParser {
-    tokenizer: PsFile,
-}
-
-#[track_caller]
-fn invalid_token_err<T>(pos: PdfInputPosition, token: Option<Token>) -> Result<T, PdfParseError> {
-    Err(PdfParseError::InvalidTokenInToUnicodeStream {
-        pos,
-        token: format!("{token:?}"),
-    })
-}
-
-impl ToUnicodeParser {
-    pub(crate) fn new(tokenizer: PsFile) -> Self {
-        Self { tokenizer }
-    }
-    fn expect_any_string(&mut self) -> Result<Vec<u8>, PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let pos = self.tokenizer.pos();
-        match self.tokenizer.next_token()? {
-            Some(Token::String(string)) => Ok(string),
-            token => invalid_token_err(pos, token),
-        }
-    }
-    pub(crate) fn expect_string_with_len(
-        &mut self,
-        expected_len: usize,
-    ) -> Result<Vec<u8>, PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let pos = self.tokenizer.pos();
-        match self.tokenizer.next_token()? {
-            Some(Token::String(string)) if string.len() == expected_len => Ok(string),
-            token => invalid_token_err(pos, token),
-        }
-    }
-    pub(crate) fn expect_literal_name(
-        &mut self,
-        expected_name: &[u8],
-    ) -> Result<(), PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let pos = self.tokenizer.pos();
-        match self.tokenizer.next_token()? {
-            Some(Token::LiteralName(name)) if name == expected_name => Ok(()),
-            token => invalid_token_err(pos, token),
-        }
-    }
-    pub(crate) fn expect_any_literal_name(&mut self) -> Result<Vec<u8>, PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let pos = self.tokenizer.pos();
-        match self.tokenizer.next_token()? {
-            Some(Token::LiteralName(name)) => Ok(name),
-            token => invalid_token_err(pos, token),
-        }
-    }
-    pub(crate) fn expect_executable_name(
-        &mut self,
-        expected_name: &[u8],
-    ) -> Result<(), PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let pos = self.tokenizer.pos();
-        match self.tokenizer.next_token()? {
-            Some(Token::ExecutableName(name)) if name == expected_name => Ok(()),
-            token => invalid_token_err(pos, token),
-        }
-    }
-    pub(crate) fn expect(&mut self, expected_token: Token) -> Result<(), PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let pos = self.tokenizer.pos();
-        match self.tokenizer.next_token()? {
-            Some(token) if token == expected_token => Ok(()),
-            token => invalid_token_err(pos, token),
-        }
-    }
-    pub(crate) fn expect_integer(&mut self) -> Result<i128, PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let pos = self.tokenizer.pos();
-        match self.tokenizer.next_token()? {
-            Some(Token::Integer(value)) => Ok(value),
-            token => invalid_token_err(pos, token),
-        }
-    }
-    pub(crate) fn parse_dict(
-        &mut self,
-        mut entry_callback: impl FnMut(Vec<u8>, PdfInputPosition, Token) -> Result<(), PdfParseError>,
-    ) -> Result<(), PdfParseError> {
-        self.expect(Token::DictStart)?;
-        loop {
-            self.tokenizer.skip_comments_and_whitespace();
-            let name_pos = self.tokenizer.pos();
-            match self.tokenizer.next_token()? {
-                Some(Token::DictEnd) => return Ok(()),
-                Some(Token::LiteralName(name)) => {
-                    self.tokenizer.skip_comments_and_whitespace();
-                    let value_pos = self.tokenizer.pos();
-                    let Some(value) = self.tokenizer.next_token()? else {
-                        return invalid_token_err(value_pos, None);
-                    };
-                    entry_callback(name, value_pos, value)?;
-                }
-                token => {
-                    return invalid_token_err(name_pos, token);
-                }
-            }
-        }
-    }
-    pub(crate) fn parse(
-        mut self,
-        base_map: Option<PdfObjectDirect>,
-    ) -> Result<PdfFontToUnicode, PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        self.expect_literal_name(b"CIDInit")?;
-        self.expect_literal_name(b"ProcSet")?;
-        self.expect_executable_name(b"findresource")?;
-        self.expect_executable_name(b"begin")?;
-        self.expect_integer()?;
-        self.expect_executable_name(b"dict")?;
-        self.expect_executable_name(b"begin")?;
-        self.expect_executable_name(b"begincmap")?;
-        self.expect_literal_name(b"CIDSystemInfo")?;
-        let mut registry = None;
-        let mut ordering = None;
-        let mut supplement = None;
-        self.parse_dict(|name, value_pos, value| match &*name {
-            b"Registry" => {
-                let Token::String(v) = value else {
-                    return invalid_token_err(value_pos, Some(value));
-                };
-                registry = Some(v);
-                Ok(())
-            }
-            b"Ordering" => {
-                let Token::String(v) = value else {
-                    return invalid_token_err(value_pos, Some(value));
-                };
-                ordering = Some(v);
-                Ok(())
-            }
-            b"Supplement" => {
-                let Token::Integer(v) = value else {
-                    return invalid_token_err(value_pos, Some(value));
-                };
-                supplement = Some(v);
-                Ok(())
-            }
-            _ => todo!("{}: {value:?}", name.escape_ascii()),
-        })?;
-        self.expect_executable_name(b"def")?;
-        self.expect_literal_name(b"CMapName")?;
-        self.tokenizer.skip_comments_and_whitespace();
-        let char_map_name_pos = self.tokenizer.pos();
-        let char_map_name = self.expect_any_literal_name()?;
-        self.expect_executable_name(b"def")?;
-        self.expect_literal_name(b"CMapType")?;
-        self.expect(Token::Integer(2))?;
-        self.expect_executable_name(b"def")?;
-        self.expect(Token::Integer(1))?;
-        self.expect_executable_name(b"begincodespacerange")?;
-        self.tokenizer.skip_comments_and_whitespace();
-        let range_start_pos = self.tokenizer.pos();
-        let range_start = self.expect_any_string()?;
-        if range_start.is_empty() {
-            return invalid_token_err(range_start_pos, Some(Token::String(range_start)));
-        }
-        self.tokenizer.skip_comments_and_whitespace();
-        let range_end_pos = self.tokenizer.pos();
-        let range_end = self.expect_string_with_len(range_start.len())?;
-        self.expect_executable_name(b"endcodespacerange")?;
-        let mut to_unicode_map: BTreeMap<PdfString, Arc<str>> = BTreeMap::new();
-        let mut dest_str = String::new();
-        let mut insert_mapping = |src_pos: PdfInputPosition,
-                                  src: &[u8],
-                                  dest_pos: PdfInputPosition,
-                                  dest_utf16_be: &[u8]|
-         -> Result<(), PdfParseError> {
-            dest_str.clear();
-            for ch in char::decode_utf16(
-                dest_utf16_be
-                    .chunks(2)
-                    .map(|chunk| u16::from_be_bytes([chunk[0], chunk[1]])),
-            ) {
-                match ch {
-                    Ok(ch) => dest_str.push(ch),
-                    Err(_) => {
-                        return Err(PdfParseError::InvalidUtf16 { pos: dest_pos });
-                    }
-                }
-            }
-            to_unicode_map.insert(
-                PdfString::new(src_pos, ArcOrRef::Arc(src.into())),
-                dest_str.as_str().into(),
-            );
-            Ok(())
-        };
-        loop {
-            match self.tokenizer.next_token()? {
-                Some(Token::Integer(size)) => match self.tokenizer.next_token()? {
-                    Some(Token::ExecutableName(name)) if name == b"beginbfrange" => {
-                        for _ in 0..size {
-                            self.tokenizer.skip_comments_and_whitespace();
-                            let src_pos = self.tokenizer.pos();
-                            let src_low = self.expect_string_with_len(range_start.len())?;
-                            self.tokenizer.skip_comments_and_whitespace();
-                            let src_high_pos = self.tokenizer.pos();
-                            let src_high = self.expect_string_with_len(range_start.len())?;
-                            if src_low.split_last().map(|(_, prefix)| prefix)
-                                != src_high.split_last().map(|(_, prefix)| prefix)
-                            {
-                                return invalid_token_err(
-                                    src_high_pos,
-                                    Some(Token::String(src_high)),
-                                );
-                            }
-                            let src_last_range = *src_low.last().expect("known to be non-empty")
-                                ..=*src_high.last().expect("known to be non-empty");
-                            self.tokenizer.skip_comments_and_whitespace();
-                            let dest_pos = self.tokenizer.pos();
-                            match self.tokenizer.next_token()? {
-                                Some(Token::String(dest))
-                                    if dest.len() >= 2 && dest.len() % 2 == 0 =>
-                                {
-                                    let mut src = src_low;
-                                    for (index, src_last_byte) in src_last_range.enumerate() {
-                                        *src.last_mut().expect("known to be non-empty") =
-                                            src_last_byte;
-                                        let mut dest = dest.clone();
-                                        let [.., last] = &mut *dest else {
-                                            unreachable!();
-                                        };
-                                        *last += index as u8;
-                                        insert_mapping(src_pos, &src, dest_pos, &dest)?;
-                                    }
-                                }
-                                Some(token @ Token::String(_)) => {
-                                    todo!("odd number of dest bytes: {token:?}");
-                                }
-                                Some(Token::ArrayStart) => {
-                                    let mut src = src_low;
-                                    for src_last_byte in src_last_range {
-                                        *src.last_mut().expect("known to be non-empty") =
-                                            src_last_byte;
-                                        self.tokenizer.skip_comments_and_whitespace();
-                                        let dest_pos = self.tokenizer.pos();
-                                        match self.tokenizer.next_token()? {
-                                            Some(Token::String(dest))
-                                                if dest.len() >= 2 && dest.len() % 2 == 0 =>
-                                            {
-                                                insert_mapping(src_pos, &src, dest_pos, &dest)?;
-                                            }
-                                            Some(token @ Token::String(_)) => {
-                                                todo!("odd number of dest bytes: {token:?}");
-                                            }
-                                            token => return invalid_token_err(dest_pos, token),
-                                        }
-                                    }
-                                    self.expect(Token::ArrayEnd)?;
-                                }
-                                token => return invalid_token_err(dest_pos, token),
-                            }
-                        }
-                        self.expect_executable_name(b"endbfrange")?;
-                    }
-                    Some(Token::ExecutableName(name)) if name == b"beginbfchar" => {
-                        for _ in 0..size {
-                            self.tokenizer.skip_comments_and_whitespace();
-                            let src_pos = self.tokenizer.pos();
-                            let src = self.expect_string_with_len(range_start.len())?;
-                            self.tokenizer.skip_comments_and_whitespace();
-                            let dest_pos = self.tokenizer.pos();
-                            match self.tokenizer.next_token()? {
-                                Some(Token::String(dest)) if dest.len() % 2 == 0 => {
-                                    insert_mapping(src_pos, &src, dest_pos, &dest)?;
-                                }
-                                Some(token @ Token::String(_)) => {
-                                    todo!("odd number of dest bytes: {token:?}");
-                                }
-                                token => return invalid_token_err(dest_pos, token),
-                            }
-                        }
-                        self.expect_executable_name(b"endbfchar")?;
-                    }
-                    token => todo!("{token:?}"),
-                },
-                Some(Token::ExecutableName(name)) if name == b"endcmap" => {
-                    break;
-                }
-                token => todo!("{token:?}"),
-            }
-        }
-        self.expect_executable_name(b"CMapName")?;
-        self.expect_executable_name(b"currentdict")?;
-        self.expect_literal_name(b"CMap")?;
-        self.expect_executable_name(b"defineresource")?;
-        self.expect_executable_name(b"pop")?;
-        self.expect_executable_name(b"end")?;
-        self.expect_executable_name(b"end")?;
-        self.tokenizer.skip_comments_and_whitespace();
-        let eof_pos = self.tokenizer.pos();
-        if let token @ Some(_) = self.tokenizer.next_token()? {
-            return invalid_token_err(eof_pos, token);
-        }
-        Ok(PdfFontToUnicode {
-            base_map,
-            char_map_name: PdfName::new(char_map_name_pos, Arc::<[u8]>::from(char_map_name)),
-            src_ranges: Arc::new([
-                PdfString::new(range_start_pos, ArcOrRef::Arc(range_start.into()))
-                    ..=PdfString::new(range_end_pos, ArcOrRef::Arc(range_end.into())),
-            ]),
-            to_unicode_map: Arc::new(to_unicode_map),
-        })
-    }
-}
diff --git a/src/pdf/font/type_1_parse.rs b/src/pdf/font/type_1_parse.rs
deleted file mode 100644
index 1825e42..0000000
--- a/src/pdf/font/type_1_parse.rs
+++ /dev/null
@@ -1,1507 +0,0 @@
-use crate::{
-    pdf::{
-        PdfObjects,
-        font::{
-            PdfFontType1FontInfo, PdfFontType1Program, PdfSimpleFontEncodingTable,
-            PdfSimpleFontEncodingTableEntry,
-        },
-        object::{PdfMatrix, PdfName, PdfRectangle, PdfStreamContents, PdfString, PdfVec2D},
-        parse::{
-            PdfInputPosition, PdfInputPositionKnown, PdfInputPositionNoCompare, PdfParseError,
-        },
-    },
-    util::ArcOrRef,
-};
-use std::{
-    cell::{Cell, RefCell},
-    collections::BTreeMap,
-    fmt,
-    num::NonZero,
-    rc::Rc,
-    sync::Arc,
-};
-
-#[derive(Debug)]
-enum PsBreakReason {
-    FoundEExec,
-    Error(PdfParseError),
-}
-
-fn custom_err<T, E: From<PdfParseError>>(msg: impl ToString) -> Result<T, E> {
-    Err(PdfParseError::Custom(msg.to_string()).into())
-}
-
-impl From<PdfParseError> for PsBreakReason {
-    fn from(value: PdfParseError) -> Self {
-        Self::Error(value)
-    }
-}
-
-struct PsFileDecryptedSource {
-    source: Box<dyn Iterator<Item = u8>>,
-    decoded: Vec<u8>,
-}
-
-impl PsFileDecryptedSource {
-    fn get(&mut self, index: usize) -> Option<u8> {
-        loop {
-            if let Some(byte) = self.decoded.get(index) {
-                return Some(*byte);
-            }
-            self.decoded.push(self.source.next()?);
-        }
-    }
-}
-
-#[derive(Clone)]
-enum PsFileSource {
-    Bytes(Arc<[u8]>),
-    Decrypted(Rc<RefCell<PsFileDecryptedSource>>),
-}
-
-impl PsFileSource {
-    fn get(&self, index: usize) -> Option<u8> {
-        match self {
-            PsFileSource::Bytes(bytes) => bytes.get(index).copied(),
-            PsFileSource::Decrypted(src) => src.borrow_mut().get(index),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct PsFile {
-    id: u64,
-    source: PsFileSource,
-    pos: Rc<Cell<PdfInputPositionKnown>>,
-}
-
-impl PartialEq for PsFile {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
-impl Eq for PsFile {}
-
-impl PartialOrd for PsFile {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for PsFile {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.id.cmp(&other.id)
-    }
-}
-
-impl fmt::Debug for PsFile {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { id, source: _, pos } = self;
-        f.debug_struct("PsFile")
-            .field("id", id)
-            .field("pos", pos)
-            .finish_non_exhaustive()
-    }
-}
-
-fn is_whitespace_char(v: u8) -> bool {
-    matches!(v, b'\0' | b'\t' | b'\n' | b'\x0C' | b'\r' | b' ')
-}
-
-fn is_special_char(v: u8) -> bool {
-    matches!(
-        v,
-        b'(' | b')' | b'<' | b'>' | b'[' | b']' | b'{' | b'}' | b'/' | b'%'
-    )
-}
-
-fn is_regular_char(v: u8) -> bool {
-    !(is_whitespace_char(v) || is_special_char(v))
-}
-
-struct NotALineEnd;
-
-#[derive(Clone, PartialEq)]
-pub(crate) enum Token {
-    Integer(i128),
-    Real(f64),
-    ArrayStart,
-    ArrayEnd,
-    ProcedureStart,
-    ProcedureEnd,
-    ExecutableName(Vec<u8>),
-    LiteralName(Vec<u8>),
-    ImmediatelyEvaluatedName(Vec<u8>),
-    String(Vec<u8>),
-    DictStart,
-    DictEnd,
-}
-
-impl fmt::Debug for Token {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Integer(v) => f.debug_tuple("Integer").field(v).finish(),
-            Self::Real(v) => f.debug_tuple("Real").field(v).finish(),
-            Self::ArrayStart => write!(f, "ArrayStart"),
-            Self::ArrayEnd => write!(f, "ArrayEnd"),
-            Self::ProcedureStart => write!(f, "ProcedureStart"),
-            Self::ProcedureEnd => write!(f, "ProcedureEnd"),
-            Self::ExecutableName(name) => write!(f, "ExecutableName({})", name.escape_ascii()),
-            Self::LiteralName(name) => write!(f, "LiteralName({})", name.escape_ascii()),
-            Self::ImmediatelyEvaluatedName(name) => {
-                write!(f, "ImmediatelyEvaluatedName({})", name.escape_ascii())
-            }
-            Self::String(contents) => {
-                write!(f, "String({})", contents.escape_ascii())
-            }
-            Self::DictStart => write!(f, "DictStart"),
-            Self::DictEnd => write!(f, "DictEnd"),
-        }
-    }
-}
-
-impl PsFile {
-    fn new(id: u64, source: PsFileSource, pos: usize, stream_pos: PdfInputPosition) -> Self {
-        Self {
-            id,
-            source,
-            pos: Rc::new(Cell::new(PdfInputPositionKnown {
-                pos,
-                containing_streams_pos: stream_pos.get().map(|v| v.pos),
-            })),
-        }
-    }
-    pub(crate) fn from_arc_bytes(bytes: Arc<[u8]>, stream_pos: PdfInputPosition) -> Self {
-        Self::new(0, PsFileSource::Bytes(bytes), 0, stream_pos)
-    }
-    pub(crate) fn pos(&self) -> PdfInputPosition {
-        PdfInputPosition::new(Some(self.pos.get()))
-    }
-    fn peek_byte(&self) -> Option<u8> {
-        self.source.get(self.pos.get().pos)
-    }
-    fn next_byte(&mut self) -> Option<u8> {
-        if let Some(b) = self.source.get(self.pos.get().pos) {
-            self.pos.update(|mut pos| {
-                pos.pos += 1;
-                pos
-            });
-            Some(b)
-        } else {
-            None
-        }
-    }
-    fn try_parse_line_end(&mut self) -> Result<(), NotALineEnd> {
-        match self.peek_byte().ok_or(NotALineEnd)? {
-            b'\r' => {
-                self.next_byte();
-                if self.peek_byte() == Some(b'\n') {
-                    self.next_byte();
-                }
-                Ok(())
-            }
-            b'\x0C' | b'\n' => Ok(()),
-            _ => Err(NotALineEnd),
-        }
-    }
-    fn skip_whitespace(&mut self) {
-        while let Some(b'\0' | b'\t' | b'\n' | b'\x0C' | b'\r' | b' ') = self.peek_byte() {
-            self.next_byte();
-        }
-    }
-    pub(crate) fn skip_comments_and_whitespace(&mut self) {
-        loop {
-            self.skip_whitespace();
-            let Some(b'%') = self.peek_byte() else {
-                break;
-            };
-            while self.peek_byte().is_some() {
-                if let Ok(()) = self.try_parse_line_end() {
-                    break;
-                }
-                self.next_byte();
-            }
-        }
-    }
-    fn parse_number(mut text: &[u8]) -> Option<Token> {
-        let full_text = text;
-        let sign = match text {
-            [sign @ (b'-' | b'+'), rest @ ..] => {
-                text = rest;
-                Some(*sign)
-            }
-            _ => None,
-        };
-        let mut radix = Some(0u32);
-        let mut any_digits = false;
-        while let [digit @ b'0'..=b'9', rest @ ..] = text {
-            text = rest;
-            any_digits = true;
-            radix = radix
-                .and_then(|v| v.checked_mul(10))
-                .and_then(|v| v.checked_add((digit - b'0').into()));
-        }
-        if let (Some(radix @ (2..=36)), [b'#', rest @ ..]) = (radix, text) {
-            text = rest;
-            if sign.is_some() || text.is_empty() {
-                return None;
-            }
-            let mut value = 0i128;
-            for &digit in text {
-                let digit = (digit as char).to_digit(radix)?;
-                value = value.checked_mul(radix.into())?;
-                value = value.checked_add(digit.into())?;
-            }
-            return Some(Token::Integer(value));
-        }
-        let mut is_real = false;
-        if let [b'.', rest @ ..] = text {
-            text = rest;
-            is_real = true;
-            while let [b'0'..=b'9', rest @ ..] = text {
-                text = rest;
-                any_digits = true;
-            }
-        }
-        if !any_digits {
-            return None;
-        }
-        if let [b'e' | b'E', rest @ ..] = text {
-            text = rest;
-            is_real = true;
-            if let [b'+' | b'-', rest @ ..] = text {
-                text = rest;
-            }
-            let [b'0'..=b'9', ..] = text else {
-                return None;
-            };
-            while let [b'0'..=b'9', rest @ ..] = text {
-                text = rest;
-            }
-        }
-        let full_text = str::from_utf8(full_text).ok()?;
-        if is_real {
-            Some(Token::Real(full_text.parse().ok()?))
-        } else {
-            Some(Token::Integer(full_text.parse().ok()?))
-        }
-    }
-    fn parse_string_after_l_paren(&mut self) -> Result<Token, PdfParseError> {
-        let mut contents = Vec::new();
-        let mut paren_level = NonZero::new(1usize).expect("non-zero");
-        while let Some(b) = self.next_byte() {
-            contents.push(match b {
-                b'(' => {
-                    paren_level = paren_level.checked_add(1).expect("overflow");
-                    b
-                }
-                b')' => {
-                    let Some(new_paren_level) = NonZero::new(paren_level.get() - 1) else {
-                        return Ok(Token::String(contents));
-                    };
-                    paren_level = new_paren_level;
-                    b
-                }
-                b'\r' if self.peek_byte() == Some(b'\n') => {
-                    self.next_byte();
-                    b'\n'
-                }
-                b'\r' | b'\n' => b'\n',
-                b'\\' => {
-                    let pos = self.pos();
-                    let Some(b) = self.next_byte() else {
-                        return Err(PdfParseError::InvalidStringEscape { pos });
-                    };
-                    match b {
-                        b'\r' if self.peek_byte() == Some(b'\n') => {
-                            self.next_byte();
-                            continue;
-                        }
-                        b'\r' | b'\n' => continue,
-                        b'n' => b'\n',
-                        b'r' => b'\r',
-                        b't' => b'\t',
-                        b'b' => b'\x08',
-                        b'f' => b'\x0C',
-                        b'(' | b')' | b'\\' => b,
-                        b'0'..=b'7' => {
-                            const MAX_OCTAL_DIGITS: usize = 3;
-                            let mut value = b - b'0';
-                            let mut len = 1;
-                            while len < MAX_OCTAL_DIGITS {
-                                let Some(b @ b'0'..=b'7') = self.peek_byte() else {
-                                    break;
-                                };
-                                value <<= 3;
-                                value |= b - b'0';
-                                len += 1;
-                                self.next_byte();
-                            }
-                            value
-                        }
-                        _ => {
-                            return Err(PdfParseError::InvalidStringEscape { pos });
-                        }
-                    }
-                }
-                _ => b,
-            });
-        }
-        Err(PdfParseError::TruncatedFile { pos: self.pos() })
-    }
-    fn parse_string_after_l_angle(&mut self) -> Result<Vec<u8>, PdfParseError> {
-        let mut contents = Vec::new();
-        let mut high_digit_value = None;
-        let mut push_digit_value = |value: u8| {
-            high_digit_value = match high_digit_value {
-                Some(high_digit_value) => {
-                    contents.push((high_digit_value << 4) | value);
-                    None
-                }
-                None => Some(value),
-            };
-        };
-        let string_pos = self.pos();
-        loop {
-            let pos = self.pos();
-            match self.next_byte() {
-                None => {
-                    return Err(PdfParseError::TruncatedFile { pos });
-                }
-                Some(b'\0' | b'\t' | b'\n' | b'\x0C' | b'\r' | b' ') => {}
-                Some(b'>') => {
-                    // if we have an odd trailing digit, add the final digit, otherwise doesn't modify contents
-                    push_digit_value(0);
-                    return Ok(contents);
-                }
-                Some(b) => {
-                    let Some(value) = (b as char).to_digit(0x10) else {
-                        return Err(PdfParseError::InvalidHexStringDigit { pos });
-                    };
-                    push_digit_value(value as u8);
-                }
-            }
-        }
-    }
-    pub(crate) fn next_token(&mut self) -> Result<Option<Token>, PdfParseError> {
-        self.skip_comments_and_whitespace();
-        let Some(first_byte) = self.peek_byte() else {
-            return Ok(None);
-        };
-        match first_byte {
-            b'(' => {
-                self.next_byte();
-                self.parse_string_after_l_paren().map(Some)
-            }
-            b')' => todo!(),
-            b'<' => {
-                self.next_byte();
-                match self.peek_byte() {
-                    Some(b'<') => {
-                        self.next_byte();
-                        Ok(Some(Token::DictStart))
-                    }
-                    Some(b'~') => todo!("base 85 encoded string"),
-                    _ => Ok(Some(Token::String(self.parse_string_after_l_angle()?))),
-                }
-            }
-            b'>' => {
-                self.next_byte();
-                match self.peek_byte() {
-                    Some(b'>') => {
-                        self.next_byte();
-                        Ok(Some(Token::DictEnd))
-                    }
-                    _ => todo!("stray >"),
-                }
-            }
-            b'[' => {
-                self.next_byte();
-                Ok(Some(Token::ArrayStart))
-            }
-            b']' => {
-                self.next_byte();
-                Ok(Some(Token::ArrayEnd))
-            }
-            b'{' => {
-                self.next_byte();
-                Ok(Some(Token::ProcedureStart))
-            }
-            b'}' => {
-                self.next_byte();
-                Ok(Some(Token::ProcedureEnd))
-            }
-            b'/' => {
-                self.next_byte();
-                let is_immediately_evaluated_name = self.peek_byte() == Some(b'/');
-                if is_immediately_evaluated_name {
-                    self.next_byte();
-                }
-                let mut name = Vec::new();
-                while self.peek_byte().is_some_and(is_regular_char) {
-                    name.extend(self.next_byte());
-                }
-                Ok(Some(if is_immediately_evaluated_name {
-                    Token::ImmediatelyEvaluatedName(name)
-                } else {
-                    Token::LiteralName(name)
-                }))
-            }
-            _ => {
-                let mut name = Vec::new();
-                name.extend(self.next_byte());
-                while self.peek_byte().is_some_and(is_regular_char) {
-                    name.extend(self.next_byte());
-                }
-                if let Some(token) = Self::parse_number(&name) {
-                    Ok(Some(token))
-                } else {
-                    Ok(Some(Token::ExecutableName(name)))
-                }
-            }
-        }
-    }
-    fn decrypt_for_eexec_helper(
-        mut self,
-        new_id: u64,
-        random_bytes: Option<[u8; 4]>,
-        next_byte: impl Fn(&mut Self) -> Option<u8> + 'static,
-    ) -> Result<Self, PdfParseError> {
-        let read_first_4 = || -> Option<[u8; 4]> {
-            let b0 = next_byte(&mut self)?;
-            let b1 = next_byte(&mut self)?;
-            let b2 = next_byte(&mut self)?;
-            let b3 = next_byte(&mut self)?;
-            Some([b0, b1, b2, b3])
-        };
-        let random_bytes = random_bytes.or_else(read_first_4).ok_or_else(|| {
-            PdfParseError::Custom("postscript eexec operator: can't read the 4 random bytes".into())
-        })?;
-        let mut r = 55665u16;
-        let c1 = 52845u16;
-        let c2 = 22719u16;
-        let mut decrypt_one = move |cipher: u8| -> u8 {
-            dbg!(cipher);
-            let plain = cipher ^ (r >> 8) as u8;
-            dbg!(plain);
-            r = (cipher as u16)
-                .wrapping_add(r)
-                .wrapping_mul(c1)
-                .wrapping_add(c2);
-            dbg!(r);
-            plain
-        };
-        for b in random_bytes {
-            decrypt_one(b);
-        }
-        let stream_pos = self.pos();
-        Ok(Self::new(
-            new_id,
-            PsFileSource::Decrypted(Rc::new(RefCell::new(PsFileDecryptedSource {
-                source: Box::new(std::iter::from_fn(move || {
-                    dbg!(next_byte(&mut self)).map(decrypt_one)
-                })),
-                decoded: Vec::new(),
-            }))),
-            0,
-            stream_pos,
-        ))
-    }
-    fn decrypt_for_eexec(mut self, new_id: u64) -> Result<Self, PdfParseError> {
-        while let Some(b' ' | b'\t' | b'\r' | b'\n') = self.peek_byte() {
-            dbg!(self.next_byte());
-        }
-        let start_pos = self.pos.get();
-        let mut read_first_4_binary = || -> Option<[u8; 4]> {
-            let b0 = self.next_byte()?;
-            let b1 = self.next_byte()?;
-            let b2 = self.next_byte()?;
-            let b3 = self.next_byte()?;
-            let retval = [b0, b1, b2, b3];
-            if retval.iter().all(u8::is_ascii_hexdigit) {
-                None
-            } else {
-                Some(retval)
-            }
-        };
-        if let Some(random_bytes) = dbg!(read_first_4_binary()) {
-            self.decrypt_for_eexec_helper(new_id, Some(random_bytes), PsFile::next_byte)
-        } else {
-            self.pos.set(start_pos);
-            let next_byte = |this: &mut Self| {
-                let mut first_digit = None;
-                loop {
-                    let byte = this.peek_byte()?;
-                    if matches!(byte, b' ' | b'\t' | b'\r' | b'\n') {
-                        this.next_byte();
-                        continue;
-                    }
-                    let digit = (byte as char).to_digit(0x10)?;
-                    this.next_byte();
-                    if let Some(first_digit) = first_digit {
-                        return Some(((first_digit << 4) | digit) as u8);
-                    } else {
-                        first_digit = Some(digit);
-                    }
-                }
-            };
-            self.decrypt_for_eexec_helper(new_id, None, next_byte)
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-struct PsReal(f64);
-
-impl PartialOrd for PsReal {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Eq for PsReal {}
-
-impl PartialEq for PsReal {
-    fn eq(&self, other: &Self) -> bool {
-        self.cmp(other).is_eq()
-    }
-}
-
-impl Ord for PsReal {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        let l = (!self.0.is_nan()).then_some(self.0);
-        let r = (!other.0.is_nan()).then_some(other.0);
-        l.partial_cmp(&r).expect("already checked for NaN")
-    }
-}
-
-macro_rules! make_operator_enum {
-    (
-        enum $enum_name:ident {
-            $($Variant:ident = $name:literal,)*
-        }
-    ) => {
-        #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
-        enum $enum_name {
-            $($Variant,)*
-        }
-
-        impl $enum_name {
-            const VARIANTS: &[Self] = &[$(Self::$Variant,)*];
-            fn name(self) -> &'static str {
-                match self {
-                    $(Self::$Variant => $name,)*
-                }
-            }
-        }
-    };
-}
-
-make_operator_enum! {
-    enum PsOperator {
-        Array = "array",
-        ArrayStart = "[",
-        ArrayEnd = "]",
-        Begin = "begin",
-        CurrentDict = "currentdict",
-        CurrentFile = "currentfile",
-        Def = "def",
-        Dict = "dict",
-        Dup = "dup",
-        FontDirectory = "FontDirectory",
-        For = "for",
-        EExec = "eexec",
-        End = "end",
-        Exch = "exch",
-        IfElse = "ifelse",
-        Index = "index",
-        Known = "known",
-        Put = "put",
-        ReadOnly = "readonly",
-    }
-}
-
-impl PsOperator {
-    fn run(self, parser: &mut PsParser) -> Result<(), PsBreakReason> {
-        match self {
-            PsOperator::Array => {
-                let Some(len) = parser.operand_stack.pop().and_then(|v| v.to_int()) else {
-                    return custom_err(
-                        "postscript array operator is missing required integer operand",
-                    );
-                };
-                let Ok(len) = len.try_into() else {
-                    return custom_err("postscript array operator passed invalid length");
-                };
-                let array = PsArray::from_elements(parser, vec![PsObject::Null; len]);
-                parser.operand_stack.push(PsObject::Array(array));
-                Ok(())
-            }
-            PsOperator::ArrayStart => {
-                parser.operand_stack.push(PsObject::Mark);
-                Ok(())
-            }
-            PsOperator::ArrayEnd => {
-                let mut elements = Vec::new();
-                while let Some(object) = parser.operand_stack.pop() {
-                    match object {
-                        PsObject::Mark => {
-                            elements.reverse();
-                            let array = PsArray::from_elements(parser, elements);
-                            parser.operand_stack.push(PsObject::Array(array));
-                            return Ok(());
-                        }
-                        _ => elements.push(object),
-                    }
-                }
-                custom_err("postscript ] operator is missing required mark operand")
-            }
-            PsOperator::Begin => {
-                let Some(PsObject::Dictionary(dict)) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript begin operator is missing required dictionary operand",
-                    );
-                };
-                parser.dictionary_stack.push(dict);
-                Ok(())
-            }
-            PsOperator::CurrentDict => {
-                let Some(dict) = parser.dictionary_stack.last().cloned() else {
-                    unreachable!();
-                };
-                parser.operand_stack.push(PsObject::Dictionary(dict));
-                Ok(())
-            }
-            PsOperator::CurrentFile => {
-                parser
-                    .operand_stack
-                    .push(PsObject::File(parser.tokenizer.clone()));
-                Ok(())
-            }
-            PsOperator::Def => {
-                let Some(value) = parser.operand_stack.pop() else {
-                    return custom_err("postscript def operator is missing required operand");
-                };
-                let Some(key) = parser.operand_stack.pop() else {
-                    return custom_err("postscript def operator is missing required operand");
-                };
-                let Some(dict) = parser.dictionary_stack.last_mut() else {
-                    unreachable!();
-                };
-                dict.insert(key, value);
-                Ok(())
-            }
-            PsOperator::Dict => {
-                let Some(_capacity) = parser.operand_stack.pop().and_then(|v| v.to_int()) else {
-                    return custom_err(
-                        "postscript dict operator is missing required integer operand",
-                    );
-                };
-                let dict = PsDictionary::new(parser);
-                parser.operand_stack.push(PsObject::Dictionary(dict));
-                Ok(())
-            }
-            PsOperator::Dup => {
-                let Some(value) = parser.operand_stack.pop() else {
-                    return custom_err("postscript dup operator is missing required operand");
-                };
-                parser.operand_stack.push(value.clone());
-                parser.operand_stack.push(value);
-                Ok(())
-            }
-            PsOperator::EExec => {
-                if parser.break_at_eexec {
-                    return Err(PsBreakReason::FoundEExec);
-                }
-                let Some(source) = parser.operand_stack.pop() else {
-                    return custom_err("postscript eexec operator is missing required operand");
-                };
-                let file = match source {
-                    PsObject::String(string) => todo!(),
-                    PsObject::File(file) => file,
-                    _ => {
-                        return custom_err("postscript eexec operator has invalid operand");
-                    }
-                };
-                dbg!(&parser.dictionary_stack);
-                dbg!(&parser.operand_stack);
-                let file = file.decrypt_for_eexec(parser.next_file_id)?;
-                parser.next_file_id += 1;
-                struct PutBackTokenizerOnDrop<'a> {
-                    parser: &'a mut PsParser,
-                    old_tokenizer: PsFile,
-                }
-                impl Drop for PutBackTokenizerOnDrop<'_> {
-                    fn drop(&mut self) {
-                        self.parser.tokenizer = self.old_tokenizer.clone();
-                    }
-                }
-                let put_back_tokenizer_on_drop = PutBackTokenizerOnDrop {
-                    old_tokenizer: std::mem::replace(&mut parser.tokenizer, file),
-                    parser,
-                };
-                put_back_tokenizer_on_drop.parser.parse_file()
-            }
-            PsOperator::End => {
-                if parser.dictionary_stack.len() <= PsParser::MIN_DICTIONARY_STACK_SIZE {
-                    return custom_err("postscript end operator without corresponding begin");
-                }
-                parser.dictionary_stack.pop();
-                Ok(())
-            }
-            PsOperator::Exch => {
-                let Some([a, b]) = parser.operand_stack.last_chunk_mut() else {
-                    return custom_err("postscript exch operator is missing required operands");
-                };
-                std::mem::swap(a, b);
-                Ok(())
-            }
-            PsOperator::FontDirectory => {
-                parser.operand_stack.push(PsObject::Dictionary(
-                    parser.font_directory.clone().expect("set in PsParser::new"),
-                ));
-                Ok(())
-            }
-            PsOperator::For => {
-                let Some(PsObject::Procedure(proc)) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript for operator is missing required procedure operand",
-                    );
-                };
-                let Some(limit) = parser.operand_stack.pop() else {
-                    return custom_err("postscript for operator is missing required limit operand");
-                };
-                let Some(increment) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript for operator is missing required increment operand",
-                    );
-                };
-                let Some(initial) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript for operator is missing required initial operand",
-                    );
-                };
-                let PsObject::Integer(initial) = initial else {
-                    todo!("{initial:?}");
-                };
-                let PsObject::Integer(increment) = increment else {
-                    todo!("{increment:?}");
-                };
-                let PsObject::Integer(limit) = limit else {
-                    todo!("{limit:?} {:?}", parser.operand_stack);
-                };
-                if increment == 0 {
-                    return custom_err("postscript for operator: increment can't be zero");
-                };
-                let mut counter = initial;
-                let proc = proc.into_vec();
-                loop {
-                    if increment < 0 {
-                        if counter < limit {
-                            break;
-                        }
-                    } else if counter > limit {
-                        break;
-                    }
-                    parser.operand_stack.push(PsObject::Integer(counter));
-                    parser.run_procedure(&proc)?;
-                    counter = counter.checked_add(increment).ok_or_else(|| {
-                        PdfParseError::Custom("postscript arithmetic overflow".into())
-                    })?;
-                }
-                Ok(())
-            }
-            PsOperator::IfElse => {
-                let Some(PsObject::Procedure(else_proc)) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript ifelse operator is missing required procedure operand",
-                    );
-                };
-                let Some(PsObject::Procedure(then_proc)) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript ifelse operator is missing required procedure operand",
-                    );
-                };
-                let Some(PsObject::Boolean(cond)) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript ifelse operator is missing required bool operand",
-                    );
-                };
-                if cond {
-                    parser.run_procedure(&then_proc.into_vec())?;
-                } else {
-                    parser.run_procedure(&else_proc.into_vec())?;
-                }
-                Ok(())
-            }
-            PsOperator::Index => {
-                let Some(index) = parser.operand_stack.pop().and_then(|v| v.to_int()) else {
-                    return custom_err(
-                        "postscript index operator is missing required integer operand",
-                    );
-                };
-                let Some(object) = index
-                    .try_into()
-                    .ok()
-                    .and_then(|index| parser.operand_stack.iter().nth_back(index).cloned())
-                else {
-                    return custom_err("postscript index operator passed invalid integer");
-                };
-                parser.operand_stack.push(object);
-                Ok(())
-            }
-            PsOperator::Known => {
-                let Some(key) = parser.operand_stack.pop() else {
-                    return custom_err("postscript known operator is missing required key operand");
-                };
-                let Some(PsObject::Dictionary(dictionary)) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript known operator is missing required dictionary operand",
-                    );
-                };
-                parser
-                    .operand_stack
-                    .push(PsObject::Boolean(dictionary.get(key).is_some()));
-                Ok(())
-            }
-            PsOperator::Put => {
-                let Some(value) = parser.operand_stack.pop() else {
-                    return custom_err("postscript put operator is missing required value operand");
-                };
-                let Some(key_or_index) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript put operator is missing required key/index operand",
-                    );
-                };
-                let Some(container) = parser.operand_stack.pop() else {
-                    return custom_err(
-                        "postscript put operator is missing required container operand",
-                    );
-                };
-                match container {
-                    PsObject::Array(array) => {
-                        let array = array.rc();
-                        let mut array = array.borrow_mut();
-                        let Some(target) = key_or_index
-                            .to_int()
-                            .and_then(|index| array.get_mut(usize::try_from(index).ok()?))
-                        else {
-                            return custom_err("postscript put operator has invalid index operand");
-                        };
-                        *target = value;
-                        Ok(())
-                    }
-                    PsObject::Dictionary(mut dict) => {
-                        dict.insert(key_or_index, value);
-                        Ok(())
-                    }
-                    PsObject::String(s) => todo!(),
-                    _ => custom_err("postscript put operator was passed invalid container operand"),
-                }
-            }
-            PsOperator::ReadOnly => {
-                // TODO: implement permissions
-                Ok(())
-            }
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Default)]
-struct PsDictionaryImpl {
-    named: BTreeMap<PsName, PsObject>,
-    other: BTreeMap<PsObject, PsObject>,
-}
-
-#[derive(Clone)]
-struct PsDictionary {
-    id: usize,
-    weak: std::rc::Weak<RefCell<PsDictionaryImpl>>,
-}
-
-impl fmt::Debug for PsDictionary {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { id, weak } = self;
-        if let Some(weak) = weak.upgrade() {
-            if let Ok(weak) = weak.try_borrow() {
-                write!(f, "#{id} ")?;
-                let PsDictionaryImpl { named, other } = &*weak;
-                return f.debug_map().entries(named).entries(other).finish();
-            }
-        }
-        f.debug_struct("PsDictionary")
-            .field("id", id)
-            .field("weak", &weak)
-            .finish()
-    }
-}
-
-impl Ord for PsDictionary {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.id.cmp(&other.id)
-    }
-}
-
-impl PartialOrd for PsDictionary {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Eq for PsDictionary {}
-
-impl PartialEq for PsDictionary {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
-impl PsDictionary {
-    fn new(parser: &mut PsParser) -> Self {
-        Self::from_impl(parser, PsDictionaryImpl::default())
-    }
-    fn rc(&self) -> Rc<RefCell<PsDictionaryImpl>> {
-        self.weak.upgrade().expect("still in parser scope")
-    }
-    fn from_impl(parser: &mut PsParser, impl_: PsDictionaryImpl) -> Self {
-        let dict = Rc::new(RefCell::new(impl_));
-        let weak = Rc::downgrade(&dict);
-        let id = parser.dictionaries.len();
-        parser.dictionaries.push(dict);
-        Self { id, weak }
-    }
-    fn from_name_value_pairs<'a>(
-        parser: &mut PsParser,
-        iter: impl IntoIterator<Item = (&'a str, PsObject)>,
-    ) -> Self {
-        Self::from_impl(
-            parser,
-            PsDictionaryImpl {
-                named: BTreeMap::from_iter(
-                    iter.into_iter()
-                        .map(|(k, v)| (PsName(k.as_bytes().into()), v)),
-                ),
-                other: BTreeMap::new(),
-            },
-        )
-    }
-    fn get_named(&self, key: &PsName) -> Option<PsObject> {
-        self.rc().borrow().named.get(key).cloned()
-    }
-    fn insert(&mut self, key: PsObject, value: PsObject) -> Option<PsObject> {
-        let this = self.rc();
-        let mut this = this.borrow_mut();
-        let PsDictionaryImpl { named, other } = &mut *this;
-        match key {
-            PsObject::String(s) => named.insert(PsName(s.0.borrow().clone()), value),
-            PsObject::Name(name) => named.insert(name, value),
-            _ => other.insert(key, value),
-        }
-    }
-    fn insert_named(&mut self, name: PsName, value: PsObject) -> Option<PsObject> {
-        self.rc().borrow_mut().named.insert(name, value)
-    }
-    fn into_impl(self) -> PsDictionaryImpl {
-        self.rc().borrow().clone()
-    }
-    fn get(&self, key: PsObject) -> Option<PsObject> {
-        let this = self.rc();
-        let this = this.borrow();
-        let PsDictionaryImpl { named, other } = &*this;
-        match key {
-            PsObject::String(s) => named.get(&PsName(s.0.borrow().clone())).cloned(),
-            PsObject::Name(name) => named.get(&name).cloned(),
-            _ => other.get(&key).cloned(),
-        }
-    }
-}
-
-#[derive(Clone)]
-struct PsArray {
-    id: usize,
-    weak: std::rc::Weak<RefCell<Vec<PsObject>>>,
-}
-
-impl fmt::Debug for PsArray {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { id, weak } = self;
-        if let Some(weak) = weak.upgrade() {
-            if let Ok(weak) = weak.try_borrow() {
-                write!(f, "#{id} ")?;
-                return Vec::fmt(&weak, f);
-            }
-        }
-        f.debug_struct("PsArray")
-            .field("id", id)
-            .field("weak", &weak)
-            .finish()
-    }
-}
-
-impl Ord for PsArray {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.id.cmp(&other.id)
-    }
-}
-
-impl PartialOrd for PsArray {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Eq for PsArray {}
-
-impl PartialEq for PsArray {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
-impl PsArray {
-    fn new(parser: &mut PsParser) -> Self {
-        Self::from_elements(parser, Vec::new())
-    }
-    fn rc(&self) -> Rc<RefCell<Vec<PsObject>>> {
-        self.weak.upgrade().expect("still in parser scope")
-    }
-    fn from_elements(parser: &mut PsParser, elements: Vec<PsObject>) -> Self {
-        let array = Rc::new(RefCell::new(elements));
-        let weak = Rc::downgrade(&array);
-        let id = parser.arrays.len();
-        parser.arrays.push(array);
-        Self { id, weak }
-    }
-    fn into_vec(self) -> Vec<PsObject> {
-        self.rc().borrow().clone()
-    }
-}
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Clone)]
-struct PsName(Vec<u8>);
-
-impl fmt::Debug for PsName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "PsName({})", self.0.escape_ascii())
-    }
-}
-
-impl From<PsName> for PdfName {
-    fn from(value: PsName) -> Self {
-        PdfName::new(PdfInputPosition::empty(), ArcOrRef::Arc(value.0.into()))
-    }
-}
-
-#[derive(PartialEq, Eq, PartialOrd, Ord, Clone)]
-struct PsString(Rc<RefCell<Vec<u8>>>);
-
-impl fmt::Debug for PsString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "PsString({})", self.0.borrow().escape_ascii())
-    }
-}
-
-impl From<PsString> for PdfString {
-    fn from(value: PsString) -> Self {
-        PdfString::new(
-            PdfInputPosition::empty(),
-            ArcOrRef::Arc(value.0.borrow().as_slice().into()),
-        )
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-enum PsObject {
-    Array(PsArray),
-    Procedure(PsArray),
-    Dictionary(PsDictionary),
-    Integer(i128),
-    Mark,
-    Name(PsName),
-    Operator(PsOperator),
-    Real(PsReal),
-    String(PsString),
-    Boolean(bool),
-    Null,
-    ExecutableName(PsName),
-    File(PsFile),
-}
-
-impl PsObject {
-    fn to_int(&self) -> Option<i128> {
-        match self {
-            PsObject::Integer(v) => Some(*v),
-            PsObject::Real(PsReal(v)) => Some(*v as i128),
-            _ => None,
-        }
-    }
-    fn to_f32(&self) -> Option<f32> {
-        match self {
-            PsObject::Integer(v) => Some(*v as f32),
-            PsObject::Real(PsReal(v)) => Some(*v as f32),
-            _ => None,
-        }
-    }
-}
-
-struct PsParser {
-    tokenizer: PsFile,
-    operand_stack: Vec<PsObject>,
-    dictionary_stack: Vec<PsDictionary>,
-    dictionaries: Vec<Rc<RefCell<PsDictionaryImpl>>>,
-    arrays: Vec<Rc<RefCell<Vec<PsObject>>>>,
-    next_file_id: u64,
-    break_at_eexec: bool,
-    font_directory: Option<PsDictionary>,
-}
-
-impl PsParser {
-    const MIN_DICTIONARY_STACK_SIZE: usize = 3;
-    fn new(tokenizer: PsFile) -> Self {
-        let mut retval = Self {
-            next_file_id: tokenizer.id + 1,
-            tokenizer,
-            operand_stack: Vec::with_capacity(16),
-            dictionary_stack: Vec::with_capacity(8),
-            dictionaries: Vec::with_capacity(16),
-            arrays: Vec::with_capacity(16),
-            break_at_eexec: false,
-            font_directory: None,
-        };
-        let mut system_dict = PsDictionary::from_name_value_pairs(
-            &mut retval,
-            PsOperator::VARIANTS
-                .iter()
-                .map(|&op| (op.name(), PsObject::Operator(op))),
-        );
-        system_dict.insert_named(PsName(b"false".into()), PsObject::Boolean(false));
-        system_dict.insert_named(PsName(b"true".into()), PsObject::Boolean(true));
-        retval.dictionary_stack.push(system_dict);
-        let dict = PsDictionary::new(&mut retval);
-        retval.dictionary_stack.push(dict);
-        let dict = PsDictionary::new(&mut retval);
-        retval.dictionary_stack.push(dict);
-        retval.font_directory = Some(PsDictionary::new(&mut retval));
-        retval
-    }
-
-    fn run_name(&mut self, name: &PsName) -> Result<(), PsBreakReason> {
-        let Some(value) = self
-            .dictionary_stack
-            .iter()
-            .rev()
-            .find_map(|dict| dict.get_named(name))
-        else {
-            todo!("unimplemented PS operator {name:?}");
-        };
-        match value {
-            PsObject::Integer(_) | PsObject::Real(_) | PsObject::Boolean(_) => {
-                self.operand_stack.push(value);
-                Ok(())
-            }
-            PsObject::Name(v) => todo!(),
-            PsObject::ExecutableName(v) => todo!(),
-            PsObject::Null => todo!(),
-            PsObject::String(v) => todo!(),
-            PsObject::Array(v) => todo!(),
-            PsObject::Dictionary(v) => todo!(),
-            PsObject::Operator(value) => value.run(self),
-            PsObject::Mark => todo!(),
-            PsObject::Procedure(v) => todo!(),
-            PsObject::File(v) => todo!(),
-        }
-    }
-
-    fn parse_procedure(&mut self) -> Result<PsArray, PdfParseError> {
-        self.tokenizer.skip_comments_and_whitespace();
-        let mut objects = Vec::new();
-        while let Some(token) = self.tokenizer.next_token()? {
-            objects.push(match token {
-                Token::Integer(v) => PsObject::Integer(v),
-                Token::Real(v) => PsObject::Real(PsReal(v)),
-                Token::ArrayStart => PsObject::ExecutableName(PsName(b"[".into())),
-                Token::ArrayEnd => PsObject::ExecutableName(PsName(b"]".into())),
-                Token::DictStart => PsObject::ExecutableName(PsName(b"<<".into())),
-                Token::DictEnd => PsObject::ExecutableName(PsName(b">>".into())),
-                Token::ProcedureStart => PsObject::Procedure(self.parse_procedure()?),
-                Token::ProcedureEnd => return Ok(PsArray::from_elements(self, objects)),
-                Token::ExecutableName(name) => PsObject::ExecutableName(PsName(name.into())),
-                Token::LiteralName(name) => PsObject::Name(PsName(name.into())),
-                Token::ImmediatelyEvaluatedName(_) => todo!("{token:?}"),
-                Token::String(v) => PsObject::String(PsString(Rc::new(RefCell::new(v)))),
-            });
-        }
-        custom_err("postscript missing closing }")
-    }
-    fn parse_file(&mut self) -> Result<(), PsBreakReason> {
-        self.tokenizer.skip_comments_and_whitespace();
-        while let Some(token) = self.tokenizer.next_token()? {
-            match token {
-                Token::Integer(v) => self.operand_stack.push(PsObject::Integer(v)),
-                Token::Real(v) => self.operand_stack.push(PsObject::Real(PsReal(v))),
-                Token::ArrayStart => self.run_name(&PsName(b"[".into()))?,
-                Token::ArrayEnd => self.run_name(&PsName(b"]".into()))?,
-                Token::DictStart => self.run_name(&PsName(b"<<".into()))?,
-                Token::DictEnd => self.run_name(&PsName(b">>".into()))?,
-                Token::ProcedureStart => {
-                    let procedure = self.parse_procedure()?;
-                    self.operand_stack.push(PsObject::Procedure(procedure))
-                }
-                Token::ProcedureEnd => todo!(),
-                Token::ExecutableName(name) => {
-                    let name = PsName(name.into());
-                    self.run_name(&name)?
-                }
-                Token::LiteralName(name) => {
-                    self.operand_stack.push(PsObject::Name(PsName(name.into())))
-                }
-                Token::ImmediatelyEvaluatedName(_) => todo!("{token:?}"),
-                Token::String(v) => self
-                    .operand_stack
-                    .push(PsObject::String(PsString(Rc::new(RefCell::new(v))))),
-            }
-        }
-        Ok(())
-    }
-    fn parse_font_encoding(
-        &mut self,
-        value: PsArray,
-    ) -> Result<PdfSimpleFontEncodingTable, PdfParseError> {
-        let value = value.rc();
-        let value = value.borrow();
-        let mut retval = PdfSimpleFontEncodingTable::empty();
-        let mut table_iter = ArcOrRef::make_mut(&mut retval.table).iter_mut();
-        for entry in value.iter() {
-            match entry {
-                PsObject::Name(name) => {
-                    let name = if name.0 == b".notdef" {
-                        None
-                    } else {
-                        Some(PdfName::new(self.tokenizer.pos(), Arc::from(&*name.0)))
-                    };
-                    if let Some(entry) = table_iter.next() {
-                        *entry = PdfSimpleFontEncodingTableEntry {
-                            name,
-                            presumed_unicode: None,
-                        };
-                    }
-                }
-                _ => todo!("{entry:?}"),
-            }
-        }
-        Ok(retval)
-    }
-    fn parse_font_bbox(&mut self, value: PsArray) -> Result<PdfRectangle, PdfParseError> {
-        let value = value.rc();
-        let value = value.borrow();
-        let mut vec = Vec::new();
-        for entry in value.iter() {
-            let Some(v) = entry.to_f32() else {
-                return custom_err("postscript invalid FontBBox entry");
-            };
-            vec.push(v);
-        }
-        match <[f32; 4]>::try_from(vec) {
-            Ok([x1, y1, x2, y2]) => Ok(PdfRectangle::new(
-                PdfVec2D {
-                    pos: PdfInputPositionNoCompare::empty(),
-                    x: x1,
-                    y: y1,
-                },
-                PdfVec2D {
-                    pos: PdfInputPositionNoCompare::empty(),
-                    x: x2,
-                    y: y2,
-                },
-            )),
-            Err(_) => custom_err("postscript invalid FontBBox entry"),
-        }
-    }
-    fn parse_font_matrix(&mut self, value: PsArray) -> Result<PdfMatrix, PdfParseError> {
-        let value = value.rc();
-        let value = value.borrow();
-        let mut vec = Vec::new();
-        for entry in value.iter() {
-            let Some(v) = entry.to_f32() else {
-                return custom_err("postscript invalid FontBBox entry");
-            };
-            vec.push(v);
-        }
-        match vec.try_into() {
-            Ok(elements) => Ok(PdfMatrix {
-                pos: PdfInputPositionNoCompare::empty(),
-                elements,
-            }),
-            Err(_) => custom_err("postscript invalid FontBBox entry"),
-        }
-    }
-    fn parse_font_info_dict(
-        &mut self,
-        font_info_dict: PsDictionary,
-    ) -> Result<PdfFontType1FontInfo, PdfParseError> {
-        let PsDictionaryImpl { named, other: _ } = font_info_dict.into_impl();
-        let mut family_name = None;
-        let mut full_name = None;
-        let mut notice = None;
-        let mut weight = None;
-        let mut version = None;
-        let mut italic_angle = None;
-        let mut is_fixed_pitch = None;
-        let mut underline_position = None;
-        let mut underline_thickness = None;
-        for (key, value) in named {
-            match (&*key.0, value) {
-                (b"FamilyName", PsObject::String(string)) => family_name = Some(string.into()),
-                (b"FullName", PsObject::String(string)) => full_name = Some(string.into()),
-                (b"Notice", PsObject::String(string)) => notice = Some(string.into()),
-                (b"Weight", PsObject::String(string)) => weight = Some(string.into()),
-                (b"version", PsObject::String(string)) => version = Some(string.into()),
-                (b"ItalicAngle", value) => {
-                    if let Some(value) = value.to_f32() {
-                        italic_angle = Some(value);
-                    } else {
-                        todo!("{value:?}")
-                    }
-                }
-                (b"isFixedPitch", PsObject::Boolean(v)) => is_fixed_pitch = Some(v),
-                (b"UnderlinePosition", value) => {
-                    if let Some(value) = value.to_f32() {
-                        underline_position = Some(value);
-                    } else {
-                        todo!("{value:?}")
-                    }
-                }
-                (b"UnderlineThickness", value) => {
-                    if let Some(value) = value.to_f32() {
-                        underline_thickness = Some(value);
-                    } else {
-                        todo!("{value:?}")
-                    }
-                }
-                _ => {}
-            }
-        }
-        Ok(PdfFontType1FontInfo {
-            family_name,
-            full_name,
-            notice,
-            weight,
-            version,
-            italic_angle,
-            is_fixed_pitch,
-            underline_position,
-            underline_thickness,
-        })
-    }
-    fn parse_font_dict(
-        &mut self,
-        dict: PsDictionary,
-    ) -> Result<PdfFontType1Program, PdfParseError> {
-        let PsDictionaryImpl { named, other } = dict.into_impl();
-        let mut encoding = None;
-        let mut font_bbox = None;
-        let mut font_info = None;
-        let mut font_matrix = None;
-        let mut font_name = None;
-        let mut vertical_writing_mode = false;
-        for (key, value) in named {
-            match (&*key.0, value) {
-                (b"Encoding", PsObject::Array(value)) => {
-                    encoding = Some(self.parse_font_encoding(value)?);
-                }
-                (b"FontBBox", PsObject::Array(value) | PsObject::Procedure(value)) => {
-                    font_bbox = Some(self.parse_font_bbox(value)?);
-                }
-                (b"FontInfo", PsObject::Dictionary(value)) => {
-                    font_info = Some(self.parse_font_info_dict(value)?);
-                }
-                (b"FontMatrix", PsObject::Array(value) | PsObject::Procedure(value)) => {
-                    font_matrix = Some(self.parse_font_matrix(value)?);
-                }
-                (b"FontName", PsObject::Name(value)) => {
-                    font_name = Some(value.into());
-                }
-                (b"WMode", PsObject::Boolean(v)) => vertical_writing_mode = v,
-                (b"FontType", _) => {
-                    // TODO
-                }
-                (b"PaintType", _) => {
-                    // TODO
-                }
-                (_, value) => todo!("{key:?}: {value:?}"),
-            }
-        }
-        for (key, value) in other {
-            todo!("{key:?}: {value:?}");
-        }
-        let Some(encoding) = encoding else {
-            return custom_err("postscript type 1 font must have Encoding");
-        };
-        let Some(font_bbox) = font_bbox else {
-            return custom_err("postscript type 1 font must have FontBBox");
-        };
-        let Some(font_matrix) = font_matrix else {
-            return custom_err("postscript type 1 font must have FontMatrix");
-        };
-        Ok(PdfFontType1Program {
-            encoding,
-            font_bbox,
-            font_info,
-            font_matrix,
-            font_name,
-            vertical_writing_mode,
-        })
-    }
-    fn parse(mut self) -> Result<PdfFontType1Program, PdfParseError> {
-        self.break_at_eexec = true;
-        match self.parse_file() {
-            Ok(()) => return custom_err("postscript eexec operator not found"),
-            Err(PsBreakReason::FoundEExec) => {}
-            Err(PsBreakReason::Error(e)) => return Err(e),
-        }
-        let Some(PsObject::File(_)) = self.operand_stack.pop() else {
-            return custom_err("postscript eexec operand not found");
-        };
-        let Some(PsObject::Dictionary(dict)) = self.operand_stack.pop() else {
-            todo!();
-        };
-        self.parse_font_dict(dict)
-    }
-    fn run_procedure(&mut self, proc: &[PsObject]) -> Result<(), PsBreakReason> {
-        for object in proc {
-            match object {
-                PsObject::Array(v) => todo!(),
-                PsObject::Procedure(v) => todo!(),
-                PsObject::Dictionary(v) => todo!(),
-                PsObject::Integer(_) => self.operand_stack.push(object.clone()),
-                PsObject::Mark => todo!(),
-                PsObject::Name(_) => self.operand_stack.push(object.clone()),
-                PsObject::ExecutableName(name) => self.run_name(name)?,
-                PsObject::Operator(v) => todo!(),
-                PsObject::Real(v) => todo!(),
-                PsObject::String(v) => todo!(),
-                PsObject::Boolean(v) => todo!(),
-                PsObject::Null => todo!(),
-                PsObject::File(v) => todo!(),
-            }
-        }
-        Ok(())
-    }
-}
-
-impl PdfStreamContents for PdfFontType1Program {
-    fn parse(
-        data: &[u8],
-        stream_pos: PdfInputPosition,
-        _objects: Arc<PdfObjects>,
-    ) -> Result<Self, PdfParseError> {
-        PsParser::new(PsFile::new(
-            0,
-            PsFileSource::Bytes(Arc::from(data)),
-            0,
-            stream_pos,
-        ))
-        .parse()
-    }
-}
diff --git a/src/pdf/object.rs b/src/pdf/object.rs
deleted file mode 100644
index bf91fac..0000000
--- a/src/pdf/object.rs
+++ /dev/null
@@ -1,2142 +0,0 @@
-use crate::{
-    pdf::{
-        PdfObjectAndParseCache, PdfObjects,
-        parse::{
-            GetPdfInputPosition, PdfInputPosition, PdfInputPositionNoCompare, PdfParse,
-            PdfParseError,
-        },
-        stream_filters::PdfStreamFilter,
-    },
-    pdf_parse,
-    util::{ArcOrRef, DagDebugState},
-};
-use std::{
-    any::TypeId,
-    borrow::{Borrow, Cow},
-    collections::BTreeMap,
-    fmt::{self, Write},
-    iter::FusedIterator,
-    num::NonZero,
-    sync::{Arc, OnceLock},
-};
-
-#[derive(Clone, Default, PartialEq, Eq, PartialOrd, Ord)]
-pub struct PdfString {
-    pos: PdfInputPositionNoCompare,
-    bytes: ArcOrRef<'static, [u8]>,
-}
-
-impl std::fmt::Debug for PdfString {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self { pos, bytes: _ } = self;
-        write!(f, "PdfString(at {pos}, {})", self.bytes_debug())
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct PdfStringBytesDebug<'a>(pub &'a [u8]);
-
-impl<'a> fmt::Display for PdfStringBytesDebug<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "b\"{}\"", self.0.escape_ascii())
-    }
-}
-
-impl<'a> fmt::Debug for PdfStringBytesDebug<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
-impl PdfString {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>, bytes: ArcOrRef<'static, [u8]>) -> Self {
-        Self {
-            pos: pos.into(),
-            bytes,
-        }
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn bytes(&self) -> &ArcOrRef<'static, [u8]> {
-        &self.bytes
-    }
-    pub fn bytes_debug(&self) -> PdfStringBytesDebug<'_> {
-        PdfStringBytesDebug(&self.bytes)
-    }
-}
-
-impl GetPdfInputPosition for PdfString {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-#[derive(Clone, PartialEq, Eq)]
-pub struct PdfDate {
-    text: PdfString,
-}
-
-impl fmt::Debug for PdfDate {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { text } = self;
-        let pos = text.pos();
-        write!(f, "PdfDate(at {pos}, {})", text.bytes_debug())
-    }
-}
-
-impl IsPdfNull for PdfDate {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfDate {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("date")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Self::try_new(PdfString::parse(object)?)
-    }
-}
-
-impl PdfDate {
-    pub fn try_new(text: PdfString) -> Result<Self, PdfParseError> {
-        // TODO: check syntax
-        Ok(Self { text })
-    }
-    pub fn text(&self) -> &PdfString {
-        &self.text
-    }
-}
-
-impl GetPdfInputPosition for PdfDate {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.text.pos()
-    }
-}
-
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct PdfName {
-    pos: PdfInputPositionNoCompare,
-    bytes: ArcOrRef<'static, [u8]>,
-}
-
-impl Borrow<[u8]> for PdfName {
-    fn borrow(&self) -> &[u8] {
-        &self.bytes
-    }
-}
-
-impl PdfName {
-    pub fn try_new(
-        pos: impl Into<PdfInputPositionNoCompare>,
-        bytes: impl Into<ArcOrRef<'static, [u8]>>,
-    ) -> Option<Self> {
-        let bytes = bytes.into();
-        if bytes.contains(&0) {
-            None
-        } else {
-            Some(Self {
-                pos: pos.into(),
-                bytes,
-            })
-        }
-    }
-    #[track_caller]
-    pub const fn new_static(bytes: &'static [u8]) -> Self {
-        let mut i = 0;
-        while i < bytes.len() {
-            if bytes[i] == 0 {
-                panic!("shouldn't contain any nul bytes");
-            }
-            i += 1;
-        }
-        Self {
-            pos: PdfInputPositionNoCompare::empty(),
-            bytes: ArcOrRef::Ref(bytes),
-        }
-    }
-    #[track_caller]
-    pub fn new(
-        pos: impl Into<PdfInputPositionNoCompare>,
-        bytes: impl Into<ArcOrRef<'static, [u8]>>,
-    ) -> Self {
-        Self::try_new(pos, bytes).expect("shouldn't contain any nul bytes")
-    }
-    pub fn as_bytes(&self) -> &ArcOrRef<'static, [u8]> {
-        &self.bytes
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-impl GetPdfInputPosition for PdfName {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-impl fmt::Debug for PdfName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "PdfName(at {}: {self})", self.pos)
-    }
-}
-
-impl fmt::Display for PdfName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("/")?;
-        for &b in self.bytes.iter() {
-            match b {
-                0x21..=0x7E if b != b'#' => f.write_char(b.into())?,
-                _ => write!(f, "#{b:02X}")?,
-            }
-        }
-        Ok(())
-    }
-}
-
-#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct PdfBoolean {
-    pos: PdfInputPositionNoCompare,
-    value: bool,
-}
-
-impl fmt::Debug for PdfBoolean {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { pos, value } = *self;
-        write!(f, "PdfBoolean(at {pos}, {value})")
-    }
-}
-
-impl PdfBoolean {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>, value: bool) -> Self {
-        Self {
-            pos: pos.into(),
-            value,
-        }
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn value(&self) -> bool {
-        self.value
-    }
-}
-
-impl GetPdfInputPosition for PdfBoolean {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Default)]
-pub struct PdfInteger {
-    pos: PdfInputPositionNoCompare,
-    value: i128,
-}
-
-impl fmt::Debug for PdfInteger {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { pos, value } = *self;
-        write!(f, "PdfInteger(at {pos}, {value})")
-    }
-}
-
-impl PdfInteger {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>, value: i128) -> Self {
-        Self {
-            pos: pos.into(),
-            value,
-        }
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn value(&self) -> i128 {
-        self.value
-    }
-}
-
-impl GetPdfInputPosition for PdfInteger {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, PartialOrd, Default)]
-pub struct PdfReal {
-    pos: PdfInputPositionNoCompare,
-    value: f64,
-}
-
-impl fmt::Debug for PdfReal {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { pos, value } = *self;
-        write!(f, "PdfReal(at {pos}, {value})")
-    }
-}
-
-impl PdfReal {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>, value: f64) -> Self {
-        Self {
-            pos: pos.into(),
-            value,
-        }
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn value(&self) -> f64 {
-        self.value
-    }
-}
-
-impl GetPdfInputPosition for PdfReal {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-#[derive(Clone, Copy)]
-pub enum PdfNumber {
-    Integer(PdfInteger),
-    Real(PdfReal),
-}
-
-impl fmt::Debug for PdfNumber {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Integer(v) => v.fmt(f),
-            Self::Real(v) => v.fmt(f),
-        }
-    }
-}
-
-impl PdfNumber {
-    pub fn pos(self) -> PdfInputPosition {
-        match self {
-            Self::Integer(v) => v.pos(),
-            Self::Real(v) => v.pos(),
-        }
-    }
-    pub fn as_f64(self) -> f64 {
-        match self {
-            Self::Integer(v) => v.value as f64,
-            Self::Real(v) => v.value,
-        }
-    }
-    pub fn as_f32(self) -> f32 {
-        match self {
-            Self::Integer(v) => v.value as f32,
-            Self::Real(v) => v.value as f32,
-        }
-    }
-}
-
-impl PartialOrd for PdfNumber {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        match (self, other) {
-            (Self::Integer(this), Self::Integer(other)) => Some(this.cmp(other)),
-            _ => self.as_f64().partial_cmp(&other.as_f64()),
-        }
-    }
-}
-
-impl PartialEq for PdfNumber {
-    fn eq(&self, other: &Self) -> bool {
-        self.partial_cmp(other).is_some_and(|v| v.is_eq())
-    }
-}
-
-impl Default for PdfNumber {
-    fn default() -> Self {
-        PdfNumber::Integer(PdfInteger::default())
-    }
-}
-
-impl PdfObjectDirect {
-    pub fn number(&self) -> Option<PdfNumber> {
-        match *self {
-            PdfObjectDirect::Integer(v) => Some(PdfNumber::Integer(v)),
-            PdfObjectDirect::Real(v) => Some(PdfNumber::Real(v)),
-            PdfObjectDirect::Boolean(_)
-            | PdfObjectDirect::String(_)
-            | PdfObjectDirect::Name(_)
-            | PdfObjectDirect::Array(_)
-            | PdfObjectDirect::Dictionary(_)
-            | PdfObjectDirect::Stream(_)
-            | PdfObjectDirect::Null(_) => None,
-        }
-    }
-}
-
-impl PdfObjectNonNull {
-    pub fn number(&self) -> Option<PdfNumber> {
-        match *self {
-            PdfObjectNonNull::Integer(v) => Some(PdfNumber::Integer(v)),
-            PdfObjectNonNull::Real(v) => Some(PdfNumber::Real(v)),
-            PdfObjectNonNull::Boolean(_)
-            | PdfObjectNonNull::String(_)
-            | PdfObjectNonNull::Name(_)
-            | PdfObjectNonNull::Array(_)
-            | PdfObjectNonNull::Dictionary(_)
-            | PdfObjectNonNull::Stream(_) => None,
-        }
-    }
-}
-
-impl IsPdfNull for PdfNumber {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfNumber {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("number")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = PdfObjectDirect::from(object);
-        object.number().ok_or(PdfParseError::InvalidType {
-            pos: object.pos(),
-            ty: object.type_name(),
-            expected_ty: "number",
-        })
-    }
-}
-
-#[derive(Clone)]
-pub enum PdfStringOrNumber {
-    String(PdfString),
-    Number(PdfNumber),
-}
-
-impl fmt::Debug for PdfStringOrNumber {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::String(v) => v.fmt(f),
-            Self::Number(v) => v.fmt(f),
-        }
-    }
-}
-
-impl PdfStringOrNumber {
-    pub fn pos(self) -> PdfInputPosition {
-        match self {
-            Self::String(v) => v.pos(),
-            Self::Number(v) => v.pos(),
-        }
-    }
-}
-
-impl PdfObjectDirect {
-    pub fn string_or_number(&self) -> Option<PdfStringOrNumber> {
-        match *self {
-            PdfObjectDirect::Integer(v) => Some(PdfStringOrNumber::Number(PdfNumber::Integer(v))),
-            PdfObjectDirect::Real(v) => Some(PdfStringOrNumber::Number(PdfNumber::Real(v))),
-            PdfObjectDirect::String(ref v) => Some(PdfStringOrNumber::String(v.clone())),
-            PdfObjectDirect::Boolean(_)
-            | PdfObjectDirect::Name(_)
-            | PdfObjectDirect::Array(_)
-            | PdfObjectDirect::Dictionary(_)
-            | PdfObjectDirect::Stream(_)
-            | PdfObjectDirect::Null(_) => None,
-        }
-    }
-}
-
-impl PdfObjectNonNull {
-    pub fn string_or_number(&self) -> Option<PdfStringOrNumber> {
-        match *self {
-            PdfObjectNonNull::Integer(v) => Some(PdfStringOrNumber::Number(PdfNumber::Integer(v))),
-            PdfObjectNonNull::Real(v) => Some(PdfStringOrNumber::Number(PdfNumber::Real(v))),
-            PdfObjectNonNull::String(ref v) => Some(PdfStringOrNumber::String(v.clone())),
-            PdfObjectNonNull::Boolean(_)
-            | PdfObjectNonNull::Name(_)
-            | PdfObjectNonNull::Array(_)
-            | PdfObjectNonNull::Dictionary(_)
-            | PdfObjectNonNull::Stream(_) => None,
-        }
-    }
-}
-
-impl IsPdfNull for PdfStringOrNumber {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfStringOrNumber {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("string or number")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = PdfObjectDirect::from(object);
-        object.string_or_number().ok_or(PdfParseError::InvalidType {
-            pos: object.pos(),
-            ty: object.type_name(),
-            expected_ty: "string or number",
-        })
-    }
-}
-
-#[derive(Clone)]
-pub enum PdfNameOrInteger {
-    Name(PdfName),
-    Integer(PdfInteger),
-}
-
-impl fmt::Debug for PdfNameOrInteger {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Name(v) => v.fmt(f),
-            Self::Integer(v) => v.fmt(f),
-        }
-    }
-}
-
-impl PdfNameOrInteger {
-    pub fn pos(self) -> PdfInputPosition {
-        match self {
-            Self::Name(v) => v.pos(),
-            Self::Integer(v) => v.pos(),
-        }
-    }
-}
-
-impl PdfObjectDirect {
-    pub fn name_or_integer(&self) -> Option<PdfNameOrInteger> {
-        match *self {
-            PdfObjectDirect::Name(ref v) => Some(PdfNameOrInteger::Name(v.clone())),
-            PdfObjectDirect::Integer(v) => Some(PdfNameOrInteger::Integer(v)),
-            PdfObjectDirect::Boolean(_)
-            | PdfObjectDirect::Real(_)
-            | PdfObjectDirect::String(_)
-            | PdfObjectDirect::Array(_)
-            | PdfObjectDirect::Dictionary(_)
-            | PdfObjectDirect::Stream(_)
-            | PdfObjectDirect::Null(_) => None,
-        }
-    }
-}
-
-impl PdfObjectNonNull {
-    pub fn name_or_integer(&self) -> Option<PdfNameOrInteger> {
-        match *self {
-            PdfObjectNonNull::Name(ref v) => Some(PdfNameOrInteger::Name(v.clone())),
-            PdfObjectNonNull::Integer(v) => Some(PdfNameOrInteger::Integer(v)),
-            PdfObjectNonNull::Boolean(_)
-            | PdfObjectNonNull::Real(_)
-            | PdfObjectNonNull::String(_)
-            | PdfObjectNonNull::Array(_)
-            | PdfObjectNonNull::Dictionary(_)
-            | PdfObjectNonNull::Stream(_) => None,
-        }
-    }
-}
-
-impl IsPdfNull for PdfNameOrInteger {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfNameOrInteger {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("name or integer")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = PdfObjectDirect::from(object);
-        object.name_or_integer().ok_or(PdfParseError::InvalidType {
-            pos: object.pos(),
-            ty: object.type_name(),
-            expected_ty: "name or integer",
-        })
-    }
-}
-
-macro_rules! make_pdf_object {
-    (
-        $(
-            #[parse = $($parse:ident)?, type_name = $type_name:literal]
-            $Variant:ident($ty:ty),
-        )+
-    ) => {
-        #[derive(Clone)]
-        pub enum PdfObjectNonNull {
-            $($Variant($ty),)*
-        }
-
-        impl fmt::Debug for PdfObjectNonNull {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                match self {
-                    $(Self::$Variant(v) => v.fmt(f),)*
-                }
-            }
-        }
-
-        impl IsPdfNull for PdfObjectNonNull {
-            fn is_pdf_null(&self) -> bool {
-                false
-            }
-        }
-
-        #[derive(Clone)]
-        pub enum PdfObjectDirect {
-            $($Variant($ty),)*
-            Null(PdfNull),
-        }
-
-        impl IsPdfNull for PdfObjectDirect {
-            fn is_pdf_null(&self) -> bool {
-                self.is_null()
-            }
-        }
-
-        impl fmt::Debug for PdfObjectDirect {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                match self {
-                    $(Self::$Variant(v) => v.fmt(f),)*
-                    Self::Null(v) => v.fmt(f),
-                }
-            }
-        }
-
-        #[derive(Clone)]
-        pub enum PdfObject {
-            $($Variant($ty),)*
-            Null(PdfNull),
-            Indirect(PdfObjectIndirect),
-        }
-
-        impl IsPdfNull for PdfObject {
-            fn is_pdf_null(&self) -> bool {
-                self.is_null()
-            }
-        }
-
-        impl fmt::Debug for PdfObject {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                match self {
-                    $(Self::$Variant(v) => v.fmt(f),)*
-                    Self::Null(v) => v.fmt(f),
-                    Self::Indirect(v) => v.fmt(f),
-                }
-            }
-        }
-
-        $(
-        impl From<$ty> for PdfObjectNonNull {
-            fn from(value: $ty) -> Self {
-                Self::$Variant(value)
-            }
-        }
-
-        impl From<$ty> for PdfObjectDirect {
-            fn from(value: $ty) -> Self {
-                Self::$Variant(value)
-            }
-        }
-
-        impl From<$ty> for PdfObject {
-            fn from(value: $ty) -> Self {
-                Self::$Variant(value)
-            }
-        }
-
-        impl From<Option<$ty>> for PdfObjectDirect {
-            fn from(value: Option<$ty>) -> Self {
-                match value {
-                    Some(value) => Self::$Variant(value),
-                    None => Self::Null(Default::default()),
-                }
-            }
-        }
-
-        impl From<Option<$ty>> for PdfObject {
-            fn from(value: Option<$ty>) -> Self {
-                match value {
-                    Some(value) => Self::$Variant(value),
-                    None => Self::Null(Default::default()),
-                }
-            }
-        }
-
-        $(impl IsPdfNull for $ty {
-            fn is_pdf_null(&self) -> bool {
-                false
-            }
-        }
-
-        impl PdfParse for $ty {
-            fn type_name() -> Cow<'static, str> {
-                Cow::Borrowed($type_name)
-            }
-            fn $parse(object: PdfObject) -> Result<Self, PdfParseError> {
-                match PdfObjectDirect::from(object) {
-                    PdfObjectDirect::$Variant(v) => Ok(v),
-                    object => Err(PdfParseError::InvalidType {
-                        pos: object.get_pdf_input_position(),
-                        ty: object.type_name(),
-                        expected_ty: $type_name,
-                    }),
-                }
-            }
-        })?
-        )*
-
-        impl From<PdfObjectNonNull> for PdfObjectDirect {
-            fn from(value: PdfObjectNonNull) -> Self {
-                match value {
-                    $(PdfObjectNonNull::$Variant(v) => Self::$Variant(v),)*
-                }
-            }
-        }
-
-        impl From<PdfObjectNonNull> for PdfObject {
-            fn from(value: PdfObjectNonNull) -> Self {
-                match value {
-                    $(PdfObjectNonNull::$Variant(v) => Self::$Variant(v),)*
-                }
-            }
-        }
-
-        impl From<PdfObjectDirect> for PdfObject {
-            fn from(value: PdfObjectDirect) -> Self {
-                match value {
-                    $(PdfObjectDirect::$Variant(v) => Self::$Variant(v),)*
-                    PdfObjectDirect::Null(v) => Self::Null(v),
-                }
-            }
-        }
-
-        impl From<PdfObject> for PdfObjectDirect {
-            fn from(value: PdfObject) -> Self {
-                match value {
-                    $(PdfObject::$Variant(v) => Self::$Variant(v),)*
-                    PdfObject::Null(v) => Self::Null(v),
-                    PdfObject::Indirect(v) => v.into(),
-                }
-            }
-        }
-
-        impl PdfObjectNonNull {
-            pub fn type_name(&self) -> &'static str {
-                match self {
-                    $(PdfObjectNonNull::$Variant(_) => $type_name,)*
-                }
-            }
-            pub fn pos(&self) -> PdfInputPosition {
-                self.get_pdf_input_position()
-            }
-        }
-
-        impl GetPdfInputPosition for PdfObjectNonNull {
-            fn get_pdf_input_position(&self) -> PdfInputPosition {
-                match self {
-                    $(PdfObjectNonNull::$Variant(v) => <$ty as GetPdfInputPosition>::get_pdf_input_position(v),)*
-                }
-            }
-        }
-
-        impl From<PdfObjectDirect> for Option<PdfObjectNonNull> {
-            fn from(value: PdfObjectDirect) -> Self {
-                match value {
-                    $(PdfObjectDirect::$Variant(v) => Some(PdfObjectNonNull::$Variant(v)),)*
-                    PdfObjectDirect::Null(_) => None,
-                }
-            }
-        }
-
-        impl From<PdfObject> for Option<PdfObjectNonNull> {
-            fn from(value: PdfObject) -> Self {
-                PdfObjectDirect::from(value).into()
-            }
-        }
-
-        impl PdfObjectDirect {
-            pub fn is_null(&self) -> bool {
-                matches!(self, PdfObjectDirect::Null(_))
-            }
-            pub fn type_name(&self) -> &'static str {
-                match self {
-                    $(PdfObjectDirect::$Variant(_) => $type_name,)*
-                    PdfObjectDirect::Null(_) => "null",
-                }
-            }
-            pub fn pos(&self) -> PdfInputPosition {
-                self.get_pdf_input_position()
-            }
-        }
-
-        impl GetPdfInputPosition for PdfObjectDirect {
-            fn get_pdf_input_position(&self) -> PdfInputPosition {
-                match self {
-                    $(PdfObjectDirect::$Variant(v) => <$ty as GetPdfInputPosition>::get_pdf_input_position(v),)*
-                    PdfObjectDirect::Null(v) => <PdfNull as GetPdfInputPosition>::get_pdf_input_position(v),
-                }
-            }
-        }
-
-        impl PdfObject {
-            pub fn is_null(&self) -> bool {
-                matches!(self, PdfObject::Null(_))
-            }
-            pub fn type_name(&self) -> &'static str {
-                match self {
-                    $(PdfObject::$Variant(_) => $type_name,)*
-                    PdfObject::Null(_) => "null",
-                    PdfObject::Indirect(_) => "indirect object",
-                }
-            }
-            pub fn pos(&self) -> PdfInputPosition {
-                self.get_pdf_input_position()
-            }
-        }
-
-        impl GetPdfInputPosition for PdfObject {
-            fn get_pdf_input_position(&self) -> PdfInputPosition {
-                match self {
-                    $(PdfObject::$Variant(v) => <$ty as GetPdfInputPosition>::get_pdf_input_position(v),)*
-                    PdfObject::Null(v) => <PdfNull as GetPdfInputPosition>::get_pdf_input_position(v),
-                    PdfObject::Indirect(v) => <PdfObjectIndirect as GetPdfInputPosition>::get_pdf_input_position(v),
-                }
-            }
-        }
-
-        const _: () = {
-            fn _assert_parsable<T: PdfParse>() {}
-
-            $(let _ = _assert_parsable::<$ty>;)*
-            let _ = _assert_parsable::<PdfNull>;
-            let _ = _assert_parsable::<PdfObjectIndirect>;
-            let _ = _assert_parsable::<PdfObjectNonNull>;
-            let _ = _assert_parsable::<PdfObjectDirect>;
-            let _ = _assert_parsable::<PdfObject>;
-        };
-    };
-}
-
-make_pdf_object! {
-    #[parse = parse, type_name = "boolean"]
-    Boolean(PdfBoolean),
-    #[parse = parse, type_name = "integer"]
-    Integer(PdfInteger),
-    #[parse = parse, type_name = "real"]
-    Real(PdfReal),
-    #[parse = parse, type_name = "string"]
-    String(PdfString),
-    #[parse = parse, type_name = "name"]
-    Name(PdfName),
-    #[parse = parse, type_name = "array"]
-    Array(PdfArray),
-    #[parse =, type_name = "dictionary"]
-    Dictionary(PdfDictionary),
-    #[parse =, type_name = "stream"]
-    Stream(PdfStream),
-}
-
-#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct PdfNull(PdfInputPositionNoCompare);
-
-impl fmt::Debug for PdfNull {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "PdfNull(at {})", self.0)
-    }
-}
-
-impl PdfNull {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>) -> Self {
-        Self(pos.into())
-    }
-}
-
-impl GetPdfInputPosition for PdfNull {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.0.0
-    }
-}
-
-impl From<PdfNull> for PdfObjectDirect {
-    fn from(v: PdfNull) -> Self {
-        Self::Null(v)
-    }
-}
-
-impl Default for PdfObjectDirect {
-    fn default() -> Self {
-        Self::Null(PdfNull(PdfInputPositionNoCompare::empty()))
-    }
-}
-
-impl From<PdfNull> for PdfObject {
-    fn from(v: PdfNull) -> Self {
-        Self::Null(v)
-    }
-}
-
-impl Default for PdfObject {
-    fn default() -> Self {
-        Self::Null(PdfNull(PdfInputPositionNoCompare::empty()))
-    }
-}
-
-impl From<PdfObjectIndirect> for PdfObject {
-    fn from(v: PdfObjectIndirect) -> Self {
-        Self::Indirect(v)
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct PdfObjectIdentifier {
-    pub pos: PdfInputPositionNoCompare,
-    pub object_number: NonZero<u32>,
-    pub generation_number: u16,
-}
-
-impl fmt::Debug for PdfObjectIdentifier {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self {
-            pos,
-            object_number,
-            generation_number,
-        } = *self;
-        write!(
-            f,
-            "PdfObjectIdentifier(at {pos}, {object_number}, {generation_number})"
-        )
-    }
-}
-
-impl GetPdfInputPosition for PdfObjectIdentifier {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfObjectIndirect {
-    objects: std::sync::Weak<PdfObjects>,
-    id: PdfObjectIdentifier,
-    final_id: Arc<OnceLock<PdfObjectIdentifier>>,
-}
-
-impl fmt::Debug for PdfObjectIndirect {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self {
-            objects: _,
-            id:
-                PdfObjectIdentifier {
-                    pos,
-                    object_number,
-                    generation_number,
-                },
-            final_id: _,
-        } = *self;
-        write!(
-            f,
-            "PdfObjectIndirect(at {pos}, {object_number}, {generation_number})"
-        )
-    }
-}
-
-impl GetPdfInputPosition for PdfObjectIndirect {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.id.get_pdf_input_position()
-    }
-}
-
-impl PartialEq for PdfObjectIndirect {
-    fn eq(&self, other: &Self) -> bool {
-        let Self {
-            objects,
-            id,
-            final_id: _,
-        } = self;
-        objects.ptr_eq(&other.objects) && *id == other.id
-    }
-}
-
-impl PdfObjectIndirect {
-    pub fn new(objects: &Arc<PdfObjects>, id: PdfObjectIdentifier) -> Self {
-        Self {
-            objects: Arc::downgrade(objects),
-            id,
-            final_id: Arc::new(OnceLock::new()),
-        }
-    }
-    pub(crate) fn cache_parse<T: 'static + Send + Sync, E>(
-        &self,
-        parse_inner: impl FnOnce(PdfObjectDirect) -> Result<Arc<T>, E>,
-    ) -> Result<Arc<T>, E> {
-        self.get_object_and_parse_cache(|object, object_and_parse_cache| {
-            match object_and_parse_cache {
-                Some(object_and_parse_cache) => {
-                    if let Some(retval) = object_and_parse_cache.parse_cache_get::<T>() {
-                        println!("cache reused for {object:?}");
-                        return Ok(retval);
-                    }
-                    parse_inner(object)
-                        .map(|retval| object_and_parse_cache.parse_cache_get_or_insert::<T>(retval))
-                }
-                None => parse_inner(object),
-            }
-        })
-    }
-    fn get_object_and_parse_cache_inner<'a>(
-        &self,
-        objects: &'a PdfObjects,
-    ) -> (PdfObjectDirect, Option<&'a PdfObjectAndParseCache>) {
-        if let Some(objects) = objects.inner.get() {
-            let final_id = self.final_id.get().copied();
-            let limit = if final_id.is_some() { 1 } else { 1000usize };
-            let mut id = final_id.unwrap_or(self.id);
-            for _ in 0..limit {
-                if let Some(object_and_parse_cache) = objects.objects.get(&self.id) {
-                    let object = match &object_and_parse_cache.object {
-                        PdfObject::Boolean(v) => PdfObjectDirect::Boolean(*v),
-                        PdfObject::Integer(v) => PdfObjectDirect::Integer(*v),
-                        PdfObject::Real(v) => PdfObjectDirect::Real(*v),
-                        PdfObject::String(v) => PdfObjectDirect::String(v.clone()),
-                        PdfObject::Name(v) => PdfObjectDirect::Name(v.clone()),
-                        PdfObject::Array(v) => PdfObjectDirect::Array(v.clone()),
-                        PdfObject::Dictionary(v) => PdfObjectDirect::Dictionary(v.clone()),
-                        PdfObject::Stream(v) => PdfObjectDirect::Stream(v.clone()),
-                        PdfObject::Null(v) => PdfObjectDirect::Null(*v),
-                        PdfObject::Indirect(v) => {
-                            id = v.id;
-                            continue;
-                        }
-                    };
-                    // we could be racing with another thread, so set can fail but that's not a problem
-                    let _ = self.final_id.set(id);
-                    return (object, Some(object_and_parse_cache));
-                } else {
-                    return (PdfNull::new(id.pos).into(), None);
-                }
-            }
-        }
-        (PdfNull::new(self.pos()).into(), None)
-    }
-    fn get_object_and_parse_cache<R>(
-        &self,
-        f: impl FnOnce(PdfObjectDirect, Option<&PdfObjectAndParseCache>) -> R,
-    ) -> R {
-        let Some(objects) = self.objects.upgrade() else {
-            panic!("PdfObjects is no longer available");
-        };
-        let (object, object_and_parse_cache) = self.get_object_and_parse_cache_inner(&objects);
-        f(object, object_and_parse_cache)
-    }
-    pub fn get(&self) -> PdfObjectDirect {
-        self.get_object_and_parse_cache(|object, _object_and_parse_cache| object)
-    }
-    pub fn id(&self) -> PdfObjectIdentifier {
-        self.id
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.id.pos.0
-    }
-}
-
-impl From<PdfObjectIndirect> for PdfObjectDirect {
-    fn from(value: PdfObjectIndirect) -> Self {
-        value.get()
-    }
-}
-
-pub trait IsPdfNull {
-    fn is_pdf_null(&self) -> bool;
-}
-
-impl<T: IsPdfNull> IsPdfNull for Option<T> {
-    fn is_pdf_null(&self) -> bool {
-        self.as_ref().is_none_or(IsPdfNull::is_pdf_null)
-    }
-}
-
-pub struct PdfDictionary<T = PdfObject> {
-    pos: PdfInputPositionNoCompare,
-    fields: Arc<BTreeMap<PdfName, T>>,
-}
-
-impl<T> Clone for PdfDictionary<T> {
-    fn clone(&self) -> Self {
-        Self {
-            pos: self.pos,
-            fields: self.fields.clone(),
-        }
-    }
-}
-
-impl<T> PdfDictionary<T> {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>) -> Self {
-        Self {
-            pos: pos.into(),
-            fields: Arc::new(BTreeMap::new()),
-        }
-    }
-    pub fn from_fields(
-        pos: impl Into<PdfInputPositionNoCompare>,
-        mut fields: Arc<BTreeMap<PdfName, T>>,
-    ) -> Self
-    where
-        T: IsPdfNull + Clone,
-    {
-        if fields.values().any(T::is_pdf_null) {
-            Arc::make_mut(&mut fields).retain(|_k, v| !v.is_pdf_null());
-        }
-        Self {
-            pos: pos.into(),
-            fields,
-        }
-    }
-    pub fn fields(&self) -> &Arc<BTreeMap<PdfName, T>> {
-        &self.fields
-    }
-    pub fn into_fields(self) -> Arc<BTreeMap<PdfName, T>> {
-        self.fields
-    }
-    pub fn iter(&self) -> std::collections::btree_map::Iter<'_, PdfName, T> {
-        self.fields.iter()
-    }
-    pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
-    where
-        PdfName: std::borrow::Borrow<Q>,
-        Q: Ord,
-    {
-        self.fields.contains_key(key)
-    }
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&T>
-    where
-        PdfName: std::borrow::Borrow<Q>,
-        Q: Ord,
-    {
-        self.fields.get(key)
-    }
-    pub fn get_or_null<Q: ?Sized>(&self, key: &Q) -> T
-    where
-        PdfName: std::borrow::Borrow<Q>,
-        Q: Ord,
-        T: Clone + From<PdfNull>,
-    {
-        self.get(key)
-            .cloned()
-            .unwrap_or_else(|| PdfNull(self.pos).into())
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-impl<T> GetPdfInputPosition for PdfDictionary<T> {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-impl<T> Default for PdfDictionary<T> {
-    fn default() -> Self {
-        Self::new(PdfInputPosition::empty())
-    }
-}
-
-impl<T: IsPdfNull> FromIterator<(PdfName, T)> for PdfDictionary<T> {
-    fn from_iter<I: IntoIterator<Item = (PdfName, T)>>(iter: I) -> Self {
-        Self {
-            pos: PdfInputPositionNoCompare::empty(),
-            fields: Arc::new(BTreeMap::from_iter(
-                iter.into_iter()
-                    .filter(|(_name, value)| !value.is_pdf_null()),
-            )),
-        }
-    }
-}
-
-impl<T: Clone> IntoIterator for PdfDictionary<T> {
-    type Item = (PdfName, T);
-    type IntoIter = std::collections::btree_map::IntoIter<PdfName, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        Arc::unwrap_or_clone(self.fields).into_iter()
-    }
-}
-
-impl<'a, T> IntoIterator for &'a PdfDictionary<T> {
-    type Item = (&'a PdfName, &'a T);
-    type IntoIter = std::collections::btree_map::Iter<'a, PdfName, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.fields.iter()
-    }
-}
-
-impl<T: fmt::Debug + 'static> fmt::Debug for PdfDictionary<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|state| {
-            state
-                .debug_or_id_with(
-                    &self.fields,
-                    |_, f| f.debug_map().entries(self).finish(),
-                    |f| f.write_str("{...}"),
-                )
-                .fmt(f)
-        })
-    }
-}
-
-impl<T> IsPdfNull for PdfDictionary<T> {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl<T: PdfParse> PdfParse for PdfDictionary<T> {
-    fn type_name() -> Cow<'static, str> {
-        if TypeId::of::<T>() == TypeId::of::<PdfObject>() {
-            Cow::Borrowed("dictionary")
-        } else {
-            Cow::Owned(format!("PdfDictionary<{}>", T::type_name()))
-        }
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = PdfObjectDirect::from(object);
-        let PdfObjectDirect::Dictionary(object) = object else {
-            return Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "dictionary",
-            });
-        };
-        if let Some(retval) = <dyn std::any::Any>::downcast_ref::<Self>(&object) {
-            return Ok(retval.clone());
-        }
-        let pos = object.pos;
-        let fields = Result::from_iter(object.fields.iter().filter_map(|(name, value)| {
-            match T::parse(value.clone()) {
-                Ok(value) => {
-                    if value.is_pdf_null() {
-                        None
-                    } else {
-                        Some(Ok((name.clone(), value)))
-                    }
-                }
-                Err(e) => Some(Err(e)),
-            }
-        }))?;
-        Ok(Self {
-            pos,
-            fields: Arc::new(fields),
-        })
-    }
-}
-
-#[derive(Clone, Default)]
-pub struct PdfArray {
-    pos: PdfInputPositionNoCompare,
-    elements: Arc<[PdfObject]>,
-}
-
-impl PdfArray {
-    pub fn new(pos: impl Into<PdfInputPositionNoCompare>) -> Self {
-        Self {
-            pos: pos.into(),
-            elements: Arc::default(),
-        }
-    }
-    pub fn from_elements(
-        pos: impl Into<PdfInputPositionNoCompare>,
-        elements: Arc<[PdfObject]>,
-    ) -> Self {
-        Self {
-            pos: pos.into(),
-            elements,
-        }
-    }
-    pub fn pos(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn elements(&self) -> &Arc<[PdfObject]> {
-        &self.elements
-    }
-    pub fn into_elements(self) -> Arc<[PdfObject]> {
-        self.elements
-    }
-    pub fn iter(&self) -> std::slice::Iter<'_, PdfObject> {
-        self.elements.iter()
-    }
-}
-
-impl GetPdfInputPosition for PdfArray {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-impl FromIterator<PdfObject> for PdfArray {
-    fn from_iter<T: IntoIterator<Item = PdfObject>>(iter: T) -> Self {
-        Self {
-            pos: PdfInputPositionNoCompare::empty(),
-            elements: Arc::from_iter(iter),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfArrayIntoIter {
-    indexes: std::ops::Range<usize>,
-    elements: Arc<[PdfObject]>,
-}
-
-impl Iterator for PdfArrayIntoIter {
-    type Item = PdfObject;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.indexes.next().map(|i| self.elements[i].clone())
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.indexes.size_hint()
-    }
-
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        self.indexes.nth(n).map(|i| self.elements[i].clone())
-    }
-
-    fn last(self) -> Option<Self::Item> {
-        self.indexes.last().map(|i| self.elements[i].clone())
-    }
-
-    fn fold<B, F>(self, init: B, mut f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        self.indexes
-            .fold(init, |init, i| f(init, self.elements[i].clone()))
-    }
-}
-
-impl std::iter::FusedIterator for PdfArrayIntoIter {}
-
-impl DoubleEndedIterator for PdfArrayIntoIter {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.indexes.next_back().map(|i| self.elements[i].clone())
-    }
-    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
-        self.indexes.nth_back(n).map(|i| self.elements[i].clone())
-    }
-    fn rfold<B, F>(self, init: B, mut f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        self.indexes
-            .rfold(init, |init, i| f(init, self.elements[i].clone()))
-    }
-}
-
-impl ExactSizeIterator for PdfArrayIntoIter {}
-
-impl IntoIterator for PdfArray {
-    type Item = PdfObject;
-    type IntoIter = PdfArrayIntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        PdfArrayIntoIter {
-            indexes: 0..self.elements.len(),
-            elements: self.elements,
-        }
-    }
-}
-
-impl<'a> IntoIterator for &'a PdfArray {
-    type Item = &'a PdfObject;
-    type IntoIter = std::slice::Iter<'a, PdfObject>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.elements.iter()
-    }
-}
-
-impl fmt::Debug for PdfArray {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.elements.fmt(f)
-    }
-}
-
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct MaybeArray<T>(pub Arc<[T]>);
-
-impl<T: fmt::Debug> fmt::Debug for MaybeArray<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl<T> std::ops::Deref for MaybeArray<T> {
-    type Target = Arc<[T]>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<T> std::ops::DerefMut for MaybeArray<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl<T> Default for MaybeArray<T> {
-    fn default() -> Self {
-        Self(Arc::default())
-    }
-}
-
-impl<'a, T> IntoIterator for &'a MaybeArray<T> {
-    type Item = &'a T;
-    type IntoIter = std::slice::Iter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-#[derive(Clone)]
-pub enum NameOr<T> {
-    Name(PdfName),
-    Value(T),
-}
-
-impl<T> NameOr<T> {
-    pub fn into_resolved<E>(self, resolve: impl FnOnce(PdfName) -> Result<T, E>) -> Result<T, E> {
-        match self {
-            Self::Name(name) => resolve(name),
-            Self::Value(v) => Ok(v),
-        }
-    }
-    pub fn replace_with_resolved<E>(
-        &mut self,
-        resolve: impl FnOnce(&PdfName) -> Result<T, E>,
-    ) -> Result<&mut T, E> {
-        match self {
-            Self::Name(name) => {
-                *self = Self::Value(resolve(name)?);
-                let Self::Value(v) = self else {
-                    unreachable!();
-                };
-                Ok(v)
-            }
-            Self::Value(v) => Ok(v),
-        }
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for NameOr<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Name(v) => v.fmt(f),
-            Self::Value(v) => v.fmt(f),
-        }
-    }
-}
-
-impl<T: GetPdfInputPosition> GetPdfInputPosition for NameOr<T> {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        match self {
-            Self::Name(v) => v.pos(),
-            Self::Value(v) => v.get_pdf_input_position(),
-        }
-    }
-}
-
-impl<T: IsPdfNull> IsPdfNull for NameOr<T> {
-    fn is_pdf_null(&self) -> bool {
-        match self {
-            Self::Name(_) => false,
-            Self::Value(v) => v.is_pdf_null(),
-        }
-    }
-}
-
-impl<T: PdfParse> PdfParse for NameOr<T> {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Owned(format!("NameOr<{}>", T::type_name()))
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Ok(match PdfObjectDirect::from(object) {
-            PdfObjectDirect::Name(name) => Self::Name(name),
-            object => Self::Value(T::parse(object.into())?),
-        })
-    }
-}
-
-#[derive(Copy, Clone, PartialEq)]
-pub struct PdfMatrix {
-    pub pos: PdfInputPositionNoCompare,
-    pub elements: [f32; 6],
-}
-
-impl PdfMatrix {
-    pub fn identity(pos: impl Into<PdfInputPositionNoCompare>) -> Self {
-        Self {
-            pos: pos.into(),
-            elements: [1.0, 0.0, 0.0, 1.0, 0.0, 0.0],
-        }
-    }
-    #[must_use]
-    pub fn mul(self, other: PdfMatrix, new_pos: impl Into<PdfInputPositionNoCompare>) -> Self {
-        let [la, lb, lc, ld, le, lf] = self.elements;
-        let [ra, rb, rc, rd, re, rf] = other.elements;
-        Self {
-            pos: new_pos.into(),
-            elements: [
-                lb * rc + la * ra,
-                lb * rd + la * rb,
-                ld * rc + lc * ra,
-                ld * rd + lc * rb,
-                re + lf * rc + le * ra,
-                rf + lf * rd + le * rb,
-            ],
-        }
-    }
-}
-
-impl fmt::Debug for PdfMatrix {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { pos, elements } = *self;
-        write!(f, "PdfMatrix(at {pos}, {elements:?})")
-    }
-}
-
-impl IsPdfNull for PdfMatrix {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfMatrix {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("matrix")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Ok(Self {
-            pos: object.pos().into(),
-            elements: PdfParse::parse(object)?,
-        })
-    }
-}
-
-impl PdfMatrix {
-    pub fn parse_flat(
-        a: PdfObject,
-        b: PdfObject,
-        c: PdfObject,
-        d: PdfObject,
-        e: PdfObject,
-        f: PdfObject,
-    ) -> Result<Self, PdfParseError> {
-        Ok(Self {
-            pos: a.pos().into(),
-            elements: [
-                PdfParse::parse(a)?,
-                PdfParse::parse(b)?,
-                PdfParse::parse(c)?,
-                PdfParse::parse(d)?,
-                PdfParse::parse(e)?,
-                PdfParse::parse(f)?,
-            ],
-        })
-    }
-}
-
-impl GetPdfInputPosition for PdfMatrix {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-#[derive(Copy, Clone, PartialEq)]
-pub struct PdfVec2D {
-    pub pos: PdfInputPositionNoCompare,
-    pub x: f32,
-    pub y: f32,
-}
-
-impl fmt::Debug for PdfVec2D {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self { pos, x, y } = *self;
-        write!(f, "PdfVec2D(at {pos}, {x}, {y})")
-    }
-}
-
-impl PdfVec2D {
-    pub fn parse(x: PdfObject, y: PdfObject) -> Result<Self, PdfParseError> {
-        Ok(Self {
-            pos: x.pos().into(),
-            x: PdfParse::parse(x)?,
-            y: PdfParse::parse(y)?,
-        })
-    }
-}
-
-impl GetPdfInputPosition for PdfVec2D {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct PdfRectangle {
-    /// the corner with the smaller x and y coordinates
-    smaller: PdfVec2D,
-    /// the corner with the larger x and y coordinates
-    larger: PdfVec2D,
-}
-
-impl PdfRectangle {
-    pub fn new(mut smaller: PdfVec2D, mut larger: PdfVec2D) -> Self {
-        // `pos` follows the `x` coordinate
-        if smaller.x.is_nan() {
-            smaller.pos = larger.pos;
-        } else if larger.x.is_nan() {
-            larger.pos = smaller.pos;
-        } else if larger.x < smaller.x {
-            std::mem::swap(&mut smaller.pos, &mut larger.pos);
-        }
-        Self {
-            smaller: PdfVec2D {
-                pos: smaller.pos,
-                x: smaller.x.min(larger.x),
-                y: smaller.y.min(larger.y),
-            },
-            larger: PdfVec2D {
-                pos: larger.pos,
-                x: smaller.x.max(larger.x),
-                y: smaller.y.max(larger.y),
-            },
-        }
-    }
-    /// return the corner with the smaller x and y coordinates
-    pub fn smaller(&self) -> PdfVec2D {
-        self.smaller
-    }
-    /// return the corner with the larger x and y coordinates
-    pub fn larger(&self) -> PdfVec2D {
-        self.larger
-    }
-    pub fn parse_flat(
-        lower_left_x: PdfObject,
-        lower_left_y: PdfObject,
-        upper_right_x: PdfObject,
-        upper_right_y: PdfObject,
-    ) -> Result<Self, PdfParseError> {
-        Ok(Self::new(
-            PdfVec2D::parse(lower_left_x, lower_left_y)?,
-            PdfVec2D::parse(upper_right_x, upper_right_y)?,
-        ))
-    }
-}
-
-impl GetPdfInputPosition for PdfRectangle {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.smaller.get_pdf_input_position()
-    }
-}
-
-impl IsPdfNull for PdfRectangle {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfRectangle {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("rectangle")
-    }
-
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let object = object.into();
-        let PdfObjectDirect::Array(array) = &object else {
-            return Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "rectangle",
-            });
-        };
-        let [lower_left_x, lower_left_y, upper_right_x, upper_right_y] = &**array.elements() else {
-            return Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "rectangle",
-            });
-        };
-        Self::parse_flat(
-            lower_left_x.clone(),
-            lower_left_y.clone(),
-            upper_right_x.clone(),
-            upper_right_y.clone(),
-        )
-    }
-}
-
-#[derive(Clone)]
-pub enum PdfFileSpecification {
-    String(PdfString),
-    Dictionary(PdfDictionary),
-}
-
-impl fmt::Debug for PdfFileSpecification {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::String(v) => v.fmt(f),
-            Self::Dictionary(v) => v.fmt(f),
-        }
-    }
-}
-
-impl IsPdfNull for PdfFileSpecification {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfFileSpecification {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("file specification")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        match PdfObjectDirect::from(object) {
-            PdfObjectDirect::String(v) => Ok(Self::String(v)),
-            PdfObjectDirect::Dictionary(v) => Ok(Self::Dictionary(v)),
-            object => Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "PdfFileSpecification",
-            }),
-        }
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfStreamDictionary<Rest = PdfDictionary> {
-        #[pdf(name = "Length")]
-        pub len: usize,
-        #[pdf(name = "Filter")]
-        pub filters: MaybeArray<PdfStreamFilter>,
-        #[pdf(name = "DecodeParms")]
-        pub decode_parms: MaybeArray<Option<PdfDictionary>>,
-        #[pdf(name = "F")]
-        pub file: Option<PdfFileSpecification>,
-        #[pdf(name = "FFilter")]
-        pub file_filters: MaybeArray<PdfStreamFilter>,
-        #[pdf(name = "FDecodeParms")]
-        pub file_decode_parms: MaybeArray<Option<PdfDictionary>>,
-        #[pdf(name = "DL")]
-        pub decoded_len: Option<usize>,
-        #[pdf(flatten)]
-        pub rest: Rest,
-    }
-}
-
-impl<Rest: fmt::Debug> fmt::Debug for PdfStreamDictionary<Rest> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|_state| {
-            let Self {
-                len,
-                filters,
-                decode_parms,
-                file,
-                file_filters,
-                file_decode_parms,
-                decoded_len,
-                rest,
-            } = self;
-            f.debug_struct("PdfStreamDictionary")
-                .field("len", len)
-                .field("filters", filters)
-                .field("decode_parms", decode_parms)
-                .field("file", file)
-                .field("file_filters", file_filters)
-                .field("file_decode_parms", file_decode_parms)
-                .field("decoded_len", decoded_len)
-                .field("rest", rest)
-                .finish()
-        })
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct PdfStreamDictionaryFiltersAndParms<'a> {
-    filters: std::iter::Enumerate<std::slice::Iter<'a, PdfStreamFilter>>,
-    decode_parms: &'a [Option<PdfDictionary>],
-}
-
-impl<'a> PdfStreamDictionaryFiltersAndParms<'a> {
-    fn item_helper(
-        filter: (usize, &'a PdfStreamFilter),
-        decode_parms: &'a [Option<PdfDictionary>],
-    ) -> (&'a PdfStreamFilter, &'a PdfDictionary) {
-        static EMPTY_DICTIONARY: OnceLock<PdfDictionary> = OnceLock::new();
-        let (index, filter) = filter;
-        (
-            filter,
-            match decode_parms.get(index) {
-                Some(Some(v)) => v,
-                _ => EMPTY_DICTIONARY.get_or_init(PdfDictionary::default),
-            },
-        )
-    }
-}
-
-impl<'a> Iterator for PdfStreamDictionaryFiltersAndParms<'a> {
-    type Item = (&'a PdfStreamFilter, &'a PdfDictionary);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.filters
-            .next()
-            .map(|filter| Self::item_helper(filter, self.decode_parms))
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.filters.size_hint()
-    }
-
-    fn nth(&mut self, n: usize) -> Option<Self::Item> {
-        self.filters
-            .nth(n)
-            .map(|filter| Self::item_helper(filter, self.decode_parms))
-    }
-
-    fn fold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        self.filters
-            .map(|filter| Self::item_helper(filter, self.decode_parms))
-            .fold(init, f)
-    }
-}
-
-impl<'a> FusedIterator for PdfStreamDictionaryFiltersAndParms<'a> {}
-
-impl<'a> ExactSizeIterator for PdfStreamDictionaryFiltersAndParms<'a> {}
-
-impl<'a> DoubleEndedIterator for PdfStreamDictionaryFiltersAndParms<'a> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.filters
-            .next_back()
-            .map(|filter| Self::item_helper(filter, self.decode_parms))
-    }
-
-    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
-        self.filters
-            .nth_back(n)
-            .map(|filter| Self::item_helper(filter, self.decode_parms))
-    }
-
-    fn rfold<B, F>(self, init: B, f: F) -> B
-    where
-        F: FnMut(B, Self::Item) -> B,
-    {
-        self.filters
-            .map(|filter| Self::item_helper(filter, self.decode_parms))
-            .rfold(init, f)
-    }
-}
-
-impl<Rest> PdfStreamDictionary<Rest> {
-    pub fn filters_and_parms<'a>(&'a self) -> PdfStreamDictionaryFiltersAndParms<'a> {
-        PdfStreamDictionaryFiltersAndParms {
-            filters: self.filters.iter().enumerate(),
-            decode_parms: &self.decode_parms,
-        }
-    }
-    pub fn file_filters_and_parms<'a>(&'a self) -> PdfStreamDictionaryFiltersAndParms<'a> {
-        PdfStreamDictionaryFiltersAndParms {
-            filters: self.file_filters.iter().enumerate(),
-            decode_parms: &self.file_decode_parms,
-        }
-    }
-}
-
-pub trait PdfStreamContents: Sized + fmt::Debug + 'static {
-    fn parse(
-        data: &[u8],
-        stream_pos: PdfInputPosition,
-        objects: Arc<PdfObjects>,
-    ) -> Result<Self, PdfParseError>;
-    fn parse_arc(
-        data: Arc<[u8]>,
-        stream_pos: PdfInputPosition,
-        objects: Arc<PdfObjects>,
-    ) -> Result<Self, PdfParseError> {
-        Self::parse(&*data, stream_pos, objects)
-    }
-}
-
-impl PdfStreamContents for Arc<[u8]> {
-    fn parse(
-        data: &[u8],
-        _stream_pos: PdfInputPosition,
-        _objects: Arc<PdfObjects>,
-    ) -> Result<Self, PdfParseError> {
-        Ok(Arc::from(data))
-    }
-    fn parse_arc(
-        data: Arc<[u8]>,
-        _stream_pos: PdfInputPosition,
-        _objects: Arc<PdfObjects>,
-    ) -> Result<Self, PdfParseError> {
-        Ok(data.clone())
-    }
-}
-
-#[derive(Clone)]
-pub struct PdfStream<Rest = PdfDictionary, Data: PdfStreamContents = Arc<[u8]>> {
-    pos: PdfInputPositionNoCompare,
-    objects: std::sync::Weak<PdfObjects>,
-    dictionary: PdfStreamDictionary<Rest>,
-    encoded_data: Arc<[u8]>,
-    decoded_data: Arc<OnceLock<Result<Data, PdfParseError>>>,
-}
-
-struct DumpBytes<'a>(&'a [u8]);
-
-impl<'a> fmt::Debug for DumpBytes<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
-impl fmt::Display for DumpBytes<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut first = true;
-        let mut fmt_chunk = |chunk: &[u8]| -> fmt::Result {
-            if first {
-                first = false;
-            } else {
-                f.write_str("\n")?;
-            }
-            write!(f, "\"{}\"", chunk.escape_ascii())
-        };
-        if self.0.is_empty() {
-            return fmt_chunk(self.0);
-        }
-        for chunk in self.0.chunks(32) {
-            fmt_chunk(chunk)?;
-        }
-        Ok(())
-    }
-}
-
-impl<Rest: fmt::Debug, Data: PdfStreamContents> fmt::Debug for PdfStream<Rest, Data> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        DagDebugState::scope(|state| {
-            state
-                .debug_or_id_with(
-                    &self.decoded_data,
-                    |_, f| {
-                        let Self {
-                            pos,
-                            objects: _,
-                            dictionary,
-                            encoded_data,
-                            decoded_data,
-                        } = self;
-                        let mut debug_struct = f.debug_struct("PdfStream");
-                        debug_struct.field("pos", pos);
-                        debug_struct.field("dictionary", dictionary);
-                        debug_struct.field("encoded_data", &DumpBytes(encoded_data));
-                        if let Some(decoded_data) = decoded_data.get() {
-                            match decoded_data {
-                                Ok(decoded_data) => {
-                                    if let Some(decoded_data) =
-                                        <dyn std::any::Any>::downcast_ref::<Arc<[u8]>>(decoded_data)
-                                    {
-                                        debug_struct
-                                            .field("decoded_data", &DumpBytes(&**decoded_data))
-                                    } else {
-                                        debug_struct.field("decoded_data", decoded_data)
-                                    }
-                                }
-                                Err(e) => debug_struct.field("decoded_data", &Err::<(), _>(e)),
-                            };
-                        } else {
-                            debug_struct.field("decoded_data", &format_args!("<not-yet-decoded>"));
-                        }
-                        debug_struct.finish()
-                    },
-                    |f| f.write_str("PdfStream(...)"),
-                )
-                .fmt(f)
-        })
-    }
-}
-
-impl<Rest, Data: PdfStreamContents> PdfStream<Rest, Data> {
-    pub fn new(
-        pos: impl Into<PdfInputPositionNoCompare>,
-        objects: &Arc<PdfObjects>,
-        dictionary: PdfStreamDictionary<Rest>,
-        encoded_data: Arc<[u8]>,
-    ) -> Self {
-        Self {
-            pos: pos.into(),
-            objects: Arc::downgrade(objects),
-            dictionary,
-            encoded_data,
-            decoded_data: Arc::new(OnceLock::new()),
-        }
-    }
-    pub fn dictionary(&self) -> &PdfStreamDictionary<Rest> {
-        &self.dictionary
-    }
-    pub fn encoded_data(&self) -> &Arc<[u8]> {
-        &self.encoded_data
-    }
-    fn try_decode_data(&self) -> Result<Data, PdfParseError> {
-        let Some(objects) = self.objects.upgrade() else {
-            panic!("PdfObjects is no longer available");
-        };
-        let dictionary = self.dictionary();
-        let (data, filters) = if let Some(file) = &dictionary.file {
-            todo!()
-        } else {
-            (&self.encoded_data, dictionary.filters_and_parms())
-        };
-        if filters.len() == 0 {
-            return Data::parse_arc(data.clone(), self.pos.0, objects);
-        }
-        let mut data: &[u8] = data;
-        let mut buffer;
-        for (filter, filter_parms) in filters {
-            buffer = filter.decode_stream_data(filter_parms.clone(), self.pos.0, &data)?;
-            data = &buffer;
-        }
-        Data::parse(data, self.pos.0, objects)
-    }
-    pub fn decoded_data(&self) -> &Result<Data, PdfParseError> {
-        self.decoded_data.get_or_init(|| self.try_decode_data())
-    }
-}
-
-impl<Rest, Data: PdfStreamContents> GetPdfInputPosition for PdfStream<Rest, Data> {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.pos.0
-    }
-}
-
-impl<Rest, Data: PdfStreamContents> IsPdfNull for PdfStream<Rest, Data> {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl<Rest: PdfParse, Data: PdfStreamContents> PdfParse for PdfStream<Rest, Data> {
-    fn type_name() -> Cow<'static, str> {
-        if TypeId::of::<Rest>() == TypeId::of::<PdfDictionary>() {
-            Cow::Borrowed("stream")
-        } else {
-            Cow::Owned(format!("PdfStream<{}>", Rest::type_name()))
-        }
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        match PdfObjectDirect::from(object) {
-            PdfObjectDirect::Stream(stream) => {
-                Ok(PdfStream {
-                    pos: stream.pos,
-                    dictionary: {
-                        let PdfStreamDictionary {
-                            len,
-                            filters,
-                            decode_parms,
-                            file,
-                            file_filters,
-                            file_decode_parms,
-                            decoded_len,
-                            rest,
-                        } = stream.dictionary;
-                        PdfStreamDictionary {
-                            len,
-                            filters,
-                            decode_parms,
-                            file,
-                            file_filters,
-                            file_decode_parms,
-                            decoded_len,
-                            rest: Rest::parse(rest.into())?,
-                        }
-                    },
-                    encoded_data: stream.encoded_data,
-                    decoded_data: if let Some(decoded_data) =
-                        <dyn std::any::Any>::downcast_ref(&stream.decoded_data)
-                    {
-                        Arc::clone(decoded_data)
-                    } else {
-                        let Some(objects) = stream.objects.upgrade() else {
-                            panic!("PdfObjects is no longer available");
-                        };
-                        Arc::new(
-                            stream
-                                .decoded_data
-                                .get()
-                                .cloned()
-                                .map(|data| {
-                                    OnceLock::from(data.and_then(|data| {
-                                        Data::parse_arc(data, stream.pos.0, objects)
-                                    }))
-                                })
-                                .unwrap_or_default(),
-                        )
-                    },
-                    objects: stream.objects,
-                })
-            }
-            object => Err(PdfParseError::InvalidType {
-                pos: object.get_pdf_input_position(),
-                ty: object.type_name(),
-                expected_ty: "stream",
-            }),
-        }
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Clone, Copy, Debug, Hash, Default, PartialEq, Eq, PartialOrd, Ord)]
-    pub enum PdfObjectStreamType {
-        #[pdf(name = "ObjStm")]
-        #[default]
-        ObjStm,
-    }
-}
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone)]
-    pub struct PdfObjectStreamDictionary {
-        #[pdf(name = Self::TYPE_NAME)]
-        pub ty: PdfObjectStreamType,
-        #[pdf(name = "N")]
-        pub n: usize,
-        #[pdf(name = "First")]
-        pub first: usize,
-        #[pdf(name = "Extends")]
-        pub extends: Option<PdfObjectIndirect>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl PdfObjectStreamDictionary {
-    pub const TYPE_NAME: &str = "Type";
-    pub(crate) fn parse_type_from_dictionary(
-        dictionary: &PdfDictionary,
-    ) -> Result<PdfObjectStreamType, PdfParseError> {
-        PdfParse::parse(dictionary.get_or_null(Self::TYPE_NAME.as_bytes()))
-    }
-}
diff --git a/src/pdf/parse.rs b/src/pdf/parse.rs
deleted file mode 100644
index 3f0ff21..0000000
--- a/src/pdf/parse.rs
+++ /dev/null
@@ -1,1341 +0,0 @@
-use crate::pdf::{
-    content_stream::{PdfOperator, PdfOperatorUnparsed},
-    object::{
-        IsPdfNull, MaybeArray, PdfInteger, PdfName, PdfNull, PdfNumber, PdfObject, PdfObjectDirect,
-        PdfObjectIdentifier, PdfObjectIndirect, PdfObjectNonNull,
-    },
-};
-use std::{any::Any, borrow::Cow, fmt, mem, num::NonZero, sync::Arc};
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct PdfInputPositionKnown {
-    pub pos: usize,
-    pub containing_streams_pos: Option<usize>,
-}
-
-impl fmt::Debug for PdfInputPositionKnown {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self, f)
-    }
-}
-
-impl fmt::Display for PdfInputPositionKnown {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let Self {
-            pos,
-            containing_streams_pos,
-        } = *self;
-        if let Some(containing_streams_pos) = containing_streams_pos {
-            write!(f, "{pos:#x} in stream at {containing_streams_pos:#x}")
-        } else {
-            write!(f, "{pos:#x}")
-        }
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
-pub struct PdfInputPosition(Option<PdfInputPositionKnown>);
-
-impl fmt::Debug for PdfInputPosition {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "at {self}")
-    }
-}
-
-impl fmt::Display for PdfInputPosition {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(pos) = self.0 {
-            pos.fmt(f)
-        } else {
-            f.write_str("<unknown>")
-        }
-    }
-}
-
-impl PdfInputPosition {
-    pub const fn new(pos: Option<PdfInputPositionKnown>) -> Self {
-        Self(pos)
-    }
-    pub const fn empty() -> PdfInputPosition {
-        Self(None)
-    }
-    pub const fn get(self) -> Option<PdfInputPositionKnown> {
-        self.0
-    }
-}
-
-pub trait GetPdfInputPosition {
-    fn get_pdf_input_position(&self) -> PdfInputPosition;
-}
-
-impl<T: ?Sized + GetPdfInputPosition> GetPdfInputPosition for &'_ T {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        T::get_pdf_input_position(self)
-    }
-}
-
-impl<T: ?Sized + GetPdfInputPosition> GetPdfInputPosition for &'_ mut T {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        T::get_pdf_input_position(self)
-    }
-}
-
-impl<T: ?Sized + GetPdfInputPosition> GetPdfInputPosition for Box<T> {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        T::get_pdf_input_position(self)
-    }
-}
-
-impl GetPdfInputPosition for PdfInputPosition {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        *self
-    }
-}
-
-impl GetPdfInputPosition for bool {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        PdfInputPosition::empty()
-    }
-}
-
-impl GetPdfInputPosition for i128 {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        PdfInputPosition::empty()
-    }
-}
-
-impl GetPdfInputPosition for f64 {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        PdfInputPosition::empty()
-    }
-}
-
-#[derive(Clone, Copy, Default)]
-pub struct PdfInputPositionNoCompare(pub PdfInputPosition);
-
-impl PdfInputPositionNoCompare {
-    pub const fn empty() -> Self {
-        Self(PdfInputPosition::empty())
-    }
-    pub const fn new(pos: Option<PdfInputPositionKnown>) -> Self {
-        Self(PdfInputPosition::new(pos))
-    }
-}
-
-impl GetPdfInputPosition for PdfInputPositionNoCompare {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        self.0
-    }
-}
-
-impl From<PdfInputPosition> for PdfInputPositionNoCompare {
-    fn from(value: PdfInputPosition) -> Self {
-        Self(value)
-    }
-}
-
-impl fmt::Debug for PdfInputPositionNoCompare {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl fmt::Display for PdfInputPositionNoCompare {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl Ord for PdfInputPositionNoCompare {
-    fn cmp(&self, _other: &Self) -> std::cmp::Ordering {
-        std::cmp::Ordering::Equal
-    }
-}
-
-impl PartialOrd for PdfInputPositionNoCompare {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl std::hash::Hash for PdfInputPositionNoCompare {
-    fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {
-        // don't hash anything since Self always compares equal
-    }
-}
-
-impl Eq for PdfInputPositionNoCompare {}
-
-impl PartialEq for PdfInputPositionNoCompare {
-    fn eq(&self, _other: &Self) -> bool {
-        true
-    }
-}
-
-#[derive(Debug, Clone)]
-#[non_exhaustive]
-pub enum PdfParseError {
-    Custom(String),
-    InvalidType {
-        pos: PdfInputPosition,
-        ty: &'static str,
-        expected_ty: &'static str,
-    },
-    InvalidName {
-        pos: PdfInputPosition,
-        name: PdfName,
-        expected_ty: &'static str,
-    },
-    NotAPdfFile,
-    TruncatedFile {
-        pos: PdfInputPosition,
-    },
-    InvalidObjectNumber {
-        pos: PdfInputPosition,
-    },
-    InvalidGenerationNumber {
-        pos: PdfInputPosition,
-    },
-    InvalidNumber {
-        pos: PdfInputPosition,
-    },
-    InvalidStringEscape {
-        pos: PdfInputPosition,
-    },
-    InvalidHexStringDigit {
-        pos: PdfInputPosition,
-    },
-    DuplicateIndirectObjectDefinition {
-        pos: PdfInputPosition,
-        id: PdfObjectIdentifier,
-    },
-    MissingObj {
-        pos: PdfInputPosition,
-    },
-    MissingEndObj {
-        pos: PdfInputPosition,
-    },
-    InvalidDictionaryClosingDoubleRAngle {
-        pos: PdfInputPosition,
-    },
-    DuplicateDictionaryKey {
-        pos: PdfInputPosition,
-        name: PdfName,
-    },
-    InvalidNameEscape {
-        pos: PdfInputPosition,
-    },
-    InvalidOrMissingEolAfterStreamKeyword {
-        pos: PdfInputPosition,
-    },
-    MissingEndStreamKeyword {
-        pos: PdfInputPosition,
-    },
-    IntegerOutOfRange {
-        pos: PdfInputPosition,
-    },
-    MissingTrailer {
-        pos: PdfInputPosition,
-    },
-    WrongArrayLength {
-        pos: PdfInputPosition,
-        len: usize,
-        expected_len: usize,
-    },
-    MissingStartXRefKeyword {
-        pos: PdfInputPosition,
-    },
-    MissingStartXRefValue {
-        pos: PdfInputPosition,
-    },
-    MissingEofComment {
-        pos: PdfInputPosition,
-    },
-    UnexpectedByte {
-        pos: PdfInputPosition,
-        byte: u8,
-    },
-    InvalidStartXRefValue {
-        pos: PdfInputPosition,
-        start_xref: usize,
-    },
-    UnknownStreamFilter {
-        pos: PdfInputPosition,
-        filter: PdfName,
-    },
-    StreamFilterError {
-        pos: PdfInputPosition,
-        filter: PdfName,
-        error: String,
-    },
-    StreamNotAllowedHere {
-        pos: PdfInputPosition,
-    },
-    OperatorNotAllowedHere {
-        operator: PdfOperatorUnparsed,
-    },
-    MissingOperator {
-        pos: PdfInputPosition,
-    },
-    OperatorHasTooFewOperands {
-        operator: PdfOperator,
-    },
-    OperatorHasTooManyOperands {
-        operator: PdfOperator,
-    },
-    CantRestoreGraphicsStateWithEmptyStack {
-        pos: PdfInputPosition,
-    },
-    FontResourceNotFound {
-        pos: PdfInputPosition,
-        font: PdfName,
-    },
-    MissingBeginTextOperator {
-        pos: PdfInputPosition,
-    },
-    MissingSetFontOperator {
-        pos: PdfInputPosition,
-    },
-    InvalidTokenInToUnicodeStream {
-        pos: PdfInputPosition,
-        token: String,
-    },
-    InvalidUtf16 {
-        pos: PdfInputPosition,
-    },
-    InvalidFontFirstLastCharWidths {
-        pos: PdfInputPosition,
-    },
-}
-
-impl From<std::convert::Infallible> for PdfParseError {
-    fn from(value: std::convert::Infallible) -> Self {
-        match value {}
-    }
-}
-
-impl<'a> From<&'a Self> for PdfParseError {
-    fn from(value: &'a Self) -> Self {
-        value.clone()
-    }
-}
-
-impl GetPdfInputPosition for PdfParseError {
-    fn get_pdf_input_position(&self) -> PdfInputPosition {
-        match *self {
-            PdfParseError::Custom(_) | PdfParseError::NotAPdfFile => PdfInputPosition::empty(),
-            PdfParseError::InvalidType { pos, .. }
-            | PdfParseError::InvalidName { pos, .. }
-            | PdfParseError::TruncatedFile { pos }
-            | PdfParseError::InvalidObjectNumber { pos }
-            | PdfParseError::InvalidGenerationNumber { pos }
-            | PdfParseError::InvalidNumber { pos }
-            | PdfParseError::InvalidStringEscape { pos }
-            | PdfParseError::InvalidHexStringDigit { pos }
-            | PdfParseError::DuplicateIndirectObjectDefinition { pos, .. }
-            | PdfParseError::MissingObj { pos }
-            | PdfParseError::MissingEndObj { pos }
-            | PdfParseError::InvalidDictionaryClosingDoubleRAngle { pos }
-            | PdfParseError::DuplicateDictionaryKey { pos, .. }
-            | PdfParseError::InvalidNameEscape { pos }
-            | PdfParseError::InvalidOrMissingEolAfterStreamKeyword { pos }
-            | PdfParseError::MissingEndStreamKeyword { pos }
-            | PdfParseError::IntegerOutOfRange { pos }
-            | PdfParseError::MissingTrailer { pos }
-            | PdfParseError::WrongArrayLength { pos, .. }
-            | PdfParseError::MissingStartXRefKeyword { pos }
-            | PdfParseError::MissingStartXRefValue { pos }
-            | PdfParseError::MissingEofComment { pos }
-            | PdfParseError::UnexpectedByte { pos, .. }
-            | PdfParseError::InvalidStartXRefValue { pos, .. }
-            | PdfParseError::UnknownStreamFilter { pos, .. }
-            | PdfParseError::StreamFilterError { pos, .. }
-            | PdfParseError::StreamNotAllowedHere { pos }
-            | PdfParseError::MissingOperator { pos }
-            | PdfParseError::CantRestoreGraphicsStateWithEmptyStack { pos }
-            | PdfParseError::FontResourceNotFound { pos, .. }
-            | PdfParseError::MissingBeginTextOperator { pos }
-            | PdfParseError::MissingSetFontOperator { pos }
-            | PdfParseError::InvalidTokenInToUnicodeStream { pos, .. }
-            | PdfParseError::InvalidUtf16 { pos }
-            | PdfParseError::InvalidFontFirstLastCharWidths { pos } => pos,
-            PdfParseError::OperatorNotAllowedHere { ref operator } => operator.pos(),
-            PdfParseError::OperatorHasTooFewOperands { ref operator }
-            | PdfParseError::OperatorHasTooManyOperands { ref operator } => operator.pos(),
-        }
-    }
-}
-
-impl fmt::Display for PdfParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match *self {
-            PdfParseError::Custom(ref v) => f.write_str(v),
-            PdfParseError::InvalidType {
-                pos,
-                ty,
-                expected_ty,
-            } => {
-                write!(
-                    f,
-                    "at {pos}: invalid type: expected {expected_ty}, got {ty}"
-                )
-            }
-            PdfParseError::InvalidName {
-                pos,
-                ref name,
-                expected_ty,
-            } => {
-                write!(
-                    f,
-                    "at {pos}: invalid name: expected a(n) {expected_ty}, got {name}"
-                )
-            }
-            PdfParseError::NotAPdfFile => f.write_str("Not a PDF file"),
-            PdfParseError::TruncatedFile { pos } => {
-                write!(f, "at {pos}: PDF file is truncated too early")
-            }
-            PdfParseError::InvalidObjectNumber { pos } => {
-                write!(f, "at {pos}: PDF object number is invalid")
-            }
-            PdfParseError::InvalidGenerationNumber { pos } => {
-                write!(
-                    f,
-                    "at {pos}: PDF object identifier's generation number is invalid"
-                )
-            }
-            PdfParseError::InvalidNumber { pos } => {
-                write!(f, "at {pos}: invalid number")
-            }
-            PdfParseError::InvalidStringEscape { pos } => {
-                write!(f, "at {pos}: invalid string escape")
-            }
-            PdfParseError::InvalidHexStringDigit { pos } => {
-                write!(f, "at {pos}: invalid hex string digit")
-            }
-            PdfParseError::DuplicateIndirectObjectDefinition { pos, id } => {
-                write!(f, "at {pos}: duplicate indirect object definition: {id:?}")
-            }
-            PdfParseError::MissingObj { pos } => {
-                write!(
-                    f,
-                    "at {pos}: indirect object definition is missing `obj` keyword"
-                )
-            }
-            PdfParseError::MissingEndObj { pos } => {
-                write!(
-                    f,
-                    "at {pos}: indirect object definition is missing `endobj` keyword"
-                )
-            }
-            PdfParseError::InvalidDictionaryClosingDoubleRAngle { pos } => {
-                write!(f, "at {pos}: dictionary has an invalid closing `>>` symbol")
-            }
-            PdfParseError::DuplicateDictionaryKey { pos, ref name } => {
-                write!(f, "at {pos}: duplicate dictionary key: {name}")
-            }
-            PdfParseError::InvalidNameEscape { pos } => {
-                write!(f, "at {pos}: invalid name escape")
-            }
-            PdfParseError::InvalidOrMissingEolAfterStreamKeyword { pos } => {
-                write!(
-                    f,
-                    "at {pos}: invalid or missing end-of-line after `stream` keyword"
-                )
-            }
-            PdfParseError::MissingEndStreamKeyword { pos } => {
-                write!(f, "at {pos}: missing `endstream` keyword")
-            }
-            PdfParseError::IntegerOutOfRange { pos } => {
-                write!(f, "at {pos}: integer out of range")
-            }
-            PdfParseError::MissingTrailer { pos } => {
-                write!(f, "at {pos}: missing `trailer` keyword")
-            }
-            PdfParseError::WrongArrayLength {
-                pos,
-                len,
-                expected_len,
-            } => {
-                write!(
-                    f,
-                    "at {pos}: wrong array length: expected {expected_len}, got {len}"
-                )
-            }
-            PdfParseError::MissingStartXRefKeyword { pos } => {
-                write!(f, "at {pos}: missing `startxref` keyword")
-            }
-            PdfParseError::MissingStartXRefValue { pos } => {
-                write!(f, "at {pos}: missing `startxref` value")
-            }
-            PdfParseError::MissingEofComment { pos } => {
-                write!(f, "at {pos}: missing `%%EOF` comment")
-            }
-            PdfParseError::UnexpectedByte { pos, byte } => {
-                write!(f, "at {pos}: unexpected byte '{}'", byte.escape_ascii())
-            }
-            PdfParseError::InvalidStartXRefValue { pos, start_xref } => {
-                write!(
-                    f,
-                    "at {pos}: invalid `startxref` value: {start_xref} ({start_xref:#x})"
-                )
-            }
-            PdfParseError::UnknownStreamFilter { pos, ref filter } => {
-                write!(f, "at {pos}: unknown stream filter: {filter}")
-            }
-            PdfParseError::StreamFilterError {
-                pos,
-                ref filter,
-                ref error,
-            } => {
-                write!(f, "at {pos}: stream filter {filter} error: {error}")
-            }
-            PdfParseError::StreamNotAllowedHere { pos } => {
-                write!(f, "at {pos}: stream not allowed here")
-            }
-            PdfParseError::OperatorNotAllowedHere { ref operator } => {
-                write!(
-                    f,
-                    "at {}: operator not allowed here: {}",
-                    operator.pos(),
-                    operator.bytes_debug()
-                )
-            }
-            PdfParseError::MissingOperator { pos } => {
-                write!(f, "at {pos}: missing operator")
-            }
-            PdfParseError::OperatorHasTooFewOperands { ref operator } => {
-                write!(
-                    f,
-                    "at {}: operator has too few operands: {operator:?}",
-                    operator.pos(),
-                )
-            }
-            PdfParseError::OperatorHasTooManyOperands { ref operator } => {
-                write!(
-                    f,
-                    "at {}: operator has too many operands: {operator:?}",
-                    operator.pos(),
-                )
-            }
-            PdfParseError::CantRestoreGraphicsStateWithEmptyStack { pos } => {
-                write!(
-                    f,
-                    "at {pos}: can't restore graphics state when the graphics state stack is empty"
-                )
-            }
-            PdfParseError::FontResourceNotFound { pos, ref font } => {
-                write!(f, "at {pos}: font resource not found: {font:?}")
-            }
-            PdfParseError::MissingBeginTextOperator { pos } => {
-                write!(
-                    f,
-                    "at {pos}: missing begin text `BT` operator before this text operator"
-                )
-            }
-            PdfParseError::MissingSetFontOperator { pos } => {
-                write!(
-                    f,
-                    "at {pos}: missing set font `Tf` operator before this text showing operator"
-                )
-            }
-            PdfParseError::InvalidTokenInToUnicodeStream { pos, ref token } => {
-                write!(f, "at {pos}: invalid token in ToUnicode stream: {token}")
-            }
-            PdfParseError::InvalidUtf16 { pos } => {
-                write!(f, "at {pos}: invalid UTF-16")
-            }
-            PdfParseError::InvalidFontFirstLastCharWidths { pos } => {
-                write!(f, "at {pos}: invalid font first/last_char and/or widths")
-            }
-        }
-    }
-}
-
-impl std::error::Error for PdfParseError {}
-
-pub trait PdfParse: Sized + 'static + IsPdfNull {
-    fn type_name() -> Cow<'static, str>;
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError>;
-    fn parse_option(object: PdfObject) -> Result<Option<Self>, PdfParseError> {
-        match object {
-            PdfObject::Null(_) => Ok(None),
-            PdfObject::Indirect(ref v) if v.get().is_null() => Ok(None),
-            PdfObject::Boolean(_)
-            | PdfObject::Integer(_)
-            | PdfObject::Real(_)
-            | PdfObject::String(_)
-            | PdfObject::Name(_)
-            | PdfObject::Array(_)
-            | PdfObject::Dictionary(_)
-            | PdfObject::Stream(_)
-            | PdfObject::Indirect(_) => Self::parse(object).map(Some),
-        }
-    }
-}
-
-impl<T: PdfParse> PdfParse for Option<T> {
-    fn type_name() -> Cow<'static, str> {
-        T::type_name()
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        T::parse_option(object)
-    }
-    fn parse_option(object: PdfObject) -> Result<Option<Self>, PdfParseError> {
-        if matches!(object, PdfObject::Null(_)) {
-            Ok(None)
-        } else {
-            Self::parse(object).map(Some)
-        }
-    }
-}
-
-macro_rules! impl_pdf_parse_prim_int {
-    ($ty:ident) => {
-        impl IsPdfNull for $ty {
-            fn is_pdf_null(&self) -> bool {
-                false
-            }
-        }
-        impl PdfParse for $ty {
-            fn type_name() -> Cow<'static, str> {
-                Cow::Borrowed(stringify!($ty))
-            }
-            fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-                let v: PdfInteger = PdfParse::parse(object)?;
-                v.value()
-                    .try_into()
-                    .map_err(|_| PdfParseError::IntegerOutOfRange { pos: v.pos() })
-            }
-        }
-        impl IsPdfNull for NonZero<$ty> {
-            fn is_pdf_null(&self) -> bool {
-                false
-            }
-        }
-        impl PdfParse for NonZero<$ty> {
-            fn type_name() -> Cow<'static, str> {
-                Cow::Borrowed(concat!("NonZero<", stringify!($ty), ">"))
-            }
-            fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-                let v: PdfInteger = PdfParse::parse(object)?;
-                v.value()
-                    .try_into()
-                    .ok()
-                    .and_then(NonZero::new)
-                    .ok_or(PdfParseError::IntegerOutOfRange { pos: v.pos() })
-            }
-        }
-    };
-}
-
-impl_pdf_parse_prim_int!(u8);
-impl_pdf_parse_prim_int!(i8);
-impl_pdf_parse_prim_int!(u16);
-impl_pdf_parse_prim_int!(i16);
-impl_pdf_parse_prim_int!(u32);
-impl_pdf_parse_prim_int!(i32);
-impl_pdf_parse_prim_int!(u64);
-impl_pdf_parse_prim_int!(i64);
-impl_pdf_parse_prim_int!(u128);
-impl_pdf_parse_prim_int!(usize);
-impl_pdf_parse_prim_int!(isize);
-
-impl IsPdfNull for i128 {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for i128 {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("i128")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let v: PdfInteger = PdfParse::parse(object)?;
-        Ok(v.value().into())
-    }
-}
-
-impl IsPdfNull for NonZero<i128> {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for NonZero<i128> {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("NonZero<i128>")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let v: PdfInteger = PdfParse::parse(object)?;
-        NonZero::new(v.value().into()).ok_or(PdfParseError::IntegerOutOfRange { pos: v.pos() })
-    }
-}
-
-impl IsPdfNull for f64 {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for f64 {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("f64")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Ok(<PdfNumber as PdfParse>::parse(object)?.as_f64())
-    }
-}
-
-impl IsPdfNull for f32 {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for f32 {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("f32")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Ok(<PdfNumber as PdfParse>::parse(object)?.as_f32())
-    }
-}
-
-impl IsPdfNull for PdfNull {
-    fn is_pdf_null(&self) -> bool {
-        true
-    }
-}
-
-impl PdfParse for PdfNull {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("null")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        match PdfObjectDirect::from(object) {
-            PdfObjectDirect::Null(v) => Ok(v),
-            object => Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "null",
-            }),
-        }
-    }
-    fn parse_option(object: PdfObject) -> Result<Option<Self>, PdfParseError> {
-        Self::parse(object).map(Some)
-    }
-}
-
-impl PdfParse for PdfObjectNonNull {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("non-null")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Option::<PdfObjectNonNull>::from(object).ok_or(PdfParseError::InvalidType {
-            pos: PdfInputPosition::empty(),
-            ty: "null",
-            expected_ty: "non-null",
-        })
-    }
-    fn parse_option(object: PdfObject) -> Result<Option<Self>, PdfParseError> {
-        Ok(object.into())
-    }
-}
-
-impl PdfParse for PdfObjectDirect {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("direct object")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Ok(object.into())
-    }
-}
-
-impl PdfParse for PdfObject {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("object")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        Ok(object)
-    }
-}
-
-impl IsPdfNull for PdfObjectIndirect {
-    fn is_pdf_null(&self) -> bool {
-        self.get().is_pdf_null()
-    }
-}
-
-impl PdfParse for PdfObjectIndirect {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("indirect object")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        match object {
-            PdfObject::Indirect(v) => Ok(v),
-            _ => Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "indirect object",
-            }),
-        }
-    }
-    fn parse_option(object: PdfObject) -> Result<Option<Self>, PdfParseError> {
-        match object {
-            PdfObject::Indirect(v) => Ok(Some(v)),
-            PdfObject::Null(_) => Ok(None),
-            _ => Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "indirect object",
-            }),
-        }
-    }
-}
-
-impl<T, const N: usize> IsPdfNull for [T; N] {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl<T: PdfParse, const N: usize> PdfParse for [T; N] {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Owned(format!("[{}; {N}]", T::type_name()))
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        match PdfObjectDirect::from(object) {
-            PdfObjectDirect::Array(array) => {
-                let array_pos = array.pos();
-                let elements = array.into_elements();
-                let mut elements: Arc<[PdfObject; N]> =
-                    elements.try_into().map_err(|elements: Arc<[PdfObject]>| {
-                        PdfParseError::WrongArrayLength {
-                            pos: array_pos,
-                            len: elements.len(),
-                            expected_len: N,
-                        }
-                    })?;
-                let elements: Box<[T]> = if let Some(elements) = Arc::get_mut(&mut elements) {
-                    Result::from_iter(elements.iter_mut().map(|v| T::parse(mem::take(v))))?
-                } else {
-                    Result::from_iter(elements.iter().map(|v| T::parse(v.clone())))?
-                };
-                Ok(*Box::<[T; N]>::try_from(elements)
-                    .ok()
-                    .expect("already checked length"))
-            }
-            object => Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "array",
-            }),
-        }
-    }
-}
-
-impl<T> IsPdfNull for Arc<[T]> {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl<T: PdfParse> PdfParse for Arc<[T]> {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Owned(format!("Arc<[{}]>", T::type_name()))
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        match PdfObjectDirect::from(object) {
-            PdfObjectDirect::Array(array) => {
-                let mut elements = array.into_elements();
-                if let Some(retval) = <dyn Any>::downcast_ref::<Self>(&elements) {
-                    return Ok(retval.clone());
-                }
-                if let Some(elements) = Arc::get_mut(&mut elements) {
-                    Result::from_iter(elements.iter_mut().map(|v| T::parse(mem::take(v))))
-                } else {
-                    Result::from_iter(elements.iter().map(|v| T::parse(v.clone())))
-                }
-            }
-            PdfObjectDirect::Null(_) => Ok(Self::default()),
-            object => Err(PdfParseError::InvalidType {
-                pos: object.pos(),
-                ty: object.type_name(),
-                expected_ty: "array",
-            }),
-        }
-    }
-}
-
-impl<T: IsPdfNull> IsPdfNull for Arc<T> {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl<T: PdfParse + Send + Sync> PdfParse for Arc<T> {
-    fn type_name() -> Cow<'static, str> {
-        T::type_name()
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        if let PdfObject::Indirect(indirect) = object {
-            indirect.cache_parse(|object| T::parse(object.into()).map(Arc::new))
-        } else {
-            T::parse(object).map(Arc::new)
-        }
-    }
-    fn parse_option(object: PdfObject) -> Result<Option<Self>, PdfParseError> {
-        if let PdfObject::Indirect(indirect) = object {
-            match indirect.cache_parse(|object| match T::parse_option(object.into()) {
-                Ok(Some(v)) => Ok(Arc::new(v)),
-                Ok(None) => Err(None),
-                Err(e) => Err(Some(e)),
-            }) {
-                Ok(v) => Ok(Some(v)),
-                Err(None) => Ok(None),
-                Err(Some(e)) => Err(e),
-            }
-        } else {
-            Ok(T::parse_option(object)?.map(Arc::new))
-        }
-    }
-}
-
-impl<T> IsPdfNull for MaybeArray<T> {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl<T: PdfParse> PdfParse for MaybeArray<T> {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Owned(format!("MaybeArray<{}>", T::type_name()))
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        match PdfObjectDirect::from(object) {
-            PdfObjectDirect::Null(_) => Ok(Self::default()),
-            PdfObjectDirect::Array(object) => Ok(Self(PdfParse::parse(object.into())?)),
-            object => Ok(Self(Arc::new([PdfParse::parse(object.into())?]))),
-        }
-    }
-}
-
-#[macro_export]
-macro_rules! pdf_parse {
-    (
-        #[pdf $($struct_pdf_meta:tt)*]
-        $(#[$($struct_meta:tt)*])*
-        $struct_vis:vis struct $Struct:ident$(<$($StructParam:ident $(: $StructBound:tt)? $(= $StructParamDefault:ty)?),* $(,)?>)? {
-            $(#[pdf $($pdf_meta:tt)*]
-            $(#[$($field_meta:tt)*])*
-            $field_vis:vis $field_name:ident: $field_ty:ty,)*
-        }
-    ) => {
-        $(#[$($struct_meta)*])*
-        $struct_vis struct $Struct$(<$($StructParam $(: $StructBound)? $(= $StructParamDefault)?),*>)? {
-            $($(#[$($field_meta)*])*
-            $field_vis $field_name: $field_ty,)*
-        }
-
-        $crate::pdf::parse::pdf_parse! {
-            @impl
-            #[pdf $($struct_pdf_meta)*]
-            struct $Struct$(<$($StructParam $(: $StructBound)?),*>)? {
-                $(#[pdf $($pdf_meta)*]
-                $(#[$($field_meta)*])*
-                $field_name: $field_ty,)*
-            }
-        }
-    };
-    (
-        @impl
-        #[pdf(transparent)]
-        struct $Struct:ident$(<$($StructParam:ident $(: $StructBound:tt)?),* $(,)?>)? {
-            #[pdf]
-            $(#[$($field_meta:tt)*])*
-            $field_name:ident: $field_ty:ty,
-            $(#[pdf]
-            $(#[$($phantom_meta:tt)*])*
-            $phantom_name:ident: PhantomData<$phantom_ty:ty>,)?
-        }
-    ) => {
-        impl$(<$($StructParam: $crate::pdf::parse::IsPdfNull $(+ $StructBound)?),*>)? $crate::pdf::object::IsPdfNull for $Struct$(<$($StructParam),*>)? {
-            fn is_pdf_null(&self) -> $crate::__std::primitive::bool {
-                <$field_ty as $crate::pdf::object::IsPdfNull>::is_pdf_null(&self.$field_name)
-            }
-        }
-        impl$(<$($StructParam: $crate::pdf::parse::PdfParse $(+ $StructBound)?),*>)? $crate::pdf::parse::PdfParse for $Struct$(<$($StructParam),*>)? {
-            fn type_name() -> $crate::__std::borrow::Cow<'static, $crate::__std::primitive::str> {
-                let args: &[$crate::__std::borrow::Cow<'static, $crate::__std::primitive::str>] = &[
-                    $($(<$StructParam as $crate::pdf::parse::PdfParse>::type_name()),*)?
-                ];
-                if args.is_empty() {
-                    $crate::__std::borrow::Cow::Borrowed($crate::__std::stringify!($Struct))
-                } else {
-                    let mut retval = $crate::__std::string::String::new();
-                    retval.push_str($crate::__std::stringify!($Struct));
-                    retval.push_str("<");
-                    let mut first = true;
-                    for arg in args {
-                        if first {
-                            first = false;
-                        } else {
-                            retval.push_str(", ");
-                        }
-                        retval.push_str(arg);
-                    }
-                    retval.push_str(">");
-                    $crate::__std::borrow::Cow::Owned(retval)
-                }
-            }
-            fn parse(object: $crate::pdf::object::PdfObject) -> $crate::__std::result::Result<Self, $crate::pdf::parse::PdfParseError> {
-                $crate::__std::result::Result::Ok(Self {
-                    $field_name: <$field_ty as $crate::pdf::parse::PdfParse>::parse(object)?,
-                    $($phantom_name: $crate::__std::marker::PhantomData,)?
-                })
-            }
-        }
-    };
-    (
-        @impl
-        #[pdf$(($(validate = |$pos:pat_param| $validate:expr)?))?]
-        struct $Struct:ident$(<$($StructParam:ident $(: $StructBound:tt)?),* $(,)?>)? {
-            $($(#[$($field_meta:tt)*])*
-            $field_name:ident: $field_ty:ty,)*
-        }
-    ) => {
-        impl$(<$($StructParam $(: $StructBound)?),*>)? $crate::pdf::object::IsPdfNull for $Struct$(<$($StructParam),*>)? {
-            fn is_pdf_null(&self) -> $crate::__std::primitive::bool {
-                false
-            }
-        }
-        impl$(<$($StructParam: $crate::pdf::parse::PdfParse $(+ $StructBound)?),*>)? $crate::pdf::parse::PdfParse for $Struct$(<$($StructParam),*>)? {
-            fn type_name() -> $crate::__std::borrow::Cow<'static, $crate::__std::primitive::str> {
-                let args: &[$crate::__std::borrow::Cow<'static, $crate::__std::primitive::str>] = &[
-                    $($(<$StructParam as $crate::pdf::parse::PdfParse>::type_name()),*)?
-                ];
-                if args.is_empty() {
-                    $crate::__std::borrow::Cow::Borrowed($crate::__std::stringify!($Struct))
-                } else {
-                    let mut retval = $crate::__std::string::String::new();
-                    retval.push_str($crate::__std::stringify!($Struct));
-                    retval.push_str("<");
-                    let mut first = true;
-                    for arg in args {
-                        if first {
-                            first = false;
-                        } else {
-                            retval.push_str(", ");
-                        }
-                        retval.push_str(arg);
-                    }
-                    retval.push_str(">");
-                    $crate::__std::borrow::Cow::Owned(retval)
-                }
-            }
-            fn parse(object: $crate::pdf::object::PdfObject) -> $crate::__std::result::Result<Self, $crate::pdf::parse::PdfParseError> {
-                let object = $crate::__std::convert::From::from(object);
-                let $crate::pdf::object::PdfObjectDirect::Dictionary(object) = object else {
-                    return $crate::__std::result::Result::Err($crate::pdf::parse::PdfParseError::InvalidType {
-                        pos: object.pos(),
-                        ty: object.type_name(),
-                        expected_ty: $crate::__std::stringify!($Struct),
-                    });
-                };
-                let pos = object.pos();
-                let mut object = object.into_fields();
-                let object_mut = $crate::__std::sync::Arc::make_mut(&mut object);
-                let _ = object_mut;
-                $($crate::pdf::parse::pdf_parse! {
-                    @impl_struct_field(pos, object, object_mut)
-                    []
-                    $(#[$($field_meta)*])*
-                    $field_name: $field_ty
-                })*
-                $($({
-                    let $pos = pos;
-                    $validate
-                })?)?
-                $crate::__std::result::Result::Ok(Self {
-                    $($field_name,)*
-                })
-            }
-        }
-    };
-    (
-        @impl_struct_field($pos:ident, $object:ident, $object_mut:ident)
-        [$(#[$($prev_field_meta:tt)*])*]
-        #[pdf $pdf_meta:tt]
-        $(#[$($field_meta:tt)*])*
-        $field_name:ident: $field_ty:ty
-    ) => {
-        $crate::pdf::parse::pdf_parse! {
-            @impl_struct_field($pos, $object, $object_mut, pdf $pdf_meta)
-            [$(#[$($prev_field_meta)*])*]
-            $(#[$($field_meta)*])*
-            $field_name: $field_ty
-        }
-    };
-    (
-        @impl_struct_field($pos:ident, $object:ident, $object_mut:ident $($pdf_meta:tt)*)
-        [$(#[$($prev_field_meta:tt)*])*]
-        #[$($next_field_meta:tt)*]
-        $(#[$($field_meta:tt)*])*
-        $field_name:ident: $field_ty:ty
-    ) => {
-        $crate::pdf::parse::pdf_parse! {
-            @impl_struct_field($pos, $object, $object_mut $($pdf_meta)*)
-            [$(#[$($prev_field_meta)*])* #[$($next_field_meta)*]]
-            $(#[$($field_meta)*])*
-            $field_name: $field_ty
-        }
-    };
-    (
-        @impl_struct_field($pos:ident, $object:ident, $object_mut:ident, pdf(flatten))
-        [$(#[$($field_meta:tt)*])*]
-        $field_name:ident: $field_ty:ty
-    ) => {
-        #[allow(unused_mut)]
-        let mut $field_name = <$field_ty as $crate::pdf::parse::PdfParse>::parse(
-            $crate::pdf::object::PdfObject::Dictionary(
-                $crate::pdf::object::PdfDictionary::from_fields($pos, $object),
-            ),
-        )?;
-    };
-    (
-        @impl_struct_field($pos:ident, $object:ident, $object_mut:ident, pdf(name = $name:expr))
-        [$(#[$($field_meta:tt)*])*]
-        $field_name:ident: $field_ty:ty
-    ) => {
-        let $field_name = $crate::__std::convert::AsRef::<[$crate::__std::primitive::u8]>::as_ref($name);
-        #[allow(unused_mut)]
-        let mut $field_name = <$field_ty as $crate::pdf::parse::PdfParse>::parse(
-            $object_mut
-                .remove($field_name)
-                .unwrap_or($crate::pdf::object::PdfObject::Null($crate::pdf::object::PdfNull::new($pos))),
-        )?;
-    };
-    (
-        #[pdf $($enum_pdf_meta:tt)*]
-        $(#[$($enum_meta:tt)*])*
-        $enum_vis:vis enum $Enum:ident {
-            $(#[pdf $($pdf_meta:tt)*]
-            $(#[$($variant_meta:tt)*])*
-            $VariantName:ident $(($($variant_paren_body:tt)*))? $({$($variant_brace_body:tt)*})?,)*
-        }
-    ) => {
-        $(#[$($enum_meta)*])*
-        $enum_vis enum $Enum {
-            $($(#[$($variant_meta)*])*
-            $VariantName $(($($variant_paren_body)*))? $({$($variant_brace_body)*})?,)*
-        }
-
-        $crate::pdf::parse::pdf_parse! {
-            @impl
-            #[pdf $($enum_pdf_meta)*]
-            $(#[$($enum_meta)*])*
-            enum $Enum {
-                $(#[pdf $($pdf_meta)*]
-                $(#[$($variant_meta)*])*
-                $VariantName $(($($variant_paren_body)*))? $({$($variant_brace_body)*})?,)*
-            }
-        }
-    };
-    (
-        @impl
-        #[pdf(tag = $tag_name:expr)]
-        $(#[$($enum_meta:tt)*])*
-        enum $Enum:ident {
-            $(#[pdf(tag_value = $tag_value:expr)]
-            $(#[$($variant_meta:tt)*])*
-            $VariantName:ident($Body:ty),)*
-            #[pdf(other)]
-            $(#[$($variant_meta_other:tt)*])*
-            $VariantNameOther:ident($Other:ty),
-        }
-    ) => {
-        impl $crate::pdf::object::IsPdfNull for $Enum {
-            fn is_pdf_null(&self) -> $crate::__std::primitive::bool {
-                if let Self::$VariantNameOther(other) = self {
-                    $crate::pdf::object::IsPdfNull::is_pdf_null(other)
-                } else {
-                    false
-                }
-            }
-        }
-        impl $crate::pdf::parse::PdfParse for $Enum {
-            fn type_name() -> $crate::__std::borrow::Cow<'static, $crate::__std::primitive::str> {
-                $crate::__std::borrow::Cow::Borrowed($crate::__std::stringify!($Enum))
-            }
-            fn parse(object: $crate::pdf::object::PdfObject) -> $crate::__std::result::Result<Self, $crate::pdf::parse::PdfParseError> {
-                let object = $crate::__std::convert::From::from(object);
-                let $crate::pdf::object::PdfObjectDirect::Dictionary(object) = object else {
-                    return <$Other as $crate::pdf::parse::PdfParse>::parse(
-                        $crate::__std::convert::From::from(object),
-                    ).map($Enum::$VariantNameOther);
-                };
-                'a: {
-                    let tag_name = $crate::__std::convert::AsRef::<[$crate::__std::primitive::u8]>::as_ref($tag_name);
-                    let $crate::__std::option::Option::Some(tag_value) = object.get(tag_name).cloned() else {
-                        break 'a;
-                    };
-                    let tag_value = $crate::__std::convert::From::from(tag_value);
-                    let $crate::pdf::object::PdfObjectDirect::Name(tag_value) = tag_value else {
-                        break 'a;
-                    };
-                    let _ = tag_value;
-                    $(if tag_value == $crate::pdf::object::PdfName::new_static(
-                        $crate::__std::convert::AsRef::<[u8]>::as_ref($tag_value),
-                    ) {
-                        return <$Body as $crate::pdf::parse::PdfParse>::parse(
-                            $crate::pdf::object::PdfObject::Dictionary(object),
-                        ).map($Enum::$VariantName);
-                    })*
-                }
-                <$Other as $crate::pdf::parse::PdfParse>::parse(
-                    $crate::pdf::object::PdfObject::Dictionary(object),
-                ).map($Enum::$VariantNameOther)
-            }
-        }
-    };
-    (
-        @impl
-        #[pdf(name)]
-        $(#[$($enum_meta:tt)*])*
-        enum $Enum:ident {
-            $(#[pdf(name = $name:expr)]
-            $(#[$($variant_meta:tt)*])*
-            $VariantName:ident,)*
-            $(#[pdf(other)]
-            $(#[$($variant_meta_other:tt)*])*
-            $VariantNameOther:ident($($PdfName:tt)*),)?
-        }
-    ) => {
-        impl $crate::__std::convert::From<$Enum> for $crate::pdf::object::PdfName {
-            fn from(value: $Enum) -> Self {
-                match value {
-                    $($Enum::$VariantName => $crate::pdf::object::PdfName::new_static(
-                        $crate::__std::convert::AsRef::<[u8]>::as_ref($name),
-                    ),)*
-                    $($Enum::$VariantNameOther(v) => $crate::__std::convert::Into::into(v),)?
-                }
-            }
-        }
-
-        $crate::pdf::parse::pdf_parse! {
-            @impl_try_from
-            $(#[$($enum_meta)*])*
-            enum $Enum {
-                $(#[pdf(name = $name)]
-                $(#[$($variant_meta)*])*
-                $VariantName,)*
-                $(#[pdf(other)]
-                $(#[$($variant_meta_other)*])*
-                $VariantNameOther($($PdfName)*),)?
-            }
-        }
-
-        impl $crate::pdf::object::IsPdfNull for $Enum {
-            fn is_pdf_null(&self) -> $crate::__std::primitive::bool {
-                false
-            }
-        }
-
-        impl $crate::pdf::parse::PdfParse for $Enum {
-            fn type_name() -> $crate::__std::borrow::Cow<'static, $crate::__std::primitive::str> {
-                $crate::__std::borrow::Cow::Borrowed($crate::__std::stringify!($Enum))
-            }
-            fn parse(object: $crate::pdf::object::PdfObject) -> $crate::__std::result::Result<Self, $crate::pdf::parse::PdfParseError> {
-                let object = $crate::__std::convert::From::from(object);
-                let $crate::pdf::object::PdfObjectDirect::Name(name) = object else {
-                    return $crate::__std::result::Result::Err($crate::pdf::parse::PdfParseError::InvalidType {
-                        pos: object.pos(),
-                        ty: object.type_name(),
-                        expected_ty: $crate::__std::stringify!($Enum),
-                    });
-                };
-                $crate::__std::result::Result::Ok($crate::__std::convert::TryInto::<$Enum>::try_into(name)?)
-            }
-        }
-    };
-    (
-        @impl_try_from
-        $(#[$($enum_meta:tt)*])*
-        enum $Enum:ident {
-            $(#[pdf(name = $name:expr)]
-            $(#[$($variant_meta:tt)*])*
-            $VariantName:ident,)*
-            #[pdf(other)]
-            $(#[$($variant_meta_other:tt)*])*
-            $VariantNameOther:ident(PdfName),
-        }
-    ) => {
-        impl $crate::__std::convert::From<$crate::pdf::object::PdfName> for $Enum {
-            fn from(name: $crate::pdf::object::PdfName) -> Self {
-                $(if name == $crate::pdf::object::PdfName::new_static(
-                    $crate::__std::convert::AsRef::<[u8]>::as_ref($name),
-                ) {
-                    $Enum::$VariantName
-                } else)* {
-                    $Enum::$VariantNameOther(name)
-                }
-            }
-        }
-    };
-    (
-        @impl_try_from
-        $(#[$($enum_meta:tt)*])*
-        enum $Enum:ident {
-            $(#[pdf(name = $name:expr)]
-            $(#[$($variant_meta:tt)*])*
-            $VariantName:ident,)*
-            #[pdf(other)]
-            $(#[$($variant_meta_other:tt)*])*
-            $VariantNameOther:ident($PdfName:ty),
-        }
-    ) => {
-        impl $crate::__std::convert::TryFrom<$crate::pdf::object::PdfName> for $Enum {
-            type Error = $crate::pdf::parse::PdfParseError;
-
-            fn try_from(name: $crate::pdf::object::PdfName) -> $crate::__std::result::Result<Self, $crate::pdf::parse::PdfParseError> {
-                $(if name == $crate::pdf::object::PdfName::new_static(
-                    $crate::__std::convert::AsRef::<[u8]>::as_ref($name),
-                ) {
-                    $crate::__std::result::Result::Ok($Enum::$VariantName)
-                } else)* {
-                    $crate::__std::result::Result::Ok($Enum::$VariantNameOther($crate::__std::convert::TryInto::<$PdfName>::try_into(name)?))
-                }
-            }
-        }
-    };
-    (
-        @impl_try_from
-        $(#[$($enum_meta:tt)*])*
-        enum $Enum:ident {
-            $(#[pdf(name = $name:expr)]
-            $(#[$($variant_meta:tt)*])*
-            $VariantName:ident,)*
-        }
-    ) => {
-        impl $crate::__std::convert::TryFrom<$crate::pdf::object::PdfName> for $Enum {
-            type Error = $crate::pdf::parse::PdfParseError;
-
-            fn try_from(name: $crate::pdf::object::PdfName) -> $crate::__std::result::Result<Self, $crate::pdf::parse::PdfParseError> {
-                $(if name == $crate::pdf::object::PdfName::new_static(
-                    $crate::__std::convert::AsRef::<[u8]>::as_ref($name),
-                ) {
-                    $crate::__std::result::Result::Ok($Enum::$VariantName)
-                } else)* {
-                    $crate::__std::result::Result::Err($crate::pdf::parse::PdfParseError::InvalidName {
-                        pos: name.pos(),
-                        name,
-                        expected_ty: $crate::__std::stringify!($Enum),
-                    })
-                }
-            }
-        }
-    };
-}
-
-pub use pdf_parse;
diff --git a/src/pdf/render.rs b/src/pdf/render.rs
deleted file mode 100644
index 4603ae1..0000000
--- a/src/pdf/render.rs
+++ /dev/null
@@ -1,1107 +0,0 @@
-use crate::{
-    pdf::{
-        content_stream::{
-            PdfOperatorAndOperands, PdfOperatorBeginCompatibilitySection,
-            PdfOperatorBeginInlineImage, PdfOperatorBeginInlineImageData,
-            PdfOperatorBeginMarkedContent, PdfOperatorBeginMarkedContentWithProperties,
-            PdfOperatorBeginText, PdfOperatorClip, PdfOperatorClipEvenOdd,
-            PdfOperatorCloseAndStrokePath, PdfOperatorCloseFillAndStrokePath,
-            PdfOperatorCloseFillAndStrokePathEvenOdd, PdfOperatorCloseSubpath,
-            PdfOperatorConcatMatrix, PdfOperatorCurveTo, PdfOperatorCurveTo13,
-            PdfOperatorCurveTo23, PdfOperatorDesignateMarkedContentPoint,
-            PdfOperatorDesignateMarkedContentPointWithProperties,
-            PdfOperatorEndCompatibilitySection, PdfOperatorEndInlineImage,
-            PdfOperatorEndMarkedContent, PdfOperatorEndPath, PdfOperatorEndText,
-            PdfOperatorFillAndStrokePath, PdfOperatorFillAndStrokePathEvenOdd, PdfOperatorFillPath,
-            PdfOperatorFillPathEvenOdd, PdfOperatorFillPathObsolete, PdfOperatorFontType3SetWidth,
-            PdfOperatorFontType3SetWidthAndBBox, PdfOperatorLineTo, PdfOperatorMoveTo,
-            PdfOperatorPaintXObject, PdfOperatorRectangle, PdfOperatorRestoreGraphicsState,
-            PdfOperatorSaveGraphicsState, PdfOperatorSetCharacterSpacing,
-            PdfOperatorSetColorRenderingIntent, PdfOperatorSetFlatnessTolerance,
-            PdfOperatorSetFontAndSize, PdfOperatorSetGraphicsState, PdfOperatorSetLineCapStyle,
-            PdfOperatorSetLineDashPattern, PdfOperatorSetLineJoinStyle, PdfOperatorSetLineWidth,
-            PdfOperatorSetMiterLimit, PdfOperatorSetNonStrokeCmyk, PdfOperatorSetNonStrokeColor,
-            PdfOperatorSetNonStrokeColorSpace, PdfOperatorSetNonStrokeColorWithName,
-            PdfOperatorSetNonStrokeGray, PdfOperatorSetNonStrokeRgb,
-            PdfOperatorSetSpacingThenTextNextLineAndShow, PdfOperatorSetStrokeCmyk,
-            PdfOperatorSetStrokeColor, PdfOperatorSetStrokeColorSpace,
-            PdfOperatorSetStrokeColorWithName, PdfOperatorSetStrokeGray, PdfOperatorSetStrokeRgb,
-            PdfOperatorSetTextHorizontalScaling, PdfOperatorSetTextLeading,
-            PdfOperatorSetTextMatrix, PdfOperatorSetTextRenderingMode, PdfOperatorSetTextRise,
-            PdfOperatorSetWordSpacing, PdfOperatorShade, PdfOperatorShowText,
-            PdfOperatorShowTextWithGlyphPositioning, PdfOperatorStrokePath,
-            PdfOperatorTextNextLine, PdfOperatorTextNextLineAndShow,
-            PdfOperatorTextNextLineWithOffset, PdfOperatorTextNextLineWithOffsetAndLeading,
-            PdfOperatorUnparsed,
-        },
-        document_structure::{PdfPage, PdfResourcesDictionary},
-        font::{PdfFont, PdfFontDescriptor, PdfSimpleFontEncodingTableEntry, PdfTodo},
-        object::{
-            IsPdfNull, PdfMatrix, PdfName, PdfNumber, PdfObject, PdfObjectDirect, PdfString,
-            PdfStringOrNumber, PdfVec2D,
-        },
-        parse::{
-            GetPdfInputPosition, PdfInputPosition, PdfInputPositionNoCompare, PdfParse,
-            PdfParseError,
-        },
-    },
-    pdf_parse,
-};
-use std::borrow::Cow;
-
-#[derive(Clone, Debug)]
-#[non_exhaustive]
-pub struct PdfPath {}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Clone, Debug)]
-    pub enum PdfColorSpace {
-        #[pdf(name = "DeviceGray")]
-        DeviceGray,
-        #[pdf(name = "DeviceRGB")]
-        DeviceRgb,
-        // TODO: add others
-        #[pdf(other)]
-        Unknown(PdfName),
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Clone, Debug)]
-    pub enum PdfRenderingIntent {
-        #[pdf(name = "RelativeColorimetric")]
-        RelativeColorimetric,
-        // TODO: add others
-        #[pdf(other)]
-        Unknown(PdfName),
-    }
-}
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Clone, Debug)]
-    pub enum PdfBlendMode {
-        #[pdf(name = "Normal")]
-        Normal,
-        // TODO: add others
-        #[pdf(other)]
-        Unknown(PdfName),
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, PartialOrd)]
-pub struct PdfColorDeviceGray {
-    pos: PdfInputPositionNoCompare,
-    level: f32,
-}
-
-impl PdfColorDeviceGray {
-    pub fn pos(self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn level(self) -> f32 {
-        self.level
-    }
-}
-
-impl IsPdfNull for PdfColorDeviceGray {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl PdfParse for PdfColorDeviceGray {
-    fn type_name() -> Cow<'static, str> {
-        Cow::Borrowed("PdfColorDeviceGray")
-    }
-    fn parse(object: PdfObject) -> Result<Self, PdfParseError> {
-        let number = PdfNumber::parse(object)?;
-        Ok(Self {
-            pos: number.pos().into(),
-            level: number.as_f32(),
-        })
-    }
-}
-
-impl std::fmt::Debug for PdfColorDeviceGray {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self { pos, level } = self;
-        write!(f, "PdfColorDeviceGray(at {pos}, {level})")
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, PartialOrd)]
-pub struct PdfColorDeviceRgb {
-    pos: PdfInputPositionNoCompare,
-    r: f32,
-    g: f32,
-    b: f32,
-}
-
-impl PdfColorDeviceRgb {
-    pub fn pos(self) -> PdfInputPosition {
-        self.pos.0
-    }
-    pub fn r(self) -> f32 {
-        self.r
-    }
-    pub fn g(self) -> f32 {
-        self.g
-    }
-    pub fn b(self) -> f32 {
-        self.b
-    }
-    pub fn parse_flat(r: PdfObject, g: PdfObject, b: PdfObject) -> Result<Self, PdfParseError> {
-        let r = PdfNumber::parse(r)?;
-        let g = f32::parse(g)?;
-        let b = f32::parse(b)?;
-        Ok(Self {
-            pos: r.pos().into(),
-            r: r.as_f32(),
-            g,
-            b,
-        })
-    }
-}
-
-impl IsPdfNull for PdfColorDeviceRgb {
-    fn is_pdf_null(&self) -> bool {
-        false
-    }
-}
-
-impl std::fmt::Debug for PdfColorDeviceRgb {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let Self { pos, r, g, b } = self;
-        write!(f, "PdfColorDeviceRgb(at {pos}, {r}, {g}, {b})")
-    }
-}
-
-#[derive(Clone, Debug)]
-pub enum PdfColor {
-    DeviceGray(PdfColorDeviceGray),
-    DeviceRgb(PdfColorDeviceRgb),
-    // TODO
-}
-
-#[derive(Clone, Debug)]
-pub struct PdfTextObjectState {
-    pub text_matrix: PdfMatrix,
-    pub text_line_matrix: PdfMatrix,
-}
-
-impl PdfTextObjectState {
-    fn require<T: std::borrow::Borrow<Self>>(
-        v: Option<T>,
-        pos: PdfInputPosition,
-    ) -> Result<T, PdfParseError> {
-        v.ok_or(PdfParseError::MissingBeginTextOperator { pos })
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct PdfTextState {
-    pub char_spacing: f32,
-    pub word_spacing: f32,
-    pub horizontal_scaling_percent: f32,
-    pub leading: f32,
-    pub font: Option<PdfFont>,
-    pub font_size: f32,
-    pub rendering_mode: u8, // TODO: replace with enum
-    pub rise: f32,
-    pub knockout: bool,
-    pub text_object: Option<PdfTextObjectState>,
-}
-
-#[derive(Clone, Debug)]
-#[non_exhaustive]
-pub struct PdfLineDashPattern {
-    // TODO
-}
-
-impl PdfLineDashPattern {
-    pub fn solid() -> Self {
-        Self {}
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct PdfGraphicsState {
-    pub current_transformation_matrix: PdfMatrix,
-    pub clipping_path: PdfPath,
-    pub stroking_color: PdfColor,
-    pub non_stroking_color: PdfColor,
-    pub text_state: PdfTextState,
-    pub line_width: f32,
-    pub line_cap_style: u8,  // TODO: replace with enum
-    pub line_join_style: u8, // TODO: replace with enum
-    pub miter_limit: f32,
-    pub line_dash_pattern: PdfLineDashPattern,
-    pub rendering_intent: PdfRenderingIntent,
-    pub automatic_stroke_adjustment: bool,
-    pub current_blend_mode: PdfBlendMode,
-    pub soft_mask: Option<PdfTodo>, // TODO: replace with struct
-    pub stroking_alpha_constant: f32,
-    pub non_stroking_alpha_constant: f32,
-    pub alpha_source: bool,
-}
-
-impl PdfGraphicsState {
-    pub fn text_rendering_matrix(&self, pos: PdfInputPosition) -> Result<PdfMatrix, PdfParseError> {
-        let text_object = PdfTextObjectState::require(self.text_state.text_object.as_ref(), pos)?;
-        Ok(PdfMatrix {
-            pos: PdfInputPositionNoCompare::empty(),
-            elements: [
-                self.text_state.font_size * self.text_state.horizontal_scaling_percent * 1e-2,
-                0.0,
-                0.0,
-                self.text_state.font_size,
-                0.0,
-                self.text_state.rise,
-            ],
-        }
-        .mul(text_object.text_matrix, PdfInputPositionNoCompare::empty())
-        .mul(
-            self.current_transformation_matrix,
-            text_object.text_matrix.pos,
-        ))
-    }
-    pub fn advance_text_matrix(
-        &mut self,
-        pos: PdfInputPosition,
-        glyph_displacement: PdfVec2D,
-        position_adjustment: f32,
-        use_word_spacing: bool,
-    ) -> Result<(), PdfParseError> {
-        let text_object = PdfTextObjectState::require(self.text_state.text_object.as_mut(), pos)?;
-        let (tx, ty) = if self
-            .text_state
-            .font
-            .as_ref()
-            .ok_or(PdfParseError::MissingSetFontOperator { pos })?
-            .is_vertical_writing_mode()
-        {
-            let mut ty =
-                (glyph_displacement.y - position_adjustment * 1e-3) * self.text_state.font_size;
-            if use_word_spacing {
-                ty += self.text_state.word_spacing;
-            } else {
-                ty += self.text_state.char_spacing;
-            }
-            (0.0, ty)
-        } else {
-            let mut tx =
-                (glyph_displacement.x - position_adjustment * 1e-3) * self.text_state.font_size;
-            if use_word_spacing {
-                tx += self.text_state.word_spacing;
-            } else {
-                tx += self.text_state.char_spacing;
-            }
-            (tx * self.text_state.horizontal_scaling_percent * 1e-2, 0.0)
-        };
-        text_object.text_matrix = PdfMatrix {
-            pos: pos.into(),
-            elements: [1.0, 0.0, 0.0, 1.0, tx, ty],
-        }
-        .mul(text_object.text_matrix, pos);
-        Ok(())
-    }
-}
-
-#[derive(Debug)]
-pub struct PdfRenderState<'a> {
-    pub graphics_state: PdfGraphicsState,
-    pub graphics_state_stack: Vec<PdfGraphicsState>,
-    pub resources: &'a PdfResourcesDictionary,
-}
-
-impl<'a> PdfRenderState<'a> {
-    pub fn new(page: &'a PdfPage) -> Self {
-        let pos = page.rest.pos().into();
-        Self {
-            graphics_state: PdfGraphicsState {
-                current_transformation_matrix: PdfMatrix::identity(pos),
-                clipping_path: PdfPath {},
-                stroking_color: PdfColor::DeviceGray(PdfColorDeviceGray { pos, level: 0.0 }),
-                non_stroking_color: PdfColor::DeviceGray(PdfColorDeviceGray { pos, level: 0.0 }),
-                text_state: PdfTextState {
-                    char_spacing: 0.0,
-                    word_spacing: 0.0,
-                    horizontal_scaling_percent: 100.0,
-                    leading: 0.0,
-                    font: None,
-                    font_size: 0.0,
-                    rendering_mode: 0,
-                    rise: 0.0,
-                    knockout: true,
-                    text_object: None,
-                },
-                line_width: 1.0,
-                line_cap_style: 0,
-                line_join_style: 0,
-                miter_limit: 10.0,
-                line_dash_pattern: PdfLineDashPattern::solid(),
-                rendering_intent: PdfRenderingIntent::RelativeColorimetric,
-                automatic_stroke_adjustment: false,
-                current_blend_mode: PdfBlendMode::Normal,
-                soft_mask: None,
-                stroking_alpha_constant: 1.0,
-                non_stroking_alpha_constant: 1.0,
-                alpha_source: false,
-            },
-            graphics_state_stack: Vec::with_capacity(3),
-            resources: &page.resources,
-        }
-    }
-    pub fn handle_unknown_operator(
-        &mut self,
-        operator: &PdfOperatorUnparsed,
-        operands: &[PdfObjectDirect],
-    ) -> Result<(), PdfParseError> {
-        todo!()
-    }
-    pub fn render_string(
-        &mut self,
-        operator_pos: PdfInputPosition,
-        position_adjustment: f32,
-        s: &PdfString,
-    ) -> Result<(), PdfParseError> {
-        for &glyph in s.bytes().iter() {
-            let font = self
-                .graphics_state
-                .text_state
-                .font
-                .as_ref()
-                .ok_or(PdfParseError::MissingSetFontOperator { pos: operator_pos })?;
-            let PdfFont::Type1(font) = font else { todo!() };
-            let Some(encoding) = font.encoding() else {
-                todo!();
-            };
-            let Some(widths) = font.widths() else {
-                todo!();
-            };
-            let Some(first_char) = font.first_char() else {
-                todo!();
-            };
-            let Some(last_char) = font.last_char() else {
-                todo!();
-            };
-            let Some(font_descriptor) = font.font_descriptor() else {
-                todo!();
-            };
-            let Some(font_program) = font_descriptor
-                .font_file
-                .as_ref()
-                .and_then(|v| v.decoded_data().as_ref().ok())
-            else {
-                todo!();
-            };
-            if font_program.vertical_writing_mode {
-                todo!();
-            }
-            let width = if u32::from(glyph) >= first_char && u32::from(glyph) <= last_char {
-                widths[usize::from(glyph) - first_char as usize]
-            } else {
-                font_descriptor
-                    .missing_width
-                    .unwrap_or(PdfFontDescriptor::DEFAULT_MISSING_WIDTH)
-            };
-            todo!("handle position_adjustment");
-            let matrix = self.graphics_state.text_rendering_matrix(s.pos())?;
-            let table = encoding.table(|| font_program.encoding.clone());
-            let PdfSimpleFontEncodingTableEntry {
-                name,
-                presumed_unicode,
-            } = table.table[usize::from(glyph)].clone();
-            todo!("{name:?} {presumed_unicode:?} {:#?}", font.to_unicode());
-            self.graphics_state.advance_text_matrix(
-                s.pos(),
-                PdfVec2D {
-                    pos: font.get_pdf_input_position().into(),
-                    x: width * 1e-3,
-                    y: 0.0,
-                },
-                position_adjustment,
-                glyph == 32,
-            )?;
-        }
-        Ok(())
-    }
-}
-
-pub trait PdfRenderOperator: Into<PdfOperatorAndOperands> {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError>;
-}
-
-impl PdfRenderOperator for PdfOperatorCloseFillAndStrokePath {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorFillAndStrokePath {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorCloseFillAndStrokePathEvenOdd {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorFillAndStrokePathEvenOdd {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorBeginMarkedContentWithProperties {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            tag,
-            properties,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorBeginInlineImage {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorBeginMarkedContent {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, tag } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorBeginText {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos } = *self;
-        state.graphics_state.text_state.text_object = Some(PdfTextObjectState {
-            text_matrix: PdfMatrix::identity(pos),
-            text_line_matrix: PdfMatrix::identity(pos),
-        });
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorBeginCompatibilitySection {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorCurveTo {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, p1, p2, p3 } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorConcatMatrix {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos, matrix } = *self;
-        state.graphics_state.current_transformation_matrix = state
-            .graphics_state
-            .current_transformation_matrix
-            .mul(matrix, pos);
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetStrokeColorSpace {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, name } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetNonStrokeColorSpace {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, name } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetLineDashPattern {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            dash_array,
-            dash_phase,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorFontType3SetWidth {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, width } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorFontType3SetWidthAndBBox {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, width, bbox } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorPaintXObject {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, name } = self; */
-        let _ = state;
-        // TODO: implement
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorDesignateMarkedContentPointWithProperties {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            tag,
-            properties,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorEndInlineImage {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorEndMarkedContent {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorEndText {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos: _ } = self;
-        state.graphics_state.text_state.text_object = None;
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorEndCompatibilitySection {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorFillPath {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorFillPathObsolete {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorFillPathEvenOdd {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetStrokeGray {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos: _, gray } = *self;
-        state.graphics_state.stroking_color = PdfColor::DeviceGray(gray);
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetNonStrokeGray {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos: _, gray } = *self;
-        state.graphics_state.non_stroking_color = PdfColor::DeviceGray(gray);
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetGraphicsState {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            dictionary_name,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorCloseSubpath {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetFlatnessTolerance {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, flatness } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorBeginInlineImageData {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetLineJoinStyle {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            line_join_style,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetLineCapStyle {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            line_cap_style,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetStrokeCmyk {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, c, m, y, k } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetNonStrokeCmyk {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, c, m, y, k } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorLineTo {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, to } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorMoveTo {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, to } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetMiterLimit {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, limit } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorDesignateMarkedContentPoint {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, tag } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorEndPath {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSaveGraphicsState {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos: _ } = self;
-        state
-            .graphics_state_stack
-            .push(state.graphics_state.clone());
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorRestoreGraphicsState {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos } = self;
-        state.graphics_state = state
-            .graphics_state_stack
-            .pop()
-            .ok_or(PdfParseError::CantRestoreGraphicsStateWithEmptyStack { pos: pos.0 })?;
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorRectangle {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, p, size } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetStrokeRgb {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos: _, color } = *self;
-        state.graphics_state.stroking_color = PdfColor::DeviceRgb(color);
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetNonStrokeRgb {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos: _, color } = *self;
-        state.graphics_state.non_stroking_color = PdfColor::DeviceRgb(color);
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetColorRenderingIntent {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, intent } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorCloseAndStrokePath {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorStrokePath {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetStrokeColor {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, color } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetNonStrokeColor {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, color } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetStrokeColorWithName {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            color_and_name,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetNonStrokeColorWithName {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            color_and_name,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorShade {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorTextNextLine {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetCharacterSpacing {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, char_space } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorTextNextLineWithOffset {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self { pos, offset } = *self;
-        let PdfTextObjectState {
-            text_matrix,
-            text_line_matrix,
-        } = PdfTextObjectState::require(
-            state.graphics_state.text_state.text_object.as_mut(),
-            pos.0,
-        )?;
-        let matrix = PdfMatrix {
-            pos,
-            elements: [1.0, 0.0, 0.0, 1.0, offset.x, offset.y],
-        }
-        .mul(*text_line_matrix, pos);
-        *text_line_matrix = matrix;
-        *text_matrix = matrix;
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorTextNextLineWithOffsetAndLeading {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, offset } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetFontAndSize {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self {
-            pos,
-            ref font,
-            size,
-        } = *self;
-        state.graphics_state.text_state.font = Some(
-            state
-                .resources
-                .fonts
-                .get(font)
-                .ok_or_else(|| PdfParseError::FontResourceNotFound {
-                    pos: pos.0,
-                    font: font.clone(),
-                })?
-                .clone(),
-        );
-        state.graphics_state.text_state.font_size = size;
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorShowText {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, text } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorShowTextWithGlyphPositioning {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        let Self {
-            pos,
-            ref text_and_positioning,
-        } = *self;
-        let mut positioning = 0.0;
-        for text_or_positioning in text_and_positioning.iter() {
-            match text_or_positioning {
-                PdfStringOrNumber::String(s) => {
-                    let positioning = std::mem::replace(&mut positioning, 0.0);
-                    state.render_string(pos.0, positioning, s)?;
-                }
-                PdfStringOrNumber::Number(number) => positioning = number.as_f32(),
-            }
-        }
-        Ok(())
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetTextLeading {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, leading } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetTextMatrix {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, matrix } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetTextRenderingMode {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            rendering_mode,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetTextRise {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, rise } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetWordSpacing {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, word_space } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetTextHorizontalScaling {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, scale_percent } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorCurveTo23 {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetLineWidth {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, line_width } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorClip {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorClipEvenOdd {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorCurveTo13 {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorTextNextLineAndShow {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self { pos, text } = self; */
-        let _ = state;
-        todo!()
-    }
-}
-
-impl PdfRenderOperator for PdfOperatorSetSpacingThenTextNextLineAndShow {
-    fn render(&self, state: &mut PdfRenderState) -> Result<(), PdfParseError> {
-        /* let Self {
-            pos,
-            word_space,
-            char_space,
-            text,
-        } = self; */
-        let _ = state;
-        todo!()
-    }
-}
diff --git a/src/pdf/stream_filters.rs b/src/pdf/stream_filters.rs
deleted file mode 100644
index baf6670..0000000
--- a/src/pdf/stream_filters.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use crate::pdf::{
-    object::{PdfDictionary, PdfName},
-    parse::{PdfInputPosition, PdfParse, PdfParseError},
-    pdf_parse,
-};
-
-pub mod flate;
-
-pdf_parse! {
-    #[pdf(name)]
-    #[derive(Clone, Debug, PartialEq, Eq)]
-    #[non_exhaustive]
-    pub enum PdfStreamFilter {
-        #[pdf(name = "ASCIIHexDecode")]
-        AsciiHexDecode,
-        #[pdf(name = "ASCII85Decode")]
-        Ascii85Decode,
-        #[pdf(name = "LZWDecode")]
-        LzwDecode,
-        #[pdf(name = "FlateDecode")]
-        FlateDecode,
-        #[pdf(name = "RunLengthDecode")]
-        RunLengthDecode,
-        #[pdf(name = "CCITTFaxDecode")]
-        CcittFaxDecode,
-        #[pdf(name = "JBIG2Decode")]
-        Jbig2Decode,
-        #[pdf(name = "DCTDecode")]
-        DctDecode,
-        #[pdf(name = "JPXDecode")]
-        JpxDecode,
-        #[pdf(name = "Crypt")]
-        Crypt,
-        #[pdf(other)]
-        Unknown(PdfName),
-    }
-}
-
-impl PdfStreamFilter {
-    pub fn decode_stream_data(
-        &self,
-        filter_parms: PdfDictionary,
-        stream_pos: PdfInputPosition,
-        encoded_data: &[u8],
-    ) -> Result<Vec<u8>, PdfParseError> {
-        match self {
-            PdfStreamFilter::AsciiHexDecode => todo!(),
-            PdfStreamFilter::Ascii85Decode => todo!(),
-            PdfStreamFilter::LzwDecode => todo!(),
-            PdfStreamFilter::FlateDecode => {
-                flate::PdfFilterParmsFlateDecode::parse(filter_parms.into())?
-                    .decode_stream_data(stream_pos, encoded_data)
-            }
-            PdfStreamFilter::RunLengthDecode => todo!(),
-            PdfStreamFilter::CcittFaxDecode => todo!(),
-            PdfStreamFilter::Jbig2Decode => todo!(),
-            PdfStreamFilter::DctDecode => todo!(),
-            PdfStreamFilter::JpxDecode => todo!(),
-            PdfStreamFilter::Crypt => todo!(),
-            PdfStreamFilter::Unknown(filter) => Err(PdfParseError::UnknownStreamFilter {
-                pos: stream_pos,
-                filter: filter.clone(),
-            }),
-        }
-    }
-}
diff --git a/src/pdf/stream_filters/flate.rs b/src/pdf/stream_filters/flate.rs
deleted file mode 100644
index b5d49e8..0000000
--- a/src/pdf/stream_filters/flate.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use crate::pdf::{
-    object::PdfDictionary,
-    parse::{PdfInputPosition, PdfParseError},
-    pdf_parse,
-    stream_filters::PdfStreamFilter,
-};
-use std::{io::Read, num::NonZero};
-
-pdf_parse! {
-    #[pdf]
-    #[derive(Clone, Debug, Default)]
-    pub struct PdfFilterParmsFlateDecode {
-        #[pdf(name = "Predictor")]
-        pub predictor: Option<NonZero<u32>>,
-        #[pdf(name = "Colors")]
-        pub colors: Option<NonZero<u32>>,
-        #[pdf(name = "BitsPerComponent")]
-        pub bits_per_component: Option<NonZero<u32>>,
-        #[pdf(name = "Columns")]
-        pub columns: Option<NonZero<u32>>,
-        #[pdf(flatten)]
-        pub rest: PdfDictionary,
-    }
-}
-
-impl PdfFilterParmsFlateDecode {
-    pub const FILTER: PdfStreamFilter = PdfStreamFilter::FlateDecode;
-    pub const DEFAULT_PREDICTOR: NonZero<u32> = const { NonZero::new(1).unwrap() };
-    pub const DEFAULT_COLORS: NonZero<u32> = const { NonZero::new(1).unwrap() };
-    pub const DEFAULT_BITS_PER_COMPONENT: NonZero<u32> = const { NonZero::new(8).unwrap() };
-    pub const DEFAULT_COLUMNS: NonZero<u32> = const { NonZero::new(1).unwrap() };
-    pub fn predictor(&self) -> NonZero<u32> {
-        self.predictor.unwrap_or(Self::DEFAULT_PREDICTOR)
-    }
-    pub fn colors(&self) -> NonZero<u32> {
-        self.colors.unwrap_or(Self::DEFAULT_COLORS)
-    }
-    pub fn bits_per_component(&self) -> NonZero<u32> {
-        self.bits_per_component
-            .unwrap_or(Self::DEFAULT_BITS_PER_COMPONENT)
-    }
-    pub fn columns(&self) -> NonZero<u32> {
-        self.columns.unwrap_or(Self::DEFAULT_COLUMNS)
-    }
-    pub fn decode_stream_data(
-        &self,
-        stream_pos: PdfInputPosition,
-        encoded_data: &[u8],
-    ) -> Result<Vec<u8>, PdfParseError> {
-        let Self {
-            predictor: _,
-            colors: _,
-            bits_per_component: _,
-            columns: _,
-            rest: _,
-        } = self;
-        let mut decoded_data = vec![];
-        flate2::bufread::ZlibDecoder::new(encoded_data)
-            .read_to_end(&mut decoded_data)
-            .map_err(|e| PdfParseError::StreamFilterError {
-                pos: stream_pos,
-                filter: Self::FILTER.into(),
-                error: e.to_string(),
-            })?;
-        let predictor = self.predictor();
-        let colors = self.colors();
-        let bits_per_component = self.bits_per_component();
-        let columns = self.columns();
-        match predictor {
-            Self::DEFAULT_PREDICTOR => Ok(decoded_data),
-            _ => todo!("{predictor}"),
-        }
-    }
-}
diff --git a/src/quad_tree.rs b/src/quad_tree.rs
new file mode 100644
index 0000000..0c57597
--- /dev/null
+++ b/src/quad_tree.rs
@@ -0,0 +1,1115 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+use std::{fmt, ops::ControlFlow};
+
+/// node in a quad-tree extending from `-(2 ** log2_size)` to
+/// `2 ** log2_size` exclusive on both sides in both `x` and `y`
+/// dimensions.
+///
+/// invariants:
+/// * if `self.values is not None` then all of
+///     `nx_ny`, `px_ny`, `nx_py`, and `px_py` are `None`.
+/// * the `log2_size` field of all of `nx_ny`, `px_ny`, `nx_py`, and `px_py`
+///     is always `self.log2_size - 1`.
+enum QuadTreeNode<V> {
+    Interior {
+        log2_size: i32,
+        nx_ny: Option<Box<QuadTreeNode<V>>>,
+        px_ny: Option<Box<QuadTreeNode<V>>>,
+        nx_py: Option<Box<QuadTreeNode<V>>>,
+        px_py: Option<Box<QuadTreeNode<V>>>,
+    },
+    Leaf {
+        log2_size: i32,
+        values: Vec<(f32, f32, V)>,
+    },
+}
+
+struct DebugQuadTreeLeafValues<'a, V>(&'a [(f32, f32, V)]);
+
+impl<V: fmt::Debug> fmt::Debug for DebugQuadTreeLeafValues<'_, V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let alternate = f.alternate();
+        let mut debug_list = f.debug_list();
+        for (x, y, v) in self.0 {
+            if alternate {
+                debug_list.entry(&format_args!("({x}, {y}, {v:#?})"));
+            } else {
+                debug_list.entry(&format_args!("({x}, {y}, {v:?})"));
+            }
+        }
+        debug_list.finish()
+    }
+}
+
+impl<V: fmt::Debug> fmt::Debug for QuadTreeNode<V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Interior {
+                log2_size,
+                nx_ny,
+                px_ny,
+                nx_py,
+                px_py,
+            } => {
+                let mut debug_struct = f.debug_struct("Interior");
+                debug_struct.field("log2_size", log2_size);
+                if let Some(nx_ny) = nx_ny {
+                    debug_struct.field("nx_ny", nx_ny);
+                }
+                if let Some(px_ny) = px_ny {
+                    debug_struct.field("px_ny", px_ny);
+                }
+                if let Some(nx_py) = nx_py {
+                    debug_struct.field("nx_py", nx_py);
+                }
+                if let Some(px_py) = px_py {
+                    debug_struct.field("px_py", px_py);
+                }
+                debug_struct.finish()
+            }
+            Self::Leaf { log2_size, values } => f
+                .debug_struct("Leaf")
+                .field("log2_size", log2_size)
+                .field("values", &DebugQuadTreeLeafValues(values))
+                .finish(),
+        }
+    }
+}
+
+trait Trace<V> {
+    fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug;
+    fn debug_value(v: &V) -> impl fmt::Debug;
+    fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result);
+}
+
+impl<V, T: Trace<V>> Trace<V> for &'_ mut T {
+    fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug {
+        T::debug_quad_tree_node(v)
+    }
+    fn debug_value(v: &V) -> impl fmt::Debug {
+        T::debug_value(v)
+    }
+    fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {
+        T::trace(self, msg);
+    }
+}
+
+impl<V> Trace<V> for () {
+    fn debug_quad_tree_node(_v: &QuadTreeNode<V>) -> impl fmt::Debug {
+        unreachable!()
+    }
+    fn debug_value(_v: &V) -> impl fmt::Debug {
+        unreachable!()
+    }
+    fn trace(&mut self, _msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {}
+}
+
+impl<V> QuadTreeNode<V> {
+    fn log2_size(&self) -> i32 {
+        match *self {
+            QuadTreeNode::Interior { log2_size, .. } | QuadTreeNode::Leaf { log2_size, .. } => {
+                log2_size
+            }
+        }
+    }
+    fn split<Tr: Trace<V>>(
+        &mut self,
+        split_x: f32,
+        split_y: f32,
+        delta: f32,
+        max_leaf_size: usize,
+        trace: &mut Tr,
+    ) {
+        let Self::Leaf {
+            log2_size,
+            ref mut values,
+        } = *self
+        else {
+            unreachable!("can't split interior node");
+        };
+        if values.len() <= max_leaf_size {
+            return;
+        }
+        let values = std::mem::take(values);
+        *self = Self::Interior {
+            log2_size,
+            nx_ny: None,
+            px_ny: None,
+            nx_py: None,
+            px_py: None,
+        };
+        for value @ (x, y, _) in values {
+            let Self::Interior {
+                log2_size: _,
+                nx_ny,
+                px_ny,
+                nx_py,
+                px_py,
+            } = self
+            else {
+                unreachable!();
+            };
+            let child = if x < split_x {
+                if y < split_y { nx_ny } else { nx_py }
+            } else {
+                if y < split_y { px_ny } else { px_py }
+            };
+            let QuadTreeNode::Leaf {
+                log2_size: _,
+                values,
+            } = &mut **child.get_or_insert_with(|| {
+                Box::new(QuadTreeNode::Leaf {
+                    log2_size: log2_size - 1,
+                    values: Vec::new(),
+                })
+            })
+            else {
+                unreachable!();
+            };
+            values.push(value);
+        }
+        trace.trace(|w| {
+            writeln!(
+                w,
+                "split leaf split_x={split_x} split_y={split_y} delta={delta} self={:#?}",
+                Tr::debug_quad_tree_node(self),
+            )
+        });
+        let Self::Interior {
+            log2_size: _,
+            nx_ny,
+            px_ny,
+            nx_py,
+            px_py,
+        } = self
+        else {
+            unreachable!();
+        };
+        if let Some(nx_ny) = nx_ny {
+            nx_ny.split(
+                split_x - delta,
+                split_y - delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(nx_py) = nx_py {
+            nx_py.split(
+                split_x - delta,
+                split_y + delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(px_ny) = px_ny {
+            px_ny.split(
+                split_x + delta,
+                split_y - delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+        if let Some(px_py) = px_py {
+            px_py.split(
+                split_x + delta,
+                split_y + delta,
+                delta * 0.5,
+                max_leaf_size,
+                trace,
+            );
+        }
+    }
+    fn range<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B, Tr: Trace<V>>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        node_min_x: f32,
+        node_max_x: f32,
+        node_min_y: f32,
+        node_max_y: f32,
+        callback: &mut F,
+        trace: &mut Tr,
+    ) -> ControlFlow<B> {
+        match self {
+            Self::Leaf {
+                log2_size: _,
+                values,
+            } => {
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "range(\n    \
+                min_x={min_x}, max_x={max_x},\n    \
+                min_y={min_y}, max_y={max_y},\n    \
+                node_min_x={node_min_x}, node_max_x={node_max_x},\n    \
+                node_min_y={node_min_y}, node_max_y={node_max_y},\n): \
+                leaf {:#?}",
+                        Tr::debug_quad_tree_node(self)
+                    )
+                });
+                for &(x, y, ref v) in values {
+                    if min_x <= x && x <= max_x && min_y <= y && y <= max_y {
+                        trace.trace(|w| writeln!(w, "yielding {:#?}", (x, y, Tr::debug_value(v))));
+                        callback(x, y, v)?;
+                    } else {
+                        trace.trace(|w| writeln!(w, "skipping {:#?}", (x, y, Tr::debug_value(v))));
+                    }
+                }
+                ControlFlow::Continue(())
+            }
+            &Self::Interior {
+                log2_size: _,
+                ref nx_ny,
+                ref px_ny,
+                ref nx_py,
+                ref px_py,
+            } => {
+                let split_x = (node_min_x + node_max_x) * 0.5;
+                let split_y = (node_min_y + node_max_y) * 0.5;
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "range(\n    \
+                min_x={min_x}, max_x={max_x},\n    \
+                min_y={min_y}, max_y={max_y},\n    \
+                node_min_x={node_min_x}, node_max_x={node_max_x},\n    \
+                node_min_y={node_min_y}, node_max_y={node_max_y},\n): \
+                interior split_x={split_x} split_y={split_y} {:#?}",
+                        Tr::debug_quad_tree_node(self),
+                    )
+                });
+                if let Some(v) = nx_ny {
+                    if min_x <= split_x && min_y <= split_y {
+                        let node_max_x = split_x;
+                        let node_max_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = nx_py {
+                    if min_x <= split_x && max_y >= split_y {
+                        let node_max_x = split_x;
+                        let node_min_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = px_ny {
+                    if max_x >= split_x && min_y <= split_y {
+                        let node_min_x = split_x;
+                        let node_max_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                if let Some(v) = px_py {
+                    if max_x >= split_x && max_y >= split_y {
+                        let node_min_x = split_x;
+                        let node_min_y = split_y;
+                        v.range(
+                            min_x, max_x, min_y, max_y, node_min_x, node_max_x, node_min_y,
+                            node_max_y, callback, trace,
+                        )?;
+                    }
+                }
+                ControlFlow::Continue(())
+            }
+        }
+    }
+}
+
+macro_rules! impl_node_iter {
+    (
+        #[mut = $($mut:tt)?];
+        #[Clone = $($Clone:tt)?];
+        Iter = $Iter:ident;
+        iter = $iter:ident;
+        IterStackEntry = $IterStackEntry:ident;
+        as_iter_stack_entry = $as_iter_stack_entry:ident;
+        as_deref = $as_deref:ident;
+    ) => {
+        impl<V> QuadTreeNode<V> {
+            fn $iter(&$($mut)? self) -> $Iter<'_, V> {
+                $Iter { stack: vec![self.$as_iter_stack_entry()] }
+            }
+            fn $as_iter_stack_entry(&$($mut)? self) -> $IterStackEntry<'_, V> {
+                match self {
+                    QuadTreeNode::Interior {
+                        log2_size: _,
+                        nx_ny,
+                        px_ny,
+                        nx_py,
+                        px_py,
+                    } => $IterStackEntry::NextIsNxNy {
+                        nx_ny: nx_ny.$as_deref(),
+                        px_ny: px_ny.$as_deref(),
+                        nx_py: nx_py.$as_deref(),
+                        px_py: px_py.$as_deref(),
+                    },
+                    QuadTreeNode::Leaf {
+                        log2_size: _,
+                        values,
+                    } => $IterStackEntry::NextIsValues {
+                        values: values.$iter(),
+                    },
+                }
+            }
+        }
+
+        #[derive($($Clone,)? Debug)]
+        enum $IterStackEntry<'a, V> {
+            NextIsNxNy {
+                nx_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsPxNy {
+                px_ny: Option<&'a $($mut)? QuadTreeNode<V>>,
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsNxPy {
+                nx_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsPxPy {
+                px_py: Option<&'a $($mut)? QuadTreeNode<V>>,
+            },
+            NextIsValues {
+                values: std::slice::$Iter<'a, (f32, f32, V)>,
+            },
+        }
+
+        impl<'a, V> Default for $IterStackEntry<'a, V> {
+            fn default() -> Self {
+                Self::NextIsValues { values: Default::default() }
+            }
+        }
+
+        #[derive($($Clone,)? Debug, Default)]
+        pub struct $Iter<'a, V> {
+            stack: Vec<$IterStackEntry<'a, V>>,
+        }
+
+        impl<'a, V> Iterator for $Iter<'a, V> {
+            type Item = (f32, f32, &'a $($mut)? V);
+
+            fn next(&mut self) -> Option<Self::Item> {
+                while let Some(top) = self.stack.pop() {
+                    match top {
+                        $IterStackEntry::NextIsNxNy {
+                            nx_ny,
+                            px_ny,
+                            nx_py,
+                            px_py,
+                        } => {
+                            self.stack.push($IterStackEntry::NextIsPxNy {
+                                px_ny,
+                                nx_py,
+                                px_py,
+                            });
+                            self.stack
+                                .extend(nx_ny.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsPxNy {
+                            px_ny,
+                            nx_py,
+                            px_py,
+                        } => {
+                            self.stack.push($IterStackEntry::NextIsNxPy {
+                                nx_py,
+                                px_py,
+                            });
+                            self.stack
+                                .extend(px_ny.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsNxPy { nx_py, px_py } => {
+                            self.stack.push($IterStackEntry::NextIsPxPy {
+                                px_py,
+                            });
+                            self.stack
+                                .extend(nx_py.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsPxPy { px_py } => {
+                            self.stack
+                                .extend(px_py.map(QuadTreeNode::$as_iter_stack_entry));
+                        }
+                        $IterStackEntry::NextIsValues { mut values } => {
+                            if let Some((x, y, v)) = values.next() {
+                                self.stack
+                                    .push($IterStackEntry::NextIsValues { values });
+                                return Some((*x, *y, v));
+                            }
+                        }
+                    }
+                }
+                None
+            }
+        }
+    };
+}
+
+impl_node_iter! {
+    #[mut =];
+    #[Clone = Clone];
+    Iter = Iter;
+    iter = iter;
+    IterStackEntry = IterStackEntry;
+    as_iter_stack_entry = as_iter_stack_entry;
+    as_deref = as_deref;
+}
+
+impl_node_iter! {
+    #[mut = mut];
+    #[Clone =];
+    Iter = IterMut;
+    iter = iter_mut;
+    IterStackEntry = IterStackEntryMut;
+    as_iter_stack_entry = as_iter_stack_entry_mut;
+    as_deref = as_deref_mut;
+}
+
+pub struct QuadTree<V> {
+    root: QuadTreeNode<V>,
+    max_leaf_size: usize,
+}
+
+impl<V: fmt::Debug> fmt::Debug for QuadTree<V> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Self {
+            root,
+            max_leaf_size: _,
+        } = self;
+        f.write_str("QuadTree(")?;
+        root.fmt(f)?;
+        f.write_str(")")
+    }
+}
+
+impl<V> QuadTree<V> {
+    pub const DEFAULT_MAX_LEAF_SIZE: usize = 16;
+    pub const fn new() -> Self {
+        Self::with_max_leaf_size(Self::DEFAULT_MAX_LEAF_SIZE)
+    }
+    pub const fn with_max_leaf_size(max_leaf_size: usize) -> Self {
+        Self {
+            root: QuadTreeNode::Leaf {
+                log2_size: 0,
+                values: Vec::new(),
+            },
+            max_leaf_size,
+        }
+    }
+    pub fn from_iter_with_max_leaf_size<I: IntoIterator<Item = (f32, f32, V)>>(
+        iter: I,
+        max_leaf_size: usize,
+    ) -> Self {
+        let mut retval = Self::with_max_leaf_size(max_leaf_size);
+        retval.extend(iter);
+        retval
+    }
+    pub fn iter(&self) -> Iter<'_, V> {
+        self.root.iter()
+    }
+    pub fn iter_mut(&mut self) -> IterMut<'_, V> {
+        self.root.iter_mut()
+    }
+    fn expand_root<Tr: Trace<V>>(&mut self, target_log2_size: i32, trace: &mut Tr) {
+        match &mut self.root {
+            QuadTreeNode::Leaf {
+                log2_size,
+                values: _,
+            } => {
+                if target_log2_size > *log2_size {
+                    // leaf node -- just expand in place
+                    trace.trace(|w| writeln!(w, "expand_root({target_log2_size}) leaf"));
+                    *log2_size = target_log2_size;
+                }
+            }
+            QuadTreeNode::Interior { .. } => {
+                while target_log2_size > self.root.log2_size() {
+                    trace.trace(|w| {
+                        writeln!(
+                            w,
+                            "expand_root({target_log2_size}) interior: {:#?}",
+                            Tr::debug_quad_tree_node(&self.root)
+                        )
+                    });
+                    let QuadTreeNode::Interior {
+                        log2_size,
+                        nx_ny,
+                        px_ny,
+                        nx_py,
+                        px_py,
+                    } = &mut self.root
+                    else {
+                        unreachable!();
+                    };
+                    *nx_ny = nx_ny.take().map(|nx_ny| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: None,
+                            nx_py: None,
+                            px_py: Some(nx_ny),
+                        })
+                    });
+                    *px_ny = px_ny.take().map(|px_ny| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: None,
+                            nx_py: Some(px_ny),
+                            px_py: None,
+                        })
+                    });
+                    *nx_py = nx_py.take().map(|nx_py| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: None,
+                            px_ny: Some(nx_py),
+                            nx_py: None,
+                            px_py: None,
+                        })
+                    });
+                    *px_py = px_py.take().map(|px_py| {
+                        Box::new(QuadTreeNode::Interior {
+                            log2_size: *log2_size,
+                            nx_ny: Some(px_py),
+                            px_ny: None,
+                            nx_py: None,
+                            px_py: None,
+                        })
+                    });
+                    *log2_size += 1
+                }
+            }
+        }
+        trace.trace(|w| {
+            writeln!(
+                w,
+                "expand_root({target_log2_size}) done: {:#?}",
+                Tr::debug_quad_tree_node(&self.root)
+            )
+        });
+    }
+    fn range_with_trace<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B, Tr: Trace<V>>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        mut callback: F,
+        mut trace: Tr,
+    ) -> ControlFlow<B> {
+        assert!(!(min_x.is_nan() || max_x.is_nan() || min_y.is_nan() || max_y.is_nan()));
+        if min_x > max_x || min_y > max_y {
+            return ControlFlow::Continue(());
+        }
+        let size = libm::ldexpf(1.0, self.root.log2_size());
+        self.root.range(
+            min_x,
+            max_x,
+            min_y,
+            max_y,
+            -size,
+            size,
+            -size,
+            size,
+            &mut callback,
+            &mut trace,
+        )
+    }
+    pub fn range<'a, F: FnMut(f32, f32, &'a V) -> ControlFlow<B>, B>(
+        &'a self,
+        min_x: f32,
+        max_x: f32,
+        min_y: f32,
+        max_y: f32,
+        callback: F,
+    ) -> ControlFlow<B> {
+        self.range_with_trace(min_x, max_x, min_y, max_y, callback, ())
+    }
+    fn insert_with_trace_inner<Tr: Trace<V>>(
+        node: &mut QuadTreeNode<V>,
+        x: f32,
+        y: f32,
+        value: V,
+        split_x: f32,
+        split_y: f32,
+        delta: f32,
+        max_leaf_size: usize,
+        trace: &mut Tr,
+    ) {
+        match node {
+            QuadTreeNode::Interior { .. } => {
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "insert({x}, {y}, _): interior: split_x={split_x} \
+                    split_y={split_y} delta={delta} node={:#?}",
+                        Tr::debug_quad_tree_node(node)
+                    )
+                });
+                let QuadTreeNode::Interior {
+                    log2_size,
+                    nx_ny,
+                    px_ny,
+                    nx_py,
+                    px_py,
+                } = node
+                else {
+                    unreachable!();
+                };
+                if x < split_x {
+                    if y < split_y {
+                        let Some(node) = nx_ny else {
+                            *nx_ny = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert nx_ny leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x - delta,
+                            split_y - delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    } else {
+                        let Some(node) = nx_py else {
+                            *nx_py = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert nx_py leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x - delta,
+                            split_y + delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    }
+                } else {
+                    if y < split_y {
+                        let Some(node) = px_ny else {
+                            *px_ny = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert px_ny leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x + delta,
+                            split_y - delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    } else {
+                        let Some(node) = px_py else {
+                            *px_py = Some(Box::new(QuadTreeNode::Leaf {
+                                log2_size: *log2_size - 1,
+                                values: vec![(x, y, value)],
+                            }));
+                            trace.trace(|w| {
+                                writeln!(
+                                    w,
+                                    "insert({x}, {y}, _): insert px_py leaf: node={:#?}",
+                                    Tr::debug_quad_tree_node(node)
+                                )
+                            });
+                            return;
+                        };
+                        Self::insert_with_trace_inner(
+                            node,
+                            x,
+                            y,
+                            value,
+                            split_x + delta,
+                            split_y + delta,
+                            delta * 0.5,
+                            max_leaf_size,
+                            trace,
+                        )
+                    }
+                }
+            }
+            QuadTreeNode::Leaf {
+                log2_size: _,
+                values,
+            } => {
+                // got to a leaf
+                values.push((x, y, value));
+                trace.trace(|w| {
+                    writeln!(
+                        w,
+                        "insert({x}, {y}, _): leaf node={:#?}",
+                        Tr::debug_quad_tree_node(node)
+                    )
+                });
+                node.split(split_x, split_y, delta, max_leaf_size, trace)
+            }
+        }
+    }
+    fn insert_with_trace<Tr: Trace<V>>(&mut self, x: f32, y: f32, value: V, mut trace: Tr) {
+        assert!(x.is_finite() && y.is_finite(), "invalid coordinates");
+        trace.trace(|w| writeln!(w, "insert({x}, {y}, {:#?})", Tr::debug_value(&value)));
+        let abs_x = x.abs();
+        let abs_y = y.abs();
+        let abs_max = abs_x.max(abs_y);
+        let (_, log2_abs_max) = libm::frexpf(abs_max);
+        trace.trace(|w| writeln!(w, "insert({x}, {y}, _): log2_abs_max={log2_abs_max}"));
+        self.expand_root(log2_abs_max, &mut trace);
+        let delta = libm::ldexpf(0.5, self.root.log2_size());
+        Self::insert_with_trace_inner(
+            &mut self.root,
+            x,
+            y,
+            value,
+            0.0,
+            0.0,
+            delta,
+            self.max_leaf_size,
+            &mut trace,
+        );
+    }
+    pub fn insert(&mut self, x: f32, y: f32, value: V) {
+        self.insert_with_trace(x, y, value, &mut ());
+    }
+}
+
+impl<V> Default for QuadTree<V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<V> FromIterator<(f32, f32, V)> for QuadTree<V> {
+    fn from_iter<T: IntoIterator<Item = (f32, f32, V)>>(iter: T) -> Self {
+        Self::from_iter_with_max_leaf_size(iter, Self::DEFAULT_MAX_LEAF_SIZE)
+    }
+}
+
+impl<V> Extend<(f32, f32, V)> for QuadTree<V> {
+    fn extend<T: IntoIterator<Item = (f32, f32, V)>>(&mut self, iter: T) {
+        iter.into_iter().for_each(|(x, y, v)| {
+            self.insert(x, y, v);
+        });
+    }
+}
+
+impl<'a, V> IntoIterator for &'a QuadTree<V> {
+    type Item = (f32, f32, &'a V);
+    type IntoIter = Iter<'a, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.root.iter()
+    }
+}
+
+impl<'a, V> IntoIterator for &'a mut QuadTree<V> {
+    type Item = (f32, f32, &'a mut V);
+    type IntoIter = IterMut<'a, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.root.iter_mut()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Print;
+
+    impl<V: fmt::Debug> Trace<V> for Print {
+        fn debug_quad_tree_node(v: &QuadTreeNode<V>) -> impl fmt::Debug {
+            v
+        }
+
+        fn debug_value(v: &V) -> impl fmt::Debug {
+            v
+        }
+
+        fn trace(&mut self, msg: impl FnOnce(&mut dyn fmt::Write) -> fmt::Result) {
+            let mut out = String::new();
+            msg(&mut out).unwrap();
+            print!("{out}");
+        }
+    }
+
+    #[test]
+    fn test_quad_tree_range() {
+        let mut items = vec![];
+        for x in 0..8 {
+            let mut x = x as f32 + 0.5;
+            x /= 4.0;
+            for y in 0..8 {
+                let mut y = y as f32 + 0.5;
+                y /= 4.0;
+                items.push((x, y, format!("{x},{y}")));
+            }
+        }
+        items.sort_by(|l, r| l.partial_cmp(r).unwrap());
+        let qt = QuadTree::from_iter(items.clone());
+        let check_range = |min_x: f32, max_x: f32, min_y: f32, max_y: f32| {
+            println!("min_x={min_x}, max_x={max_x}, min_y={min_y}, max_y={max_y}");
+            let expected = Vec::from_iter(
+                items
+                    .iter()
+                    .filter(|&&(x, y, _)| min_x <= x && x <= max_x && min_y <= y && y <= max_y)
+                    .map(|&(x, y, ref v)| (x, y, v)),
+            );
+            let mut range_result = Vec::new();
+            let _ = qt.range_with_trace(
+                min_x,
+                max_x,
+                min_y,
+                max_y,
+                |x, y, v| {
+                    range_result.push((x, y, v));
+                    ControlFlow::<()>::Continue(())
+                },
+                &mut Print,
+            );
+            range_result.sort_by(|l, r| l.partial_cmp(r).unwrap());
+            println!("expected={expected:?}");
+            println!("range_result={range_result:?}");
+            assert_eq!(expected, range_result);
+        };
+        check_range(-1.0, 1.0, -1.0, 1.0);
+        check_range(0.125, 0.25, 0.125, 0.25);
+        check_range(items[0].0, items[0].0, items[0].1, items[0].1);
+        check_range(1.0, 0.0, -1.0, 1.0);
+    }
+
+    #[test]
+    fn test_quad_tree_insert() {
+        let mut qt = QuadTree::with_max_leaf_size(4);
+        for x in 0..8 {
+            let mut x = x as f32 + 0.5;
+            x /= 4.0;
+            for y in 0..8 {
+                let mut y = y as f32 + 0.5;
+                y /= 4.0;
+                qt.insert_with_trace(x, y, format!("{x},{y}"), &mut Print);
+            }
+        }
+        println!("{qt:#?}");
+        assert_eq!(
+            format!("{qt:#?}"),
+            r#"QuadTree(Interior {
+    log2_size: 1,
+    px_py: Interior {
+        log2_size: 0,
+        nx_ny: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 0.125, "0.125,0.125"),
+                    (0.125, 0.375, "0.125,0.375"),
+                    (0.375, 0.125, "0.375,0.125"),
+                    (0.375, 0.375, "0.375,0.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 0.125, "0.625,0.125"),
+                    (0.625, 0.375, "0.625,0.375"),
+                    (0.875, 0.125, "0.875,0.125"),
+                    (0.875, 0.375, "0.875,0.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 0.625, "0.125,0.625"),
+                    (0.125, 0.875, "0.125,0.875"),
+                    (0.375, 0.625, "0.375,0.625"),
+                    (0.375, 0.875, "0.375,0.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 0.625, "0.625,0.625"),
+                    (0.625, 0.875, "0.625,0.875"),
+                    (0.875, 0.625, "0.875,0.625"),
+                    (0.875, 0.875, "0.875,0.875"),
+                ],
+            },
+        },
+        px_ny: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 0.125, "1.125,0.125"),
+                    (1.125, 0.375, "1.125,0.375"),
+                    (1.375, 0.125, "1.375,0.125"),
+                    (1.375, 0.375, "1.375,0.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 0.125, "1.625,0.125"),
+                    (1.625, 0.375, "1.625,0.375"),
+                    (1.875, 0.125, "1.875,0.125"),
+                    (1.875, 0.375, "1.875,0.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 0.625, "1.125,0.625"),
+                    (1.125, 0.875, "1.125,0.875"),
+                    (1.375, 0.625, "1.375,0.625"),
+                    (1.375, 0.875, "1.375,0.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 0.625, "1.625,0.625"),
+                    (1.625, 0.875, "1.625,0.875"),
+                    (1.875, 0.625, "1.875,0.625"),
+                    (1.875, 0.875, "1.875,0.875"),
+                ],
+            },
+        },
+        nx_py: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 1.125, "0.125,1.125"),
+                    (0.125, 1.375, "0.125,1.375"),
+                    (0.375, 1.125, "0.375,1.125"),
+                    (0.375, 1.375, "0.375,1.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 1.125, "0.625,1.125"),
+                    (0.625, 1.375, "0.625,1.375"),
+                    (0.875, 1.125, "0.875,1.125"),
+                    (0.875, 1.375, "0.875,1.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.125, 1.625, "0.125,1.625"),
+                    (0.125, 1.875, "0.125,1.875"),
+                    (0.375, 1.625, "0.375,1.625"),
+                    (0.375, 1.875, "0.375,1.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (0.625, 1.625, "0.625,1.625"),
+                    (0.625, 1.875, "0.625,1.875"),
+                    (0.875, 1.625, "0.875,1.625"),
+                    (0.875, 1.875, "0.875,1.875"),
+                ],
+            },
+        },
+        px_py: Interior {
+            log2_size: -1,
+            nx_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 1.125, "1.125,1.125"),
+                    (1.125, 1.375, "1.125,1.375"),
+                    (1.375, 1.125, "1.375,1.125"),
+                    (1.375, 1.375, "1.375,1.375"),
+                ],
+            },
+            px_ny: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 1.125, "1.625,1.125"),
+                    (1.625, 1.375, "1.625,1.375"),
+                    (1.875, 1.125, "1.875,1.125"),
+                    (1.875, 1.375, "1.875,1.375"),
+                ],
+            },
+            nx_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.125, 1.625, "1.125,1.625"),
+                    (1.125, 1.875, "1.125,1.875"),
+                    (1.375, 1.625, "1.375,1.625"),
+                    (1.375, 1.875, "1.375,1.875"),
+                ],
+            },
+            px_py: Leaf {
+                log2_size: -2,
+                values: [
+                    (1.625, 1.625, "1.625,1.625"),
+                    (1.625, 1.875, "1.625,1.875"),
+                    (1.875, 1.625, "1.875,1.625"),
+                    (1.875, 1.875, "1.875,1.875"),
+                ],
+            },
+        },
+    },
+})"#
+        );
+    }
+}
diff --git a/src/util.rs b/src/util.rs
deleted file mode 100644
index 9d576f8..0000000
--- a/src/util.rs
+++ /dev/null
@@ -1,382 +0,0 @@
-use std::{
-    any::{Any, TypeId},
-    borrow::Borrow,
-    cell::Cell,
-    collections::HashMap,
-    fmt,
-    hash::{Hash, Hasher},
-    sync::Arc,
-};
-
-pub enum ArcOrRef<'a, T: ?Sized> {
-    Arc(Arc<T>),
-    Ref(&'a T),
-}
-
-impl<'a, T: ?Sized> AsRef<T> for ArcOrRef<'a, T> {
-    fn as_ref(&self) -> &T {
-        self
-    }
-}
-
-impl<'a, T: ?Sized> Borrow<T> for ArcOrRef<'a, T> {
-    fn borrow(&self) -> &T {
-        self
-    }
-}
-
-impl<'a, T: ?Sized> From<Arc<T>> for ArcOrRef<'a, T> {
-    fn from(value: Arc<T>) -> Self {
-        Self::Arc(value)
-    }
-}
-
-impl<'a, T: ?Sized> From<&'a T> for ArcOrRef<'a, T> {
-    fn from(value: &'a T) -> Self {
-        Self::Ref(value)
-    }
-}
-
-impl<'a, T: ?Sized> Default for ArcOrRef<'a, T>
-where
-    &'a T: Default,
-{
-    fn default() -> Self {
-        Self::Ref(Default::default())
-    }
-}
-
-impl<T: ?Sized> Clone for ArcOrRef<'_, T> {
-    fn clone(&self) -> Self {
-        match self {
-            Self::Arc(v) => Self::Arc(v.clone()),
-            Self::Ref(v) => Self::Ref(v),
-        }
-    }
-}
-
-impl<T: ?Sized + Hash> Hash for ArcOrRef<'_, T> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        T::hash(self, state)
-    }
-}
-
-impl<'a, 'b, T: ?Sized + PartialEq<U>, U: ?Sized> PartialEq<ArcOrRef<'b, U>> for ArcOrRef<'a, T> {
-    fn eq(&self, other: &ArcOrRef<'b, U>) -> bool {
-        T::eq(self, other)
-    }
-}
-
-impl<T: ?Sized + Eq> Eq for ArcOrRef<'_, T> {}
-
-impl<'a, 'b, T: ?Sized + PartialOrd<U>, U: ?Sized> PartialOrd<ArcOrRef<'b, U>> for ArcOrRef<'a, T> {
-    fn partial_cmp(&self, other: &ArcOrRef<'b, U>) -> Option<std::cmp::Ordering> {
-        T::partial_cmp(self, other)
-    }
-}
-
-impl<T: ?Sized + Ord> Ord for ArcOrRef<'_, T> {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        T::cmp(self, other)
-    }
-}
-
-impl<T: ?Sized> std::ops::Deref for ArcOrRef<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            ArcOrRef::Arc(v) => v,
-            ArcOrRef::Ref(v) => v,
-        }
-    }
-}
-
-impl<T: ?Sized + fmt::Debug> fmt::Debug for ArcOrRef<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        T::fmt(self, f)
-    }
-}
-
-impl<T: ?Sized + fmt::Display> fmt::Display for ArcOrRef<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        T::fmt(self, f)
-    }
-}
-
-/// a stable alternative to `CloneToUninit` for `Arc`
-pub trait ArcFromRef {
-    /// like `Arc::new(Self::clone(self))` but works for unsized types too
-    fn arc_from_ref(&self) -> Arc<Self>;
-    /// generic version of `Arc::make_mut`
-    fn make_mut(this: &mut Arc<Self>) -> &mut Self;
-}
-
-impl<T: Clone> ArcFromRef for T {
-    fn arc_from_ref(&self) -> Arc<Self> {
-        Arc::new(Self::clone(self))
-    }
-    fn make_mut(this: &mut Arc<Self>) -> &mut Self {
-        Arc::make_mut(this)
-    }
-}
-
-impl<T: Clone> ArcFromRef for [T] {
-    fn arc_from_ref(&self) -> Arc<Self> {
-        Arc::from(self)
-    }
-    fn make_mut(this: &mut Arc<Self>) -> &mut Self {
-        Arc::make_mut(this)
-    }
-}
-
-impl ArcFromRef for str {
-    fn arc_from_ref(&self) -> Arc<Self> {
-        Arc::from(self)
-    }
-    fn make_mut(this: &mut Arc<Self>) -> &mut Self {
-        Arc::make_mut(this)
-    }
-}
-
-impl<'a, T: ?Sized + ArcFromRef> ArcOrRef<'a, T> {
-    pub fn into_arc(this: Self) -> Arc<T> {
-        match this {
-            ArcOrRef::Arc(v) => v,
-            ArcOrRef::Ref(v) => T::arc_from_ref(v),
-        }
-    }
-    pub fn make_arc(this: &mut Self) -> &mut Arc<T> {
-        match this {
-            ArcOrRef::Arc(v) => v,
-            ArcOrRef::Ref(v) => {
-                *this = ArcOrRef::Arc(T::arc_from_ref(v));
-                let ArcOrRef::Arc(v) = this else {
-                    unreachable!();
-                };
-                v
-            }
-        }
-    }
-    pub fn make_mut(this: &mut Self) -> &mut T {
-        T::make_mut(Self::make_arc(this))
-    }
-}
-
-trait DagDebugStateSealed {}
-
-#[expect(private_bounds)]
-pub trait SupportsDagDebugState: DagDebugStateSealed + 'static + Clone {
-    type Key: Clone + Hash + Eq + 'static;
-    fn key(this: &Self) -> Self::Key;
-}
-
-impl<T: 'static> DagDebugStateSealed for Arc<T> {}
-
-impl<T: 'static> SupportsDagDebugState for Arc<T> {
-    type Key = *const T;
-
-    fn key(this: &Self) -> Self::Key {
-        Arc::as_ptr(this)
-    }
-}
-
-impl<T: 'static> DagDebugStateSealed for Arc<[T]> {}
-
-impl<T: 'static> SupportsDagDebugState for Arc<[T]> {
-    type Key = *const [T];
-
-    fn key(this: &Self) -> Self::Key {
-        Arc::as_ptr(this)
-    }
-}
-
-impl DagDebugStateSealed for Arc<str> {}
-
-impl SupportsDagDebugState for Arc<str> {
-    type Key = *const str;
-
-    fn key(this: &Self) -> Self::Key {
-        Arc::as_ptr(this)
-    }
-}
-
-trait DagDebugStatePartTrait: 'static {
-    fn reset(&mut self);
-    fn as_any_mut(&mut self) -> &mut dyn Any;
-}
-
-struct DagDebugStatePart<T: SupportsDagDebugState> {
-    table: HashMap<T::Key, (u64, T)>,
-    next_id: u64,
-}
-
-impl<T: SupportsDagDebugState> DagDebugStatePartTrait for DagDebugStatePart<T> {
-    fn reset(&mut self) {
-        let Self { table, next_id } = self;
-        table.clear();
-        *next_id = 0;
-    }
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-}
-
-impl<T: SupportsDagDebugState> DagDebugStatePart<T> {
-    fn insert(&mut self, value: &T) -> DagDebugStateInsertResult {
-        use std::collections::hash_map::Entry;
-        match self.table.entry(T::key(value)) {
-            Entry::Occupied(entry) => DagDebugStateInsertResult::Old { id: entry.get().0 },
-            Entry::Vacant(entry) => {
-                let value = T::clone(value);
-                let id = self.next_id;
-                self.next_id += 1;
-                entry.insert((id, value));
-                DagDebugStateInsertResult::New { id }
-            }
-        }
-    }
-}
-
-impl<T: SupportsDagDebugState> Default for DagDebugStatePart<T> {
-    fn default() -> Self {
-        Self {
-            table: HashMap::default(),
-            next_id: 0,
-        }
-    }
-}
-
-pub struct DagDebugState {
-    parts: std::cell::RefCell<HashMap<TypeId, Box<dyn DagDebugStatePartTrait>>>,
-    ref_count: Cell<usize>,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub enum DagDebugStateInsertResult {
-    New { id: u64 },
-    Old { id: u64 },
-}
-
-impl DagDebugStateInsertResult {
-    pub fn id(self) -> u64 {
-        match self {
-            Self::New { id } | Self::Old { id } => id,
-        }
-    }
-}
-
-impl DagDebugState {
-    fn with_part<T: SupportsDagDebugState, R>(
-        &self,
-        f: impl FnOnce(&mut DagDebugStatePart<T>) -> R,
-    ) -> R {
-        let mut parts = self.parts.borrow_mut();
-        let Some(part) = parts
-            .entry(TypeId::of::<DagDebugStatePart<T>>())
-            .or_insert_with(|| Box::new(DagDebugStatePart::<T>::default()))
-            .as_any_mut()
-            .downcast_mut::<DagDebugStatePart<T>>()
-        else {
-            unreachable!()
-        };
-        f(part)
-    }
-    pub fn insert<T: SupportsDagDebugState>(&self, value: &T) -> DagDebugStateInsertResult {
-        self.with_part(|part: &mut DagDebugStatePart<T>| part.insert(value))
-    }
-    pub fn debug_or_id<'a, T: SupportsDagDebugState + fmt::Debug, Abbreviated: fmt::Display>(
-        &self,
-        value: &'a T,
-        abbreviated: Abbreviated,
-    ) -> impl fmt::Debug + fmt::Display + use<'a, T, Abbreviated> {
-        self.debug_or_id_with(value, fmt::Debug::fmt, move |f| abbreviated.fmt(f))
-    }
-    pub fn debug_or_id_with<
-        'a,
-        T: SupportsDagDebugState,
-        DebugValue: Fn(&'a T, &mut fmt::Formatter<'_>) -> fmt::Result,
-        DebugAbbreviated: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
-    >(
-        &self,
-        value: &'a T,
-        debug_value: DebugValue,
-        debug_abbreviated: DebugAbbreviated,
-    ) -> impl fmt::Debug + fmt::Display + use<'a, T, DebugValue, DebugAbbreviated> {
-        struct DebugOrIdWith<
-            'a,
-            T: SupportsDagDebugState,
-            DebugValue: Fn(&'a T, &mut fmt::Formatter<'_>) -> fmt::Result,
-            DebugAbbreviated: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
-        > {
-            insert_result: DagDebugStateInsertResult,
-            value: &'a T,
-            debug_value: DebugValue,
-            debug_abbreviated: DebugAbbreviated,
-        }
-        impl<
-            'a,
-            T: SupportsDagDebugState,
-            DebugValue: Fn(&'a T, &mut fmt::Formatter<'_>) -> fmt::Result,
-            DebugAbbreviated: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
-        > fmt::Debug for DebugOrIdWith<'a, T, DebugValue, DebugAbbreviated>
-        {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                fmt::Display::fmt(self, f)
-            }
-        }
-        impl<
-            'a,
-            T: SupportsDagDebugState,
-            DebugValue: Fn(&'a T, &mut fmt::Formatter<'_>) -> fmt::Result,
-            DebugAbbreviated: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
-        > fmt::Display for DebugOrIdWith<'a, T, DebugValue, DebugAbbreviated>
-        {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                write!(f, "#{} ", self.insert_result.id())?;
-                match self.insert_result {
-                    DagDebugStateInsertResult::New { id: _ } => (self.debug_value)(self.value, f),
-                    DagDebugStateInsertResult::Old { id: _ } => (self.debug_abbreviated)(f),
-                }
-            }
-        }
-        DebugOrIdWith {
-            insert_result: self.insert(value),
-            value,
-            debug_value,
-            debug_abbreviated,
-        }
-    }
-    #[must_use]
-    fn inc_ref_count_scope(&self) -> impl Sized {
-        struct DecRefCountOnDrop<'a>(&'a DagDebugState);
-        impl Drop for DecRefCountOnDrop<'_> {
-            fn drop(&mut self) {
-                self.0.ref_count.set(self.0.ref_count.get() - 1);
-                if self.0.ref_count.get() == 0 {
-                    self.0
-                        .parts
-                        .borrow_mut()
-                        .values_mut()
-                        .for_each(|v| v.reset());
-                }
-            }
-        }
-        self.ref_count.set(
-            self.ref_count
-                .get()
-                .checked_add(1)
-                .expect("too many nested calls"),
-        );
-        DecRefCountOnDrop(self)
-    }
-    pub fn scope<R>(f: impl FnOnce(&Self) -> R) -> R {
-        thread_local! {
-            static STATE: DagDebugState = DagDebugState { parts: Default::default(), ref_count: Cell::new(0) };
-        }
-        STATE.with(|state| {
-            let _scope = state.inc_ref_count_scope();
-            f(state)
-        })
-    }
-}
diff --git a/src/xml_tree.rs b/src/xml_tree.rs
new file mode 100644
index 0000000..4831a38
--- /dev/null
+++ b/src/xml_tree.rs
@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use quick_xml::{
+    Writer,
+    events::{BytesDecl, BytesStart, BytesText, Event},
+};
+use std::fmt;
+
+struct FmtToIoAdaptor<W> {
+    writer: W,
+    partial_char: [u8; 4],
+    partial_char_len: u8,
+}
+
+impl<W: fmt::Write> FmtToIoAdaptor<W> {
+    fn new(writer: W) -> Self {
+        Self {
+            writer,
+            partial_char: [0; 4],
+            partial_char_len: 0,
+        }
+    }
+    fn finish(self) -> Result<W, fmt::Error> {
+        let Self {
+            writer,
+            partial_char: _,
+            partial_char_len,
+        } = self;
+        if partial_char_len != 0 {
+            Err(fmt::Error)
+        } else {
+            Ok(writer)
+        }
+    }
+    fn write_byte(&mut self, b: u8) -> std::io::Result<()> {
+        let Self {
+            writer,
+            partial_char,
+            partial_char_len,
+        } = self;
+        partial_char[usize::from(*partial_char_len)] = b;
+        *partial_char_len += 1;
+        match str::from_utf8(&partial_char[..usize::from(*partial_char_len)]) {
+            Ok(s) => {
+                *partial_char_len = 0;
+                writer.write_str(s).map_err(std::io::Error::other)
+            }
+            Err(e) => {
+                if e.error_len().is_some() {
+                    *partial_char_len = 0;
+                    Err(std::io::Error::new(std::io::ErrorKind::InvalidData, e))
+                } else {
+                    Ok(())
+                }
+            }
+        }
+    }
+}
+
+impl<W: fmt::Write> std::io::Write for FmtToIoAdaptor<W> {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        for &b in buf {
+            self.write_byte(b)?;
+        }
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) enum ElementTag {
+    Comment,
+    Normal(String),
+}
+
+impl ElementTag {
+    pub(crate) fn normal(&self) -> Option<&str> {
+        match self {
+            ElementTag::Comment => None,
+            ElementTag::Normal(v) => Some(v),
+        }
+    }
+}
+
+impl fmt::Debug for ElementTag {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Comment => f.write_str("<Comment>"),
+            Self::Normal(v) => v.fmt(f),
+        }
+    }
+}
+
+/// like python's xml.etree.ElementTree.Element
+#[derive(Clone, Debug)]
+pub(crate) struct Element {
+    pub(crate) tag: ElementTag,
+    pub(crate) attrib: Vec<(String, String)>,
+    /// text contained in this element but before any children
+    pub(crate) text: String,
+    pub(crate) children: Vec<Element>,
+    /// text after the end of this element
+    pub(crate) tail: String,
+}
+
+/// equivalent to python `xml.etree.ElementTree.tostring(self, encoding="unicode")`
+impl fmt::Display for Element {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut writer = Writer::new(FmtToIoAdaptor::new(f));
+        self.write_to(&mut writer).map_err(|_| fmt::Error)?;
+        writer.into_inner().finish()?;
+        Ok(())
+    }
+}
+
+impl Element {
+    pub(crate) fn new(tag: String, attrib: impl IntoIterator<Item = (String, String)>) -> Self {
+        Self {
+            tag: ElementTag::Normal(tag),
+            attrib: Vec::from_iter(attrib),
+            text: String::new(),
+            children: Vec::new(),
+            tail: String::new(),
+        }
+    }
+    /// equivalent of python's `xml.etree.ElementTree.Comment()`
+    pub(crate) fn comment(text: String) -> Self {
+        Self {
+            tag: ElementTag::Comment,
+            attrib: Vec::new(),
+            text,
+            children: Vec::new(),
+            tail: String::new(),
+        }
+    }
+    /// equivalent to python `"".join(self.itertext())`
+    pub(crate) fn inner_text(&self) -> String {
+        let mut retval = String::new();
+        fn helper(element: &Element, retval: &mut String) {
+            let Element {
+                tag,
+                attrib: _,
+                text,
+                children,
+                tail: _,
+            } = element;
+            let ElementTag::Normal(_) = tag else {
+                return;
+            };
+            retval.push_str(text);
+            for child in children {
+                helper(child, retval);
+                retval.push_str(&child.tail);
+            }
+        }
+        helper(self, &mut retval);
+        retval
+    }
+    /// equivalent of python's `xml.etree.ElementTree.SubElement()`
+    pub(crate) fn sub_element(
+        &mut self,
+        tag: String,
+        attrib: impl IntoIterator<Item = (String, String)>,
+    ) -> &mut Self {
+        self.children.push(Self::new(tag, attrib));
+        self.children.last_mut().expect("just pushed")
+    }
+    pub(crate) fn write_to(&self, writer: &mut Writer<impl std::io::Write>) -> std::io::Result<()> {
+        let Element {
+            tag,
+            attrib,
+            text,
+            children,
+            tail,
+        } = self;
+        match tag {
+            ElementTag::Comment => {
+                writer.write_event(Event::Comment(BytesText::new(text)))?;
+            }
+            ElementTag::Normal(tag) if tag.is_empty() => {
+                writer.write_event(Event::Text(BytesText::new(text)))?;
+            }
+            ElementTag::Normal(tag)
+                if attrib.is_empty() && text.is_empty() && children.is_empty() =>
+            {
+                // write element like `<br />` to match python instead of like `<br/>`
+                writer.write_event(Event::Empty(BytesStart::from_content(
+                    tag.clone() + " ",
+                    tag.len(),
+                )))?;
+            }
+            ElementTag::Normal(tag) => {
+                let mut element_writer = writer.create_element(tag);
+                for (name, value) in attrib {
+                    element_writer = element_writer.with_attribute((name.as_str(), value.as_str()));
+                }
+                if text.is_empty() && children.is_empty() {
+                    element_writer.write_empty()?;
+                } else {
+                    element_writer.write_inner_content(|writer| {
+                        writer.write_event(Event::Text(BytesText::new(text)))?;
+                        for child in children {
+                            child.write_to(writer)?;
+                        }
+                        Ok(())
+                    })?;
+                }
+            }
+        }
+        writer.write_event(Event::Text(BytesText::new(tail)))?;
+        Ok(())
+    }
+    /// equivalent of python's `xml.etree.ElementTree(self).write(writer, encoding='utf-8', xml_declaration=xml_declaration)`
+    pub(crate) fn write(
+        &self,
+        writer: impl std::io::Write,
+        xml_declaration: bool,
+    ) -> std::io::Result<()> {
+        let mut writer = Writer::new(writer);
+        if xml_declaration {
+            // use specific string to match python
+            writer.write_event(Event::Decl(BytesDecl::from_start(
+                BytesStart::from_content("xml version='1.0' encoding='utf-8'", 3),
+            )))?;
+            writer.write_event(Event::Text(BytesText::new("\n")))?;
+        }
+        self.write_to(&mut writer)
+    }
+}