diff --git a/.forgejo/workflows/test.yml b/.forgejo/workflows/test.yml
deleted file mode 100644
index bed4795..0000000
--- a/.forgejo/workflows/test.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-# 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 454d147..e11e257 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,7 @@
-# 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 4321809..10be7b1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3,56 +3,10 @@
 version = 4
 
 [[package]]
-name = "aho-corasick"
-version = "1.1.4"
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-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",
-]
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "cfg-if"
@@ -61,16 +15,39 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
-name = "clang-sys"
-version = "1.8.1"
+name = "crc32fast"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
- "glob",
- "libc",
- "libloading",
+ "cfg-if",
 ]
 
+[[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"
@@ -78,228 +55,55 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
 [[package]]
-name = "equivalent"
-version = "1.0.2"
+name = "flate2"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-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"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
- "equivalent",
- "hashbrown",
+ "crc32fast",
+ "miniz_oxide",
 ]
 
 [[package]]
-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"
+name = "miniz_oxide"
 version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
 dependencies = [
- "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",
+ "adler2",
+ "simd-adler32",
 ]
 
 [[package]]
 name = "parse_powerisa_pdf"
 version = "0.1.0"
 dependencies = [
- "indexmap",
- "libm",
- "mupdf-sys",
- "quick-xml",
+ "flate2",
+ "rayon",
 ]
 
 [[package]]
-name = "pkg-config"
-version = "0.3.32"
+name = "rayon"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.104"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
 dependencies = [
- "unicode-ident",
+ "either",
+ "rayon-core",
 ]
 
 [[package]]
-name = "quick-xml"
-version = "0.38.4"
+name = "rayon-core"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
 dependencies = [
- "memchr",
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "quote"
-version = "1.0.42"
+name = "simd-adler32"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-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",
-]
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
diff --git a/Cargo.toml b/Cargo.toml
index 21175d6..20ecf46 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,17 +1,10 @@
-# SPDX-License-Identifier: LGPL-3.0-or-later
-# See Notices.txt for copyright information
 [package]
 name = "parse_powerisa_pdf"
 version = "0.1.0"
-license = "LGPL-3.0-or-later"
 edition = "2024"
-repository = ""
-keywords = []
-categories = []
-rust-version = "1.89.0"
+license = "LGPL-3.0-or-later"
 
 [dependencies]
-indexmap = "2.12.1"
-libm = "0.2.15"
-mupdf-sys = { version = "0.5.0", default-features = false }
-quick-xml = "0.38.4"
+flate2 = "1.1.5"
+rayon = "1.11.0"
+
diff --git a/README.md b/README.md
index f589559..f8fae5d 100644
--- a/README.md
+++ b/README.md
@@ -1,38 +1,5 @@
-<!--
-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 3c2afe5..c7187d1 100755
--- a/parse_powerisa_pdf/parse_powerisa_pdf.py
+++ b/parse_powerisa_pdf/parse_powerisa_pdf.py
@@ -1,5 +1,3 @@
-# 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
@@ -765,7 +763,7 @@ class Page:
     unprocessed_non_text: SetById[LTLine | LTRect]
 
     @staticmethod
-    def from_lt_page(page_num: int, page: LTPage, first_seen_fonts: defaultdict[str, set[float]]) -> Page:
+    def from_lt_page(page_num: int, page: LTPage) -> Page:
         qt: defaultdict[TextSection, QuadTree[Char | LTLine | LTRect]] = defaultdict(QuadTree)
         unprocessed_chars = defaultdict(lambda: defaultdict(SetById[Char]))
         unprocessed_non_text: SetById[LTLine | LTRect] = SetById()
@@ -804,25 +802,20 @@ 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=font_size),
+                        font=Font(font_name=element.fontname, size=round(element.size, 3)),
                         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 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}")
+        for i in unprocessed_chars.values():
+            for j in i.values():
+                j.sort(key=Char.top_down_left_to_right_sort_key)
         unknown_fonts=[]
         unknown_font_errors=[]
         for i in unprocessed_chars.values():
@@ -1186,14 +1179,13 @@ 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, first_seen_fonts=first_seen_fonts)
+            yield Page.from_lt_page(page_num=page_num, page=page)
 
     def parse_pdf(self, file: Path, page_numbers: Iterable[int] | None = None):
         self.pages = Pages(pages_gen=Parser.__pages_gen(
@@ -1509,7 +1501,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{v_lines}")
+                f"instruction bit fields box has too few vertical lines:\n{h_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 bee9d76..34343e8 100644
--- a/parse_powerisa_pdf/quad_tree.py
+++ b/parse_powerisa_pdf/quad_tree.py
@@ -1,5 +1,3 @@
-# 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 969f8d7..444741b 100644
--- a/parse_powerisa_pdf/set_by_id.py
+++ b/parse_powerisa_pdf/set_by_id.py
@@ -1,5 +1,3 @@
-# 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 0f3e887..c2ec3e0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,5 +1,3 @@
-# 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"
@@ -13,7 +11,4 @@ dependencies = [
 requires-python = ">= 3.11"
 
 [project.scripts]
-parse_powerisa_pdf = "parse_powerisa_pdf.parse_powerisa_pdf:main"
-
-[tool.setuptools]
-packages = ["parse_powerisa_pdf"]
+parse_powerisa_pdf = "parse_powerisa_pdf.parse_powerisa_pdf:main"
\ No newline at end of file
diff --git a/scripts/check-copyright.sh b/scripts/check-copyright.sh
deleted file mode 100755
index a9dc2bc..0000000
--- a/scripts/check-copyright.sh
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/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 0ea6a19..d0e7860 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,3828 +1,5 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// See Notices.txt for copyright information
+#[doc(hidden)]
+pub use std as __std;
 
-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
-        }
-    }
-}
+pub mod pdf;
+pub mod util;
diff --git a/src/main.rs b/src/main.rs
index 23e46da..533a408 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,38 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// See Notices.txt for copyright information
+use parse_powerisa_pdf::pdf::Pdf;
+use std::{
+    error::Error,
+    io::{IsTerminal, Read},
+    process::ExitCode,
+};
 
-fn main() -> std::process::ExitCode {
-    parse_powerisa_pdf::main()
+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)
 }
diff --git a/src/mupdf_ffi.rs b/src/mupdf_ffi.rs
deleted file mode 100644
index 809ee44..0000000
--- a/src/mupdf_ffi.rs
+++ /dev/null
@@ -1,871 +0,0 @@
-// 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
new file mode 100644
index 0000000..be57b31
--- /dev/null
+++ b/src/pdf.rs
@@ -0,0 +1,1279 @@
+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
new file mode 100644
index 0000000..79764c2
--- /dev/null
+++ b/src/pdf/content_stream.rs
@@ -0,0 +1,829 @@
+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
new file mode 100644
index 0000000..268d503
--- /dev/null
+++ b/src/pdf/document_structure.rs
@@ -0,0 +1,743 @@
+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
new file mode 100644
index 0000000..5f096b4
--- /dev/null
+++ b/src/pdf/font.rs
@@ -0,0 +1,1057 @@
+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
new file mode 100644
index 0000000..fcb8218
--- /dev/null
+++ b/src/pdf/font/tables.rs
@@ -0,0 +1,1067 @@
+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
new file mode 100644
index 0000000..e5c57be
--- /dev/null
+++ b/src/pdf/font/to_unicode_parse.rs
@@ -0,0 +1,325 @@
+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
new file mode 100644
index 0000000..1825e42
--- /dev/null
+++ b/src/pdf/font/type_1_parse.rs
@@ -0,0 +1,1507 @@
+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
new file mode 100644
index 0000000..bf91fac
--- /dev/null
+++ b/src/pdf/object.rs
@@ -0,0 +1,2142 @@
+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
new file mode 100644
index 0000000..3f0ff21
--- /dev/null
+++ b/src/pdf/parse.rs
@@ -0,0 +1,1341 @@
+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
new file mode 100644
index 0000000..4603ae1
--- /dev/null
+++ b/src/pdf/render.rs
@@ -0,0 +1,1107 @@
+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
new file mode 100644
index 0000000..baf6670
--- /dev/null
+++ b/src/pdf/stream_filters.rs
@@ -0,0 +1,66 @@
+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
new file mode 100644
index 0000000..b5d49e8
--- /dev/null
+++ b/src/pdf/stream_filters/flate.rs
@@ -0,0 +1,74 @@
+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
deleted file mode 100644
index 0c57597..0000000
--- a/src/quad_tree.rs
+++ /dev/null
@@ -1,1115 +0,0 @@
-// 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
new file mode 100644
index 0000000..9d576f8
--- /dev/null
+++ b/src/util.rs
@@ -0,0 +1,382 @@
+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
deleted file mode 100644
index 4831a38..0000000
--- a/src/xml_tree.rs
+++ /dev/null
@@ -1,232 +0,0 @@
-// 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)
-    }
-}